fs/fat/inode.c

   1 /*
   2  *  linux/fs/fat/inode.c
   3  *
   4  *  Written 1992,1993 by Werner Almesberger
   5  *  VFAT extensions by Gordon Chaffee, merged with msdos fs by Henrik Storner
   6  *
   7  *  Fixes:
   8  *
   9  *      Max Cohan: Fixed invalid FSINFO offset when info_sector is 0
  10  */
  11
  12 #include <linux/version.h>
  13 #define __NO_VERSION__
  14 #include <linux/module.h>
  15
  16 #include <linux/msdos_fs.h>
  17 #include <linux/nls.h>
  18 #include <linux/kernel.h>
  19 #include <linux/sched.h>
  20 #include <linux/errno.h>
  21 #include <linux/string.h>
  22 #include <linux/major.h>
  23 #include <linux/blkdev.h>
  24 #include <linux/fs.h>
  25 #include <linux/stat.h>
  26 #include <linux/locks.h>
  27 #include <linux/fat_cvf.h>
  28 #include <linux/malloc.h>
  29
  30 #include "msbuffer.h"
  31
  32 #include <asm/uaccess.h>
  33 #include <asm/unaligned.h>
  34
  35 /* #define FAT_PARANOIA 1 */
  36 #define DEBUG_LEVEL 0
  37 #ifdef FAT_DEBUG
  38 #  define PRINTK(x) printk x
  39 #else
  40 #  define PRINTK(x)
  41 #endif
  42 #if (DEBUG_LEVEL >= 1)
  43 #  define PRINTK1(x) printk x
  44 #else
  45 #  define PRINTK1(x)
  46 #endif
  47
  48 void fat_put_inode(struct inode *inode)
  49 {
  50         /*
  51          * Check whether we're a dependent of other inodes ...
  52          */
  53         if (inode->i_count <= 1) {
  54 #ifdef FAT_PARANOIA
  55 printk("fat_put_inode: last use for (%p,%ld), i_count=%d\n",
  56 inode, inode->i_ino, inode->i_count);
  57 #endif
  58                 if (inode->i_nlink) {
  59                         if (MSDOS_I(inode)->i_busy)
  60                                 fat_cache_inval_inode(inode);
  61                 }
  62         }
  63 }
  64
  65 void fat_delete_inode(struct inode *inode)
  66 {
  67         /*
  68          * Make sure there are no active dependencies ...
  69          */
  70         fat_cache_inval_inode(inode);
  71         inode->i_size = 0;
  72         fat_truncate(inode);
  73         clear_inode(inode);
  74 }
  75
  76
  77 void fat_put_super(struct super_block *sb)
  78 {
  79         if (MSDOS_SB(sb)->cvf_format) {
  80                 dec_cvf_format_use_count_by_version(MSDOS_SB(sb)->cvf_format->cvf_version);
  81                 MSDOS_SB(sb)->cvf_format->unmount_cvf(sb);
  82         }
  83         if (MSDOS_SB(sb)->fat_bits == 32) {
  84                 fat_clusters_flush(sb);
  85         }
  86         fat_cache_inval_dev(sb->s_dev);
  87         set_blocksize (sb->s_dev,BLOCK_SIZE);
  88         if (MSDOS_SB(sb)->nls_disk) {
  89                 unload_nls(MSDOS_SB(sb)->nls_disk);
  90                 MSDOS_SB(sb)->nls_disk = NULL;
  91                 MSDOS_SB(sb)->options.codepage = 0;
  92         }
  93         if (MSDOS_SB(sb)->nls_io) {
  94                 unload_nls(MSDOS_SB(sb)->nls_io);
  95                 MSDOS_SB(sb)->nls_io = NULL;
  96         }
  97         /*
  98          * Note: the iocharset option might have been specified
  99          * without enabling nls_io, so check for it here.
 100          */
 101         if (MSDOS_SB(sb)->options.iocharset) {
 102                 kfree(MSDOS_SB(sb)->options.iocharset);
 103                 MSDOS_SB(sb)->options.iocharset = NULL;
 104         }
 105
 106         MOD_DEC_USE_COUNT;
 107         return;
 108 }
 109
 110
 111 static int parse_options(char *options,int *fat, int *blksize, int *debug,
 112                          struct fat_mount_options *opts,
 113                          char *cvf_format, char *cvf_options)
 114 {
 115         char *this_char,*value,save,*savep;
 116         char *p;
 117         int ret = 1, len;
 118
 119         opts->name_check = 'n';
 120         opts->conversion = 'b';
 121         opts->fs_uid = current->uid;
 122         opts->fs_gid = current->gid;
 123         opts->fs_umask = current->fs->umask;
 124         opts->quiet = opts->sys_immutable = opts->dotsOK = opts->showexec = 0;
 125         opts->codepage = 0;
 126         opts->utf8 = 0;
 127         opts->iocharset = NULL;
 128         *debug = *fat = 0;
 129
 130         if (!options)
 131                 goto out;
 132         save = 0;
 133         savep = NULL;
 134         for (this_char = strtok(options,","); this_char;
 135              this_char = strtok(NULL,",")) {
 136                 if ((value = strchr(this_char,'=')) != NULL) {
 137                         save = *value;
 138                         savep = value;
 139                         *value++ = 0;
 140                 }
 141                 if (!strcmp(this_char,"check") && value) {
 142                         if (value[0] && !value[1] && strchr("rns",*value))
 143                                 opts->name_check = *value;
 144                         else if (!strcmp(value,"relaxed"))
 145                                 opts->name_check = 'r';
 146                         else if (!strcmp(value,"normal"))
 147                                 opts->name_check = 'n';
 148                         else if (!strcmp(value,"strict"))
 149                                 opts->name_check = 's';
 150                         else ret = 0;
 151                 }
 152                 else if (!strcmp(this_char,"conv") && value) {
 153                         if (value[0] && !value[1] && strchr("bta",*value))
 154                                 opts->conversion = *value;
 155                         else if (!strcmp(value,"binary"))
 156                                 opts->conversion = 'b';
 157                         else if (!strcmp(value,"text"))
 158                                 opts->conversion = 't';
 159                         else if (!strcmp(value,"auto"))
 160                                 opts->conversion = 'a';
 161                         else ret = 0;
 162                 }
 163                 else if (!strcmp(this_char,"dots")) {
 164                         opts->dotsOK = 1;
 165                 }
 166                 else if (!strcmp(this_char,"nodots")) {
 167                         opts->dotsOK = 0;
 168                 }
 169                 else if (!strcmp(this_char,"showexec")) {
 170                         opts->showexec = 1;
 171                 }
 172                 else if (!strcmp(this_char,"dotsOK") && value) {
 173                         if (!strcmp(value,"yes")) opts->dotsOK = 1;
 174                         else if (!strcmp(value,"no")) opts->dotsOK = 0;
 175                         else ret = 0;
 176                 }
 177                 else if (!strcmp(this_char,"uid")) {
 178                         if (!value || !*value) ret = 0;
 179                         else {
 180                                 opts->fs_uid = simple_strtoul(value,&value,0);
 181                                 if (*value) ret = 0;
 182                         }
 183                 }
 184                 else if (!strcmp(this_char,"gid")) {
 185                         if (!value || !*value) ret= 0;
 186                         else {
 187                                 opts->fs_gid = simple_strtoul(value,&value,0);
 188                                 if (*value) ret = 0;
 189                         }
 190                 }
 191                 else if (!strcmp(this_char,"umask")) {
 192                         if (!value || !*value) ret = 0;
 193                         else {
 194                                 opts->fs_umask = simple_strtoul(value,&value,8);
 195                                 if (*value) ret = 0;
 196                         }
 197                 }
 198                 else if (!strcmp(this_char,"debug")) {
 199                         if (value) ret = 0;
 200                         else *debug = 1;
 201                 }
 202                 else if (!strcmp(this_char,"fat")) {
 203                         if (!value || !*value) ret = 0;
 204                         else {
 205                                 *fat = simple_strtoul(value,&value,0);
 206                                 if (*value || (*fat != 12 && *fat != 16 &&
 207                                                *fat != 32))
 208                                         ret = 0;
 209                         }
 210                 }
 211                 else if (!strcmp(this_char,"quiet")) {
 212                         if (value) ret = 0;
 213                         else opts->quiet = 1;
 214                 }
 215                 else if (!strcmp(this_char,"blocksize")) {
 216                         if (*value) ret = 0;
 217                         else if (*blksize != 512  &&
 218                                  *blksize != 1024 &&
 219                                  *blksize != 2048) {
 220                                 printk ("MSDOS FS: Invalid blocksize "
 221                                         "(512, 1024, or 2048)\n");
 222                         }
 223                 }
 224                 else if (!strcmp(this_char,"sys_immutable")) {
 225                         if (value) ret = 0;
 226                         else opts->sys_immutable = 1;
 227                 }
 228                 else if (!strcmp(this_char,"codepage") && value) {
 229                         opts->codepage = simple_strtoul(value,&value,0);
 230                         if (*value) ret = 0;
 231                         else printk ("MSDOS FS: Using codepage %d\n",
 232                                         opts->codepage);
 233                 }
 234                 else if (!strcmp(this_char,"iocharset") && value) {
 235                         p = value;
 236                         while (*value && *value != ',') value++;
 237                         len = value - p;
 238                         if (len) {
 239                                 char * buffer = kmalloc(len+1, GFP_KERNEL);
 240                                 if (buffer) {
 241                                         opts->iocharset = buffer;
 242                                         memcpy(buffer, p, len);
 243                                         buffer[len] = 0;
 244                                         printk("MSDOS FS: IO charset %s\n",
 245                                                 buffer);
 246                                 } else
 247                                         ret = 0;
 248                         }
 249                 }
 250                 else if (!strcmp(this_char,"cvf_format")) {
 251                         if (!value)
 252                                 return 0;
 253                         strncpy(cvf_format,value,20);
 254                 }
 255                 else if (!strcmp(this_char,"cvf_options")) {
 256                         if (!value)
 257                                 return 0;
 258                         strncpy(cvf_options,value,100);
 259                 }
 260
 261                 if (this_char != options) *(this_char-1) = ',';
 262                 if (value) *savep = save;
 263                 if (ret == 0)
 264                         break;
 265         }
 266 out:
 267         return ret;
 268 }
 269
 270 /*
 271  * Read the super block of an MS-DOS FS.
 272  *
 273  * Note that this may be called from vfat_read_super
 274  * with some fields already initialized.
 275  */
 276 struct super_block *
 277 fat_read_super(struct super_block *sb, void *data, int silent)
 278 {
 279         struct inode *root_inode;
 280         struct buffer_head *bh;
 281         struct fat_boot_sector *b;
 282         char *p;
 283         int data_sectors,logical_sector_size,sector_mult,fat_clusters=0;
 284         int debug,error,fat,cp;
 285         int blksize = 512;
 286         int fat32;
 287         struct fat_mount_options opts;
 288         char buf[50];
 289         int i;
 290         char cvf_format[21];
 291         char cvf_options[101];
 292
 293         cvf_format[0] = '\0';
 294         cvf_options[0] = '\0';
 295         MSDOS_SB(sb)->cvf_format = NULL;
 296         MSDOS_SB(sb)->private_data = NULL;
 297
 298         MOD_INC_USE_COUNT;
 299         if (hardsect_size[MAJOR(sb->s_dev)] != NULL){
 300                 blksize = hardsect_size[MAJOR(sb->s_dev)][MINOR(sb->s_dev)];
 301                 if (blksize != 512){
 302                         printk ("MSDOS: Hardware sector size is %d\n",blksize);
 303                 }
 304
 305         }
 306
 307         opts.isvfat = MSDOS_SB(sb)->options.isvfat;
 308         if (!parse_options((char *) data, &fat, &blksize, &debug, &opts,
 309                            cvf_format, cvf_options)
 310             || (blksize != 512 && blksize != 1024 && blksize != 2048))
 311                 goto out_fail;
 312         /* N.B. we should parse directly into the sb structure */
 313         memcpy(&(MSDOS_SB(sb)->options), &opts, sizeof(struct fat_mount_options));
 314
 315         fat_cache_init();
 316         lock_super(sb);
 317         if( blksize > 1024 )
 318           {
 319             /* Force the superblock to a larger size here. */
 320             sb->s_blocksize = blksize;
 321             set_blocksize(sb->s_dev, blksize);
 322           }
 323         else
 324           {
 325             /* The first read is always 1024 bytes */
 326             sb->s_blocksize = 1024;
 327             set_blocksize(sb->s_dev, 1024);
 328           }
 329         bh = fat_bread(sb, 0);
 330         unlock_super(sb);
 331         if (bh == NULL || !fat_is_uptodate(sb,bh)) {
 332                 fat_brelse (sb, bh);
 333                 goto out_no_bread;
 334         }
 335
 336 /*
 337  * The DOS3 partition size limit is *not* 32M as many people think.
 338  * Instead, it is 64K sectors (with the usual sector size being
 339  * 512 bytes, leading to a 32M limit).
 340  *
 341  * DOS 3 partition managers got around this problem by faking a
 342  * larger sector size, ie treating multiple physical sectors as
 343  * a single logical sector.
 344  *
 345  * We can accommodate this scheme by adjusting our cluster size,
 346  * fat_start, and data_start by an appropriate value.
 347  *
 348  * (by Drew Eckhardt)
 349  */
 350
 351 #define ROUND_TO_MULTIPLE(n,m) ((n) && (m) ? (n)+(m)-1-((n)-1)%(m) : 0)
 352     /* don't divide by zero */
 353
 354         b = (struct fat_boot_sector *) bh->b_data;
 355         logical_sector_size =
 356                 CF_LE_W(get_unaligned((unsigned short *) &b->sector_size));
 357         sector_mult = logical_sector_size >> SECTOR_BITS;
 358         MSDOS_SB(sb)->cluster_size = b->cluster_size*sector_mult;
 359         MSDOS_SB(sb)->fats = b->fats;
 360         MSDOS_SB(sb)->fat_start = CF_LE_W(b->reserved)*sector_mult;
 361         if (!b->fat_length && b->fat32_length) {
 362                 struct fat_boot_fsinfo *fsinfo;
 363
 364                 /* Must be FAT32 */
 365                 fat32 = 1;
 366                 MSDOS_SB(sb)->fat_length= CF_LE_W(b->fat32_length)*sector_mult;
 367                 MSDOS_SB(sb)->root_cluster = CF_LE_L(b->root_cluster);
 368
 369                 /* MC - if info_sector is 0, don't multiply by 0 */
 370                 if(CF_LE_W(b->info_sector) == 0) {
 371                         MSDOS_SB(sb)->fsinfo_offset =
 372                                 logical_sector_size + 0x1e0;
 373                 } else {
 374                         MSDOS_SB(sb)->fsinfo_offset =
 375                                 (CF_LE_W(b->info_sector) * logical_sector_size)
 376                                 + 0x1e0;
 377                 }
 378                 if (MSDOS_SB(sb)->fsinfo_offset + sizeof(struct fat_boot_fsinfo) > sb->s_blocksize) {
 379                         printk("fat_read_super: Bad fsinfo_offset\n");
 380                         fat_brelse(sb, bh);
 381                         goto out_invalid;
 382                 }
 383                 fsinfo = (struct fat_boot_fsinfo *)
 384                         &bh->b_data[MSDOS_SB(sb)->fsinfo_offset];
 385                 if (CF_LE_L(fsinfo->signature) != 0x61417272) {
 386                         printk("fat_read_super: Did not find valid FSINFO "
 387                                 "signature. Found 0x%x\n",
 388                                 CF_LE_L(fsinfo->signature));
 389                 } else {
 390                         MSDOS_SB(sb)->free_clusters = CF_LE_L(fsinfo->free_clusters);
 391                 }
 392         } else {
 393                 fat32 = 0;
 394                 MSDOS_SB(sb)->fat_length = CF_LE_W(b->fat_length)*sector_mult;
 395                 MSDOS_SB(sb)->root_cluster = 0;
 396                 MSDOS_SB(sb)->free_clusters = -1; /* Don't know yet */
 397         }
 398         MSDOS_SB(sb)->dir_start= CF_LE_W(b->reserved)*sector_mult+
 399             b->fats*MSDOS_SB(sb)->fat_length;
 400         MSDOS_SB(sb)->dir_entries =
 401                 CF_LE_W(get_unaligned((unsigned short *) &b->dir_entries));
 402         MSDOS_SB(sb)->data_start = MSDOS_SB(sb)->dir_start+ROUND_TO_MULTIPLE((
 403             MSDOS_SB(sb)->dir_entries << MSDOS_DIR_BITS) >> SECTOR_BITS,
 404             sector_mult);
 405         data_sectors = CF_LE_W(get_unaligned((unsigned short *) &b->sectors));
 406         if (!data_sectors) {
 407                 data_sectors = CF_LE_L(b->total_sect);
 408         }
 409         data_sectors = data_sectors * sector_mult - MSDOS_SB(sb)->data_start;
 410         error = !b->cluster_size || !sector_mult;
 411         if (!error) {
 412                 MSDOS_SB(sb)->clusters = b->cluster_size ? data_sectors/
 413                     b->cluster_size/sector_mult : 0;
 414                 MSDOS_SB(sb)->fat_bits = fat32 ? 32 :
 415                         (fat ? fat :
 416                          (MSDOS_SB(sb)->clusters > MSDOS_FAT12 ? 16 : 12));
 417                 fat_clusters = MSDOS_SB(sb)->fat_length*SECTOR_SIZE*8/
 418                     MSDOS_SB(sb)->fat_bits;
 419                 error = !MSDOS_SB(sb)->fats || (MSDOS_SB(sb)->dir_entries &
 420                     (MSDOS_DPS-1)) || MSDOS_SB(sb)->clusters+2 > fat_clusters+
 421                     MSDOS_MAX_EXTRA || (logical_sector_size & (SECTOR_SIZE-1))
 422                     || !b->secs_track || !b->heads;
 423         }
 424         fat_brelse(sb, bh);
 425         set_blocksize(sb->s_dev, blksize);
 426         /*
 427                 This must be done after the brelse because the bh is a dummy
 428                 allocated by fat_bread (see buffer.c)
 429         */
 430         sb->s_blocksize = blksize;    /* Using this small block size solves */
 431                                 /* the misfit with buffer cache and cluster */
 432                                 /* because clusters (DOS) are often aligned */
 433                                 /* on odd sectors. */
 434         sb->s_blocksize_bits = blksize == 512 ? 9 : (blksize == 1024 ? 10 : 11);
 435         if (!strcmp(cvf_format,"none"))
 436                 i = -1;
 437         else
 438                 i = detect_cvf(sb,cvf_format);
 439         if (i >= 0)
 440                 error = cvf_formats[i]->mount_cvf(sb,cvf_options);
 441         if (error || debug) {
 442                 /* The MSDOS_CAN_BMAP is obsolete, but left just to remember */
 443                 printk("[MS-DOS FS Rel. 12,FAT %d,check=%c,conv=%c,"
 444                        "uid=%d,gid=%d,umask=%03o%s]\n",
 445                        MSDOS_SB(sb)->fat_bits,opts.name_check,
 446                        opts.conversion,opts.fs_uid,opts.fs_gid,opts.fs_umask,
 447                        MSDOS_CAN_BMAP(MSDOS_SB(sb)) ? ",bmap" : "");
 448                 printk("[me=0x%x,cs=%d,#f=%d,fs=%d,fl=%ld,ds=%ld,de=%d,data=%ld,"
 449                        "se=%d,ts=%ld,ls=%d,rc=%ld,fc=%u]\n",
 450                         b->media,MSDOS_SB(sb)->cluster_size,
 451                         MSDOS_SB(sb)->fats,MSDOS_SB(sb)->fat_start,
 452                         MSDOS_SB(sb)->fat_length,
 453                        MSDOS_SB(sb)->dir_start,MSDOS_SB(sb)->dir_entries,
 454                        MSDOS_SB(sb)->data_start,
 455                        CF_LE_W(*(unsigned short *) &b->sectors),
 456                        (unsigned long)b->total_sect,logical_sector_size,
 457                        MSDOS_SB(sb)->root_cluster,MSDOS_SB(sb)->free_clusters);
 458                 printk ("Transaction block size = %d\n",blksize);
 459         }
 460         if (i<0) if (MSDOS_SB(sb)->clusters+2 > fat_clusters)
 461                 MSDOS_SB(sb)->clusters = fat_clusters-2;
 462         if (error)
 463                 goto out_invalid;
 464
 465         sb->s_magic = MSDOS_SUPER_MAGIC;
 466         /* set up enough so that it can read an inode */
 467         MSDOS_SB(sb)->fat_wait = NULL;
 468         MSDOS_SB(sb)->fat_lock = 0;
 469         MSDOS_SB(sb)->prev_free = 0;
 470
 471         cp = opts.codepage ? opts.codepage : 437;
 472         sprintf(buf, "cp%d", cp);
 473         MSDOS_SB(sb)->nls_disk = load_nls(buf);
 474         if (! MSDOS_SB(sb)->nls_disk) {
 475                 /* Fail only if explicit charset specified */
 476                 if (opts.codepage != 0)
 477                         goto out_fail;
 478                 MSDOS_SB(sb)->options.codepage = 0; /* already 0?? */
 479                 MSDOS_SB(sb)->nls_disk = load_nls_default();
 480         }
 481
 482         MSDOS_SB(sb)->nls_io = NULL;
 483         if (MSDOS_SB(sb)->options.isvfat && !opts.utf8) {
 484                 p = opts.iocharset ? opts.iocharset : "iso8859-1";
 485                 MSDOS_SB(sb)->nls_io = load_nls(p);
 486                 if (! MSDOS_SB(sb)->nls_io) {
 487                         /* Fail only if explicit charset specified */
 488                         if (opts.iocharset)
 489                                 goto out_unload_nls;
 490                         MSDOS_SB(sb)->nls_io = load_nls_default();
 491                 }
 492         }
 493
 494         root_inode = iget(sb, MSDOS_ROOT_INO);
 495         if (!root_inode)
 496                 goto out_no_root;
 497         sb->s_root = d_alloc_root(root_inode, NULL);
 498         if (!sb->s_root)
 499                 goto out_no_root;
 500         if(i>=0) {
 501                 MSDOS_SB(sb)->cvf_format = cvf_formats[i];
 502                 ++cvf_format_use_count[i];
 503         }
 504         return sb;
 505
 506 out_no_root:
 507         printk("get root inode failed\n");
 508         iput(root_inode);
 509         if (MSDOS_SB(sb)->nls_io)
 510                 unload_nls(MSDOS_SB(sb)->nls_io);
 511 out_unload_nls:
 512         unload_nls(MSDOS_SB(sb)->nls_disk);
 513         goto out_fail;
 514 out_invalid:
 515         if (!silent)
 516                 printk("VFS: Can't find a valid MSDOS filesystem on dev %s.\n",
 517                         kdevname(sb->s_dev));
 518         goto out_fail;
 519 out_no_bread:
 520         printk("FAT bread failed\n");
 521 out_fail:
 522         if (opts.iocharset) {
 523                 printk("VFS: freeing iocharset=%s\n", opts.iocharset);
 524                 kfree(opts.iocharset);
 525         }
 526         sb->s_dev = 0;
 527         if(MSDOS_SB(sb)->private_data)kfree(MSDOS_SB(sb)->private_data);
 528         MSDOS_SB(sb)->private_data=NULL;
 529
 530         MOD_DEC_USE_COUNT;
 531         return NULL;
 532 }
 533
 534 int fat_statfs(struct super_block *sb,struct statfs *buf, int bufsiz)
 535 {
 536         int free,nr;
 537         struct statfs tmp;
 538
 539         if (MSDOS_SB(sb)->cvf_format &&
 540             MSDOS_SB(sb)->cvf_format->cvf_statfs)
 541                 return MSDOS_SB(sb)->cvf_format->cvf_statfs(sb,buf,bufsiz);
 542
 543         lock_fat(sb);
 544         if (MSDOS_SB(sb)->free_clusters != -1)
 545                 free = MSDOS_SB(sb)->free_clusters;
 546         else {
 547                 free = 0;
 548                 for (nr = 2; nr < MSDOS_SB(sb)->clusters+2; nr++)
 549                         if (!fat_access(sb,nr,-1)) free++;
 550                 MSDOS_SB(sb)->free_clusters = free;
 551         }
 552         unlock_fat(sb);
 553         tmp.f_type = sb->s_magic;
 554         tmp.f_bsize = MSDOS_SB(sb)->cluster_size*SECTOR_SIZE;
 555         tmp.f_blocks = MSDOS_SB(sb)->clusters;
 556         tmp.f_bfree = free;
 557         tmp.f_bavail = free;
 558         tmp.f_files = 0;
 559         tmp.f_ffree = 0;
 560         tmp.f_namelen = MSDOS_SB(sb)->options.isvfat ? 260 : 12;
 561         return copy_to_user(buf, &tmp, bufsiz) ? -EFAULT : 0;
 562 }
 563
 564
 565 int fat_bmap(struct inode *inode,int block)
 566 {
 567         struct msdos_sb_info *sb;
 568         int cluster,offset;
 569
 570         sb = MSDOS_SB(inode->i_sb);
 571         if (sb->cvf_format &&
 572             sb->cvf_format->cvf_bmap)
 573                 return sb->cvf_format->cvf_bmap(inode,block);
 574         if ((inode->i_ino == MSDOS_ROOT_INO) && (sb->fat_bits != 32)) {
 575                 return sb->dir_start + block;
 576         }
 577         cluster = block/sb->cluster_size;
 578         offset = block % sb->cluster_size;
 579         if (!(cluster = fat_get_cluster(inode,cluster))) return 0;
 580         return (cluster-2)*sb->cluster_size+sb->data_start+offset;
 581 }
 582
 583 static int is_exec(char *extension)
 584 {
 585         char *exe_extensions = "EXECOMBAT", *walk;
 586
 587         for (walk = exe_extensions; *walk; walk += 3)
 588                 if (!strncmp(extension, walk, 3))
 589                         return 1;
 590         return 0;
 591 }
 592
 593 void fat_read_inode(struct inode *inode, struct inode_operations *fs_dir_inode_ops)
 594 {
 595         struct super_block *sb = inode->i_sb;
 596         struct buffer_head *bh;
 597         struct msdos_dir_entry *raw_entry;
 598         int nr;
 599
 600         PRINTK1(("fat_read_inode: inode=%p, ino=%ld, sb->dir_start=0x%x\n",
 601                  inode, inode->i_ino, MSDOS_SB(sb)->dir_start));
 602         MSDOS_I(inode)->i_busy = 0;
 603         MSDOS_I(inode)->i_binary = 1;
 604         inode->i_uid = MSDOS_SB(sb)->options.fs_uid;
 605         inode->i_gid = MSDOS_SB(sb)->options.fs_gid;
 606         inode->i_version = ++event;
 607         if (inode->i_ino == MSDOS_ROOT_INO) {
 608                 inode->i_mode = (S_IRWXUGO & ~MSDOS_SB(sb)->options.fs_umask) |
 609                     S_IFDIR;
 610                 inode->i_op = fs_dir_inode_ops;
 611                 if (MSDOS_SB(sb)->fat_bits == 32) {
 612                         MSDOS_I(inode)->i_start = MSDOS_SB(sb)->root_cluster;
 613                         if ((nr = MSDOS_I(inode)->i_start) != 0) {
 614                                 while (nr != -1) {
 615                                         inode->i_size += SECTOR_SIZE*MSDOS_SB(sb)->cluster_size;
 616                                         if (!(nr = fat_access(sb,nr,-1))) {
 617                                                 printk("Directory %ld: bad FAT\n",
 618                                                        inode->i_ino);
 619                                                 break;
 620                                         }
 621                                 }
 622                         }
 623                 } else {
 624                         MSDOS_I(inode)->i_start = 0;
 625                         inode->i_size = MSDOS_SB(sb)->dir_entries*
 626                                 sizeof(struct msdos_dir_entry);
 627                 }
 628                 inode->i_blksize = MSDOS_SB(sb)->cluster_size*
 629                     SECTOR_SIZE;
 630                 inode->i_blocks = (inode->i_size+inode->i_blksize-1)/
 631                     inode->i_blksize*MSDOS_SB(sb)->cluster_size;
 632                 MSDOS_I(inode)->i_logstart = 0;
 633
 634                 MSDOS_I(inode)->i_attrs = 0;
 635                 inode->i_mtime = inode->i_atime = inode->i_ctime = 0;
 636                 MSDOS_I(inode)->i_ctime_ms = 0;
 637                 inode->i_nlink = fat_subdirs(inode)+2;
 638                     /* subdirs (neither . nor ..) plus . and "self" */
 639                 return;
 640         }
 641         if (!(bh = fat_bread(sb, inode->i_ino >> MSDOS_DPB_BITS))) {
 642                 printk("dev = %s, ino = %ld\n",
 643                        kdevname(inode->i_dev), inode->i_ino);
 644                 fat_fs_panic(sb, "fat_read_inode: unable to read i-node block");
 645                 return;
 646         }
 647         raw_entry = &((struct msdos_dir_entry *) (bh->b_data))
 648             [inode->i_ino & (MSDOS_DPB-1)];
 649         if ((raw_entry->attr & ATTR_DIR) && !IS_FREE(raw_entry->name)) {
 650                 inode->i_mode = MSDOS_MKMODE(raw_entry->attr,S_IRWXUGO &
 651                     ~MSDOS_SB(sb)->options.fs_umask) | S_IFDIR;
 652                 inode->i_op = fs_dir_inode_ops;
 653
 654                 MSDOS_I(inode)->i_start = CF_LE_W(raw_entry->start);
 655                 if (MSDOS_SB(sb)->fat_bits == 32) {
 656                         MSDOS_I(inode)->i_start |=
 657                                 (CF_LE_W(raw_entry->starthi) << 16);
 658                 }
 659                 MSDOS_I(inode)->i_logstart = MSDOS_I(inode)->i_start;
 660                 inode->i_nlink = fat_subdirs(inode);
 661                     /* includes .., compensating for "self" */
 662 #ifdef DEBUG
 663                 if (!inode->i_nlink) {
 664                         printk("directory %d: i_nlink == 0\n",inode->i_ino);
 665                         inode->i_nlink = 1;
 666                 }
 667 #endif
 668                 inode->i_size = 0;
 669                 if ((nr = MSDOS_I(inode)->i_start) != 0)
 670                         while (nr != -1) {
 671                                 inode->i_size += SECTOR_SIZE*MSDOS_SB(inode->
 672                                     i_sb)->cluster_size;
 673                                 if (!(nr = fat_access(sb,nr,-1))) {
 674                                         printk("Directory %ld: bad FAT\n",
 675                                             inode->i_ino);
 676                                         break;
 677                                 }
 678                         }
 679         } else { /* not a directory */
 680                 inode->i_mode = MSDOS_MKMODE(raw_entry->attr,
 681                     ((IS_NOEXEC(inode) ||
 682                       (MSDOS_SB(sb)->options.showexec &&
 683                        !is_exec(raw_entry->ext)))
 684                         ? S_IRUGO|S_IWUGO : S_IRWXUGO)
 685                     & ~MSDOS_SB(sb)->options.fs_umask) | S_IFREG;
 686                 if (MSDOS_SB(sb)->cvf_format)
 687                         inode->i_op = (MSDOS_SB(sb)->cvf_format->flags & CVF_USE_READPAGE)
 688                                 ? &fat_file_inode_operations_readpage
 689                                 : &fat_file_inode_operations_1024;
 690                 else
 691                   inode->i_op = (sb->s_blocksize == 1024 || sb->s_blocksize == 2048)
 692                         ? &fat_file_inode_operations_1024
 693                         : &fat_file_inode_operations;
 694                 MSDOS_I(inode)->i_start = CF_LE_W(raw_entry->start);
 695                 if (MSDOS_SB(sb)->fat_bits == 32) {
 696                         MSDOS_I(inode)->i_start |=
 697                                 (CF_LE_W(raw_entry->starthi) << 16);
 698                 }
 699                 MSDOS_I(inode)->i_logstart = MSDOS_I(inode)->i_start;
 700                 inode->i_nlink = 1;
 701                 inode->i_size = CF_LE_L(raw_entry->size);
 702         }
 703         if(raw_entry->attr & ATTR_SYS)
 704                 if (MSDOS_SB(sb)->options.sys_immutable)
 705                         inode->i_flags |= S_IMMUTABLE;
 706         MSDOS_I(inode)->i_binary =
 707             fat_is_binary(MSDOS_SB(sb)->options.conversion, raw_entry->ext);
 708         MSDOS_I(inode)->i_attrs = raw_entry->attr & ATTR_UNUSED;
 709         /* this is as close to the truth as we can get ... */
 710         inode->i_blksize = MSDOS_SB(sb)->cluster_size*SECTOR_SIZE;
 711         inode->i_blocks = (inode->i_size+inode->i_blksize-1)/
 712             inode->i_blksize*MSDOS_SB(sb)->cluster_size;
 713         inode->i_mtime = inode->i_atime =
 714             date_dos2unix(CF_LE_W(raw_entry->time),CF_LE_W(raw_entry->date));
 715         inode->i_ctime =
 716                 MSDOS_SB(sb)->options.isvfat
 717                 ? date_dos2unix(CF_LE_W(raw_entry->ctime),CF_LE_W(raw_entry->cdate))
 718                 : inode->i_mtime;
 719         MSDOS_I(inode)->i_ctime_ms = raw_entry->ctime_ms;
 720         fat_brelse(sb, bh);
 721 }
 722
 723
 724 void fat_write_inode(struct inode *inode)
 725 {
 726         struct super_block *sb = inode->i_sb;
 727         struct buffer_head *bh;
 728         struct msdos_dir_entry *raw_entry;
 729
 730         if (inode->i_ino == MSDOS_ROOT_INO || !inode->i_nlink) return;
 731         if (!(bh = fat_bread(sb, inode->i_ino >> MSDOS_DPB_BITS))) {
 732                 printk("dev = %s, ino = %ld\n",
 733                        kdevname(inode->i_dev), inode->i_ino);
 734                 fat_fs_panic(sb, "msdos_write_inode: unable to read i-node block");
 735                 return;
 736         }
 737         raw_entry = &((struct msdos_dir_entry *) (bh->b_data))
 738             [inode->i_ino & (MSDOS_DPB-1)];
 739         if (S_ISDIR(inode->i_mode)) {
 740                 raw_entry->attr = ATTR_DIR;
 741                 raw_entry->size = 0;
 742         }
 743         else {
 744                 raw_entry->attr = ATTR_NONE;
 745                 raw_entry->size = CT_LE_L(inode->i_size);
 746         }
 747         raw_entry->attr |= MSDOS_MKATTR(inode->i_mode) |
 748             MSDOS_I(inode)->i_attrs;
 749         raw_entry->start = CT_LE_W(MSDOS_I(inode)->i_logstart);
 750         raw_entry->starthi = CT_LE_W(MSDOS_I(inode)->i_logstart >> 16);
 751         fat_date_unix2dos(inode->i_mtime,&raw_entry->time,&raw_entry->date);
 752         raw_entry->time = CT_LE_W(raw_entry->time);
 753         raw_entry->date = CT_LE_W(raw_entry->date);
 754         if (MSDOS_SB(sb)->options.isvfat) {
 755                 fat_date_unix2dos(inode->i_ctime,&raw_entry->ctime,&raw_entry->cdate);
 756                 raw_entry->ctime_ms = MSDOS_I(inode)->i_ctime_ms;
 757                 raw_entry->ctime = CT_LE_W(raw_entry->ctime);
 758                 raw_entry->cdate = CT_LE_W(raw_entry->cdate);
 759         }
 760         fat_mark_buffer_dirty(sb, bh, 1);
 761         fat_brelse(sb, bh);
 762 }
 763
 764
 765 int fat_notify_change(struct dentry * dentry, struct iattr * attr)
 766 {
 767         struct super_block *sb = dentry->d_sb;
 768         struct inode *inode = dentry->d_inode;
 769         int error;
 770
 771         error = inode_change_ok(inode, attr);
 772         if (error)
 773                 return MSDOS_SB(sb)->options.quiet ? 0 : error;
 774
 775         if (((attr->ia_valid & ATTR_UID) &&
 776              (attr->ia_uid != MSDOS_SB(sb)->options.fs_uid)) ||
 777             ((attr->ia_valid & ATTR_GID) &&
 778              (attr->ia_gid != MSDOS_SB(sb)->options.fs_gid)) ||
 779             ((attr->ia_valid & ATTR_MODE) &&
 780              (attr->ia_mode & ~MSDOS_VALID_MODE)))
 781                 error = -EPERM;
 782
 783         if (error)
 784                 return MSDOS_SB(sb)->options.quiet ? 0 : error;
 785
 786         inode_setattr(inode, attr);
 787
 788         if (IS_NOEXEC(inode) && !S_ISDIR(inode->i_mode))
 789                 inode->i_mode &= S_IFMT | S_IRUGO | S_IWUGO;
 790         else
 791                 inode->i_mode |= S_IXUGO;
 792
 793         inode->i_mode = ((inode->i_mode & S_IFMT) | ((((inode->i_mode & S_IRWXU
 794             & ~MSDOS_SB(sb)->options.fs_umask) | S_IRUSR) >> 6)*S_IXUGO)) &
 795             ~MSDOS_SB(sb)->options.fs_umask;
 796         return 0;
 797 }
 798
 799
 800 #ifdef MODULE
 801 int init_module(void)
 802 {
 803         return init_fat_fs();
 804 }
 805
 806
 807 void cleanup_module(void)
 808 {
 809         /* Nothing to be done, really! */
 810         return;
 811 }
 812 #endif
 813