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