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