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