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