From beb116954b9b7f3bb56412b2494b562f02b864b1 Mon Sep 17 00:00:00 2001 From: Ralf Baechle Date: Tue, 7 Jan 1997 02:33:00 +0000 Subject: Import of Linux/MIPS 2.1.14 --- fs/fat/inode.c | 596 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 596 insertions(+) create mode 100644 fs/fat/inode.c (limited to 'fs/fat/inode.c') diff --git a/fs/fat/inode.c b/fs/fat/inode.c new file mode 100644 index 000000000..55d91ba2b --- /dev/null +++ b/fs/fat/inode.c @@ -0,0 +1,596 @@ +/* + * linux/fs/fat/inode.c + * + * Written 1992,1993 by Werner Almesberger + * VFAT extensions by Gordon Chaffee, merged with msdos fs by Henrik Storner + * + * 3 May 1996 Fixed alignment problems for RISC architectures. + */ + +#define __NO_VERSION__ +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "msbuffer.h" +#include "tables.h" + +#include +#include + + + +void fat_put_inode(struct inode *inode) +{ + struct inode *depend, *linked; + struct super_block *sb; + + depend = MSDOS_I(inode)->i_depend; + linked = MSDOS_I(inode)->i_linked; + sb = inode->i_sb; + if (inode->i_nlink) { + if (depend) { + iput(depend); + } + if (linked) { + iput(linked); + MSDOS_I(inode)->i_linked = NULL; + } + if (MSDOS_I(inode)->i_busy) fat_cache_inval_inode(inode); + return; + } + inode->i_size = 0; + fat_truncate(inode); + if (depend) { + if (MSDOS_I(depend)->i_old != inode) { + printk("Invalid link (0x%p): expected 0x%p, got 0x%p\n", + depend, inode, MSDOS_I(depend)->i_old); + fat_fs_panic(sb,"..."); + goto done; + } + MSDOS_I(depend)->i_old = NULL; + iput(depend); + } + if (linked) { + if (MSDOS_I(linked)->i_oldlink != inode) { + printk("Invalid link (0x%p): expected 0x%p, got 0x%p\n", + linked, inode, MSDOS_I(linked)->i_oldlink); + fat_fs_panic(sb,"..."); + goto done; + } + MSDOS_I(linked)->i_oldlink = NULL; + iput(linked); + } +done: + clear_inode(inode); +} + + +void fat_put_super(struct super_block *sb) +{ + fat_cache_inval_dev(sb->s_dev); + set_blocksize (sb->s_dev,BLOCK_SIZE); + lock_super(sb); + sb->s_dev = 0; + unlock_super(sb); + MOD_DEC_USE_COUNT; + return; +} + + +static int parse_options(char *options,int *fat, int *blksize, int *debug, + struct fat_mount_options *opts) +{ + char *this_char,*value; + + opts->name_check = 'n'; + opts->conversion = 'b'; + opts->fs_uid = current->uid; + opts->fs_gid = current->gid; + opts->fs_umask = current->fs->umask; + opts->quiet = opts->sys_immutable = opts->dotsOK = opts->showexec = opts->isvfat = 0; + *debug = *fat = 0; + + if (!options) return 1; + for (this_char = strtok(options,","); this_char; this_char = strtok(NULL,",")) { + if ((value = strchr(this_char,'=')) != NULL) + *value++ = 0; + if (!strcmp(this_char,"check") && value) { + if (value[0] && !value[1] && strchr("rns",*value)) + opts->name_check = *value; + else if (!strcmp(value,"relaxed")) opts->name_check = 'r'; + else if (!strcmp(value,"normal")) opts->name_check = 'n'; + else if (!strcmp(value,"strict")) opts->name_check = 's'; + else return 0; + } + else if (!strcmp(this_char,"conv") && value) { + if (value[0] && !value[1] && strchr("bta",*value)) + opts->conversion = *value; + else if (!strcmp(value,"binary")) opts->conversion = 'b'; + else if (!strcmp(value,"text")) opts->conversion = 't'; + else if (!strcmp(value,"auto")) opts->conversion = 'a'; + else return 0; + } + else if (!strcmp(this_char,"dots")) { + opts->dotsOK = 1; + } + else if (!strcmp(this_char,"nodots")) { + opts->dotsOK = 0; + } + else if (!strcmp(this_char,"showexec")) { + opts->showexec = 1; + } + else if (!strcmp(this_char,"dotsOK") && value) { + if (!strcmp(value,"yes")) opts->dotsOK = 1; + else if (!strcmp(value,"no")) opts->dotsOK = 0; + else return 0; + } + else if (!strcmp(this_char,"uid")) { + if (!value || !*value) + return 0; + opts->fs_uid = simple_strtoul(value,&value,0); + if (*value) + return 0; + } + else if (!strcmp(this_char,"gid")) { + if (!value || !*value) + return 0; + opts->fs_gid = simple_strtoul(value,&value,0); + if (*value) + return 0; + } + else if (!strcmp(this_char,"umask")) { + if (!value || !*value) + return 0; + opts->fs_umask = simple_strtoul(value,&value,8); + if (*value) + return 0; + } + else if (!strcmp(this_char,"debug")) { + if (value) return 0; + *debug = 1; + } + else if (!strcmp(this_char,"fat")) { + if (!value || !*value) + return 0; + *fat = simple_strtoul(value,&value,0); + if (*value || (*fat != 12 && *fat != 16)) + return 0; + } + else if (!strcmp(this_char,"quiet")) { + if (value) return 0; + opts->quiet = 1; + } + else if (!strcmp(this_char,"blocksize")) { + *blksize = simple_strtoul(value,&value,0); + if (*value) + return 0; + if (*blksize != 512 && *blksize != 1024){ + printk ("MSDOS FS: Invalid blocksize (512 or 1024)\n"); + } + } + else if (!strcmp(this_char,"sys_immutable")) { + if (value) + return 0; + opts->sys_immutable = 1; + } + } + return 1; +} + + +/* Read the super block of an MS-DOS FS. */ + +struct super_block *fat_read_super(struct super_block *sb,void *data, int silent) +{ + struct buffer_head *bh; + struct msdos_boot_sector *b; + int data_sectors,logical_sector_size,sector_mult,fat_clusters=0; + int debug,error,fat; + int blksize = 512; + struct fat_mount_options opts; + + MOD_INC_USE_COUNT; + if (hardsect_size[MAJOR(sb->s_dev)] != NULL){ + blksize = hardsect_size[MAJOR(sb->s_dev)][MINOR(sb->s_dev)]; + if (blksize != 512){ + printk ("MSDOS: Hardware sector size is %d\n",blksize); + } + } + if (!parse_options((char *) data, &fat, &blksize, &debug, &opts) + || (blksize != 512 && blksize != 1024)) { + sb->s_dev = 0; + MOD_DEC_USE_COUNT; + return NULL; + } + cache_init(); + lock_super(sb); + /* The first read is always 1024 bytes */ + sb->s_blocksize = 1024; + set_blocksize(sb->s_dev, 1024); + bh = fat_bread(sb, 0); + unlock_super(sb); + if (bh == NULL || !fat_is_uptodate(sb,bh)) { + fat_brelse (sb, bh); + sb->s_dev = 0; + printk("FAT bread failed\n"); + MOD_DEC_USE_COUNT; + return NULL; + } + b = (struct msdos_boot_sector *) bh->b_data; + set_blocksize(sb->s_dev, blksize); +/* + * The DOS3 partition size limit is *not* 32M as many people think. + * Instead, it is 64K sectors (with the usual sector size being + * 512 bytes, leading to a 32M limit). + * + * DOS 3 partition managers got around this problem by faking a + * larger sector size, ie treating multiple physical sectors as + * a single logical sector. + * + * We can accommodate this scheme by adjusting our cluster size, + * fat_start, and data_start by an appropriate value. + * + * (by Drew Eckhardt) + */ + +#define ROUND_TO_MULTIPLE(n,m) ((n) && (m) ? (n)+(m)-1-((n)-1)%(m) : 0) + /* don't divide by zero */ + + logical_sector_size = b->sector_size[0] | (b->sector_size[1] << 8); + logical_sector_size = + CF_LE_W(get_unaligned((unsigned short *) &b->sector_size)); + sector_mult = logical_sector_size >> SECTOR_BITS; + MSDOS_SB(sb)->cluster_size = b->cluster_size*sector_mult; + MSDOS_SB(sb)->fats = b->fats; + MSDOS_SB(sb)->fat_start = CF_LE_W(b->reserved)*sector_mult; + MSDOS_SB(sb)->fat_length = CF_LE_W(b->fat_length)*sector_mult; + MSDOS_SB(sb)->dir_start = (CF_LE_W(b->reserved)+b->fats*CF_LE_W( + b->fat_length))*sector_mult; + MSDOS_SB(sb)->dir_entries = + CF_LE_W(get_unaligned((unsigned short *) &b->dir_entries)); + MSDOS_SB(sb)->data_start = MSDOS_SB(sb)->dir_start+ROUND_TO_MULTIPLE(( + MSDOS_SB(sb)->dir_entries << MSDOS_DIR_BITS) >> SECTOR_BITS, + sector_mult); + data_sectors = ((b->sectors[0] | (b->sectors[1] << 8)) ? + (b->sectors[0] | (b->sectors[1] << 8)) : + CF_LE_L(b->total_sect))*sector_mult-MSDOS_SB(sb)->data_start; + data_sectors = CF_LE_W(get_unaligned((unsigned short *) &b->sectors)); + if (!data_sectors) { + data_sectors = CF_LE_L(b->total_sect); + } + data_sectors = data_sectors * sector_mult - MSDOS_SB(sb)->data_start; + error = !b->cluster_size || !sector_mult; + if (!error) { + MSDOS_SB(sb)->clusters = b->cluster_size ? data_sectors/ + b->cluster_size/sector_mult : 0; + MSDOS_SB(sb)->fat_bits = fat ? fat : MSDOS_SB(sb)->clusters > + MSDOS_FAT12 ? 16 : 12; + fat_clusters = MSDOS_SB(sb)->fat_length*SECTOR_SIZE*8/ + MSDOS_SB(sb)->fat_bits; + error = !MSDOS_SB(sb)->fats || (MSDOS_SB(sb)->dir_entries & + (MSDOS_DPS-1)) || MSDOS_SB(sb)->clusters+2 > fat_clusters+ + MSDOS_MAX_EXTRA || (logical_sector_size & (SECTOR_SIZE-1)) + || !b->secs_track || !b->heads; + } + fat_brelse(sb, bh); + /* + This must be done after the brelse because the bh is a dummy + allocated by fat_bread (see buffer.c) + */ + sb->s_blocksize = blksize; /* Using this small block size solves */ + /* the misfit with buffer cache and cluster */ + /* because clusters (DOS) are often aligned */ + /* on odd sectors. */ + sb->s_blocksize_bits = blksize == 512 ? 9 : 10; + if (error || debug) { + /* The MSDOS_CAN_BMAP is obsolete, but left just to remember */ + printk("[MS-DOS FS Rel. 12,FAT %d,check=%c,conv=%c," + "uid=%d,gid=%d,umask=%03o%s]\n", + MSDOS_SB(sb)->fat_bits,opts.name_check, + opts.conversion,opts.fs_uid,opts.fs_gid,opts.fs_umask, + MSDOS_CAN_BMAP(MSDOS_SB(sb)) ? ",bmap" : ""); + printk("[me=0x%x,cs=%d,#f=%d,fs=%d,fl=%d,ds=%d,de=%d,data=%d," + "se=%d,ts=%ld,ls=%d]\n",b->media,MSDOS_SB(sb)->cluster_size, + MSDOS_SB(sb)->fats,MSDOS_SB(sb)->fat_start,MSDOS_SB(sb)->fat_length, + MSDOS_SB(sb)->dir_start,MSDOS_SB(sb)->dir_entries, + MSDOS_SB(sb)->data_start, + (b->sectors[0] | (b->sectors[1] << 8)), + (unsigned long)b->total_sect,logical_sector_size); + printk ("Transaction block size = %d\n",blksize); + } + if (MSDOS_SB(sb)->clusters+2 > fat_clusters) + MSDOS_SB(sb)->clusters = fat_clusters-2; + if (error) { + if (!silent) + printk("VFS: Can't find a valid MSDOS filesystem on dev " + "%s.\n", kdevname(sb->s_dev)); + sb->s_dev = 0; + MOD_DEC_USE_COUNT; + return NULL; + } + sb->s_magic = MSDOS_SUPER_MAGIC; + /* set up enough so that it can read an inode */ + MSDOS_SB(sb)->free_clusters = -1; /* don't know yet */ + MSDOS_SB(sb)->fat_wait = NULL; + MSDOS_SB(sb)->fat_lock = 0; + MSDOS_SB(sb)->prev_free = 0; + memcpy(&(MSDOS_SB(sb)->options), &opts, sizeof(struct fat_mount_options)); + if (!(sb->s_mounted = iget(sb,MSDOS_ROOT_INO))) { + sb->s_dev = 0; + printk("get root inode failed\n"); + MOD_DEC_USE_COUNT; + return NULL; + } + return sb; +} + + +void fat_statfs(struct super_block *sb,struct statfs *buf, int bufsiz) +{ + int free,nr; + struct statfs tmp; + + lock_fat(sb); + if (MSDOS_SB(sb)->free_clusters != -1) + free = MSDOS_SB(sb)->free_clusters; + else { + free = 0; + for (nr = 2; nr < MSDOS_SB(sb)->clusters+2; nr++) + if (!fat_access(sb,nr,-1)) free++; + MSDOS_SB(sb)->free_clusters = free; + } + unlock_fat(sb); + tmp.f_type = sb->s_magic; + tmp.f_bsize = MSDOS_SB(sb)->cluster_size*SECTOR_SIZE; + tmp.f_blocks = MSDOS_SB(sb)->clusters; + tmp.f_bfree = free; + tmp.f_bavail = free; + tmp.f_files = 0; + tmp.f_ffree = 0; + tmp.f_namelen = 12; + copy_to_user(buf, &tmp, bufsiz); +} + + +int fat_bmap(struct inode *inode,int block) +{ + struct msdos_sb_info *sb; + int cluster,offset; + + sb = MSDOS_SB(inode->i_sb); + if (inode->i_ino == MSDOS_ROOT_INO) { + return sb->dir_start + block; + } + cluster = block/sb->cluster_size; + offset = block % sb->cluster_size; + if (!(cluster = get_cluster(inode,cluster))) return 0; + return (cluster-2)*sb->cluster_size+sb->data_start+offset; +} + +static int is_exec(char *extension) +{ + char *exe_extensions = "EXECOMBAT", *walk; + + for (walk = exe_extensions; *walk; walk += 3) + if (!strncmp(extension, walk, 3)) + return 1; + return 0; +} + +void fat_read_inode(struct inode *inode, struct inode_operations *fs_dir_inode_ops) +{ + struct super_block *sb = inode->i_sb; + struct buffer_head *bh; + struct msdos_dir_entry *raw_entry; + int nr; + + MSDOS_I(inode)->i_busy = 0; + MSDOS_I(inode)->i_depend = MSDOS_I(inode)->i_old = NULL; + MSDOS_I(inode)->i_linked = MSDOS_I(inode)->i_oldlink = NULL; + MSDOS_I(inode)->i_binary = 1; + inode->i_uid = MSDOS_SB(sb)->options.fs_uid; + inode->i_gid = MSDOS_SB(sb)->options.fs_gid; + inode->i_version = ++event; + if (inode->i_ino == MSDOS_ROOT_INO) { + inode->i_mode = (S_IRWXUGO & ~MSDOS_SB(sb)->options.fs_umask) | + S_IFDIR; + inode->i_op = fs_dir_inode_ops; + inode->i_nlink = fat_subdirs(inode)+2; + /* subdirs (neither . nor ..) plus . and "self" */ + inode->i_size = MSDOS_SB(sb)->dir_entries* + sizeof(struct msdos_dir_entry); + inode->i_blksize = MSDOS_SB(sb)->cluster_size* + SECTOR_SIZE; + inode->i_blocks = (inode->i_size+inode->i_blksize-1)/ + inode->i_blksize*MSDOS_SB(sb)->cluster_size; + MSDOS_I(inode)->i_start = 0; + MSDOS_I(inode)->i_attrs = 0; + inode->i_mtime = inode->i_atime = inode->i_ctime = 0; + return; + } + if (!(bh = fat_bread(sb, inode->i_ino >> MSDOS_DPB_BITS))) { + printk("dev = %s, ino = %ld\n", + kdevname(inode->i_dev), inode->i_ino); + panic("fat_read_inode: unable to read i-node block"); + } + raw_entry = &((struct msdos_dir_entry *) (bh->b_data)) + [inode->i_ino & (MSDOS_DPB-1)]; + if ((raw_entry->attr & ATTR_DIR) && !IS_FREE(raw_entry->name)) { + inode->i_mode = MSDOS_MKMODE(raw_entry->attr,S_IRWXUGO & + ~MSDOS_SB(sb)->options.fs_umask) | S_IFDIR; + inode->i_op = fs_dir_inode_ops; + + MSDOS_I(inode)->i_start = CF_LE_W(raw_entry->start); + inode->i_nlink = fat_subdirs(inode); + /* includes .., compensating for "self" */ +#ifdef DEBUG + if (!inode->i_nlink) { + printk("directory %d: i_nlink == 0\n",inode->i_ino); + inode->i_nlink = 1; + } +#endif + inode->i_size = 0; + if ((nr = CF_LE_W(raw_entry->start)) != 0) + while (nr != -1) { + inode->i_size += SECTOR_SIZE*MSDOS_SB(inode-> + i_sb)->cluster_size; + if (!(nr = fat_access(sb,nr,-1))) { + printk("Directory %ld: bad FAT\n", + inode->i_ino); + break; + } + } + } else { /* not a directory */ + inode->i_mode = MSDOS_MKMODE(raw_entry->attr, + ((IS_NOEXEC(inode) || + (MSDOS_SB(sb)->options.showexec && + !is_exec(raw_entry->ext))) + ? S_IRUGO|S_IWUGO : S_IRWXUGO) + & ~MSDOS_SB(sb)->options.fs_umask) | S_IFREG; + inode->i_op = (sb->s_blocksize == 1024) + ? &fat_file_inode_operations_1024 + : &fat_file_inode_operations; + MSDOS_I(inode)->i_start = CF_LE_W(raw_entry->start); + inode->i_nlink = 1; + inode->i_size = CF_LE_L(raw_entry->size); + } + if(raw_entry->attr & ATTR_SYS) + if (MSDOS_SB(sb)->options.sys_immutable) + inode->i_flags |= S_IMMUTABLE; + MSDOS_I(inode)->i_binary = is_binary(MSDOS_SB(sb)->options.conversion, + raw_entry->ext); + MSDOS_I(inode)->i_attrs = raw_entry->attr & ATTR_UNUSED; + /* this is as close to the truth as we can get ... */ + inode->i_blksize = MSDOS_SB(sb)->cluster_size*SECTOR_SIZE; + inode->i_blocks = (inode->i_size+inode->i_blksize-1)/ + inode->i_blksize*MSDOS_SB(sb)->cluster_size; + inode->i_mtime = inode->i_atime = + date_dos2unix(CF_LE_W(raw_entry->time),CF_LE_W(raw_entry->date)); + inode->i_ctime = + MSDOS_SB(sb)->options.isvfat + ? date_dos2unix(CF_LE_W(raw_entry->ctime),CF_LE_W(raw_entry->cdate)) + : inode->i_mtime; + fat_brelse(sb, bh); +} + + +void fat_write_inode(struct inode *inode) +{ + struct super_block *sb = inode->i_sb; + struct buffer_head *bh; + struct msdos_dir_entry *raw_entry; + struct inode *linked; + + linked = MSDOS_I(inode)->i_linked; + if (linked) { + if (MSDOS_I(linked)->i_oldlink != inode) { + printk("Invalid link (0x%p): expected 0x%p, got 0x%p\n", + linked, inode, MSDOS_I(linked)->i_oldlink); + fat_fs_panic(sb,"..."); + return; + } + linked->i_version = ++event; + linked->i_mode = inode->i_mode; + linked->i_uid = inode->i_uid; + linked->i_gid = inode->i_gid; + linked->i_size = inode->i_size; + linked->i_atime = inode->i_atime; + linked->i_mtime = inode->i_mtime; + linked->i_ctime = inode->i_ctime; + linked->i_blocks = inode->i_blocks; + linked->i_atime = inode->i_atime; + MSDOS_I(linked)->i_attrs = MSDOS_I(inode)->i_attrs; + linked->i_dirt = 1; + } + + inode->i_dirt = 0; + if (inode->i_ino == MSDOS_ROOT_INO || !inode->i_nlink) return; + if (!(bh = fat_bread(sb, inode->i_ino >> MSDOS_DPB_BITS))) { + printk("dev = %s, ino = %ld\n", + kdevname(inode->i_dev), inode->i_ino); + panic("msdos_write_inode: unable to read i-node block"); + } + raw_entry = &((struct msdos_dir_entry *) (bh->b_data)) + [inode->i_ino & (MSDOS_DPB-1)]; + if (S_ISDIR(inode->i_mode)) { + raw_entry->attr = ATTR_DIR; + raw_entry->size = 0; + } + else { + raw_entry->attr = ATTR_NONE; + raw_entry->size = CT_LE_L(inode->i_size); + } + raw_entry->attr |= MSDOS_MKATTR(inode->i_mode) | + MSDOS_I(inode)->i_attrs; + raw_entry->start = CT_LE_W(MSDOS_I(inode)->i_start); + fat_date_unix2dos(inode->i_mtime,&raw_entry->time,&raw_entry->date); + raw_entry->time = CT_LE_W(raw_entry->time); + raw_entry->date = CT_LE_W(raw_entry->date); + if (MSDOS_SB(sb)->options.isvfat) { + fat_date_unix2dos(inode->i_ctime,&raw_entry->ctime,&raw_entry->cdate); + raw_entry->ctime = CT_LE_W(raw_entry->ctime); + raw_entry->cdate = CT_LE_W(raw_entry->cdate); + } + fat_mark_buffer_dirty(sb, bh, 1); + fat_brelse(sb, bh); +} + + +int fat_notify_change(struct inode * inode,struct iattr * attr) +{ + struct super_block *sb = inode->i_sb; + int error; + + error = inode_change_ok(inode, attr); + if (error) + return MSDOS_SB(sb)->options.quiet ? 0 : error; + + if (((attr->ia_valid & ATTR_UID) && + (attr->ia_uid != MSDOS_SB(sb)->options.fs_uid)) || + ((attr->ia_valid & ATTR_GID) && + (attr->ia_gid != MSDOS_SB(sb)->options.fs_gid)) || + ((attr->ia_valid & ATTR_MODE) && + (attr->ia_mode & ~MSDOS_VALID_MODE))) + error = -EPERM; + + if (error) + return MSDOS_SB(sb)->options.quiet ? 0 : error; + + inode_setattr(inode, attr); + + if (IS_NOEXEC(inode) && !S_ISDIR(inode->i_mode)) + inode->i_mode &= S_IFMT | S_IRUGO | S_IWUGO; + else + inode->i_mode |= S_IXUGO; + + inode->i_mode = ((inode->i_mode & S_IFMT) | ((((inode->i_mode & S_IRWXU + & ~MSDOS_SB(sb)->options.fs_umask) | S_IRUSR) >> 6)*S_IXUGO)) & + ~MSDOS_SB(sb)->options.fs_umask; + return 0; +} + + +#ifdef MODULE +int init_module(void) +{ + return init_fat_fs(); +} + + +void cleanup_module(void) +{ + /* Nothing to be done, really! */ + return; +} +#endif + -- cgit v1.2.3