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