?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] orinoco: Remove unneeded forward declarations.
[linux-2.6/sactl.git] / fs / isofs / inode.c
blob1652de1b6cb9e0a57bb9d33f6dff568b3f84196d
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");
SocketAccessConTroL development