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