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