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