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