fs/isofs/inode.c

   1 /*
   2  *  linux/fs/isofs/inode.c
   3  *
   4  *  (C) 1991  Linus Torvalds - minix filesystem
   5  *      1992, 1993, 1994  Eric Youngdale Modified for ISO 9660 filesystem.
   6  *      1994  Eberhard Moenkeberg - multi session handling.
   7  *      1995  Mark Dobie - allow mounting of some weird VideoCDs and PhotoCDs.
   8  *      1997  Gordon Chaffee - Joliet CDs
   9  *      1998  Eric Lammerts - ISO 9660 Level 3
  10  */
  11
  12 #include <linux/config.h>
  13 #include <linux/module.h>
  14
  15 #include <linux/stat.h>
  16 #include <linux/time.h>
  17 #include <linux/iso_fs.h>
  18 #include <linux/kernel.h>
  19 #include <linux/major.h>
  20 #include <linux/mm.h>
  21 #include <linux/string.h>
  22 #include <linux/slab.h>
  23 #include <linux/errno.h>
  24 #include <linux/cdrom.h>
  25 #include <linux/init.h>
  26 #include <linux/nls.h>
  27 #include <linux/ctype.h>
  28 #include <linux/smp_lock.h>
  29 #include <linux/blkdev.h>
  30 #include <linux/buffer_head.h>
  31 #include <linux/vfs.h>
  32 #include <linux/parser.h>
  33 #include <asm/system.h>
  34 #include <asm/uaccess.h>
  35
  36 #include "zisofs.h"
  37
  38 #define BEQUIET
  39
  40 #ifdef LEAK_CHECK
  41 static int check_malloc;
  42 static int check_bread;
  43 #endif
  44
  45 static int isofs_hashi(struct dentry *parent, struct qstr *qstr);
  46 static int isofs_hash(struct dentry *parent, struct qstr *qstr);
  47 static int isofs_dentry_cmpi(struct dentry *dentry, struct qstr *a, struct qstr *b);
  48 static int isofs_dentry_cmp(struct dentry *dentry, struct qstr *a, struct qstr *b);
  49
  50 #ifdef CONFIG_JOLIET
  51 static int isofs_hashi_ms(struct dentry *parent, struct qstr *qstr);
  52 static int isofs_hash_ms(struct dentry *parent, struct qstr *qstr);
  53 static int isofs_dentry_cmpi_ms(struct dentry *dentry, struct qstr *a, struct qstr *b);
  54 static int isofs_dentry_cmp_ms(struct dentry *dentry, struct qstr *a, struct qstr *b);
  55 #endif
  56
  57 static void isofs_put_super(struct super_block *sb)
  58 {
  59         struct isofs_sb_info *sbi = ISOFS_SB(sb);
  60 #ifdef CONFIG_JOLIET
  61         if (sbi->s_nls_iocharset) {
  62                 unload_nls(sbi->s_nls_iocharset);
  63                 sbi->s_nls_iocharset = NULL;
  64         }
  65 #endif
  66
  67 #ifdef LEAK_CHECK
  68         printk("Outstanding mallocs:%d, outstanding buffers: %d\n",
  69                check_malloc, check_bread);
  70 #endif
  71
  72         kfree(sbi);
  73         sb->s_fs_info = NULL;
  74         return;
  75 }
  76
  77 static void isofs_read_inode(struct inode *);
  78 static int isofs_statfs (struct super_block *, struct kstatfs *);
  79
  80 static kmem_cache_t *isofs_inode_cachep;
  81
  82 static struct inode *isofs_alloc_inode(struct super_block *sb)
  83 {
  84         struct iso_inode_info *ei;
  85         ei = (struct iso_inode_info *)kmem_cache_alloc(isofs_inode_cachep, SLAB_KERNEL);
  86         if (!ei)
  87                 return NULL;
  88         return &ei->vfs_inode;
  89 }
  90
  91 static void isofs_destroy_inode(struct inode *inode)
  92 {
  93         kmem_cache_free(isofs_inode_cachep, ISOFS_I(inode));
  94 }
  95
  96 static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
  97 {
  98         struct iso_inode_info *ei = (struct iso_inode_info *) foo;
  99
 100         if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
 101             SLAB_CTOR_CONSTRUCTOR)
 102                 inode_init_once(&ei->vfs_inode);
 103 }
 104
 105 static int init_inodecache(void)
 106 {
 107         isofs_inode_cachep = kmem_cache_create("isofs_inode_cache",
 108                                              sizeof(struct iso_inode_info),
 109                                              0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT,
 110                                              init_once, NULL);
 111         if (isofs_inode_cachep == NULL)
 112                 return -ENOMEM;
 113         return 0;
 114 }
 115
 116 static void destroy_inodecache(void)
 117 {
 118         if (kmem_cache_destroy(isofs_inode_cachep))
 119                 printk(KERN_INFO "iso_inode_cache: not all structures were freed\n");
 120 }
 121
 122 static int isofs_remount(struct super_block *sb, int *flags, char *data)
 123 {
 124         /* we probably want a lot more here */
 125         *flags |= MS_RDONLY;
 126         return 0;
 127 }
 128
 129 static struct super_operations isofs_sops = {
 130         .alloc_inode    = isofs_alloc_inode,
 131         .destroy_inode  = isofs_destroy_inode,
 132         .read_inode     = isofs_read_inode,
 133         .put_super      = isofs_put_super,
 134         .statfs         = isofs_statfs,
 135         .remount_fs     = isofs_remount,
 136 };
 137
 138 /* the export_operations structure for describing
 139  * how to export (e.g. via kNFSd) is deliberately
 140  * empty.
 141  * This means that the filesystem want to use iget
 142  * to map an inode number into an inode.
 143  * The lack of a get_parent operation means that
 144  * if something isn't in the cache, then you cannot
 145  * access it.
 146  * It should be possible to write a get_parent,
 147  * but it would be a bit hairy...
 148  */
 149 static struct export_operations isofs_export_ops = {
 150 };
 151
 152
 153 static struct dentry_operations isofs_dentry_ops[] = {
 154         {
 155                 .d_hash         = isofs_hash,
 156                 .d_compare      = isofs_dentry_cmp,
 157         },
 158         {
 159                 .d_hash         = isofs_hashi,
 160                 .d_compare      = isofs_dentry_cmpi,
 161         },
 162 #ifdef CONFIG_JOLIET
 163         {
 164                 .d_hash         = isofs_hash_ms,
 165                 .d_compare      = isofs_dentry_cmp_ms,
 166         },
 167         {
 168                 .d_hash         = isofs_hashi_ms,
 169                 .d_compare      = isofs_dentry_cmpi_ms,
 170         }
 171 #endif
 172 };
 173
 174 struct iso9660_options{
 175         char map;
 176         char rock;
 177         char joliet;
 178         char cruft;
 179         char unhide;
 180         char nocompress;
 181         unsigned char check;
 182         unsigned int blocksize;
 183         mode_t mode;
 184         gid_t gid;
 185         uid_t uid;
 186         char *iocharset;
 187         unsigned char utf8;
 188         /* LVE */
 189         s32 session;
 190         s32 sbsector;
 191 };
 192
 193 /*
 194  * Compute the hash for the isofs name corresponding to the dentry.
 195  */
 196 static int
 197 isofs_hash_common(struct dentry *dentry, struct qstr *qstr, int ms)
 198 {
 199         const char *name;
 200         int len;
 201
 202         len = qstr->len;
 203         name = qstr->name;
 204         if (ms) {
 205                 while (len && name[len-1] == '.')
 206                         len--;
 207         }
 208
 209         qstr->hash = full_name_hash(name, len);
 210
 211         return 0;
 212 }
 213
 214 /*
 215  * Compute the hash for the isofs name corresponding to the dentry.
 216  */
 217 static int
 218 isofs_hashi_common(struct dentry *dentry, struct qstr *qstr, int ms)
 219 {
 220         const char *name;
 221         int len;
 222         char c;
 223         unsigned long hash;
 224
 225         len = qstr->len;
 226         name = qstr->name;
 227         if (ms) {
 228                 while (len && name[len-1] == '.')
 229                         len--;
 230         }
 231
 232         hash = init_name_hash();
 233         while (len--) {
 234                 c = tolower(*name++);
 235                 hash = partial_name_hash(tolower(c), hash);
 236         }
 237         qstr->hash = end_name_hash(hash);
 238
 239         return 0;
 240 }
 241
 242 /*
 243  * Case insensitive compare of two isofs names.
 244  */
 245 static int
 246 isofs_dentry_cmpi_common(struct dentry *dentry,struct qstr *a,struct qstr *b,int ms)
 247 {
 248         int alen, blen;
 249
 250         /* A filename cannot end in '.' or we treat it like it has none */
 251         alen = a->len;
 252         blen = b->len;
 253         if (ms) {
 254                 while (alen && a->name[alen-1] == '.')
 255                         alen--;
 256                 while (blen && b->name[blen-1] == '.')
 257                         blen--;
 258         }
 259         if (alen == blen) {
 260                 if (strnicmp(a->name, b->name, alen) == 0)
 261                         return 0;
 262         }
 263         return 1;
 264 }
 265
 266 /*
 267  * Case sensitive compare of two isofs names.
 268  */
 269 static int
 270 isofs_dentry_cmp_common(struct dentry *dentry,struct qstr *a,struct qstr *b,int ms)
 271 {
 272         int alen, blen;
 273
 274         /* A filename cannot end in '.' or we treat it like it has none */
 275         alen = a->len;
 276         blen = b->len;
 277         if (ms) {
 278                 while (alen && a->name[alen-1] == '.')
 279                         alen--;
 280                 while (blen && b->name[blen-1] == '.')
 281                         blen--;
 282         }
 283         if (alen == blen) {
 284                 if (strncmp(a->name, b->name, alen) == 0)
 285                         return 0;
 286         }
 287         return 1;
 288 }
 289
 290 static int
 291 isofs_hash(struct dentry *dentry, struct qstr *qstr)
 292 {
 293         return isofs_hash_common(dentry, qstr, 0);
 294 }
 295
 296 static int
 297 isofs_hashi(struct dentry *dentry, struct qstr *qstr)
 298 {
 299         return isofs_hashi_common(dentry, qstr, 0);
 300 }
 301
 302 static int
 303 isofs_dentry_cmp(struct dentry *dentry,struct qstr *a,struct qstr *b)
 304 {
 305         return isofs_dentry_cmp_common(dentry, a, b, 0);
 306 }
 307
 308 static int
 309 isofs_dentry_cmpi(struct dentry *dentry,struct qstr *a,struct qstr *b)
 310 {
 311         return isofs_dentry_cmpi_common(dentry, a, b, 0);
 312 }
 313
 314 #ifdef CONFIG_JOLIET
 315 static int
 316 isofs_hash_ms(struct dentry *dentry, struct qstr *qstr)
 317 {
 318         return isofs_hash_common(dentry, qstr, 1);
 319 }
 320
 321 static int
 322 isofs_hashi_ms(struct dentry *dentry, struct qstr *qstr)
 323 {
 324         return isofs_hashi_common(dentry, qstr, 1);
 325 }
 326
 327 static int
 328 isofs_dentry_cmp_ms(struct dentry *dentry,struct qstr *a,struct qstr *b)
 329 {
 330         return isofs_dentry_cmp_common(dentry, a, b, 1);
 331 }
 332
 333 static int
 334 isofs_dentry_cmpi_ms(struct dentry *dentry,struct qstr *a,struct qstr *b)
 335 {
 336         return isofs_dentry_cmpi_common(dentry, a, b, 1);
 337 }
 338 #endif
 339
 340 enum {
 341         Opt_block, Opt_check_r, Opt_check_s, Opt_cruft, Opt_gid, Opt_ignore,
 342         Opt_iocharset, Opt_map_a, Opt_map_n, Opt_map_o, Opt_mode, Opt_nojoliet,
 343         Opt_norock, Opt_sb, Opt_session, Opt_uid, Opt_unhide, Opt_utf8, Opt_err,
 344         Opt_nocompress,
 345 };
 346
 347 static match_table_t tokens = {
 348         {Opt_norock, "norock"},
 349         {Opt_nojoliet, "nojoliet"},
 350         {Opt_unhide, "unhide"},
 351         {Opt_cruft, "cruft"},
 352         {Opt_utf8, "utf8"},
 353         {Opt_iocharset, "iocharset=%s"},
 354         {Opt_map_a, "map=acorn"},
 355         {Opt_map_a, "map=a"},
 356         {Opt_map_n, "map=normal"},
 357         {Opt_map_n, "map=n"},
 358         {Opt_map_o, "map=off"},
 359         {Opt_map_o, "map=o"},
 360         {Opt_session, "session=%u"},
 361         {Opt_sb, "sbsector=%u"},
 362         {Opt_check_r, "check=relaxed"},
 363         {Opt_check_r, "check=r"},
 364         {Opt_check_s, "check=strict"},
 365         {Opt_check_s, "check=s"},
 366         {Opt_uid, "uid=%u"},
 367         {Opt_gid, "gid=%u"},
 368         {Opt_mode, "mode=%u"},
 369         {Opt_block, "block=%u"},
 370         {Opt_ignore, "conv=binary"},
 371         {Opt_ignore, "conv=b"},
 372         {Opt_ignore, "conv=text"},
 373         {Opt_ignore, "conv=t"},
 374         {Opt_ignore, "conv=mtext"},
 375         {Opt_ignore, "conv=m"},
 376         {Opt_ignore, "conv=auto"},
 377         {Opt_ignore, "conv=a"},
 378         {Opt_nocompress, "nocompress"},
 379         {Opt_err, NULL}
 380 };
 381
 382 static int parse_options(char *options, struct iso9660_options * popt)
 383 {
 384         char *p;
 385         int option;
 386
 387         popt->map = 'n';
 388         popt->rock = 'y';
 389         popt->joliet = 'y';
 390         popt->cruft = 'n';
 391         popt->unhide = 'n';
 392         popt->check = 'u';              /* unset */
 393         popt->nocompress = 0;
 394         popt->blocksize = 1024;
 395         popt->mode = S_IRUGO | S_IXUGO; /* r-x for all.  The disc could
 396                                            be shared with DOS machines so
 397                                            virtually anything could be
 398                                            a valid executable. */
 399         popt->gid = 0;
 400         popt->uid = 0;
 401         popt->iocharset = NULL;
 402         popt->utf8 = 0;
 403         popt->session=-1;
 404         popt->sbsector=-1;
 405         if (!options)
 406                 return 1;
 407
 408         while ((p = strsep(&options, ",")) != NULL) {
 409                 int token;
 410                 substring_t args[MAX_OPT_ARGS];
 411                 unsigned n;
 412
 413                 if (!*p)
 414                         continue;
 415
 416                 token = match_token(p, tokens, args);
 417                 switch (token) {
 418                 case Opt_norock:
 419                         popt->rock = 'n';
 420                         break;
 421                 case Opt_nojoliet:
 422                         popt->joliet = 'n';
 423                         break;
 424                 case Opt_unhide:
 425                         popt->unhide = 'y';
 426                         break;
 427                 case Opt_cruft:
 428                         popt->cruft = 'y';
 429                         break;
 430                 case Opt_utf8:
 431                         popt->utf8 = 1;
 432                         break;
 433 #ifdef CONFIG_JOLIET
 434                 case Opt_iocharset:
 435                         popt->iocharset = match_strdup(&args[0]);
 436                         break;
 437 #endif
 438                 case Opt_map_a:
 439                         popt->map = 'a';
 440                         break;
 441                 case Opt_map_o:
 442                         popt->map = 'o';
 443                         break;
 444                 case Opt_map_n:
 445                         popt->map = 'n';
 446                         break;
 447                 case Opt_session:
 448                         if (match_int(&args[0], &option))
 449                                 return 0;
 450                         n = option;
 451                         if (n > 99)
 452                                 return 0;
 453                         popt->session = n + 1;
 454                         break;
 455                 case Opt_sb:
 456                         if (match_int(&args[0], &option))
 457                                 return 0;
 458                         popt->sbsector = option;
 459                         break;
 460                 case Opt_check_r:
 461                         popt->check = 'r';
 462                         break;
 463                 case Opt_check_s:
 464                         popt->check = 's';
 465                         break;
 466                 case Opt_ignore:
 467                         break;
 468                 case Opt_uid:
 469                         if (match_int(&args[0], &option))
 470                                 return 0;
 471                         popt->uid = option;
 472                         break;
 473                 case Opt_gid:
 474                         if (match_int(&args[0], &option))
 475                                 return 0;
 476                         popt->gid = option;
 477                         break;
 478                 case Opt_mode:
 479                         if (match_int(&args[0], &option))
 480                                 return 0;
 481                         popt->mode = option;
 482                         break;
 483                 case Opt_block:
 484                         if (match_int(&args[0], &option))
 485                                 return 0;
 486                         n = option;
 487                         if (n != 512 && n != 1024 && n != 2048)
 488                                 return 0;
 489                         popt->blocksize = n;
 490                         break;
 491                 case Opt_nocompress:
 492                         popt->nocompress = 1;
 493                         break;
 494                 default:
 495                         return 0;
 496                 }
 497         }
 498         return 1;
 499 }
 500
 501 /*
 502  * look if the driver can tell the multi session redirection value
 503  *
 504  * don't change this if you don't know what you do, please!
 505  * Multisession is legal only with XA disks.
 506  * A non-XA disk with more than one volume descriptor may do it right, but
 507  * usually is written in a nowhere standardized "multi-partition" manner.
 508  * Multisession uses absolute addressing (solely the first frame of the whole
 509  * track is #0), multi-partition uses relative addressing (each first frame of
 510  * each track is #0), and a track is not a session.
 511  *
 512  * A broken CDwriter software or drive firmware does not set new standards,
 513  * at least not if conflicting with the existing ones.
 514  *
 515  * emoenke@gwdg.de
 516  */
 517 #define WE_OBEY_THE_WRITTEN_STANDARDS 1
 518
 519 static unsigned int isofs_get_last_session(struct super_block *sb,s32 session )
 520 {
 521         struct cdrom_multisession ms_info;
 522         unsigned int vol_desc_start;
 523         struct block_device *bdev = sb->s_bdev;
 524         int i;
 525
 526         vol_desc_start=0;
 527         ms_info.addr_format=CDROM_LBA;
 528         if(session >= 0 && session <= 99) {
 529                 struct cdrom_tocentry Te;
 530                 Te.cdte_track=session;
 531                 Te.cdte_format=CDROM_LBA;
 532                 i = ioctl_by_bdev(bdev, CDROMREADTOCENTRY, (unsigned long) &Te);
 533                 if (!i) {
 534                         printk(KERN_DEBUG "Session %d start %d type %d\n",
 535                                session, Te.cdte_addr.lba,
 536                                Te.cdte_ctrl&CDROM_DATA_TRACK);
 537                         if ((Te.cdte_ctrl&CDROM_DATA_TRACK) == 4)
 538                                 return Te.cdte_addr.lba;
 539                 }
 540
 541                 printk(KERN_ERR "Invalid session number or type of track\n");
 542         }
 543         i = ioctl_by_bdev(bdev, CDROMMULTISESSION, (unsigned long) &ms_info);
 544         if(session > 0) printk(KERN_ERR "Invalid session number\n");
 545 #if 0
 546         printk("isofs.inode: CDROMMULTISESSION: rc=%d\n",i);
 547         if (i==0) {
 548                 printk("isofs.inode: XA disk: %s\n",ms_info.xa_flag?"yes":"no");
 549                 printk("isofs.inode: vol_desc_start = %d\n", ms_info.addr.lba);
 550         }
 551 #endif
 552         if (i==0)
 553 #if WE_OBEY_THE_WRITTEN_STANDARDS
 554         if (ms_info.xa_flag) /* necessary for a valid ms_info.addr */
 555 #endif
 556                 vol_desc_start=ms_info.addr.lba;
 557         return vol_desc_start;
 558 }
 559
 560 /*
 561  * Initialize the superblock and read the root inode.
 562  *
 563  * Note: a check_disk_change() has been done immediately prior
 564  * to this call, so we don't need to check again.
 565  */
 566 static int isofs_fill_super(struct super_block *s, void *data, int silent)
 567 {
 568         struct buffer_head            * bh = NULL, *pri_bh = NULL;
 569         struct hs_primary_descriptor  * h_pri = NULL;
 570         struct iso_primary_descriptor * pri = NULL;
 571         struct iso_supplementary_descriptor *sec = NULL;
 572         struct iso_directory_record   * rootp;
 573         int                             joliet_level = 0;
 574         int                             iso_blknum, block;
 575         int                             orig_zonesize;
 576         int                             table;
 577         unsigned int                    vol_desc_start;
 578         unsigned long                   first_data_zone;
 579         struct inode                  * inode;
 580         struct iso9660_options          opt;
 581         struct isofs_sb_info          * sbi;
 582
 583         sbi = kmalloc(sizeof(struct isofs_sb_info), GFP_KERNEL);
 584         if (!sbi)
 585                 return -ENOMEM;
 586         s->s_fs_info = sbi;
 587         memset(sbi, 0, sizeof(struct isofs_sb_info));
 588
 589         if (!parse_options((char *) data, &opt))
 590                 goto out_freesbi;
 591
 592         /*
 593          * First of all, get the hardware blocksize for this device.
 594          * If we don't know what it is, or the hardware blocksize is
 595          * larger than the blocksize the user specified, then use
 596          * that value.
 597          */
 598         /*
 599          * What if bugger tells us to go beyond page size?
 600          */
 601         opt.blocksize = sb_min_blocksize(s, opt.blocksize);
 602
 603         sbi->s_high_sierra = 0; /* default is iso9660 */
 604
 605         vol_desc_start = (opt.sbsector != -1) ?
 606                 opt.sbsector : isofs_get_last_session(s,opt.session);
 607
 608         for (iso_blknum = vol_desc_start+16;
 609              iso_blknum < vol_desc_start+100; iso_blknum++)
 610         {
 611             struct hs_volume_descriptor   * hdp;
 612             struct iso_volume_descriptor  * vdp;
 613
 614             block = iso_blknum << (ISOFS_BLOCK_BITS - s->s_blocksize_bits);
 615             if (!(bh = sb_bread(s, block)))
 616                 goto out_no_read;
 617
 618             vdp = (struct iso_volume_descriptor *)bh->b_data;
 619             hdp = (struct hs_volume_descriptor *)bh->b_data;
 620
 621             /* Due to the overlapping physical location of the descriptors,
 622              * ISO CDs can match hdp->id==HS_STANDARD_ID as well. To ensure
 623              * proper identification in this case, we first check for ISO.
 624              */
 625             if (strncmp (vdp->id, ISO_STANDARD_ID, sizeof vdp->id) == 0) {
 626                 if (isonum_711 (vdp->type) == ISO_VD_END)
 627                     break;
 628                 if (isonum_711 (vdp->type) == ISO_VD_PRIMARY) {
 629                     if (pri == NULL) {
 630                         pri = (struct iso_primary_descriptor *)vdp;
 631                         /* Save the buffer in case we need it ... */
 632                         pri_bh = bh;
 633                         bh = NULL;
 634                     }
 635                 }
 636 #ifdef CONFIG_JOLIET
 637                 else if (isonum_711 (vdp->type) == ISO_VD_SUPPLEMENTARY) {
 638                     sec = (struct iso_supplementary_descriptor *)vdp;
 639                     if (sec->escape[0] == 0x25 && sec->escape[1] == 0x2f) {
 640                         if (opt.joliet == 'y') {
 641                             if (sec->escape[2] == 0x40) {
 642                                 joliet_level = 1;
 643                             } else if (sec->escape[2] == 0x43) {
 644                                 joliet_level = 2;
 645                             } else if (sec->escape[2] == 0x45) {
 646                                 joliet_level = 3;
 647                             }
 648                             printk(KERN_DEBUG"ISO 9660 Extensions: Microsoft Joliet Level %d\n",
 649                                    joliet_level);
 650                         }
 651                         goto root_found;
 652                     } else {
 653                         /* Unknown supplementary volume descriptor */
 654                         sec = NULL;
 655                     }
 656                 }
 657 #endif
 658             } else {
 659                 if (strncmp (hdp->id, HS_STANDARD_ID, sizeof hdp->id) == 0) {
 660                     if (isonum_711 (hdp->type) != ISO_VD_PRIMARY)
 661                         goto out_freebh;
 662
 663                     sbi->s_high_sierra = 1;
 664                     opt.rock = 'n';
 665                     h_pri = (struct hs_primary_descriptor *)vdp;
 666                     goto root_found;
 667                 }
 668             }
 669
 670             /* Just skip any volume descriptors we don't recognize */
 671
 672             brelse(bh);
 673             bh = NULL;
 674         }
 675         /*
 676          * If we fall through, either no volume descriptor was found,
 677          * or else we passed a primary descriptor looking for others.
 678          */
 679         if (!pri)
 680                 goto out_unknown_format;
 681         brelse(bh);
 682         bh = pri_bh;
 683         pri_bh = NULL;
 684
 685 root_found:
 686
 687         if (joliet_level && (pri == NULL || opt.rock == 'n')) {
 688             /* This is the case of Joliet with the norock mount flag.
 689              * A disc with both Joliet and Rock Ridge is handled later
 690              */
 691             pri = (struct iso_primary_descriptor *) sec;
 692         }
 693
 694         if(sbi->s_high_sierra){
 695           rootp = (struct iso_directory_record *) h_pri->root_directory_record;
 696           sbi->s_nzones = isonum_733 (h_pri->volume_space_size);
 697           sbi->s_log_zone_size = isonum_723 (h_pri->logical_block_size);
 698           sbi->s_max_size = isonum_733(h_pri->volume_space_size);
 699         } else {
 700           rootp = (struct iso_directory_record *) pri->root_directory_record;
 701           sbi->s_nzones = isonum_733 (pri->volume_space_size);
 702           sbi->s_log_zone_size = isonum_723 (pri->logical_block_size);
 703           sbi->s_max_size = isonum_733(pri->volume_space_size);
 704         }
 705
 706         sbi->s_ninodes = 0; /* No way to figure this out easily */
 707
 708         orig_zonesize = sbi->s_log_zone_size;
 709         /*
 710          * If the zone size is smaller than the hardware sector size,
 711          * this is a fatal error.  This would occur if the disc drive
 712          * had sectors that were 2048 bytes, but the filesystem had
 713          * blocks that were 512 bytes (which should only very rarely
 714          * happen.)
 715          */
 716         if(orig_zonesize < opt.blocksize)
 717                 goto out_bad_size;
 718
 719         /* RDE: convert log zone size to bit shift */
 720         switch (sbi->s_log_zone_size)
 721           { case  512: sbi->s_log_zone_size =  9; break;
 722             case 1024: sbi->s_log_zone_size = 10; break;
 723             case 2048: sbi->s_log_zone_size = 11; break;
 724
 725             default:
 726                 goto out_bad_zone_size;
 727           }
 728
 729         s->s_magic = ISOFS_SUPER_MAGIC;
 730
 731         /* The CDROM is read-only, has no nodes (devices) on it, and since
 732            all of the files appear to be owned by root, we really do not want
 733            to allow suid.  (suid or devices will not show up unless we have
 734            Rock Ridge extensions) */
 735
 736         s->s_flags |= MS_RDONLY /* | MS_NODEV | MS_NOSUID */;
 737
 738         /* Set this for reference. Its not currently used except on write
 739            which we don't have .. */
 740
 741         /* RDE: data zone now byte offset! */
 742
 743         first_data_zone = ((isonum_733 (rootp->extent) +
 744                           isonum_711 (rootp->ext_attr_length))
 745                          << sbi->s_log_zone_size);
 746         sbi->s_firstdatazone = first_data_zone;
 747 #ifndef BEQUIET
 748         printk(KERN_DEBUG "Max size:%ld   Log zone size:%ld\n",
 749                sbi->s_max_size,
 750                1UL << sbi->s_log_zone_size);
 751         printk(KERN_DEBUG "First datazone:%ld   Root inode number:%ld\n",
 752                sbi->s_firstdatazone >> sbi->s_log_zone_size,
 753                sbi->s_firstdatazone);
 754         if(sbi->s_high_sierra)
 755                 printk(KERN_DEBUG "Disc in High Sierra format.\n");
 756 #endif
 757
 758         /*
 759          * If the Joliet level is set, we _may_ decide to use the
 760          * secondary descriptor, but can't be sure until after we
 761          * read the root inode. But before reading the root inode
 762          * we may need to change the device blocksize, and would
 763          * rather release the old buffer first. So, we cache the
 764          * first_data_zone value from the secondary descriptor.
 765          */
 766         if (joliet_level) {
 767                 pri = (struct iso_primary_descriptor *) sec;
 768                 rootp = (struct iso_directory_record *)
 769                         pri->root_directory_record;
 770                 first_data_zone = ((isonum_733 (rootp->extent) +
 771                                 isonum_711 (rootp->ext_attr_length))
 772                                  << sbi->s_log_zone_size);
 773         }
 774
 775         /*
 776          * We're all done using the volume descriptor, and may need
 777          * to change the device blocksize, so release the buffer now.
 778          */
 779         brelse(pri_bh);
 780         brelse(bh);
 781
 782         /*
 783          * Force the blocksize to 512 for 512 byte sectors.  The file
 784          * read primitives really get it wrong in a bad way if we don't
 785          * do this.
 786          *
 787          * Note - we should never be setting the blocksize to something
 788          * less than the hardware sector size for the device.  If we
 789          * do, we would end up having to read larger buffers and split
 790          * out portions to satisfy requests.
 791          *
 792          * Note2- the idea here is that we want to deal with the optimal
 793          * zonesize in the filesystem.  If we have it set to something less,
 794          * then we have horrible problems with trying to piece together
 795          * bits of adjacent blocks in order to properly read directory
 796          * entries.  By forcing the blocksize in this way, we ensure
 797          * that we will never be required to do this.
 798          */
 799         sb_set_blocksize(s, orig_zonesize);
 800
 801         sbi->s_nls_iocharset = NULL;
 802
 803 #ifdef CONFIG_JOLIET
 804         if (joliet_level && opt.utf8 == 0) {
 805                 char * p = opt.iocharset ? opt.iocharset : CONFIG_NLS_DEFAULT;
 806                 sbi->s_nls_iocharset = load_nls(p);
 807                 if (! sbi->s_nls_iocharset) {
 808                         /* Fail only if explicit charset specified */
 809                         if (opt.iocharset)
 810                                 goto out_freesbi;
 811                         sbi->s_nls_iocharset = load_nls_default();
 812                 }
 813         }
 814 #endif
 815         s->s_op = &isofs_sops;
 816         s->s_export_op = &isofs_export_ops;
 817         sbi->s_mapping = opt.map;
 818         sbi->s_rock = (opt.rock == 'y' ? 2 : 0);
 819         sbi->s_rock_offset = -1; /* initial offset, will guess until SP is found*/
 820         sbi->s_cruft = opt.cruft;
 821         sbi->s_unhide = opt.unhide;
 822         sbi->s_uid = opt.uid;
 823         sbi->s_gid = opt.gid;
 824         sbi->s_utf8 = opt.utf8;
 825         sbi->s_nocompress = opt.nocompress;
 826         /*
 827          * It would be incredibly stupid to allow people to mark every file
 828          * on the disk as suid, so we merely allow them to set the default
 829          * permissions.
 830          */
 831         sbi->s_mode = opt.mode & 0777;
 832
 833         /*
 834          * Read the root inode, which _may_ result in changing
 835          * the s_rock flag. Once we have the final s_rock value,
 836          * we then decide whether to use the Joliet descriptor.
 837          */
 838         inode = iget(s, sbi->s_firstdatazone);
 839
 840         /*
 841          * If this disk has both Rock Ridge and Joliet on it, then we
 842          * want to use Rock Ridge by default.  This can be overridden
 843          * by using the norock mount option.  There is still one other
 844          * possibility that is not taken into account: a Rock Ridge
 845          * CD with Unicode names.  Until someone sees such a beast, it
 846          * will not be supported.
 847          */
 848         if (sbi->s_rock == 1) {
 849                 joliet_level = 0;
 850         } else if (joliet_level) {
 851                 sbi->s_rock = 0;
 852                 if (sbi->s_firstdatazone != first_data_zone) {
 853                         sbi->s_firstdatazone = first_data_zone;
 854                         printk(KERN_DEBUG
 855                                 "ISOFS: changing to secondary root\n");
 856                         iput(inode);
 857                         inode = iget(s, sbi->s_firstdatazone);
 858                 }
 859         }
 860
 861         if (opt.check == 'u') {
 862                 /* Only Joliet is case insensitive by default */
 863                 if (joliet_level) opt.check = 'r';
 864                 else opt.check = 's';
 865         }
 866         sbi->s_joliet_level = joliet_level;
 867
 868         /* check the root inode */
 869         if (!inode)
 870                 goto out_no_root;
 871         if (!inode->i_op)
 872                 goto out_bad_root;
 873         /* get the root dentry */
 874         s->s_root = d_alloc_root(inode);
 875         if (!(s->s_root))
 876                 goto out_no_root;
 877
 878         table = 0;
 879         if (joliet_level) table += 2;
 880         if (opt.check == 'r') table++;
 881         s->s_root->d_op = &isofs_dentry_ops[table];
 882
 883         if (opt.iocharset)
 884                 kfree(opt.iocharset);
 885
 886         return 0;
 887
 888         /*
 889          * Display error messages and free resources.
 890          */
 891 out_bad_root:
 892         printk(KERN_WARNING "isofs_fill_super: root inode not initialized\n");
 893         goto out_iput;
 894 out_no_root:
 895         printk(KERN_WARNING "isofs_fill_super: get root inode failed\n");
 896 out_iput:
 897         iput(inode);
 898 #ifdef CONFIG_JOLIET
 899         if (sbi->s_nls_iocharset)
 900                 unload_nls(sbi->s_nls_iocharset);
 901 #endif
 902         goto out_freesbi;
 903 out_no_read:
 904         printk(KERN_WARNING "isofs_fill_super: "
 905                 "bread failed, dev=%s, iso_blknum=%d, block=%d\n",
 906                 s->s_id, iso_blknum, block);
 907         goto out_freesbi;
 908 out_bad_zone_size:
 909         printk(KERN_WARNING "Bad logical zone size %ld\n",
 910                 sbi->s_log_zone_size);
 911         goto out_freebh;
 912 out_bad_size:
 913         printk(KERN_WARNING "Logical zone size(%d) < hardware blocksize(%u)\n",
 914                 orig_zonesize, opt.blocksize);
 915         goto out_freebh;
 916 out_unknown_format:
 917         if (!silent)
 918                 printk(KERN_WARNING "Unable to identify CD-ROM format.\n");
 919
 920 out_freebh:
 921         brelse(bh);
 922 out_freesbi:
 923         if (opt.iocharset)
 924                 kfree(opt.iocharset);
 925         kfree(sbi);
 926         s->s_fs_info = NULL;
 927         return -EINVAL;
 928 }
 929
 930 static int isofs_statfs (struct super_block *sb, struct kstatfs *buf)
 931 {
 932         buf->f_type = ISOFS_SUPER_MAGIC;
 933         buf->f_bsize = sb->s_blocksize;
 934         buf->f_blocks = (ISOFS_SB(sb)->s_nzones
 935                   << (ISOFS_SB(sb)->s_log_zone_size - sb->s_blocksize_bits));
 936         buf->f_bfree = 0;
 937         buf->f_bavail = 0;
 938         buf->f_files = ISOFS_SB(sb)->s_ninodes;
 939         buf->f_ffree = 0;
 940         buf->f_namelen = NAME_MAX;
 941         return 0;
 942 }
 943
 944 /*
 945  * Get a set of blocks; filling in buffer_heads if already allocated
 946  * or getblk() if they are not.  Returns the number of blocks inserted
 947  * (0 == error.)
 948  */
 949 int isofs_get_blocks(struct inode *inode, sector_t iblock_s,
 950                      struct buffer_head **bh, unsigned long nblocks)
 951 {
 952         unsigned long b_off;
 953         unsigned offset, sect_size;
 954         unsigned int firstext;
 955         unsigned long nextino;
 956         long iblock = (long)iblock_s;
 957         int section, rv;
 958         struct iso_inode_info *ei = ISOFS_I(inode);
 959
 960         lock_kernel();
 961
 962         rv = 0;
 963         if (iblock < 0 || iblock != iblock_s) {
 964                 printk("isofs_get_blocks: block number too large\n");
 965                 goto abort;
 966         }
 967
 968         b_off = iblock;
 969
 970         offset    = 0;
 971         firstext  = ei->i_first_extent;
 972         sect_size = ei->i_section_size >> ISOFS_BUFFER_BITS(inode);
 973         nextino   = ei->i_next_section_ino;
 974         section   = 0;
 975
 976         while ( nblocks ) {
 977                 /* If we are *way* beyond the end of the file, print a message.
 978                  * Access beyond the end of the file up to the next page boundary
 979                  * is normal, however because of the way the page cache works.
 980                  * In this case, we just return 0 so that we can properly fill
 981                  * the page with useless information without generating any
 982                  * I/O errors.
 983                  */
 984                 if (b_off > ((inode->i_size + PAGE_CACHE_SIZE - 1) >> ISOFS_BUFFER_BITS(inode))) {
 985                         printk("isofs_get_blocks: block >= EOF (%ld, %ld)\n",
 986                                iblock, (unsigned long) inode->i_size);
 987                         goto abort;
 988                 }
 989
 990                 if (nextino) {
 991                         while (b_off >= (offset + sect_size)) {
 992                                 struct inode *ninode;
 993
 994                                 offset += sect_size;
 995                                 if (nextino == 0)
 996                                         goto abort;
 997                                 ninode = iget(inode->i_sb, nextino);
 998                                 if (!ninode)
 999                                         goto abort;
1000                                 firstext  = ISOFS_I(ninode)->i_first_extent;
1001                                 sect_size = ISOFS_I(ninode)->i_section_size;
1002                                 nextino   = ISOFS_I(ninode)->i_next_section_ino;
1003                                 iput(ninode);
1004
1005                                 if (++section > 100) {
1006                                         printk("isofs_get_blocks: More than 100 file sections ?!?, aborting...\n");
1007                                         printk("isofs_get_blocks: ino=%lu block=%ld firstext=%u sect_size=%u nextino=%lu\n",
1008                                                inode->i_ino, iblock, firstext, (unsigned) sect_size, nextino);
1009                                         goto abort;
1010                                 }
1011                         }
1012                 }
1013
1014                 if ( *bh ) {
1015                         map_bh(*bh, inode->i_sb, firstext + b_off - offset);
1016                 } else {
1017                         *bh = sb_getblk(inode->i_sb, firstext+b_off-offset);
1018                         if ( !*bh )
1019                                 goto abort;
1020                 }
1021                 bh++;   /* Next buffer head */
1022                 b_off++;        /* Next buffer offset */
1023                 nblocks--;
1024                 rv++;
1025         }
1026
1027
1028 abort:
1029         unlock_kernel();
1030         return rv;
1031 }
1032
1033 /*
1034  * Used by the standard interfaces.
1035  */
1036 static int isofs_get_block(struct inode *inode, sector_t iblock,
1037                     struct buffer_head *bh_result, int create)
1038 {
1039         if ( create ) {
1040                 printk("isofs_get_block: Kernel tries to allocate a block\n");
1041                 return -EROFS;
1042         }
1043
1044         return isofs_get_blocks(inode, iblock, &bh_result, 1) ? 0 : -EIO;
1045 }
1046
1047 static int isofs_bmap(struct inode *inode, int block)
1048 {
1049         struct buffer_head dummy;
1050         int error;
1051
1052         dummy.b_state = 0;
1053         dummy.b_blocknr = -1000;
1054         error = isofs_get_block(inode, block, &dummy, 0);
1055         if (!error)
1056                 return dummy.b_blocknr;
1057         return 0;
1058 }
1059
1060 struct buffer_head *isofs_bread(struct inode *inode, sector_t block)
1061 {
1062         sector_t blknr = isofs_bmap(inode, block);
1063         if (!blknr)
1064                 return NULL;
1065         return sb_bread(inode->i_sb, blknr);
1066 }
1067
1068 static int isofs_readpage(struct file *file, struct page *page)
1069 {
1070         return block_read_full_page(page,isofs_get_block);
1071 }
1072
1073 static sector_t _isofs_bmap(struct address_space *mapping, sector_t block)
1074 {
1075         return generic_block_bmap(mapping,block,isofs_get_block);
1076 }
1077
1078 static struct address_space_operations isofs_aops = {
1079         .readpage = isofs_readpage,
1080         .sync_page = block_sync_page,
1081         .bmap = _isofs_bmap
1082 };
1083
1084 static inline void test_and_set_uid(uid_t *p, uid_t value)
1085 {
1086         if(value) {
1087                 *p = value;
1088         }
1089 }
1090
1091 static inline void test_and_set_gid(gid_t *p, gid_t value)
1092 {
1093         if(value) {
1094                 *p = value;
1095         }
1096 }
1097
1098 static int isofs_read_level3_size(struct inode * inode)
1099 {
1100         unsigned long f_pos = inode->i_ino;
1101         unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
1102         int high_sierra = ISOFS_SB(inode->i_sb)->s_high_sierra;
1103         struct buffer_head * bh = NULL;
1104         unsigned long block, offset;
1105         int i = 0;
1106         int more_entries = 0;
1107         struct iso_directory_record * tmpde = NULL;
1108         struct iso_inode_info *ei = ISOFS_I(inode);
1109
1110         inode->i_size = 0;
1111         ei->i_next_section_ino = 0;
1112
1113         block = f_pos >> ISOFS_BUFFER_BITS(inode);
1114         offset = f_pos & (bufsize-1);
1115
1116         do {
1117                 struct iso_directory_record * de;
1118                 unsigned int de_len;
1119
1120                 if (!bh) {
1121                         bh = sb_bread(inode->i_sb, block);
1122                         if (!bh)
1123                                 goto out_noread;
1124                 }
1125                 de = (struct iso_directory_record *) (bh->b_data + offset);
1126                 de_len = *(unsigned char *) de;
1127
1128                 if (de_len == 0) {
1129                         brelse(bh);
1130                         bh = NULL;
1131                         f_pos = (f_pos + ISOFS_BLOCK_SIZE) & ~(ISOFS_BLOCK_SIZE - 1);
1132                         block = f_pos >> ISOFS_BUFFER_BITS(inode);
1133                         offset = 0;
1134                         continue;
1135                 }
1136
1137                 offset += de_len;
1138
1139                 /* Make sure we have a full directory entry */
1140                 if (offset >= bufsize) {
1141                         int slop = bufsize - offset + de_len;
1142                         if (!tmpde) {
1143                                 tmpde = kmalloc(256, GFP_KERNEL);
1144                                 if (!tmpde)
1145                                         goto out_nomem;
1146                         }
1147                         memcpy(tmpde, de, slop);
1148                         offset &= bufsize - 1;
1149                         block++;
1150                         brelse(bh);
1151                         bh = NULL;
1152                         if (offset) {
1153                                 bh = sb_bread(inode->i_sb, block);
1154                                 if (!bh)
1155                                         goto out_noread;
1156                                 memcpy((void *) tmpde + slop, bh->b_data, offset);
1157                         }
1158                         de = tmpde;
1159                 }
1160
1161                 inode->i_size += isonum_733(de->size);
1162                 if (i == 1)
1163                         ei->i_next_section_ino = f_pos;
1164
1165                 more_entries = de->flags[-high_sierra] & 0x80;
1166
1167                 f_pos += de_len;
1168                 i++;
1169                 if(i > 100)
1170                         goto out_toomany;
1171         } while(more_entries);
1172 out:
1173         if (tmpde)
1174                 kfree(tmpde);
1175         if (bh)
1176                 brelse(bh);
1177         return 0;
1178
1179 out_nomem:
1180         if (bh)
1181                 brelse(bh);
1182         return -ENOMEM;
1183
1184 out_noread:
1185         printk(KERN_INFO "ISOFS: unable to read i-node block %lu\n", block);
1186         if (tmpde)
1187                 kfree(tmpde);
1188         return -EIO;
1189
1190 out_toomany:
1191         printk(KERN_INFO "isofs_read_level3_size: "
1192                 "More than 100 file sections ?!?, aborting...\n"
1193                 "isofs_read_level3_size: inode=%lu ino=%lu\n",
1194                 inode->i_ino, f_pos);
1195         goto out;
1196 }
1197
1198 static void isofs_read_inode(struct inode * inode)
1199 {
1200         struct super_block *sb = inode->i_sb;
1201         struct isofs_sb_info *sbi = ISOFS_SB(sb);
1202         unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
1203         int block = inode->i_ino >> ISOFS_BUFFER_BITS(inode);
1204         int high_sierra = sbi->s_high_sierra;
1205         struct buffer_head * bh = NULL;
1206         struct iso_directory_record * de;
1207         struct iso_directory_record * tmpde = NULL;
1208         unsigned int de_len;
1209         unsigned long offset;
1210         int i;
1211         struct iso_inode_info *ei = ISOFS_I(inode);
1212
1213         bh = sb_bread(inode->i_sb, block);
1214         if (!bh)
1215                 goto out_badread;
1216
1217         offset = (inode->i_ino & (bufsize - 1));
1218         de = (struct iso_directory_record *) (bh->b_data + offset);
1219         de_len = *(unsigned char *) de;
1220
1221         if (offset + de_len > bufsize) {
1222                 int frag1 = bufsize - offset;
1223
1224                 tmpde = kmalloc(de_len, GFP_KERNEL);
1225                 if (tmpde == NULL) {
1226                         printk(KERN_INFO "isofs_read_inode: out of memory\n");
1227                         goto fail;
1228                 }
1229                 memcpy(tmpde, bh->b_data + offset, frag1);
1230                 brelse(bh);
1231                 bh = sb_bread(inode->i_sb, ++block);
1232                 if (!bh)
1233                         goto out_badread;
1234                 memcpy((char *)tmpde+frag1, bh->b_data, de_len - frag1);
1235                 de = tmpde;
1236         }
1237
1238         /* Assume it is a normal-format file unless told otherwise */
1239         ei->i_file_format = isofs_file_normal;
1240
1241         if (de->flags[-high_sierra] & 2) {
1242                 inode->i_mode = S_IRUGO | S_IXUGO | S_IFDIR;
1243                 inode->i_nlink = 1; /* Set to 1.  We know there are 2, but
1244                                        the find utility tries to optimize
1245                                        if it is 2, and it screws up.  It is
1246                                        easier to give 1 which tells find to
1247                                        do it the hard way. */
1248         } else {
1249                 /* Everybody gets to read the file. */
1250                 inode->i_mode = sbi->s_mode;
1251                 inode->i_nlink = 1;
1252                 inode->i_mode |= S_IFREG;
1253                 /* If there are no periods in the name,
1254                  * then set the execute permission bit
1255                  */
1256                 for(i=0; i< de->name_len[0]; i++)
1257                         if(de->name[i]=='.' || de->name[i]==';')
1258                                 break;
1259                 if(i == de->name_len[0] || de->name[i] == ';')
1260                         inode->i_mode |= S_IXUGO; /* execute permission */
1261         }
1262         inode->i_uid = sbi->s_uid;
1263         inode->i_gid = sbi->s_gid;
1264         inode->i_blocks = inode->i_blksize = 0;
1265
1266         ei->i_format_parm[0] = 0;
1267         ei->i_format_parm[1] = 0;
1268         ei->i_format_parm[2] = 0;
1269
1270         ei->i_section_size = isonum_733 (de->size);
1271         if(de->flags[-high_sierra] & 0x80) {
1272                 if(isofs_read_level3_size(inode)) goto fail;
1273         } else {
1274                 ei->i_next_section_ino = 0;
1275                 inode->i_size = isonum_733 (de->size);
1276         }
1277
1278         /*
1279          * The ISO-9660 filesystem only stores 32 bits for file size.
1280          * mkisofs handles files up to 2GB-2 = 2147483646 = 0x7FFFFFFE bytes
1281          * in size. This is according to the large file summit paper from 1996.
1282          * WARNING: ISO-9660 filesystems > 1 GB and even > 2 GB are fully
1283          *          legal. Do not prevent to use DVD's schilling@fokus.gmd.de
1284          */
1285         if ((inode->i_size < 0 || inode->i_size > 0x7FFFFFFE) &&
1286             sbi->s_cruft == 'n') {
1287                 printk(KERN_WARNING "Warning: defective CD-ROM.  "
1288                        "Enabling \"cruft\" mount option.\n");
1289                 sbi->s_cruft = 'y';
1290         }
1291
1292         /*
1293          * Some dipshit decided to store some other bit of information
1294          * in the high byte of the file length.  Catch this and holler.
1295          * WARNING: this will make it impossible for a file to be > 16MB
1296          * on the CDROM.
1297          */
1298
1299         if (sbi->s_cruft == 'y' &&
1300             inode->i_size & 0xff000000) {
1301                 inode->i_size &= 0x00ffffff;
1302         }
1303
1304         if (de->interleave[0]) {
1305                 printk("Interleaved files not (yet) supported.\n");
1306                 inode->i_size = 0;
1307         }
1308
1309         /* I have no idea what file_unit_size is used for, so
1310            we will flag it for now */
1311         if (de->file_unit_size[0] != 0) {
1312                 printk("File unit size != 0 for ISO file (%ld).\n",
1313                        inode->i_ino);
1314         }
1315
1316         /* I have no idea what other flag bits are used for, so
1317            we will flag it for now */
1318 #ifdef DEBUG
1319         if((de->flags[-high_sierra] & ~2)!= 0){
1320                 printk("Unusual flag settings for ISO file (%ld %x).\n",
1321                        inode->i_ino, de->flags[-high_sierra]);
1322         }
1323 #endif
1324
1325         inode->i_mtime.tv_sec =
1326         inode->i_atime.tv_sec =
1327         inode->i_ctime.tv_sec = iso_date(de->date, high_sierra);
1328         inode->i_mtime.tv_nsec =
1329         inode->i_atime.tv_nsec =
1330         inode->i_ctime.tv_nsec = 0;
1331
1332         ei->i_first_extent = (isonum_733 (de->extent) +
1333                               isonum_711 (de->ext_attr_length));
1334
1335         /* Set the number of blocks for stat() - should be done before RR */
1336         inode->i_blksize = PAGE_CACHE_SIZE; /* For stat() only */
1337         inode->i_blocks  = (inode->i_size + 511) >> 9;
1338
1339         /*
1340          * Now test for possible Rock Ridge extensions which will override
1341          * some of these numbers in the inode structure.
1342          */
1343
1344         if (!high_sierra) {
1345                 parse_rock_ridge_inode(de, inode);
1346                 /* if we want uid/gid set, override the rock ridge setting */
1347                 test_and_set_uid(&inode->i_uid, sbi->s_uid);
1348                 test_and_set_gid(&inode->i_gid, sbi->s_gid);
1349         }
1350
1351         /* Install the inode operations vector */
1352         if (S_ISREG(inode->i_mode)) {
1353                 inode->i_fop = &generic_ro_fops;
1354                 switch ( ei->i_file_format ) {
1355 #ifdef CONFIG_ZISOFS
1356                 case isofs_file_compressed:
1357                         inode->i_data.a_ops = &zisofs_aops;
1358                         break;
1359 #endif
1360                 default:
1361                         inode->i_data.a_ops = &isofs_aops;
1362                         break;
1363                 }
1364         } else if (S_ISDIR(inode->i_mode)) {
1365                 inode->i_op = &isofs_dir_inode_operations;
1366                 inode->i_fop = &isofs_dir_operations;
1367         } else if (S_ISLNK(inode->i_mode)) {
1368                 inode->i_op = &page_symlink_inode_operations;
1369                 inode->i_data.a_ops = &isofs_symlink_aops;
1370         } else
1371                 /* XXX - parse_rock_ridge_inode() had already set i_rdev. */
1372                 init_special_inode(inode, inode->i_mode, inode->i_rdev);
1373
1374  out:
1375         if (tmpde)
1376                 kfree(tmpde);
1377         if (bh)
1378                 brelse(bh);
1379         return;
1380
1381  out_badread:
1382         printk(KERN_WARNING "ISOFS: unable to read i-node block\n");
1383  fail:
1384         make_bad_inode(inode);
1385         goto out;
1386 }
1387
1388 #ifdef LEAK_CHECK
1389 #undef malloc
1390 #undef free_s
1391 #undef sb_bread
1392 #undef brelse
1393
1394 void * leak_check_malloc(unsigned int size){
1395   void * tmp;
1396   check_malloc++;
1397   tmp = kmalloc(size, GFP_KERNEL);
1398   return tmp;
1399 }
1400
1401 void leak_check_free_s(void * obj, int size){
1402   check_malloc--;
1403   return kfree(obj);
1404 }
1405
1406 struct buffer_head * leak_check_bread(struct super_block *sb, int block){
1407   check_bread++;
1408   return sb_bread(sb, block);
1409 }
1410
1411 void leak_check_brelse(struct buffer_head * bh){
1412   check_bread--;
1413   return brelse(bh);
1414 }
1415
1416 #endif
1417
1418 static struct super_block *isofs_get_sb(struct file_system_type *fs_type,
1419         int flags, const char *dev_name, void *data)
1420 {
1421         return get_sb_bdev(fs_type, flags, dev_name, data, isofs_fill_super);
1422 }
1423
1424 static struct file_system_type iso9660_fs_type = {
1425         .owner          = THIS_MODULE,
1426         .name           = "iso9660",
1427         .get_sb         = isofs_get_sb,
1428         .kill_sb        = kill_block_super,
1429         .fs_flags       = FS_REQUIRES_DEV,
1430 };
1431
1432 static int __init init_iso9660_fs(void)
1433 {
1434         int err = init_inodecache();
1435         if (err)
1436                 goto out;
1437 #ifdef CONFIG_ZISOFS
1438         err = zisofs_init();
1439         if (err)
1440                 goto out1;
1441 #endif
1442         err = register_filesystem(&iso9660_fs_type);
1443         if (err)
1444                 goto out2;
1445         return 0;
1446 out2:
1447 #ifdef CONFIG_ZISOFS
1448         zisofs_cleanup();
1449 out1:
1450 #endif
1451         destroy_inodecache();
1452 out:
1453         return err;
1454 }
1455
1456 static void __exit exit_iso9660_fs(void)
1457 {
1458         unregister_filesystem(&iso9660_fs_type);
1459 #ifdef CONFIG_ZISOFS
1460         zisofs_cleanup();
1461 #endif
1462         destroy_inodecache();
1463 }
1464
1465 module_init(init_iso9660_fs)
1466 module_exit(exit_iso9660_fs)
1467 MODULE_LICENSE("GPL");
1468 /* Actual filesystem name is iso9660, as requested in filesystems.c */
1469 MODULE_ALIAS("iso9660");