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