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