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