projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
merge by hand - fix up rejections in Documentation/DocBook/Makefile
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / fs / isofs / inode.c
1 /*
2 * linux/fs/isofs/inode.c
3 *
4 * (C) 1991 Linus Torvalds - minix filesystem
5 * 1992, 1993, 1994 Eric Youngdale Modified for ISO 9660 filesystem.
6 * 1994 Eberhard Moenkeberg - multi session handling.
7 * 1995 Mark Dobie - allow mounting of some weird VideoCDs and PhotoCDs.
8 * 1997 Gordon Chaffee - Joliet CDs
9 * 1998 Eric Lammerts - ISO 9660 Level 3
10 * 2004 Paul Serice - Inode Support pushed out from 4GB to 128GB
11 * 2004 Paul Serice - NFS Export Operations
12 */
13
14 #include <linux/config.h>
15 #include <linux/init.h>
16 #include <linux/module.h>
17
18 #include <linux/slab.h>
19 #include <linux/nls.h>
20 #include <linux/ctype.h>
21 #include <linux/smp_lock.h>
22 #include <linux/statfs.h>
23 #include <linux/cdrom.h>
24 #include <linux/parser.h>
25
26 #include "isofs.h"
27 #include "zisofs.h"
28
29 #define BEQUIET
30
31 #ifdef LEAK_CHECK
32 static int check_malloc;
33 static int check_bread;
34 #endif
35
36 static int isofs_hashi(struct dentry *parent, struct qstr *qstr);
37 static int isofs_hash(struct dentry *parent, struct qstr *qstr);
38 static int isofs_dentry_cmpi(struct dentry *dentry, struct qstr *a, struct qstr *b);
39 static int isofs_dentry_cmp(struct dentry *dentry, struct qstr *a, struct qstr *b);
40
41 #ifdef CONFIG_JOLIET
42 static int isofs_hashi_ms(struct dentry *parent, struct qstr *qstr);
43 static int isofs_hash_ms(struct dentry *parent, struct qstr *qstr);
44 static int isofs_dentry_cmpi_ms(struct dentry *dentry, struct qstr *a, struct qstr *b);
45 static int isofs_dentry_cmp_ms(struct dentry *dentry, struct qstr *a, struct qstr *b);
46 #endif
47
48 static void isofs_put_super(struct super_block *sb)
49 {
50 struct isofs_sb_info *sbi = ISOFS_SB(sb);
51 #ifdef CONFIG_JOLIET
52 if (sbi->s_nls_iocharset) {
53 unload_nls(sbi->s_nls_iocharset);
54 sbi->s_nls_iocharset = NULL;
55 }
56 #endif
57
58 #ifdef LEAK_CHECK
59 printk("Outstanding mallocs:%d, outstanding buffers: %d\n",
60 check_malloc, check_bread);
61 #endif
62
63 kfree(sbi);
64 sb->s_fs_info = NULL;
65 return;
66 }
67
68 static void isofs_read_inode(struct inode *);
69 static int isofs_statfs (struct super_block *, struct kstatfs *);
70
71 static kmem_cache_t *isofs_inode_cachep;
72
73 static struct inode *isofs_alloc_inode(struct super_block *sb)
74 {
75 struct iso_inode_info *ei;
76 ei = (struct iso_inode_info *)kmem_cache_alloc(isofs_inode_cachep, SLAB_KERNEL);
77 if (!ei)
78 return NULL;
79 return &ei->vfs_inode;
80 }
81
82 static void isofs_destroy_inode(struct inode *inode)
83 {
84 kmem_cache_free(isofs_inode_cachep, ISOFS_I(inode));
85 }
86
87 static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
88 {
89 struct iso_inode_info *ei = (struct iso_inode_info *) foo;
90
91 if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
92 SLAB_CTOR_CONSTRUCTOR)
93 inode_init_once(&ei->vfs_inode);
94 }
95
96 static int init_inodecache(void)
97 {
98 isofs_inode_cachep = kmem_cache_create("isofs_inode_cache",
99 sizeof(struct iso_inode_info),
100 0, SLAB_RECLAIM_ACCOUNT,
101 init_once, NULL);
102 if (isofs_inode_cachep == NULL)
103 return -ENOMEM;
104 return 0;
105 }
106
107 static void destroy_inodecache(void)
108 {
109 if (kmem_cache_destroy(isofs_inode_cachep))
110 printk(KERN_INFO "iso_inode_cache: not all structures were freed\n");
111 }
112
113 static int isofs_remount(struct super_block *sb, int *flags, char *data)
114 {
115 /* we probably want a lot more here */
116 *flags |= MS_RDONLY;
117 return 0;
118 }
119
120 static struct super_operations isofs_sops = {
121 .alloc_inode = isofs_alloc_inode,
122 .destroy_inode = isofs_destroy_inode,
123 .read_inode = isofs_read_inode,
124 .put_super = isofs_put_super,
125 .statfs = isofs_statfs,
126 .remount_fs = isofs_remount,
127 };
128
129
130 static struct dentry_operations isofs_dentry_ops[] = {
131 {
132 .d_hash = isofs_hash,
133 .d_compare = isofs_dentry_cmp,
134 },
135 {
136 .d_hash = isofs_hashi,
137 .d_compare = isofs_dentry_cmpi,
138 },
139 #ifdef CONFIG_JOLIET
140 {
141 .d_hash = isofs_hash_ms,
142 .d_compare = isofs_dentry_cmp_ms,
143 },
144 {
145 .d_hash = isofs_hashi_ms,
146 .d_compare = isofs_dentry_cmpi_ms,
147 }
148 #endif
149 };
150
151 struct iso9660_options{
152 char map;
153 char rock;
154 char joliet;
155 char cruft;
156 char unhide;
157 char nocompress;
158 unsigned char check;
159 unsigned int blocksize;
160 mode_t mode;
161 gid_t gid;
162 uid_t uid;
163 char *iocharset;
164 unsigned char utf8;
165 /* LVE */
166 s32 session;
167 s32 sbsector;
168 };
169
170 /*
171 * Compute the hash for the isofs name corresponding to the dentry.
172 */
173 static int
174 isofs_hash_common(struct dentry *dentry, struct qstr *qstr, int ms)
175 {
176 const char *name;
177 int len;
178
179 len = qstr->len;
180 name = qstr->name;
181 if (ms) {
182 while (len && name[len-1] == '.')
183 len--;
184 }
185
186 qstr->hash = full_name_hash(name, len);
187
188 return 0;
189 }
190
191 /*
192 * Compute the hash for the isofs name corresponding to the dentry.
193 */
194 static int
195 isofs_hashi_common(struct dentry *dentry, struct qstr *qstr, int ms)
196 {
197 const char *name;
198 int len;
199 char c;
200 unsigned long hash;
201
202 len = qstr->len;
203 name = qstr->name;
204 if (ms) {
205 while (len && name[len-1] == '.')
206 len--;
207 }
208
209 hash = init_name_hash();
210 while (len--) {
211 c = tolower(*name++);
212 hash = partial_name_hash(tolower(c), hash);
213 }
214 qstr->hash = end_name_hash(hash);
215
216 return 0;
217 }
218
219 /*
220 * Case insensitive compare of two isofs names.
221 */
222 static int
223 isofs_dentry_cmpi_common(struct dentry *dentry,struct qstr *a,struct qstr *b,int ms)
224 {
225 int alen, blen;
226
227 /* A filename cannot end in '.' or we treat it like it has none */
228 alen = a->len;
229 blen = b->len;
230 if (ms) {
231 while (alen && a->name[alen-1] == '.')
232 alen--;
233 while (blen && b->name[blen-1] == '.')
234 blen--;
235 }
236 if (alen == blen) {
237 if (strnicmp(a->name, b->name, alen) == 0)
238 return 0;
239 }
240 return 1;
241 }
242
243 /*
244 * Case sensitive compare of two isofs names.
245 */
246 static int
247 isofs_dentry_cmp_common(struct dentry *dentry,struct qstr *a,struct qstr *b,int ms)
248 {
249 int alen, blen;
250
251 /* A filename cannot end in '.' or we treat it like it has none */
252 alen = a->len;
253 blen = b->len;
254 if (ms) {
255 while (alen && a->name[alen-1] == '.')
256 alen--;
257 while (blen && b->name[blen-1] == '.')
258 blen--;
259 }
260 if (alen == blen) {
261 if (strncmp(a->name, b->name, alen) == 0)
262 return 0;
263 }
264 return 1;
265 }
266
267 static int
268 isofs_hash(struct dentry *dentry, struct qstr *qstr)
269 {
270 return isofs_hash_common(dentry, qstr, 0);
271 }
272
273 static int
274 isofs_hashi(struct dentry *dentry, struct qstr *qstr)
275 {
276 return isofs_hashi_common(dentry, qstr, 0);
277 }
278
279 static int
280 isofs_dentry_cmp(struct dentry *dentry,struct qstr *a,struct qstr *b)
281 {
282 return isofs_dentry_cmp_common(dentry, a, b, 0);
283 }
284
285 static int
286 isofs_dentry_cmpi(struct dentry *dentry,struct qstr *a,struct qstr *b)
287 {
288 return isofs_dentry_cmpi_common(dentry, a, b, 0);
289 }
290
291 #ifdef CONFIG_JOLIET
292 static int
293 isofs_hash_ms(struct dentry *dentry, struct qstr *qstr)
294 {
295 return isofs_hash_common(dentry, qstr, 1);
296 }
297
298 static int
299 isofs_hashi_ms(struct dentry *dentry, struct qstr *qstr)
300 {
301 return isofs_hashi_common(dentry, qstr, 1);
302 }
303
304 static int
305 isofs_dentry_cmp_ms(struct dentry *dentry,struct qstr *a,struct qstr *b)
306 {
307 return isofs_dentry_cmp_common(dentry, a, b, 1);
308 }
309
310 static int
311 isofs_dentry_cmpi_ms(struct dentry *dentry,struct qstr *a,struct qstr *b)
312 {
313 return isofs_dentry_cmpi_common(dentry, a, b, 1);
314 }
315 #endif
316
317 enum {
318 Opt_block, Opt_check_r, Opt_check_s, Opt_cruft, Opt_gid, Opt_ignore,
319 Opt_iocharset, Opt_map_a, Opt_map_n, Opt_map_o, Opt_mode, Opt_nojoliet,
320 Opt_norock, Opt_sb, Opt_session, Opt_uid, Opt_unhide, Opt_utf8, Opt_err,
321 Opt_nocompress,
322 };
323
324 static match_table_t tokens = {
325 {Opt_norock, "norock"},
326 {Opt_nojoliet, "nojoliet"},
327 {Opt_unhide, "unhide"},
328 {Opt_cruft, "cruft"},
329 {Opt_utf8, "utf8"},
330 {Opt_iocharset, "iocharset=%s"},
331 {Opt_map_a, "map=acorn"},
332 {Opt_map_a, "map=a"},
333 {Opt_map_n, "map=normal"},
334 {Opt_map_n, "map=n"},
335 {Opt_map_o, "map=off"},
336 {Opt_map_o, "map=o"},
337 {Opt_session, "session=%u"},
338 {Opt_sb, "sbsector=%u"},
339 {Opt_check_r, "check=relaxed"},
340 {Opt_check_r, "check=r"},
341 {Opt_check_s, "check=strict"},
342 {Opt_check_s, "check=s"},
343 {Opt_uid, "uid=%u"},
344 {Opt_gid, "gid=%u"},
345 {Opt_mode, "mode=%u"},
346 {Opt_block, "block=%u"},
347 {Opt_ignore, "conv=binary"},
348 {Opt_ignore, "conv=b"},
349 {Opt_ignore, "conv=text"},
350 {Opt_ignore, "conv=t"},
351 {Opt_ignore, "conv=mtext"},
352 {Opt_ignore, "conv=m"},
353 {Opt_ignore, "conv=auto"},
354 {Opt_ignore, "conv=a"},
355 {Opt_nocompress, "nocompress"},
356 {Opt_err, NULL}
357 };
358
359 static int parse_options(char *options, struct iso9660_options * popt)
360 {
361 char *p;
362 int option;
363
364 popt->map = 'n';
365 popt->rock = 'y';
366 popt->joliet = 'y';
367 popt->cruft = 'n';
368 popt->unhide = 'n';
369 popt->check = 'u'; /* unset */
370 popt->nocompress = 0;
371 popt->blocksize = 1024;
372 popt->mode = S_IRUGO | S_IXUGO; /* r-x for all. The disc could
373 be shared with DOS machines so
374 virtually anything could be
375 a valid executable. */
376 popt->gid = 0;
377 popt->uid = 0;
378 popt->iocharset = NULL;
379 popt->utf8 = 0;
380 popt->session=-1;
381 popt->sbsector=-1;
382 if (!options)
383 return 1;
384
385 while ((p = strsep(&options, ",")) != NULL) {
386 int token;
387 substring_t args[MAX_OPT_ARGS];
388 unsigned n;
389
390 if (!*p)
391 continue;
392
393 token = match_token(p, tokens, args);
394 switch (token) {
395 case Opt_norock:
396 popt->rock = 'n';
397 break;
398 case Opt_nojoliet:
399 popt->joliet = 'n';
400 break;
401 case Opt_unhide:
402 popt->unhide = 'y';
403 break;
404 case Opt_cruft:
405 popt->cruft = 'y';
406 break;
407 case Opt_utf8:
408 popt->utf8 = 1;
409 break;
410 #ifdef CONFIG_JOLIET
411 case Opt_iocharset:
412 popt->iocharset = match_strdup(&args[0]);
413 break;
414 #endif
415 case Opt_map_a:
416 popt->map = 'a';
417 break;
418 case Opt_map_o:
419 popt->map = 'o';
420 break;
421 case Opt_map_n:
422 popt->map = 'n';
423 break;
424 case Opt_session:
425 if (match_int(&args[0], &option))
426 return 0;
427 n = option;
428 if (n > 99)
429 return 0;
430 popt->session = n + 1;
431 break;
432 case Opt_sb:
433 if (match_int(&args[0], &option))
434 return 0;
435 popt->sbsector = option;
436 break;
437 case Opt_check_r:
438 popt->check = 'r';
439 break;
440 case Opt_check_s:
441 popt->check = 's';
442 break;
443 case Opt_ignore:
444 break;
445 case Opt_uid:
446 if (match_int(&args[0], &option))
447 return 0;
448 popt->uid = option;
449 break;
450 case Opt_gid:
451 if (match_int(&args[0], &option))
452 return 0;
453 popt->gid = option;
454 break;
455 case Opt_mode:
456 if (match_int(&args[0], &option))
457 return 0;
458 popt->mode = option;
459 break;
460 case Opt_block:
461 if (match_int(&args[0], &option))
462 return 0;
463 n = option;
464 if (n != 512 && n != 1024 && n != 2048)
465 return 0;
466 popt->blocksize = n;
467 break;
468 case Opt_nocompress:
469 popt->nocompress = 1;
470 break;
471 default:
472 return 0;
473 }
474 }
475 return 1;
476 }
477
478 /*
479 * look if the driver can tell the multi session redirection value
480 *
481 * don't change this if you don't know what you do, please!
482 * Multisession is legal only with XA disks.
483 * A non-XA disk with more than one volume descriptor may do it right, but
484 * usually is written in a nowhere standardized "multi-partition" manner.
485 * Multisession uses absolute addressing (solely the first frame of the whole
486 * track is #0), multi-partition uses relative addressing (each first frame of
487 * each track is #0), and a track is not a session.
488 *
489 * A broken CDwriter software or drive firmware does not set new standards,
490 * at least not if conflicting with the existing ones.
491 *
492 * emoenke@gwdg.de
493 */
494 #define WE_OBEY_THE_WRITTEN_STANDARDS 1
495
496 static unsigned int isofs_get_last_session(struct super_block *sb,s32 session )
497 {
498 struct cdrom_multisession ms_info;
499 unsigned int vol_desc_start;
500 struct block_device *bdev = sb->s_bdev;
501 int i;
502
503 vol_desc_start=0;
504 ms_info.addr_format=CDROM_LBA;
505 if(session >= 0 && session <= 99) {
506 struct cdrom_tocentry Te;
507 Te.cdte_track=session;
508 Te.cdte_format=CDROM_LBA;
509 i = ioctl_by_bdev(bdev, CDROMREADTOCENTRY, (unsigned long) &Te);
510 if (!i) {
511 printk(KERN_DEBUG "Session %d start %d type %d\n",
512 session, Te.cdte_addr.lba,
513 Te.cdte_ctrl&CDROM_DATA_TRACK);
514 if ((Te.cdte_ctrl&CDROM_DATA_TRACK) == 4)
515 return Te.cdte_addr.lba;
516 }
517
518 printk(KERN_ERR "Invalid session number or type of track\n");
519 }
520 i = ioctl_by_bdev(bdev, CDROMMULTISESSION, (unsigned long) &ms_info);
521 if(session > 0) 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(struct isofs_sb_info), GFP_KERNEL);
561 if (!sbi)
562 return -ENOMEM;
563 s->s_fs_info = sbi;
564 memset(sbi, 0, sizeof(struct isofs_sb_info));
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_unhide = opt.unhide;
796 sbi->s_uid = opt.uid;
797 sbi->s_gid = opt.gid;
798 sbi->s_utf8 = opt.utf8;
799 sbi->s_nocompress = opt.nocompress;
800 /*
801 * It would be incredibly stupid to allow people to mark every file
802 * on the disk as suid, so we merely allow them to set the default
803 * permissions.
804 */
805 sbi->s_mode = opt.mode & 0777;
806
807 /*
808 * Read the root inode, which _may_ result in changing
809 * the s_rock flag. Once we have the final s_rock value,
810 * we then decide whether to use the Joliet descriptor.
811 */
812 inode = isofs_iget(s, sbi->s_firstdatazone, 0);
813
814 /*
815 * If this disk has both Rock Ridge and Joliet on it, then we
816 * want to use Rock Ridge by default. This can be overridden
817 * by using the norock mount option. There is still one other
818 * possibility that is not taken into account: a Rock Ridge
819 * CD with Unicode names. Until someone sees such a beast, it
820 * will not be supported.
821 */
822 if (sbi->s_rock == 1) {
823 joliet_level = 0;
824 } else if (joliet_level) {
825 sbi->s_rock = 0;
826 if (sbi->s_firstdatazone != first_data_zone) {
827 sbi->s_firstdatazone = first_data_zone;
828 printk(KERN_DEBUG
829 "ISOFS: changing to secondary root\n");
830 iput(inode);
831 inode = isofs_iget(s, sbi->s_firstdatazone, 0);
832 }
833 }
834
835 if (opt.check == 'u') {
836 /* Only Joliet is case insensitive by default */
837 if (joliet_level) opt.check = 'r';
838 else opt.check = 's';
839 }
840 sbi->s_joliet_level = joliet_level;
841
842 /* check the root inode */
843 if (!inode)
844 goto out_no_root;
845 if (!inode->i_op)
846 goto out_bad_root;
847 /* get the root dentry */
848 s->s_root = d_alloc_root(inode);
849 if (!(s->s_root))
850 goto out_no_root;
851
852 table = 0;
853 if (joliet_level) table += 2;
854 if (opt.check == 'r') table++;
855 s->s_root->d_op = &isofs_dentry_ops[table];
856
857 if (opt.iocharset)
858 kfree(opt.iocharset);
859
860 return 0;
861
862 /*
863 * Display error messages and free resources.
864 */
865 out_bad_root:
866 printk(KERN_WARNING "isofs_fill_super: root inode not initialized\n");
867 goto out_iput;
868 out_no_root:
869 printk(KERN_WARNING "isofs_fill_super: get root inode failed\n");
870 out_iput:
871 iput(inode);
872 #ifdef CONFIG_JOLIET
873 if (sbi->s_nls_iocharset)
874 unload_nls(sbi->s_nls_iocharset);
875 #endif
876 goto out_freesbi;
877 out_no_read:
878 printk(KERN_WARNING "isofs_fill_super: "
879 "bread failed, dev=%s, iso_blknum=%d, block=%d\n",
880 s->s_id, iso_blknum, block);
881 goto out_freesbi;
882 out_bad_zone_size:
883 printk(KERN_WARNING "Bad logical zone size %ld\n",
884 sbi->s_log_zone_size);
885 goto out_freebh;
886 out_bad_size:
887 printk(KERN_WARNING "Logical zone size(%d) < hardware blocksize(%u)\n",
888 orig_zonesize, opt.blocksize);
889 goto out_freebh;
890 out_unknown_format:
891 if (!silent)
892 printk(KERN_WARNING "Unable to identify CD-ROM format.\n");
893
894 out_freebh:
895 brelse(bh);
896 out_freesbi:
897 if (opt.iocharset)
898 kfree(opt.iocharset);
899 kfree(sbi);
900 s->s_fs_info = NULL;
901 return -EINVAL;
902 }
903
904 static int isofs_statfs (struct super_block *sb, struct kstatfs *buf)
905 {
906 buf->f_type = ISOFS_SUPER_MAGIC;
907 buf->f_bsize = sb->s_blocksize;
908 buf->f_blocks = (ISOFS_SB(sb)->s_nzones
909 << (ISOFS_SB(sb)->s_log_zone_size - sb->s_blocksize_bits));
910 buf->f_bfree = 0;
911 buf->f_bavail = 0;
912 buf->f_files = ISOFS_SB(sb)->s_ninodes;
913 buf->f_ffree = 0;
914 buf->f_namelen = NAME_MAX;
915 return 0;
916 }
917
918 /*
919 * Get a set of blocks; filling in buffer_heads if already allocated
920 * or getblk() if they are not. Returns the number of blocks inserted
921 * (0 == error.)
922 */
923 int isofs_get_blocks(struct inode *inode, sector_t iblock_s,
924 struct buffer_head **bh, unsigned long nblocks)
925 {
926 unsigned long b_off;
927 unsigned offset, sect_size;
928 unsigned int firstext;
929 unsigned long nextblk, nextoff;
930 long iblock = (long)iblock_s;
931 int section, rv;
932 struct iso_inode_info *ei = ISOFS_I(inode);
933
934 lock_kernel();
935
936 rv = 0;
937 if (iblock < 0 || iblock != iblock_s) {
938 printk("isofs_get_blocks: block number too large\n");
939 goto abort;
940 }
941
942 b_off = iblock;
943
944 offset = 0;
945 firstext = ei->i_first_extent;
946 sect_size = ei->i_section_size >> ISOFS_BUFFER_BITS(inode);
947 nextblk = ei->i_next_section_block;
948 nextoff = ei->i_next_section_offset;
949 section = 0;
950
951 while ( nblocks ) {
952 /* If we are *way* beyond the end of the file, print a message.
953 * Access beyond the end of the file up to the next page boundary
954 * is normal, however because of the way the page cache works.
955 * In this case, we just return 0 so that we can properly fill
956 * the page with useless information without generating any
957 * I/O errors.
958 */
959 if (b_off > ((inode->i_size + PAGE_CACHE_SIZE - 1) >> ISOFS_BUFFER_BITS(inode))) {
960 printk("isofs_get_blocks: block >= EOF (%ld, %ld)\n",
961 iblock, (unsigned long) inode->i_size);
962 goto abort;
963 }
964
965 if (nextblk) {
966 while (b_off >= (offset + sect_size)) {
967 struct inode *ninode;
968
969 offset += sect_size;
970 if (nextblk == 0)
971 goto abort;
972 ninode = isofs_iget(inode->i_sb, nextblk, nextoff);
973 if (!ninode)
974 goto abort;
975 firstext = ISOFS_I(ninode)->i_first_extent;
976 sect_size = ISOFS_I(ninode)->i_section_size >> ISOFS_BUFFER_BITS(ninode);
977 nextblk = ISOFS_I(ninode)->i_next_section_block;
978 nextoff = ISOFS_I(ninode)->i_next_section_offset;
979 iput(ninode);
980
981 if (++section > 100) {
982 printk("isofs_get_blocks: More than 100 file sections ?!?, aborting...\n");
983 printk("isofs_get_blocks: block=%ld firstext=%u sect_size=%u "
984 "nextblk=%lu nextoff=%lu\n",
985 iblock, firstext, (unsigned) sect_size,
986 nextblk, nextoff);
987 goto abort;
988 }
989 }
990 }
991
992 if ( *bh ) {
993 map_bh(*bh, inode->i_sb, firstext + b_off - offset);
994 } else {
995 *bh = sb_getblk(inode->i_sb, firstext+b_off-offset);
996 if ( !*bh )
997 goto abort;
998 }
999 bh++; /* Next buffer head */
1000 b_off++; /* Next buffer offset */
1001 nblocks--;
1002 rv++;
1003 }
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
1069 static inline void test_and_set_gid(gid_t *p, gid_t value)
1070 {
1071 if(value) {
1072 *p = value;
1073 }
1074 }
1075
1076 static int isofs_read_level3_size(struct inode * inode)
1077 {
1078 unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
1079 int high_sierra = ISOFS_SB(inode->i_sb)->s_high_sierra;
1080 struct buffer_head * bh = NULL;
1081 unsigned long block, offset, block_saved, offset_saved;
1082 int i = 0;
1083 int more_entries = 0;
1084 struct iso_directory_record * tmpde = NULL;
1085 struct iso_inode_info *ei = ISOFS_I(inode);
1086
1087 inode->i_size = 0;
1088
1089 /* The first 16 blocks are reserved as the System Area. Thus,
1090 * no inodes can appear in block 0. We use this to flag that
1091 * this is the last section. */
1092 ei->i_next_section_block = 0;
1093 ei->i_next_section_offset = 0;
1094
1095 block = ei->i_iget5_block;
1096 offset = ei->i_iget5_offset;
1097
1098 do {
1099 struct iso_directory_record * de;
1100 unsigned int de_len;
1101
1102 if (!bh) {
1103 bh = sb_bread(inode->i_sb, block);
1104 if (!bh)
1105 goto out_noread;
1106 }
1107 de = (struct iso_directory_record *) (bh->b_data + offset);
1108 de_len = *(unsigned char *) de;
1109
1110 if (de_len == 0) {
1111 brelse(bh);
1112 bh = NULL;
1113 ++block;
1114 offset = 0;
1115 continue;
1116 }
1117
1118 block_saved = block;
1119 offset_saved = offset;
1120 offset += de_len;
1121
1122 /* Make sure we have a full directory entry */
1123 if (offset >= bufsize) {
1124 int slop = bufsize - offset + de_len;
1125 if (!tmpde) {
1126 tmpde = kmalloc(256, GFP_KERNEL);
1127 if (!tmpde)
1128 goto out_nomem;
1129 }
1130 memcpy(tmpde, de, slop);
1131 offset &= bufsize - 1;
1132 block++;
1133 brelse(bh);
1134 bh = NULL;
1135 if (offset) {
1136 bh = sb_bread(inode->i_sb, block);
1137 if (!bh)
1138 goto out_noread;
1139 memcpy((void *) tmpde + slop, bh->b_data, offset);
1140 }
1141 de = tmpde;
1142 }
1143
1144 inode->i_size += isonum_733(de->size);
1145 if (i == 1) {
1146 ei->i_next_section_block = block_saved;
1147 ei->i_next_section_offset = offset_saved;
1148 }
1149
1150 more_entries = de->flags[-high_sierra] & 0x80;
1151
1152 i++;
1153 if(i > 100)
1154 goto out_toomany;
1155 } while(more_entries);
1156 out:
1157 if (tmpde)
1158 kfree(tmpde);
1159 if (bh)
1160 brelse(bh);
1161 return 0;
1162
1163 out_nomem:
1164 if (bh)
1165 brelse(bh);
1166 return -ENOMEM;
1167
1168 out_noread:
1169 printk(KERN_INFO "ISOFS: unable to read i-node block %lu\n", block);
1170 if (tmpde)
1171 kfree(tmpde);
1172 return -EIO;
1173
1174 out_toomany:
1175 printk(KERN_INFO "isofs_read_level3_size: "
1176 "More than 100 file sections ?!?, aborting...\n"
1177 "isofs_read_level3_size: inode=%lu\n",
1178 inode->i_ino);
1179 goto out;
1180 }
1181
1182 static void isofs_read_inode(struct inode * inode)
1183 {
1184 struct super_block *sb = inode->i_sb;
1185 struct isofs_sb_info *sbi = ISOFS_SB(sb);
1186 unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
1187 unsigned long block;
1188 int high_sierra = sbi->s_high_sierra;
1189 struct buffer_head * bh = NULL;
1190 struct iso_directory_record * de;
1191 struct iso_directory_record * tmpde = NULL;
1192 unsigned int de_len;
1193 unsigned long offset;
1194 struct iso_inode_info *ei = ISOFS_I(inode);
1195
1196 block = ei->i_iget5_block;
1197 bh = sb_bread(inode->i_sb, block);
1198 if (!bh)
1199 goto out_badread;
1200
1201 offset = ei->i_iget5_offset;
1202
1203 de = (struct iso_directory_record *) (bh->b_data + offset);
1204 de_len = *(unsigned char *) de;
1205
1206 if (offset + de_len > bufsize) {
1207 int frag1 = bufsize - offset;
1208
1209 tmpde = kmalloc(de_len, GFP_KERNEL);
1210 if (tmpde == NULL) {
1211 printk(KERN_INFO "isofs_read_inode: out of memory\n");
1212 goto fail;
1213 }
1214 memcpy(tmpde, bh->b_data + offset, frag1);
1215 brelse(bh);
1216 bh = sb_bread(inode->i_sb, ++block);
1217 if (!bh)
1218 goto out_badread;
1219 memcpy((char *)tmpde+frag1, bh->b_data, de_len - frag1);
1220 de = tmpde;
1221 }
1222
1223 inode->i_ino = isofs_get_ino(ei->i_iget5_block,
1224 ei->i_iget5_offset,
1225 ISOFS_BUFFER_BITS(inode));
1226
1227 /* Assume it is a normal-format file unless told otherwise */
1228 ei->i_file_format = isofs_file_normal;
1229
1230 if (de->flags[-high_sierra] & 2) {
1231 inode->i_mode = S_IRUGO | S_IXUGO | S_IFDIR;
1232 inode->i_nlink = 1; /* Set to 1. We know there are 2, but
1233 the find utility tries to optimize
1234 if it is 2, and it screws up. It is
1235 easier to give 1 which tells find to
1236 do it the hard way. */
1237 } else {
1238 /* Everybody gets to read the file. */
1239 inode->i_mode = sbi->s_mode;
1240 inode->i_nlink = 1;
1241 inode->i_mode |= S_IFREG;
1242 }
1243 inode->i_uid = sbi->s_uid;
1244 inode->i_gid = sbi->s_gid;
1245 inode->i_blocks = inode->i_blksize = 0;
1246
1247 ei->i_format_parm[0] = 0;
1248 ei->i_format_parm[1] = 0;
1249 ei->i_format_parm[2] = 0;
1250
1251 ei->i_section_size = isonum_733 (de->size);
1252 if(de->flags[-high_sierra] & 0x80) {
1253 if(isofs_read_level3_size(inode)) goto fail;
1254 } else {
1255 ei->i_next_section_block = 0;
1256 ei->i_next_section_offset = 0;
1257 inode->i_size = isonum_733 (de->size);
1258 }
1259
1260 /*
1261 * Some dipshit decided to store some other bit of information
1262 * in the high byte of the file length. Truncate size in case
1263 * this CDROM was mounted with the cruft option.
1264 */
1265
1266 if (sbi->s_cruft == 'y')
1267 inode->i_size &= 0x00ffffff;
1268
1269 if (de->interleave[0]) {
1270 printk("Interleaved files not (yet) supported.\n");
1271 inode->i_size = 0;
1272 }
1273
1274 /* I have no idea what file_unit_size is used for, so
1275 we will flag it for now */
1276 if (de->file_unit_size[0] != 0) {
1277 printk("File unit size != 0 for ISO file (%ld).\n",
1278 inode->i_ino);
1279 }
1280
1281 /* I have no idea what other flag bits are used for, so
1282 we will flag it for now */
1283 #ifdef DEBUG
1284 if((de->flags[-high_sierra] & ~2)!= 0){
1285 printk("Unusual flag settings for ISO file (%ld %x).\n",
1286 inode->i_ino, de->flags[-high_sierra]);
1287 }
1288 #endif
1289
1290 inode->i_mtime.tv_sec =
1291 inode->i_atime.tv_sec =
1292 inode->i_ctime.tv_sec = iso_date(de->date, high_sierra);
1293 inode->i_mtime.tv_nsec =
1294 inode->i_atime.tv_nsec =
1295 inode->i_ctime.tv_nsec = 0;
1296
1297 ei->i_first_extent = (isonum_733 (de->extent) +
1298 isonum_711 (de->ext_attr_length));
1299
1300 /* Set the number of blocks for stat() - should be done before RR */
1301 inode->i_blksize = PAGE_CACHE_SIZE; /* For stat() only */
1302 inode->i_blocks = (inode->i_size + 511) >> 9;
1303
1304 /*
1305 * Now test for possible Rock Ridge extensions which will override
1306 * some of these numbers in the inode structure.
1307 */
1308
1309 if (!high_sierra) {
1310 parse_rock_ridge_inode(de, inode);
1311 /* if we want uid/gid set, override the rock ridge setting */
1312 test_and_set_uid(&inode->i_uid, sbi->s_uid);
1313 test_and_set_gid(&inode->i_gid, sbi->s_gid);
1314 }
1315
1316 /* Install the inode operations vector */
1317 if (S_ISREG(inode->i_mode)) {
1318 inode->i_fop = &generic_ro_fops;
1319 switch ( ei->i_file_format ) {
1320 #ifdef CONFIG_ZISOFS
1321 case isofs_file_compressed:
1322 inode->i_data.a_ops = &zisofs_aops;
1323 break;
1324 #endif
1325 default:
1326 inode->i_data.a_ops = &isofs_aops;
1327 break;
1328 }
1329 } else if (S_ISDIR(inode->i_mode)) {
1330 inode->i_op = &isofs_dir_inode_operations;
1331 inode->i_fop = &isofs_dir_operations;
1332 } else if (S_ISLNK(inode->i_mode)) {
1333 inode->i_op = &page_symlink_inode_operations;
1334 inode->i_data.a_ops = &isofs_symlink_aops;
1335 } else
1336 /* XXX - parse_rock_ridge_inode() had already set i_rdev. */
1337 init_special_inode(inode, inode->i_mode, inode->i_rdev);
1338
1339 out:
1340 if (tmpde)
1341 kfree(tmpde);
1342 if (bh)
1343 brelse(bh);
1344 return;
1345
1346 out_badread:
1347 printk(KERN_WARNING "ISOFS: unable to read i-node block\n");
1348 fail:
1349 make_bad_inode(inode);
1350 goto out;
1351 }
1352
1353 struct isofs_iget5_callback_data {
1354 unsigned long block;
1355 unsigned long offset;
1356 };
1357
1358 static int isofs_iget5_test(struct inode *ino, void *data)
1359 {
1360 struct iso_inode_info *i = ISOFS_I(ino);
1361 struct isofs_iget5_callback_data *d =
1362 (struct isofs_iget5_callback_data*)data;
1363 return (i->i_iget5_block == d->block)
1364 && (i->i_iget5_offset == d->offset);
1365 }
1366
1367 static int isofs_iget5_set(struct inode *ino, void *data)
1368 {
1369 struct iso_inode_info *i = ISOFS_I(ino);
1370 struct isofs_iget5_callback_data *d =
1371 (struct isofs_iget5_callback_data*)data;
1372 i->i_iget5_block = d->block;
1373 i->i_iget5_offset = d->offset;
1374 return 0;
1375 }
1376
1377 /* Store, in the inode's containing structure, the block and block
1378 * offset that point to the underlying meta-data for the inode. The
1379 * code below is otherwise similar to the iget() code in
1380 * include/linux/fs.h */
1381 struct inode *isofs_iget(struct super_block *sb,
1382 unsigned long block,
1383 unsigned long offset)
1384 {
1385 unsigned long hashval;
1386 struct inode *inode;
1387 struct isofs_iget5_callback_data data;
1388
1389 if (offset >= 1ul << sb->s_blocksize_bits)
1390 return NULL;
1391
1392 data.block = block;
1393 data.offset = offset;
1394
1395 hashval = (block << sb->s_blocksize_bits) | offset;
1396
1397 inode = iget5_locked(sb,
1398 hashval,
1399 &isofs_iget5_test,
1400 &isofs_iget5_set,
1401 &data);
1402
1403 if (inode && (inode->i_state & I_NEW)) {
1404 sb->s_op->read_inode(inode);
1405 unlock_new_inode(inode);
1406 }
1407
1408 return inode;
1409 }
1410
1411 #ifdef LEAK_CHECK
1412 #undef malloc
1413 #undef free_s
1414 #undef sb_bread
1415 #undef brelse
1416
1417 void * leak_check_malloc(unsigned int size){
1418 void * tmp;
1419 check_malloc++;
1420 tmp = kmalloc(size, GFP_KERNEL);
1421 return tmp;
1422 }
1423
1424 void leak_check_free_s(void * obj, int size){
1425 check_malloc--;
1426 return kfree(obj);
1427 }
1428
1429 struct buffer_head * leak_check_bread(struct super_block *sb, int block){
1430 check_bread++;
1431 return sb_bread(sb, block);
1432 }
1433
1434 void leak_check_brelse(struct buffer_head * bh){
1435 check_bread--;
1436 return brelse(bh);
1437 }
1438
1439 #endif
1440
1441 static struct super_block *isofs_get_sb(struct file_system_type *fs_type,
1442 int flags, const char *dev_name, void *data)
1443 {
1444 return get_sb_bdev(fs_type, flags, dev_name, data, isofs_fill_super);
1445 }
1446
1447 static struct file_system_type iso9660_fs_type = {
1448 .owner = THIS_MODULE,
1449 .name = "iso9660",
1450 .get_sb = isofs_get_sb,
1451 .kill_sb = kill_block_super,
1452 .fs_flags = FS_REQUIRES_DEV,
1453 };
1454
1455 static int __init init_iso9660_fs(void)
1456 {
1457 int err = init_inodecache();
1458 if (err)
1459 goto out;
1460 #ifdef CONFIG_ZISOFS
1461 err = zisofs_init();
1462 if (err)
1463 goto out1;
1464 #endif
1465 err = register_filesystem(&iso9660_fs_type);
1466 if (err)
1467 goto out2;
1468 return 0;
1469 out2:
1470 #ifdef CONFIG_ZISOFS
1471 zisofs_cleanup();
1472 out1:
1473 #endif
1474 destroy_inodecache();
1475 out:
1476 return err;
1477 }
1478
1479 static void __exit exit_iso9660_fs(void)
1480 {
1481 unregister_filesystem(&iso9660_fs_type);
1482 #ifdef CONFIG_ZISOFS
1483 zisofs_cleanup();
1484 #endif
1485 destroy_inodecache();
1486 }
1487
1488 module_init(init_iso9660_fs)
1489 module_exit(exit_iso9660_fs)
1490 MODULE_LICENSE("GPL");
1491 /* Actual filesystem name is iso9660, as requested in filesystems.c */
1492 MODULE_ALIAS("iso9660");
kernel source for telekom puls (alcatel/mediatek)