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 #ifdef LEAK_CHECK
  32 static int check_malloc;
  33 static int check_bread;
  34 #endif
  35
  36 static int isofs_hashi(struct dentry *parent, struct qstr *qstr);
  37 static int isofs_hash(struct dentry *parent, struct qstr *qstr);
  38 static int isofs_dentry_cmpi(struct dentry *dentry, struct qstr *a, struct qstr *b);
  39 static int isofs_dentry_cmp(struct dentry *dentry, struct qstr *a, struct qstr *b);
  40
  41 #ifdef CONFIG_JOLIET
  42 static int isofs_hashi_ms(struct dentry *parent, struct qstr *qstr);
  43 static int isofs_hash_ms(struct dentry *parent, struct qstr *qstr);
  44 static int isofs_dentry_cmpi_ms(struct dentry *dentry, struct qstr *a, struct qstr *b);
  45 static int isofs_dentry_cmp_ms(struct dentry *dentry, struct qstr *a, struct qstr *b);
  46 #endif
  47
  48 static void isofs_put_super(struct super_block *sb)
  49 {
  50         struct isofs_sb_info *sbi = ISOFS_SB(sb);
  51 #ifdef CONFIG_JOLIET
  52         if (sbi->s_nls_iocharset) {
  53                 unload_nls(sbi->s_nls_iocharset);
  54                 sbi->s_nls_iocharset = NULL;
  55         }
  56 #endif
  57
  58 #ifdef LEAK_CHECK
  59         printk("Outstanding mallocs:%d, outstanding buffers: %d\n",
  60                check_malloc, check_bread);
  61 #endif
  62
  63         kfree(sbi);
  64         sb->s_fs_info = NULL;
  65         return;
  66 }
  67
  68 static void isofs_read_inode(struct inode *);
  69 static int isofs_statfs (struct super_block *, struct kstatfs *);
  70
  71 static kmem_cache_t *isofs_inode_cachep;
  72
  73 static struct inode *isofs_alloc_inode(struct super_block *sb)
  74 {
  75         struct iso_inode_info *ei;
  76         ei = (struct iso_inode_info *)kmem_cache_alloc(isofs_inode_cachep, SLAB_KERNEL);
  77         if (!ei)
  78                 return NULL;
  79         return &ei->vfs_inode;
  80 }
  81
  82 static void isofs_destroy_inode(struct inode *inode)
  83 {
  84         kmem_cache_free(isofs_inode_cachep, ISOFS_I(inode));
  85 }
  86
  87 static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
  88 {
  89         struct iso_inode_info *ei = (struct iso_inode_info *) foo;
  90
  91         if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
  92             SLAB_CTOR_CONSTRUCTOR)
  93                 inode_init_once(&ei->vfs_inode);
  94 }
  95
  96 static int init_inodecache(void)
  97 {
  98         isofs_inode_cachep = kmem_cache_create("isofs_inode_cache",
  99                                              sizeof(struct iso_inode_info),
 100                                              0, SLAB_RECLAIM_ACCOUNT,
 101                                              init_once, NULL);
 102         if (isofs_inode_cachep == NULL)
 103                 return -ENOMEM;
 104         return 0;
 105 }
 106
 107 static void destroy_inodecache(void)
 108 {
 109         if (kmem_cache_destroy(isofs_inode_cachep))
 110                 printk(KERN_INFO "iso_inode_cache: not all structures were freed\n");
 111 }
 112
 113 static int isofs_remount(struct super_block *sb, int *flags, char *data)
 114 {
 115         /* we probably want a lot more here */
 116         *flags |= MS_RDONLY;
 117         return 0;
 118 }
 119
 120 static struct super_operations isofs_sops = {
 121         .alloc_inode    = isofs_alloc_inode,
 122         .destroy_inode  = isofs_destroy_inode,
 123         .read_inode     = isofs_read_inode,
 124         .put_super      = isofs_put_super,
 125         .statfs         = isofs_statfs,
 126         .remount_fs     = isofs_remount,
 127 };
 128
 129
 130 static struct dentry_operations isofs_dentry_ops[] = {
 131         {
 132                 .d_hash         = isofs_hash,
 133                 .d_compare      = isofs_dentry_cmp,
 134         },
 135         {
 136                 .d_hash         = isofs_hashi,
 137                 .d_compare      = isofs_dentry_cmpi,
 138         },
 139 #ifdef CONFIG_JOLIET
 140         {
 141                 .d_hash         = isofs_hash_ms,
 142                 .d_compare      = isofs_dentry_cmp_ms,
 143         },
 144         {
 145                 .d_hash         = isofs_hashi_ms,
 146                 .d_compare      = isofs_dentry_cmpi_ms,
 147         }
 148 #endif
 149 };
 150
 151 struct iso9660_options{
 152         char map;
 153         char rock;
 154         char joliet;
 155         char cruft;
 156         char unhide;
 157         char nocompress;
 158         unsigned char check;
 159         unsigned int blocksize;
 160         mode_t mode;
 161         gid_t gid;
 162         uid_t uid;
 163         char *iocharset;
 164         unsigned char utf8;
 165         /* LVE */
 166         s32 session;
 167         s32 sbsector;
 168 };
 169
 170 /*
 171  * Compute the hash for the isofs name corresponding to the dentry.
 172  */
 173 static int
 174 isofs_hash_common(struct dentry *dentry, struct qstr *qstr, int ms)
 175 {
 176         const char *name;
 177         int len;
 178
 179         len = qstr->len;
 180         name = qstr->name;
 181         if (ms) {
 182                 while (len && name[len-1] == '.')
 183                         len--;
 184         }
 185
 186         qstr->hash = full_name_hash(name, len);
 187
 188         return 0;
 189 }
 190
 191 /*
 192  * Compute the hash for the isofs name corresponding to the dentry.
 193  */
 194 static int
 195 isofs_hashi_common(struct dentry *dentry, struct qstr *qstr, int ms)
 196 {
 197         const char *name;
 198         int len;
 199         char c;
 200         unsigned long hash;
 201
 202         len = qstr->len;
 203         name = qstr->name;
 204         if (ms) {
 205                 while (len && name[len-1] == '.')
 206                         len--;
 207         }
 208
 209         hash = init_name_hash();
 210         while (len--) {
 211                 c = tolower(*name++);
 212                 hash = partial_name_hash(tolower(c), hash);
 213         }
 214         qstr->hash = end_name_hash(hash);
 215
 216         return 0;
 217 }
 218
 219 /*
 220  * Case insensitive compare of two isofs names.
 221  */
 222 static int
 223 isofs_dentry_cmpi_common(struct dentry *dentry,struct qstr *a,struct qstr *b,int ms)
 224 {
 225         int alen, blen;
 226
 227         /* A filename cannot end in '.' or we treat it like it has none */
 228         alen = a->len;
 229         blen = b->len;
 230         if (ms) {
 231                 while (alen && a->name[alen-1] == '.')
 232                         alen--;
 233                 while (blen && b->name[blen-1] == '.')
 234                         blen--;
 235         }
 236         if (alen == blen) {
 237                 if (strnicmp(a->name, b->name, alen) == 0)
 238                         return 0;
 239         }
 240         return 1;
 241 }
 242
 243 /*
 244  * Case sensitive compare of two isofs names.
 245  */
 246 static int
 247 isofs_dentry_cmp_common(struct dentry *dentry,struct qstr *a,struct qstr *b,int ms)
 248 {
 249         int alen, blen;
 250
 251         /* A filename cannot end in '.' or we treat it like it has none */
 252         alen = a->len;
 253         blen = b->len;
 254         if (ms) {
 255                 while (alen && a->name[alen-1] == '.')
 256                         alen--;
 257                 while (blen && b->name[blen-1] == '.')
 258                         blen--;
 259         }
 260         if (alen == blen) {
 261                 if (strncmp(a->name, b->name, alen) == 0)
 262                         return 0;
 263         }
 264         return 1;
 265 }
 266
 267 static int
 268 isofs_hash(struct dentry *dentry, struct qstr *qstr)
 269 {
 270         return isofs_hash_common(dentry, qstr, 0);
 271 }
 272
 273 static int
 274 isofs_hashi(struct dentry *dentry, struct qstr *qstr)
 275 {
 276         return isofs_hashi_common(dentry, qstr, 0);
 277 }
 278
 279 static int
 280 isofs_dentry_cmp(struct dentry *dentry,struct qstr *a,struct qstr *b)
 281 {
 282         return isofs_dentry_cmp_common(dentry, a, b, 0);
 283 }
 284
 285 static int
 286 isofs_dentry_cmpi(struct dentry *dentry,struct qstr *a,struct qstr *b)
 287 {
 288         return isofs_dentry_cmpi_common(dentry, a, b, 0);
 289 }
 290
 291 #ifdef CONFIG_JOLIET
 292 static int
 293 isofs_hash_ms(struct dentry *dentry, struct qstr *qstr)
 294 {
 295         return isofs_hash_common(dentry, qstr, 1);
 296 }
 297
 298 static int
 299 isofs_hashi_ms(struct dentry *dentry, struct qstr *qstr)
 300 {
 301         return isofs_hashi_common(dentry, qstr, 1);
 302 }
 303
 304 static int
 305 isofs_dentry_cmp_ms(struct dentry *dentry,struct qstr *a,struct qstr *b)
 306 {
 307         return isofs_dentry_cmp_common(dentry, a, b, 1);
 308 }
 309
 310 static int
 311 isofs_dentry_cmpi_ms(struct dentry *dentry,struct qstr *a,struct qstr *b)
 312 {
 313         return isofs_dentry_cmpi_common(dentry, a, b, 1);
 314 }
 315 #endif
 316
 317 enum {
 318         Opt_block, Opt_check_r, Opt_check_s, Opt_cruft, Opt_gid, Opt_ignore,
 319         Opt_iocharset, Opt_map_a, Opt_map_n, Opt_map_o, Opt_mode, Opt_nojoliet,
 320         Opt_norock, Opt_sb, Opt_session, Opt_uid, Opt_unhide, Opt_utf8, Opt_err,
 321         Opt_nocompress,
 322 };
 323
 324 static match_table_t tokens = {
 325         {Opt_norock, "norock"},
 326         {Opt_nojoliet, "nojoliet"},
 327         {Opt_unhide, "unhide"},
 328         {Opt_cruft, "cruft"},
 329         {Opt_utf8, "utf8"},
 330         {Opt_iocharset, "iocharset=%s"},
 331         {Opt_map_a, "map=acorn"},
 332         {Opt_map_a, "map=a"},
 333         {Opt_map_n, "map=normal"},
 334         {Opt_map_n, "map=n"},
 335         {Opt_map_o, "map=off"},
 336         {Opt_map_o, "map=o"},
 337         {Opt_session, "session=%u"},
 338         {Opt_sb, "sbsector=%u"},
 339         {Opt_check_r, "check=relaxed"},
 340         {Opt_check_r, "check=r"},
 341         {Opt_check_s, "check=strict"},
 342         {Opt_check_s, "check=s"},
 343         {Opt_uid, "uid=%u"},
 344         {Opt_gid, "gid=%u"},
 345         {Opt_mode, "mode=%u"},
 346         {Opt_block, "block=%u"},
 347         {Opt_ignore, "conv=binary"},
 348         {Opt_ignore, "conv=b"},
 349         {Opt_ignore, "conv=text"},
 350         {Opt_ignore, "conv=t"},
 351         {Opt_ignore, "conv=mtext"},
 352         {Opt_ignore, "conv=m"},
 353         {Opt_ignore, "conv=auto"},
 354         {Opt_ignore, "conv=a"},
 355         {Opt_nocompress, "nocompress"},
 356         {Opt_err, NULL}
 357 };
 358
 359 static int parse_options(char *options, struct iso9660_options * popt)
 360 {
 361         char *p;
 362         int option;
 363
 364         popt->map = 'n';
 365         popt->rock = 'y';
 366         popt->joliet = 'y';
 367         popt->cruft = 'n';
 368         popt->unhide = 'n';
 369         popt->check = 'u';              /* unset */
 370         popt->nocompress = 0;
 371         popt->blocksize = 1024;
 372         popt->mode = S_IRUGO | S_IXUGO; /* r-x for all.  The disc could
 373                                            be shared with DOS machines so
 374                                            virtually anything could be
 375                                            a valid executable. */
 376         popt->gid = 0;
 377         popt->uid = 0;
 378         popt->iocharset = NULL;
 379         popt->utf8 = 0;
 380         popt->session=-1;
 381         popt->sbsector=-1;
 382         if (!options)
 383                 return 1;
 384
 385         while ((p = strsep(&options, ",")) != NULL) {
 386                 int token;
 387                 substring_t args[MAX_OPT_ARGS];
 388                 unsigned n;
 389
 390                 if (!*p)
 391                         continue;
 392
 393                 token = match_token(p, tokens, args);
 394                 switch (token) {
 395                 case Opt_norock:
 396                         popt->rock = 'n';
 397                         break;
 398                 case Opt_nojoliet:
 399                         popt->joliet = 'n';
 400                         break;
 401                 case Opt_unhide:
 402                         popt->unhide = 'y';
 403                         break;
 404                 case Opt_cruft:
 405                         popt->cruft = 'y';
 406                         break;
 407                 case Opt_utf8:
 408                         popt->utf8 = 1;
 409                         break;
 410 #ifdef CONFIG_JOLIET
 411                 case Opt_iocharset:
 412                         popt->iocharset = match_strdup(&args[0]);
 413                         break;
 414 #endif
 415                 case Opt_map_a:
 416                         popt->map = 'a';
 417                         break;
 418                 case Opt_map_o:
 419                         popt->map = 'o';
 420                         break;
 421                 case Opt_map_n:
 422                         popt->map = 'n';
 423                         break;
 424                 case Opt_session:
 425                         if (match_int(&args[0], &option))
 426                                 return 0;
 427                         n = option;
 428                         if (n > 99)
 429                                 return 0;
 430                         popt->session = n + 1;
 431                         break;
 432                 case Opt_sb:
 433                         if (match_int(&args[0], &option))
 434                                 return 0;
 435                         popt->sbsector = option;
 436                         break;
 437                 case Opt_check_r:
 438                         popt->check = 'r';
 439                         break;
 440                 case Opt_check_s:
 441                         popt->check = 's';
 442                         break;
 443                 case Opt_ignore:
 444                         break;
 445                 case Opt_uid:
 446                         if (match_int(&args[0], &option))
 447                                 return 0;
 448                         popt->uid = option;
 449                         break;
 450                 case Opt_gid:
 451                         if (match_int(&args[0], &option))
 452                                 return 0;
 453                         popt->gid = option;
 454                         break;
 455                 case Opt_mode:
 456                         if (match_int(&args[0], &option))
 457                                 return 0;
 458                         popt->mode = option;
 459                         break;
 460                 case Opt_block:
 461                         if (match_int(&args[0], &option))
 462                                 return 0;
 463                         n = option;
 464                         if (n != 512 && n != 1024 && n != 2048)
 465                                 return 0;
 466                         popt->blocksize = n;
 467                         break;
 468                 case Opt_nocompress:
 469                         popt->nocompress = 1;
 470                         break;
 471                 default:
 472                         return 0;
 473                 }
 474         }
 475         return 1;
 476 }
 477
 478 /*
 479  * look if the driver can tell the multi session redirection value
 480  *
 481  * don't change this if you don't know what you do, please!
 482  * Multisession is legal only with XA disks.
 483  * A non-XA disk with more than one volume descriptor may do it right, but
 484  * usually is written in a nowhere standardized "multi-partition" manner.
 485  * Multisession uses absolute addressing (solely the first frame of the whole
 486  * track is #0), multi-partition uses relative addressing (each first frame of
 487  * each track is #0), and a track is not a session.
 488  *
 489  * A broken CDwriter software or drive firmware does not set new standards,
 490  * at least not if conflicting with the existing ones.
 491  *
 492  * emoenke@gwdg.de
 493  */
 494 #define WE_OBEY_THE_WRITTEN_STANDARDS 1
 495
 496 static unsigned int isofs_get_last_session(struct super_block *sb,s32 session )
 497 {
 498         struct cdrom_multisession ms_info;
 499         unsigned int vol_desc_start;
 500         struct block_device *bdev = sb->s_bdev;
 501         int i;
 502
 503         vol_desc_start=0;
 504         ms_info.addr_format=CDROM_LBA;
 505         if(session >= 0 && session <= 99) {
 506                 struct cdrom_tocentry Te;
 507                 Te.cdte_track=session;
 508                 Te.cdte_format=CDROM_LBA;
 509                 i = ioctl_by_bdev(bdev, CDROMREADTOCENTRY, (unsigned long) &Te);
 510                 if (!i) {
 511                         printk(KERN_DEBUG "Session %d start %d type %d\n",
 512                                session, Te.cdte_addr.lba,
 513                                Te.cdte_ctrl&CDROM_DATA_TRACK);
 514                         if ((Te.cdte_ctrl&CDROM_DATA_TRACK) == 4)
 515                                 return Te.cdte_addr.lba;
 516                 }
 517
 518                 printk(KERN_ERR "Invalid session number or type of track\n");
 519         }
 520         i = ioctl_by_bdev(bdev, CDROMMULTISESSION, (unsigned long) &ms_info);
 521         if(session > 0) 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(struct isofs_sb_info), GFP_KERNEL);
 561         if (!sbi)
 562                 return -ENOMEM;
 563         s->s_fs_info = sbi;
 564         memset(sbi, 0, sizeof(struct isofs_sb_info));
 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_unhide = opt.unhide;
 796         sbi->s_uid = opt.uid;
 797         sbi->s_gid = opt.gid;
 798         sbi->s_utf8 = opt.utf8;
 799         sbi->s_nocompress = opt.nocompress;
 800         /*
 801          * It would be incredibly stupid to allow people to mark every file
 802          * on the disk as suid, so we merely allow them to set the default
 803          * permissions.
 804          */
 805         sbi->s_mode = opt.mode & 0777;
 806
 807         /*
 808          * Read the root inode, which _may_ result in changing
 809          * the s_rock flag. Once we have the final s_rock value,
 810          * we then decide whether to use the Joliet descriptor.
 811          */
 812         inode = isofs_iget(s, sbi->s_firstdatazone, 0);
 813
 814         /*
 815          * If this disk has both Rock Ridge and Joliet on it, then we
 816          * want to use Rock Ridge by default.  This can be overridden
 817          * by using the norock mount option.  There is still one other
 818          * possibility that is not taken into account: a Rock Ridge
 819          * CD with Unicode names.  Until someone sees such a beast, it
 820          * will not be supported.
 821          */
 822         if (sbi->s_rock == 1) {
 823                 joliet_level = 0;
 824         } else if (joliet_level) {
 825                 sbi->s_rock = 0;
 826                 if (sbi->s_firstdatazone != first_data_zone) {
 827                         sbi->s_firstdatazone = first_data_zone;
 828                         printk(KERN_DEBUG
 829                                 "ISOFS: changing to secondary root\n");
 830                         iput(inode);
 831                         inode = isofs_iget(s, sbi->s_firstdatazone, 0);
 832                 }
 833         }
 834
 835         if (opt.check == 'u') {
 836                 /* Only Joliet is case insensitive by default */
 837                 if (joliet_level) opt.check = 'r';
 838                 else opt.check = 's';
 839         }
 840         sbi->s_joliet_level = joliet_level;
 841
 842         /* check the root inode */
 843         if (!inode)
 844                 goto out_no_root;
 845         if (!inode->i_op)
 846                 goto out_bad_root;
 847         /* get the root dentry */
 848         s->s_root = d_alloc_root(inode);
 849         if (!(s->s_root))
 850                 goto out_no_root;
 851
 852         table = 0;
 853         if (joliet_level) table += 2;
 854         if (opt.check == 'r') table++;
 855         s->s_root->d_op = &isofs_dentry_ops[table];
 856
 857         if (opt.iocharset)
 858                 kfree(opt.iocharset);
 859
 860         return 0;
 861
 862         /*
 863          * Display error messages and free resources.
 864          */
 865 out_bad_root:
 866         printk(KERN_WARNING "isofs_fill_super: root inode not initialized\n");
 867         goto out_iput;
 868 out_no_root:
 869         printk(KERN_WARNING "isofs_fill_super: get root inode failed\n");
 870 out_iput:
 871         iput(inode);
 872 #ifdef CONFIG_JOLIET
 873         if (sbi->s_nls_iocharset)
 874                 unload_nls(sbi->s_nls_iocharset);
 875 #endif
 876         goto out_freesbi;
 877 out_no_read:
 878         printk(KERN_WARNING "isofs_fill_super: "
 879                 "bread failed, dev=%s, iso_blknum=%d, block=%d\n",
 880                 s->s_id, iso_blknum, block);
 881         goto out_freesbi;
 882 out_bad_zone_size:
 883         printk(KERN_WARNING "Bad logical zone size %ld\n",
 884                 sbi->s_log_zone_size);
 885         goto out_freebh;
 886 out_bad_size:
 887         printk(KERN_WARNING "Logical zone size(%d) < hardware blocksize(%u)\n",
 888                 orig_zonesize, opt.blocksize);
 889         goto out_freebh;
 890 out_unknown_format:
 891         if (!silent)
 892                 printk(KERN_WARNING "Unable to identify CD-ROM format.\n");
 893
 894 out_freebh:
 895         brelse(bh);
 896 out_freesbi:
 897         if (opt.iocharset)
 898                 kfree(opt.iocharset);
 899         kfree(sbi);
 900         s->s_fs_info = NULL;
 901         return -EINVAL;
 902 }
 903
 904 static int isofs_statfs (struct super_block *sb, struct kstatfs *buf)
 905 {
 906         buf->f_type = ISOFS_SUPER_MAGIC;
 907         buf->f_bsize = sb->s_blocksize;
 908         buf->f_blocks = (ISOFS_SB(sb)->s_nzones
 909                   << (ISOFS_SB(sb)->s_log_zone_size - sb->s_blocksize_bits));
 910         buf->f_bfree = 0;
 911         buf->f_bavail = 0;
 912         buf->f_files = ISOFS_SB(sb)->s_ninodes;
 913         buf->f_ffree = 0;
 914         buf->f_namelen = NAME_MAX;
 915         return 0;
 916 }
 917
 918 /*
 919  * Get a set of blocks; filling in buffer_heads if already allocated
 920  * or getblk() if they are not.  Returns the number of blocks inserted
 921  * (0 == error.)
 922  */
 923 int isofs_get_blocks(struct inode *inode, sector_t iblock_s,
 924                      struct buffer_head **bh, unsigned long nblocks)
 925 {
 926         unsigned long b_off;
 927         unsigned offset, sect_size;
 928         unsigned int firstext;
 929         unsigned long nextblk, nextoff;
 930         long iblock = (long)iblock_s;
 931         int section, rv;
 932         struct iso_inode_info *ei = ISOFS_I(inode);
 933
 934         lock_kernel();
 935
 936         rv = 0;
 937         if (iblock < 0 || iblock != iblock_s) {
 938                 printk("isofs_get_blocks: block number too large\n");
 939                 goto abort;
 940         }
 941
 942         b_off = iblock;
 943
 944         offset    = 0;
 945         firstext  = ei->i_first_extent;
 946         sect_size = ei->i_section_size >> ISOFS_BUFFER_BITS(inode);
 947         nextblk   = ei->i_next_section_block;
 948         nextoff   = ei->i_next_section_offset;
 949         section   = 0;
 950
 951         while ( nblocks ) {
 952                 /* If we are *way* beyond the end of the file, print a message.
 953                  * Access beyond the end of the file up to the next page boundary
 954                  * is normal, however because of the way the page cache works.
 955                  * In this case, we just return 0 so that we can properly fill
 956                  * the page with useless information without generating any
 957                  * I/O errors.
 958                  */
 959                 if (b_off > ((inode->i_size + PAGE_CACHE_SIZE - 1) >> ISOFS_BUFFER_BITS(inode))) {
 960                         printk("isofs_get_blocks: block >= EOF (%ld, %ld)\n",
 961                                iblock, (unsigned long) inode->i_size);
 962                         goto abort;
 963                 }
 964
 965                 if (nextblk) {
 966                         while (b_off >= (offset + sect_size)) {
 967                                 struct inode *ninode;
 968
 969                                 offset += sect_size;
 970                                 if (nextblk == 0)
 971                                         goto abort;
 972                                 ninode = isofs_iget(inode->i_sb, nextblk, nextoff);
 973                                 if (!ninode)
 974                                         goto abort;
 975                                 firstext  = ISOFS_I(ninode)->i_first_extent;
 976                                 sect_size = ISOFS_I(ninode)->i_section_size >> ISOFS_BUFFER_BITS(ninode);
 977                                 nextblk   = ISOFS_I(ninode)->i_next_section_block;
 978                                 nextoff   = ISOFS_I(ninode)->i_next_section_offset;
 979                                 iput(ninode);
 980
 981                                 if (++section > 100) {
 982                                         printk("isofs_get_blocks: More than 100 file sections ?!?, aborting...\n");
 983                                         printk("isofs_get_blocks: block=%ld firstext=%u sect_size=%u "
 984                                                "nextblk=%lu nextoff=%lu\n",
 985                                                iblock, firstext, (unsigned) sect_size,
 986                                                nextblk, nextoff);
 987                                         goto abort;
 988                                 }
 989                         }
 990                 }
 991
 992                 if ( *bh ) {
 993                         map_bh(*bh, inode->i_sb, firstext + b_off - offset);
 994                 } else {
 995                         *bh = sb_getblk(inode->i_sb, firstext+b_off-offset);
 996                         if ( !*bh )
 997                                 goto abort;
 998                 }
 999                 bh++;   /* Next buffer head */
1000                 b_off++;        /* Next buffer offset */
1001                 nblocks--;
1002                 rv++;
1003         }
1004
1005
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
1069 static inline void test_and_set_gid(gid_t *p, gid_t value)
1070 {
1071         if(value) {
1072                 *p = value;
1073         }
1074 }
1075
1076 static int isofs_read_level3_size(struct inode * inode)
1077 {
1078         unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
1079         int high_sierra = ISOFS_SB(inode->i_sb)->s_high_sierra;
1080         struct buffer_head * bh = NULL;
1081         unsigned long block, offset, block_saved, offset_saved;
1082         int i = 0;
1083         int more_entries = 0;
1084         struct iso_directory_record * tmpde = NULL;
1085         struct iso_inode_info *ei = ISOFS_I(inode);
1086
1087         inode->i_size = 0;
1088
1089         /* The first 16 blocks are reserved as the System Area.  Thus,
1090          * no inodes can appear in block 0.  We use this to flag that
1091          * this is the last section. */
1092         ei->i_next_section_block = 0;
1093         ei->i_next_section_offset = 0;
1094
1095         block = ei->i_iget5_block;
1096         offset = ei->i_iget5_offset;
1097
1098         do {
1099                 struct iso_directory_record * de;
1100                 unsigned int de_len;
1101
1102                 if (!bh) {
1103                         bh = sb_bread(inode->i_sb, block);
1104                         if (!bh)
1105                                 goto out_noread;
1106                 }
1107                 de = (struct iso_directory_record *) (bh->b_data + offset);
1108                 de_len = *(unsigned char *) de;
1109
1110                 if (de_len == 0) {
1111                         brelse(bh);
1112                         bh = NULL;
1113                         ++block;
1114                         offset = 0;
1115                         continue;
1116                 }
1117
1118                 block_saved = block;
1119                 offset_saved = offset;
1120                 offset += de_len;
1121
1122                 /* Make sure we have a full directory entry */
1123                 if (offset >= bufsize) {
1124                         int slop = bufsize - offset + de_len;
1125                         if (!tmpde) {
1126                                 tmpde = kmalloc(256, GFP_KERNEL);
1127                                 if (!tmpde)
1128                                         goto out_nomem;
1129                         }
1130                         memcpy(tmpde, de, slop);
1131                         offset &= bufsize - 1;
1132                         block++;
1133                         brelse(bh);
1134                         bh = NULL;
1135                         if (offset) {
1136                                 bh = sb_bread(inode->i_sb, block);
1137                                 if (!bh)
1138                                         goto out_noread;
1139                                 memcpy((void *) tmpde + slop, bh->b_data, offset);
1140                         }
1141                         de = tmpde;
1142                 }
1143
1144                 inode->i_size += isonum_733(de->size);
1145                 if (i == 1) {
1146                         ei->i_next_section_block = block_saved;
1147                         ei->i_next_section_offset = offset_saved;
1148                 }
1149
1150                 more_entries = de->flags[-high_sierra] & 0x80;
1151
1152                 i++;
1153                 if(i > 100)
1154                         goto out_toomany;
1155         } while(more_entries);
1156 out:
1157         if (tmpde)
1158                 kfree(tmpde);
1159         if (bh)
1160                 brelse(bh);
1161         return 0;
1162
1163 out_nomem:
1164         if (bh)
1165                 brelse(bh);
1166         return -ENOMEM;
1167
1168 out_noread:
1169         printk(KERN_INFO "ISOFS: unable to read i-node block %lu\n", block);
1170         if (tmpde)
1171                 kfree(tmpde);
1172         return -EIO;
1173
1174 out_toomany:
1175         printk(KERN_INFO "isofs_read_level3_size: "
1176                 "More than 100 file sections ?!?, aborting...\n"
1177                 "isofs_read_level3_size: inode=%lu\n",
1178                 inode->i_ino);
1179         goto out;
1180 }
1181
1182 static void isofs_read_inode(struct inode * inode)
1183 {
1184         struct super_block *sb = inode->i_sb;
1185         struct isofs_sb_info *sbi = ISOFS_SB(sb);
1186         unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
1187         unsigned long block;
1188         int high_sierra = sbi->s_high_sierra;
1189         struct buffer_head * bh = NULL;
1190         struct iso_directory_record * de;
1191         struct iso_directory_record * tmpde = NULL;
1192         unsigned int de_len;
1193         unsigned long offset;
1194         struct iso_inode_info *ei = ISOFS_I(inode);
1195
1196         block = ei->i_iget5_block;
1197         bh = sb_bread(inode->i_sb, block);
1198         if (!bh)
1199                 goto out_badread;
1200
1201         offset = ei->i_iget5_offset;
1202
1203         de = (struct iso_directory_record *) (bh->b_data + offset);
1204         de_len = *(unsigned char *) de;
1205
1206         if (offset + de_len > bufsize) {
1207                 int frag1 = bufsize - offset;
1208
1209                 tmpde = kmalloc(de_len, GFP_KERNEL);
1210                 if (tmpde == NULL) {
1211                         printk(KERN_INFO "isofs_read_inode: out of memory\n");
1212                         goto fail;
1213                 }
1214                 memcpy(tmpde, bh->b_data + offset, frag1);
1215                 brelse(bh);
1216                 bh = sb_bread(inode->i_sb, ++block);
1217                 if (!bh)
1218                         goto out_badread;
1219                 memcpy((char *)tmpde+frag1, bh->b_data, de_len - frag1);
1220                 de = tmpde;
1221         }
1222
1223         inode->i_ino = isofs_get_ino(ei->i_iget5_block,
1224                                      ei->i_iget5_offset,
1225                                      ISOFS_BUFFER_BITS(inode));
1226
1227         /* Assume it is a normal-format file unless told otherwise */
1228         ei->i_file_format = isofs_file_normal;
1229
1230         if (de->flags[-high_sierra] & 2) {
1231                 inode->i_mode = S_IRUGO | S_IXUGO | S_IFDIR;
1232                 inode->i_nlink = 1; /* Set to 1.  We know there are 2, but
1233                                        the find utility tries to optimize
1234                                        if it is 2, and it screws up.  It is
1235                                        easier to give 1 which tells find to
1236                                        do it the hard way. */
1237         } else {
1238                 /* Everybody gets to read the file. */
1239                 inode->i_mode = sbi->s_mode;
1240                 inode->i_nlink = 1;
1241                 inode->i_mode |= S_IFREG;
1242         }
1243         inode->i_uid = sbi->s_uid;
1244         inode->i_gid = sbi->s_gid;
1245         inode->i_blocks = inode->i_blksize = 0;
1246
1247         ei->i_format_parm[0] = 0;
1248         ei->i_format_parm[1] = 0;
1249         ei->i_format_parm[2] = 0;
1250
1251         ei->i_section_size = isonum_733 (de->size);
1252         if(de->flags[-high_sierra] & 0x80) {
1253                 if(isofs_read_level3_size(inode)) goto fail;
1254         } else {
1255                 ei->i_next_section_block = 0;
1256                 ei->i_next_section_offset = 0;
1257                 inode->i_size = isonum_733 (de->size);
1258         }
1259
1260         /*
1261          * Some dipshit decided to store some other bit of information
1262          * in the high byte of the file length.  Truncate size in case
1263          * this CDROM was mounted with the cruft option.
1264          */
1265
1266         if (sbi->s_cruft == 'y')
1267                 inode->i_size &= 0x00ffffff;
1268
1269         if (de->interleave[0]) {
1270                 printk("Interleaved files not (yet) supported.\n");
1271                 inode->i_size = 0;
1272         }
1273
1274         /* I have no idea what file_unit_size is used for, so
1275            we will flag it for now */
1276         if (de->file_unit_size[0] != 0) {
1277                 printk("File unit size != 0 for ISO file (%ld).\n",
1278                        inode->i_ino);
1279         }
1280
1281         /* I have no idea what other flag bits are used for, so
1282            we will flag it for now */
1283 #ifdef DEBUG
1284         if((de->flags[-high_sierra] & ~2)!= 0){
1285                 printk("Unusual flag settings for ISO file (%ld %x).\n",
1286                        inode->i_ino, de->flags[-high_sierra]);
1287         }
1288 #endif
1289
1290         inode->i_mtime.tv_sec =
1291         inode->i_atime.tv_sec =
1292         inode->i_ctime.tv_sec = iso_date(de->date, high_sierra);
1293         inode->i_mtime.tv_nsec =
1294         inode->i_atime.tv_nsec =
1295         inode->i_ctime.tv_nsec = 0;
1296
1297         ei->i_first_extent = (isonum_733 (de->extent) +
1298                               isonum_711 (de->ext_attr_length));
1299
1300         /* Set the number of blocks for stat() - should be done before RR */
1301         inode->i_blksize = PAGE_CACHE_SIZE; /* For stat() only */
1302         inode->i_blocks  = (inode->i_size + 511) >> 9;
1303
1304         /*
1305          * Now test for possible Rock Ridge extensions which will override
1306          * some of these numbers in the inode structure.
1307          */
1308
1309         if (!high_sierra) {
1310                 parse_rock_ridge_inode(de, inode);
1311                 /* if we want uid/gid set, override the rock ridge setting */
1312                 test_and_set_uid(&inode->i_uid, sbi->s_uid);
1313                 test_and_set_gid(&inode->i_gid, sbi->s_gid);
1314         }
1315
1316         /* Install the inode operations vector */
1317         if (S_ISREG(inode->i_mode)) {
1318                 inode->i_fop = &generic_ro_fops;
1319                 switch ( ei->i_file_format ) {
1320 #ifdef CONFIG_ZISOFS
1321                 case isofs_file_compressed:
1322                         inode->i_data.a_ops = &zisofs_aops;
1323                         break;
1324 #endif
1325                 default:
1326                         inode->i_data.a_ops = &isofs_aops;
1327                         break;
1328                 }
1329         } else if (S_ISDIR(inode->i_mode)) {
1330                 inode->i_op = &isofs_dir_inode_operations;
1331                 inode->i_fop = &isofs_dir_operations;
1332         } else if (S_ISLNK(inode->i_mode)) {
1333                 inode->i_op = &page_symlink_inode_operations;
1334                 inode->i_data.a_ops = &isofs_symlink_aops;
1335         } else
1336                 /* XXX - parse_rock_ridge_inode() had already set i_rdev. */
1337                 init_special_inode(inode, inode->i_mode, inode->i_rdev);
1338
1339  out:
1340         if (tmpde)
1341                 kfree(tmpde);
1342         if (bh)
1343                 brelse(bh);
1344         return;
1345
1346  out_badread:
1347         printk(KERN_WARNING "ISOFS: unable to read i-node block\n");
1348  fail:
1349         make_bad_inode(inode);
1350         goto out;
1351 }
1352
1353 struct isofs_iget5_callback_data {
1354         unsigned long block;
1355         unsigned long offset;
1356 };
1357
1358 static int isofs_iget5_test(struct inode *ino, void *data)
1359 {
1360         struct iso_inode_info *i = ISOFS_I(ino);
1361         struct isofs_iget5_callback_data *d =
1362                 (struct isofs_iget5_callback_data*)data;
1363         return (i->i_iget5_block == d->block)
1364                && (i->i_iget5_offset == d->offset);
1365 }
1366
1367 static int isofs_iget5_set(struct inode *ino, void *data)
1368 {
1369         struct iso_inode_info *i = ISOFS_I(ino);
1370         struct isofs_iget5_callback_data *d =
1371                 (struct isofs_iget5_callback_data*)data;
1372         i->i_iget5_block = d->block;
1373         i->i_iget5_offset = d->offset;
1374         return 0;
1375 }
1376
1377 /* Store, in the inode's containing structure, the block and block
1378  * offset that point to the underlying meta-data for the inode.  The
1379  * code below is otherwise similar to the iget() code in
1380  * include/linux/fs.h */
1381 struct inode *isofs_iget(struct super_block *sb,
1382                          unsigned long block,
1383                          unsigned long offset)
1384 {
1385         unsigned long hashval;
1386         struct inode *inode;
1387         struct isofs_iget5_callback_data data;
1388
1389         if (offset >= 1ul << sb->s_blocksize_bits)
1390                 return NULL;
1391
1392         data.block = block;
1393         data.offset = offset;
1394
1395         hashval = (block << sb->s_blocksize_bits) | offset;
1396
1397         inode = iget5_locked(sb,
1398                              hashval,
1399                              &isofs_iget5_test,
1400                              &isofs_iget5_set,
1401                              &data);
1402
1403         if (inode && (inode->i_state & I_NEW)) {
1404                 sb->s_op->read_inode(inode);
1405                 unlock_new_inode(inode);
1406         }
1407
1408         return inode;
1409 }
1410
1411 #ifdef LEAK_CHECK
1412 #undef malloc
1413 #undef free_s
1414 #undef sb_bread
1415 #undef brelse
1416
1417 void * leak_check_malloc(unsigned int size){
1418   void * tmp;
1419   check_malloc++;
1420   tmp = kmalloc(size, GFP_KERNEL);
1421   return tmp;
1422 }
1423
1424 void leak_check_free_s(void * obj, int size){
1425   check_malloc--;
1426   return kfree(obj);
1427 }
1428
1429 struct buffer_head * leak_check_bread(struct super_block *sb, int block){
1430   check_bread++;
1431   return sb_bread(sb, block);
1432 }
1433
1434 void leak_check_brelse(struct buffer_head * bh){
1435   check_bread--;
1436   return brelse(bh);
1437 }
1438
1439 #endif
1440
1441 static struct super_block *isofs_get_sb(struct file_system_type *fs_type,
1442         int flags, const char *dev_name, void *data)
1443 {
1444         return get_sb_bdev(fs_type, flags, dev_name, data, isofs_fill_super);
1445 }
1446
1447 static struct file_system_type iso9660_fs_type = {
1448         .owner          = THIS_MODULE,
1449         .name           = "iso9660",
1450         .get_sb         = isofs_get_sb,
1451         .kill_sb        = kill_block_super,
1452         .fs_flags       = FS_REQUIRES_DEV,
1453 };
1454
1455 static int __init init_iso9660_fs(void)
1456 {
1457         int err = init_inodecache();
1458         if (err)
1459                 goto out;
1460 #ifdef CONFIG_ZISOFS
1461         err = zisofs_init();
1462         if (err)
1463                 goto out1;
1464 #endif
1465         err = register_filesystem(&iso9660_fs_type);
1466         if (err)
1467                 goto out2;
1468         return 0;
1469 out2:
1470 #ifdef CONFIG_ZISOFS
1471         zisofs_cleanup();
1472 out1:
1473 #endif
1474         destroy_inodecache();
1475 out:
1476         return err;
1477 }
1478
1479 static void __exit exit_iso9660_fs(void)
1480 {
1481         unregister_filesystem(&iso9660_fs_type);
1482 #ifdef CONFIG_ZISOFS
1483         zisofs_cleanup();
1484 #endif
1485         destroy_inodecache();
1486 }
1487
1488 module_init(init_iso9660_fs)
1489 module_exit(exit_iso9660_fs)
1490 MODULE_LICENSE("GPL");
1491 /* Actual filesystem name is iso9660, as requested in filesystems.c */
1492 MODULE_ALIAS("iso9660");