root/fs/msdos/inode.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. msdos_put_inode
  2. msdos_put_super
  3. parse_options
  4. msdos_read_super
  5. msdos_statfs
  6. msdos_bmap
  7. msdos_read_inode
  8. msdos_write_inode
  9. msdos_notify_change

   1 /*
   2  *  linux/fs/msdos/inode.c
   3  *
   4  *  Written 1992,1993 by Werner Almesberger
   5  */
   6 
   7 #include <linux/msdos_fs.h>
   8 #include <linux/kernel.h>
   9 #include <linux/sched.h>
  10 #include <linux/errno.h>
  11 #include <linux/string.h>
  12 #include <linux/ctype.h>
  13 #include <linux/stat.h>
  14 #include <linux/locks.h>
  15 
  16 #include <asm/segment.h>
  17 
  18 
  19 void msdos_put_inode(struct inode *inode)
     /* [previous][next][first][last][top][bottom][index][help] */
  20 {
  21         struct inode *depend;
  22         struct super_block *sb;
  23 
  24         if (inode->i_nlink) {
  25                 if (MSDOS_I(inode)->i_busy) cache_inval_inode(inode);
  26                 return;
  27         }
  28         inode->i_size = 0;
  29         msdos_truncate(inode);
  30         depend = MSDOS_I(inode)->i_depend;
  31         sb = inode->i_sb;
  32         clear_inode(inode);
  33         if (depend) {
  34                 if (MSDOS_I(depend)->i_old != inode) {
  35                         printk("Invalid link (0x%X): expected 0x%X, got 0x%X\n",
  36                             (int) depend,(int) inode,(int) MSDOS_I(depend)->
  37                             i_old);
  38                         fs_panic(sb,"...");
  39                         return;
  40                 }
  41                 MSDOS_I(depend)->i_old = NULL;
  42                 iput(depend);
  43         }
  44 }
  45 
  46 
  47 void msdos_put_super(struct super_block *sb)
     /* [previous][next][first][last][top][bottom][index][help] */
  48 {
  49         cache_inval_dev(sb->s_dev);
  50         lock_super(sb);
  51         sb->s_dev = 0;
  52         unlock_super(sb);
  53         return;
  54 }
  55 
  56 
  57 static struct super_operations msdos_sops = { 
  58         msdos_read_inode,
  59         msdos_notify_change,
  60         msdos_write_inode,
  61         msdos_put_inode,
  62         msdos_put_super,
  63         NULL, /* added in 0.96c */
  64         msdos_statfs
  65 };
  66 
  67 
  68 static int parse_options(char *options,char *check,char *conversion,uid_t *uid,
     /* [previous][next][first][last][top][bottom][index][help] */
  69     gid_t *gid,int *umask,int *debug,int *fat,int *quiet)
  70 {
  71         char *this,*value;
  72 
  73         *check = 'n';
  74         *conversion = 'b';
  75         *uid = current->uid;
  76         *gid = current->gid;
  77         *umask = current->umask;
  78         *debug = *fat = *quiet = 0;
  79         if (!options) return 1;
  80         for (this = strtok(options,","); this; this = strtok(NULL,",")) {
  81                 if ((value = strchr(this,'=')) != NULL)
  82                         *value++ = 0;
  83                 if (!strcmp(this,"check") && value) {
  84                         if (value[0] && !value[1] && strchr("rns",*value))
  85                                 *check = *value;
  86                         else if (!strcmp(value,"relaxed")) *check = 'r';
  87                         else if (!strcmp(value,"normal")) *check = 'n';
  88                         else if (!strcmp(value,"strict")) *check = 's';
  89                         else return 0;
  90                 }
  91                 else if (!strcmp(this,"conv") && value) {
  92                         if (value[0] && !value[1] && strchr("bta",*value))
  93                                 *conversion = *value;
  94                         else if (!strcmp(value,"binary")) *conversion = 'b';
  95                         else if (!strcmp(value,"text")) *conversion = 't';
  96                         else if (!strcmp(value,"auto")) *conversion = 'a';
  97                         else return 0;
  98                 }
  99                 else if (!strcmp(this,"uid")) {
 100                         if (!value || !*value)
 101                                 return 0;
 102                         *uid = simple_strtoul(value,&value,0);
 103                         if (*value)
 104                                 return 0;
 105                 }
 106                 else if (!strcmp(this,"gid")) {
 107                         if (!value || !*value)
 108                                 return 0;
 109                         *gid = simple_strtoul(value,&value,0);
 110                         if (*value)
 111                                 return 0;
 112                 }
 113                 else if (!strcmp(this,"umask")) {
 114                         if (!value || !*value)
 115                                 return 0;
 116                         *umask = simple_strtoul(value,&value,8);
 117                         if (*value)
 118                                 return 0;
 119                 }
 120                 else if (!strcmp(this,"debug")) {
 121                         if (value) return 0;
 122                         *debug = 1;
 123                 }
 124                 else if (!strcmp(this,"fat")) {
 125                         if (!value || !*value)
 126                                 return 0;
 127                         *fat = simple_strtoul(value,&value,0);
 128                         if (*value || (*fat != 12 && *fat != 16))
 129                                 return 0;
 130                 }
 131                 else if (!strcmp(this,"quiet")) {
 132                         if (value) return 0;
 133                         *quiet = 1;
 134                 }
 135                 else return 0;
 136         }
 137         return 1;
 138 }
 139 
 140 
 141 /* Read the super block of an MS-DOS FS. */
 142 
 143 struct super_block *msdos_read_super(struct super_block *s,void *data,
     /* [previous][next][first][last][top][bottom][index][help] */
 144                                      int silent)
 145 {
 146         struct buffer_head *bh;
 147         struct msdos_boot_sector *b;
 148         int data_sectors,logical_sector_size,sector_mult;
 149         int debug,error,fat,quiet;
 150         char check,conversion;
 151         uid_t uid;
 152         gid_t gid;
 153         int umask;
 154 
 155         if (!parse_options((char *) data,&check,&conversion,&uid,&gid,&umask,
 156             &debug,&fat,&quiet)) {
 157                 s->s_dev = 0;
 158                 return NULL;
 159         }
 160         cache_init();
 161         lock_super(s);
 162         bh = bread(s->s_dev, 0, BLOCK_SIZE);
 163         unlock_super(s);
 164         if (bh == NULL) {
 165                 s->s_dev = 0;
 166                 printk("MSDOS bread failed\n");
 167                 return NULL;
 168         }
 169         b = (struct msdos_boot_sector *) bh->b_data;
 170         s->s_blocksize = 1024;  /* we cannot handle anything else yet */
 171 
 172 /*
 173  * The DOS3 partition size limit is *not* 32M as many people think.  
 174  * Instead, it is 64K sectors (with the usual sector size being
 175  * 512 bytes, leading to a 32M limit).
 176  * 
 177  * DOS 3 partition managers got around this problem by faking a 
 178  * larger sector size, ie treating multiple physical sectors as 
 179  * a single logical sector.
 180  * 
 181  * We can accommodate this scheme by adjusting our cluster size,
 182  * fat_start, and data_start by an appropriate value.
 183  *
 184  * (by Drew Eckhardt)
 185  */
 186 
 187 #define ROUND_TO_MULTIPLE(n,m) ((n) && (m) ? (n)+(m)-1-((n)-1)%(m) : 0)
 188     /* don't divide by zero */
 189 
 190         logical_sector_size = CF_LE_W(*(unsigned short *) &b->sector_size);
 191         sector_mult = logical_sector_size >> SECTOR_BITS;
 192         MSDOS_SB(s)->cluster_size = b->cluster_size*sector_mult;
 193         MSDOS_SB(s)->fats = b->fats;
 194         MSDOS_SB(s)->fat_start = CF_LE_W(b->reserved)*sector_mult;
 195         MSDOS_SB(s)->fat_length = CF_LE_W(b->fat_length)*sector_mult;
 196         MSDOS_SB(s)->dir_start = (CF_LE_W(b->reserved)+b->fats*CF_LE_W(
 197             b->fat_length))*sector_mult;
 198         MSDOS_SB(s)->dir_entries = CF_LE_W(*((unsigned short *) &b->dir_entries
 199             ));
 200         MSDOS_SB(s)->data_start = MSDOS_SB(s)->dir_start+ROUND_TO_MULTIPLE((
 201             MSDOS_SB(s)->dir_entries << MSDOS_DIR_BITS) >> SECTOR_BITS,
 202             sector_mult);
 203         data_sectors = (CF_LE_W(*((unsigned short *) &b->sectors)) ?
 204             CF_LE_W(*((unsigned short *) &b->sectors)) :
 205             CF_LE_L(b->total_sect))*sector_mult-MSDOS_SB(s)->data_start;
 206         error = !b->cluster_size || !sector_mult;
 207         if (!error) {
 208                 MSDOS_SB(s)->clusters = b->cluster_size ? data_sectors/
 209                     b->cluster_size/sector_mult : 0;
 210                 MSDOS_SB(s)->fat_bits = fat ? fat : MSDOS_SB(s)->clusters >
 211                     MSDOS_FAT12 ? 16 : 12;
 212                 error = !MSDOS_SB(s)->fats || (MSDOS_SB(s)->dir_entries &
 213                     (MSDOS_DPS-1)) || MSDOS_SB(s)->clusters+2 > MSDOS_SB(s)->
 214                     fat_length*SECTOR_SIZE*8/MSDOS_SB(s)->fat_bits ||
 215                     (logical_sector_size & (SECTOR_SIZE-1)) || !b->secs_track ||
 216                     !b->heads;
 217         }
 218         brelse(bh);
 219         if (error || debug) {
 220                 printk("[MS-DOS FS Rel. 12,FAT %d,check=%c,conv=%c,"
 221                     "uid=%d,gid=%d,umask=%03o%s]\n",MSDOS_SB(s)->fat_bits,check,
 222                     conversion,uid,gid,umask,MSDOS_CAN_BMAP(MSDOS_SB(s)) ?
 223                     ",bmap" : "");
 224                 printk("[me=0x%x,cs=%d,#f=%d,fs=%d,fl=%d,ds=%d,de=%d,data=%d,"
 225                     "se=%d,ts=%d,ls=%d]\n",b->media,MSDOS_SB(s)->cluster_size,
 226                     MSDOS_SB(s)->fats,MSDOS_SB(s)->fat_start,MSDOS_SB(s)->
 227                     fat_length,MSDOS_SB(s)->dir_start,MSDOS_SB(s)->dir_entries,
 228                     MSDOS_SB(s)->data_start,CF_LE_W(*(unsigned short *) &b->
 229                     sectors),b->total_sect,logical_sector_size);
 230         }
 231         if (error) {
 232                 if (!silent)
 233                         printk("VFS: Can't find a valid MSDOS filesystem on dev 0x%04x.\n",
 234                                    s->s_dev);
 235                 s->s_dev = 0;
 236                 return NULL;
 237         }
 238         s->s_magic = MSDOS_SUPER_MAGIC;
 239         MSDOS_SB(s)->name_check = check;
 240         MSDOS_SB(s)->conversion = conversion;
 241         /* set up enough so that it can read an inode */
 242         s->s_op = &msdos_sops;
 243         MSDOS_SB(s)->fs_uid = uid;
 244         MSDOS_SB(s)->fs_gid = gid;
 245         MSDOS_SB(s)->fs_umask = umask;
 246         MSDOS_SB(s)->quiet = quiet;
 247         MSDOS_SB(s)->free_clusters = -1; /* don't know yet */
 248         MSDOS_SB(s)->fat_wait = NULL;
 249         MSDOS_SB(s)->fat_lock = 0;
 250         MSDOS_SB(s)->prev_free = 0;
 251         if (!(s->s_mounted = iget(s,MSDOS_ROOT_INO))) {
 252                 s->s_dev = 0;
 253                 printk("get root inode failed\n");
 254                 return NULL;
 255         }
 256         return s;
 257 }
 258 
 259 
 260 void msdos_statfs(struct super_block *sb,struct statfs *buf)
     /* [previous][next][first][last][top][bottom][index][help] */
 261 {
 262         int free,this;
 263 
 264         put_fs_long(sb->s_magic,&buf->f_type);
 265         put_fs_long(MSDOS_SB(sb)->cluster_size*SECTOR_SIZE,&buf->f_bsize);
 266         put_fs_long(MSDOS_SB(sb)->clusters,&buf->f_blocks);
 267         lock_fat(sb);
 268         if (MSDOS_SB(sb)->free_clusters != -1)
 269                 free = MSDOS_SB(sb)->free_clusters;
 270         else {
 271                 free = 0;
 272                 for (this = 2; this < MSDOS_SB(sb)->clusters+2; this++)
 273                         if (!fat_access(sb,this,-1)) free++;
 274                 MSDOS_SB(sb)->free_clusters = free;
 275         }
 276         unlock_fat(sb);
 277         put_fs_long(free,&buf->f_bfree);
 278         put_fs_long(free,&buf->f_bavail);
 279         put_fs_long(0,&buf->f_files);
 280         put_fs_long(0,&buf->f_ffree);
 281         put_fs_long(12,&buf->f_namelen);
 282 }
 283 
 284 
 285 int msdos_bmap(struct inode *inode,int block)
     /* [previous][next][first][last][top][bottom][index][help] */
 286 {
 287         struct msdos_sb_info *sb;
 288         int cluster,offset;
 289 
 290         sb = MSDOS_SB(inode->i_sb);
 291         if ((sb->cluster_size & 1) || (sb->data_start & 1)) return 0;
 292         if (inode->i_ino == MSDOS_ROOT_INO) {
 293                 if (sb->dir_start & 1) return 0;
 294                 return (sb->dir_start >> 1)+block;
 295         }
 296         cluster = (block*2)/sb->cluster_size;
 297         offset = (block*2) % sb->cluster_size;
 298         if (!(cluster = get_cluster(inode,cluster))) return 0;
 299         return ((cluster-2)*sb->cluster_size+sb->data_start+offset) >> 1;
 300 }
 301 
 302 
 303 void msdos_read_inode(struct inode *inode)
     /* [previous][next][first][last][top][bottom][index][help] */
 304 {
 305         struct buffer_head *bh;
 306         struct msdos_dir_entry *raw_entry;
 307         int this;
 308 
 309 /* printk("read inode %d\n",inode->i_ino); */
 310         MSDOS_I(inode)->i_busy = 0;
 311         MSDOS_I(inode)->i_depend = MSDOS_I(inode)->i_old = NULL;
 312         MSDOS_I(inode)->i_binary = 1;
 313         inode->i_uid = MSDOS_SB(inode->i_sb)->fs_uid;
 314         inode->i_gid = MSDOS_SB(inode->i_sb)->fs_gid;
 315         if (inode->i_ino == MSDOS_ROOT_INO) {
 316                 inode->i_mode = (0777 & ~MSDOS_SB(inode->i_sb)->fs_umask) |
 317                     S_IFDIR;
 318                 inode->i_op = &msdos_dir_inode_operations;
 319                 inode->i_nlink = msdos_subdirs(inode)+2;
 320                     /* subdirs (neither . nor ..) plus . and "self" */
 321                 inode->i_size = MSDOS_SB(inode->i_sb)->dir_entries*
 322                     sizeof(struct msdos_dir_entry);
 323                 inode->i_blksize = MSDOS_SB(inode->i_sb)->cluster_size*
 324                     SECTOR_SIZE;
 325                 inode->i_blocks = (inode->i_size+inode->i_blksize-1)/
 326                     inode->i_blksize*MSDOS_SB(inode->i_sb)->cluster_size;
 327                 MSDOS_I(inode)->i_start = 0;
 328                 MSDOS_I(inode)->i_attrs = 0;
 329                 inode->i_mtime = inode->i_atime = inode->i_ctime = 0;
 330                 return;
 331         }
 332         if (!(bh = bread(inode->i_dev,inode->i_ino >> MSDOS_DPB_BITS,
 333             BLOCK_SIZE))) {
 334                 printk("dev = 0x%04X, ino = %d\n",inode->i_dev,inode->i_ino);
 335                 panic("msdos_read_inode: unable to read i-node block");
 336         }
 337         raw_entry = &((struct msdos_dir_entry *) (bh->b_data))
 338             [inode->i_ino & (MSDOS_DPB-1)];
 339         if ((raw_entry->attr & ATTR_DIR) && !IS_FREE(raw_entry->name)) {
 340                 inode->i_mode = MSDOS_MKMODE(raw_entry->attr,0777 &
 341                     ~MSDOS_SB(inode->i_sb)->fs_umask) | S_IFDIR;
 342                 inode->i_op = &msdos_dir_inode_operations;
 343                 MSDOS_I(inode)->i_start = CF_LE_W(raw_entry->start);
 344                 inode->i_nlink = msdos_subdirs(inode);
 345                     /* includes .., compensating for "self" */
 346 #ifdef DEBUG
 347                 if (!inode->i_nlink) {
 348                         printk("directory %d: i_nlink == 0\n",inode->i_ino);
 349                         inode->i_nlink = 1;
 350                 }
 351 #endif
 352                 inode->i_size = 0;
 353                 if ((this = CF_LE_W(raw_entry->start)) != 0)
 354                         while (this != -1) {
 355                                 inode->i_size += SECTOR_SIZE*MSDOS_SB(inode->
 356                                     i_sb)->cluster_size;
 357                                 if (!(this = fat_access(inode->i_sb,this,-1)))
 358                                         printk("Directory %d: bad FAT\n",
 359                                             inode->i_ino);
 360                         }
 361         }
 362         else {
 363                 inode->i_mode = MSDOS_MKMODE(raw_entry->attr,(IS_NOEXEC(inode)
 364                     ? 0666 : 0777) & ~MSDOS_SB(inode->i_sb)->fs_umask) |
 365                     S_IFREG;
 366                 inode->i_op = MSDOS_CAN_BMAP(MSDOS_SB(inode->i_sb)) ? 
 367                     &msdos_file_inode_operations :
 368                     &msdos_file_inode_operations_no_bmap;
 369                 MSDOS_I(inode)->i_start = CF_LE_W(raw_entry->start);
 370                 inode->i_nlink = 1;
 371                 inode->i_size = CF_LE_L(raw_entry->size);
 372         }
 373         MSDOS_I(inode)->i_binary = is_binary(MSDOS_SB(inode->i_sb)->conversion,
 374             raw_entry->ext);
 375         MSDOS_I(inode)->i_attrs = raw_entry->attr & ATTR_UNUSED;
 376         /* this is as close to the truth as we can get ... */
 377         inode->i_blksize = MSDOS_SB(inode->i_sb)->cluster_size*SECTOR_SIZE;
 378         inode->i_blocks = (inode->i_size+inode->i_blksize-1)/
 379             inode->i_blksize*MSDOS_SB(inode->i_sb)->cluster_size;
 380         inode->i_mtime = inode->i_atime = inode->i_ctime =
 381             date_dos2unix(CF_LE_W(raw_entry->time),CF_LE_W(raw_entry->date));
 382         brelse(bh);
 383 }
 384 
 385 
 386 void msdos_write_inode(struct inode *inode)
     /* [previous][next][first][last][top][bottom][index][help] */
 387 {
 388         struct buffer_head *bh;
 389         struct msdos_dir_entry *raw_entry;
 390 
 391         inode->i_dirt = 0;
 392         if (inode->i_ino == MSDOS_ROOT_INO || !inode->i_nlink) return;
 393         if (!(bh = bread(inode->i_dev,inode->i_ino >> MSDOS_DPB_BITS,
 394             BLOCK_SIZE))) {
 395                 printk("dev = 0x%04X, ino = %d\n",inode->i_dev,inode->i_ino);
 396                 panic("msdos_write_inode: unable to read i-node block");
 397         }
 398         raw_entry = &((struct msdos_dir_entry *) (bh->b_data))
 399             [inode->i_ino & (MSDOS_DPB-1)];
 400         if (S_ISDIR(inode->i_mode)) {
 401                 raw_entry->attr = ATTR_DIR;
 402                 raw_entry->size = 0;
 403         }
 404         else {
 405                 raw_entry->attr = ATTR_NONE;
 406                 raw_entry->size = CT_LE_L(inode->i_size);
 407         }
 408         raw_entry->attr |= MSDOS_MKATTR(inode->i_mode) |
 409             MSDOS_I(inode)->i_attrs;
 410         raw_entry->start = CT_LE_L(MSDOS_I(inode)->i_start);
 411         date_unix2dos(inode->i_mtime,&raw_entry->time,&raw_entry->date);
 412         raw_entry->time = CT_LE_W(raw_entry->time);
 413         raw_entry->date = CT_LE_W(raw_entry->date);
 414         bh->b_dirt = 1;
 415         brelse(bh);
 416 }
 417 
 418 
 419 int msdos_notify_change(int flags,struct inode *inode)
     /* [previous][next][first][last][top][bottom][index][help] */
 420 {
 421         int error;
 422 
 423         error = 0;
 424         if ((flags & NOTIFY_UIDGID) && (inode->i_uid != MSDOS_SB(inode->i_sb)->
 425             fs_uid || inode->i_gid != MSDOS_SB(inode->i_sb)->fs_gid)) {
 426                 inode->i_uid = MSDOS_SB(inode->i_sb)->fs_uid;
 427                 inode->i_gid = MSDOS_SB(inode->i_sb)->fs_gid;
 428                 error = -EPERM;
 429         }
 430         if (!(flags & NOTIFY_MODE))
 431                 return MSDOS_SB(inode->i_sb)->quiet ? 0 : error;
 432         if (inode->i_mode & ~MSDOS_VALID_MODE) {
 433                 inode->i_mode &= MSDOS_VALID_MODE;
 434                 error = -EPERM;
 435         }
 436         if (IS_NOEXEC(inode) && !S_ISDIR(inode->i_mode))
 437                 inode->i_mode &= S_IFMT | 0666;
 438         else inode->i_mode |= 0111;
 439         inode->i_mode = ((inode->i_mode & S_IFMT) | ((((inode->i_mode & S_IRWXU
 440             & ~MSDOS_SB(inode->i_sb)->fs_umask) | S_IRUSR) >> 6)*0111)) &
 441             ~MSDOS_SB(inode->i_sb)->fs_umask;
 442         return MSDOS_SB(inode->i_sb)->quiet ? 0 : error;
 443 }

/* [previous][next][first][last][top][bottom][index][help] */