1
2
3
4
5
6
7
8
9
10
11
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/statfs.h>
21#include <linux/cdrom.h>
22#include <linux/parser.h>
23#include <linux/mpage.h>
24#include <linux/user_namespace.h>
25
26#include "isofs.h"
27#include "zisofs.h"
28
29#define BEQUIET
30
31static int isofs_hashi(const struct dentry *parent, const struct inode *inode,
32 struct qstr *qstr);
33static int isofs_hash(const struct dentry *parent, const struct inode *inode,
34 struct qstr *qstr);
35static int isofs_dentry_cmpi(const struct dentry *parent,
36 const struct inode *pinode,
37 const struct dentry *dentry, const struct inode *inode,
38 unsigned int len, const char *str, const struct qstr *name);
39static int isofs_dentry_cmp(const struct dentry *parent,
40 const struct inode *pinode,
41 const struct dentry *dentry, const struct inode *inode,
42 unsigned int len, const char *str, const struct qstr *name);
43
44#ifdef CONFIG_JOLIET
45static int isofs_hashi_ms(const struct dentry *parent, const struct inode *inode,
46 struct qstr *qstr);
47static int isofs_hash_ms(const struct dentry *parent, const struct inode *inode,
48 struct qstr *qstr);
49static int isofs_dentry_cmpi_ms(const struct dentry *parent,
50 const struct inode *pinode,
51 const struct dentry *dentry, const struct inode *inode,
52 unsigned int len, const char *str, const struct qstr *name);
53static int isofs_dentry_cmp_ms(const struct dentry *parent,
54 const struct inode *pinode,
55 const struct dentry *dentry, const struct inode *inode,
56 unsigned int len, const char *str, const struct qstr *name);
57#endif
58
59static void isofs_put_super(struct super_block *sb)
60{
61 struct isofs_sb_info *sbi = ISOFS_SB(sb);
62
63#ifdef CONFIG_JOLIET
64 unload_nls(sbi->s_nls_iocharset);
65#endif
66
67 kfree(sbi);
68 sb->s_fs_info = NULL;
69 return;
70}
71
72static int isofs_read_inode(struct inode *);
73static int isofs_statfs (struct dentry *, struct kstatfs *);
74
75static struct kmem_cache *isofs_inode_cachep;
76
77static struct inode *isofs_alloc_inode(struct super_block *sb)
78{
79 struct iso_inode_info *ei;
80 ei = kmem_cache_alloc(isofs_inode_cachep, GFP_KERNEL);
81 if (!ei)
82 return NULL;
83 return &ei->vfs_inode;
84}
85
86static void isofs_i_callback(struct rcu_head *head)
87{
88 struct inode *inode = container_of(head, struct inode, i_rcu);
89 kmem_cache_free(isofs_inode_cachep, ISOFS_I(inode));
90}
91
92static void isofs_destroy_inode(struct inode *inode)
93{
94 call_rcu(&inode->i_rcu, isofs_i_callback);
95}
96
97static void init_once(void *foo)
98{
99 struct iso_inode_info *ei = foo;
100
101 inode_init_once(&ei->vfs_inode);
102}
103
104static int init_inodecache(void)
105{
106 isofs_inode_cachep = kmem_cache_create("isofs_inode_cache",
107 sizeof(struct iso_inode_info),
108 0, (SLAB_RECLAIM_ACCOUNT|
109 SLAB_MEM_SPREAD),
110 init_once);
111 if (isofs_inode_cachep == NULL)
112 return -ENOMEM;
113 return 0;
114}
115
116static void destroy_inodecache(void)
117{
118
119
120
121
122 rcu_barrier();
123 kmem_cache_destroy(isofs_inode_cachep);
124}
125
126static int isofs_remount(struct super_block *sb, int *flags, char *data)
127{
128
129 *flags |= MS_RDONLY;
130 return 0;
131}
132
133static const struct super_operations isofs_sops = {
134 .alloc_inode = isofs_alloc_inode,
135 .destroy_inode = isofs_destroy_inode,
136 .put_super = isofs_put_super,
137 .statfs = isofs_statfs,
138 .remount_fs = isofs_remount,
139 .show_options = generic_show_options,
140};
141
142
143static const struct dentry_operations isofs_dentry_ops[] = {
144 {
145 .d_hash = isofs_hash,
146 .d_compare = isofs_dentry_cmp,
147 },
148 {
149 .d_hash = isofs_hashi,
150 .d_compare = isofs_dentry_cmpi,
151 },
152#ifdef CONFIG_JOLIET
153 {
154 .d_hash = isofs_hash_ms,
155 .d_compare = isofs_dentry_cmp_ms,
156 },
157 {
158 .d_hash = isofs_hashi_ms,
159 .d_compare = isofs_dentry_cmpi_ms,
160 },
161#endif
162};
163
164struct iso9660_options{
165 unsigned int rock:1;
166 unsigned int joliet:1;
167 unsigned int cruft:1;
168 unsigned int hide:1;
169 unsigned int showassoc:1;
170 unsigned int nocompress:1;
171 unsigned int overriderockperm:1;
172 unsigned int uid_set:1;
173 unsigned int gid_set:1;
174 unsigned int utf8:1;
175 unsigned char map;
176 unsigned char check;
177 unsigned int blocksize;
178 umode_t fmode;
179 umode_t dmode;
180 kgid_t gid;
181 kuid_t uid;
182 char *iocharset;
183
184 s32 session;
185 s32 sbsector;
186};
187
188
189
190
191static int
192isofs_hash_common(const struct dentry *dentry, struct qstr *qstr, int ms)
193{
194 const char *name;
195 int len;
196
197 len = qstr->len;
198 name = qstr->name;
199 if (ms) {
200 while (len && name[len-1] == '.')
201 len--;
202 }
203
204 qstr->hash = full_name_hash(name, len);
205
206 return 0;
207}
208
209
210
211
212static int
213isofs_hashi_common(const struct dentry *dentry, struct qstr *qstr, int ms)
214{
215 const char *name;
216 int len;
217 char c;
218 unsigned long hash;
219
220 len = qstr->len;
221 name = qstr->name;
222 if (ms) {
223 while (len && name[len-1] == '.')
224 len--;
225 }
226
227 hash = init_name_hash();
228 while (len--) {
229 c = tolower(*name++);
230 hash = partial_name_hash(c, hash);
231 }
232 qstr->hash = end_name_hash(hash);
233
234 return 0;
235}
236
237
238
239
240static int isofs_dentry_cmp_common(
241 unsigned int len, const char *str,
242 const struct qstr *name, int ms, int ci)
243{
244 int alen, blen;
245
246
247 alen = name->len;
248 blen = len;
249 if (ms) {
250 while (alen && name->name[alen-1] == '.')
251 alen--;
252 while (blen && str[blen-1] == '.')
253 blen--;
254 }
255 if (alen == blen) {
256 if (ci) {
257 if (strnicmp(name->name, str, alen) == 0)
258 return 0;
259 } else {
260 if (strncmp(name->name, str, alen) == 0)
261 return 0;
262 }
263 }
264 return 1;
265}
266
267static int
268isofs_hash(const struct dentry *dentry, const struct inode *inode,
269 struct qstr *qstr)
270{
271 return isofs_hash_common(dentry, qstr, 0);
272}
273
274static int
275isofs_hashi(const struct dentry *dentry, const struct inode *inode,
276 struct qstr *qstr)
277{
278 return isofs_hashi_common(dentry, qstr, 0);
279}
280
281static int
282isofs_dentry_cmp(const struct dentry *parent, const struct inode *pinode,
283 const struct dentry *dentry, const struct inode *inode,
284 unsigned int len, const char *str, const struct qstr *name)
285{
286 return isofs_dentry_cmp_common(len, str, name, 0, 0);
287}
288
289static int
290isofs_dentry_cmpi(const struct dentry *parent, const struct inode *pinode,
291 const struct dentry *dentry, const struct inode *inode,
292 unsigned int len, const char *str, const struct qstr *name)
293{
294 return isofs_dentry_cmp_common(len, str, name, 0, 1);
295}
296
297#ifdef CONFIG_JOLIET
298static int
299isofs_hash_ms(const struct dentry *dentry, const struct inode *inode,
300 struct qstr *qstr)
301{
302 return isofs_hash_common(dentry, qstr, 1);
303}
304
305static int
306isofs_hashi_ms(const struct dentry *dentry, const struct inode *inode,
307 struct qstr *qstr)
308{
309 return isofs_hashi_common(dentry, qstr, 1);
310}
311
312static int
313isofs_dentry_cmp_ms(const struct dentry *parent, const struct inode *pinode,
314 const struct dentry *dentry, const struct inode *inode,
315 unsigned int len, const char *str, const struct qstr *name)
316{
317 return isofs_dentry_cmp_common(len, str, name, 1, 0);
318}
319
320static int
321isofs_dentry_cmpi_ms(const struct dentry *parent, const struct inode *pinode,
322 const struct dentry *dentry, const struct inode *inode,
323 unsigned int len, const char *str, const struct qstr *name)
324{
325 return isofs_dentry_cmp_common(len, str, name, 1, 1);
326}
327#endif
328
329enum {
330 Opt_block, Opt_check_r, Opt_check_s, Opt_cruft, Opt_gid, Opt_ignore,
331 Opt_iocharset, Opt_map_a, Opt_map_n, Opt_map_o, Opt_mode, Opt_nojoliet,
332 Opt_norock, Opt_sb, Opt_session, Opt_uid, Opt_unhide, Opt_utf8, Opt_err,
333 Opt_nocompress, Opt_hide, Opt_showassoc, Opt_dmode, Opt_overriderockperm,
334};
335
336static const match_table_t tokens = {
337 {Opt_norock, "norock"},
338 {Opt_nojoliet, "nojoliet"},
339 {Opt_unhide, "unhide"},
340 {Opt_hide, "hide"},
341 {Opt_showassoc, "showassoc"},
342 {Opt_cruft, "cruft"},
343 {Opt_utf8, "utf8"},
344 {Opt_iocharset, "iocharset=%s"},
345 {Opt_map_a, "map=acorn"},
346 {Opt_map_a, "map=a"},
347 {Opt_map_n, "map=normal"},
348 {Opt_map_n, "map=n"},
349 {Opt_map_o, "map=off"},
350 {Opt_map_o, "map=o"},
351 {Opt_session, "session=%u"},
352 {Opt_sb, "sbsector=%u"},
353 {Opt_check_r, "check=relaxed"},
354 {Opt_check_r, "check=r"},
355 {Opt_check_s, "check=strict"},
356 {Opt_check_s, "check=s"},
357 {Opt_uid, "uid=%u"},
358 {Opt_gid, "gid=%u"},
359 {Opt_mode, "mode=%u"},
360 {Opt_dmode, "dmode=%u"},
361 {Opt_overriderockperm, "overriderockperm"},
362 {Opt_block, "block=%u"},
363 {Opt_ignore, "conv=binary"},
364 {Opt_ignore, "conv=b"},
365 {Opt_ignore, "conv=text"},
366 {Opt_ignore, "conv=t"},
367 {Opt_ignore, "conv=mtext"},
368 {Opt_ignore, "conv=m"},
369 {Opt_ignore, "conv=auto"},
370 {Opt_ignore, "conv=a"},
371 {Opt_nocompress, "nocompress"},
372 {Opt_err, NULL}
373};
374
375static int parse_options(char *options, struct iso9660_options *popt)
376{
377 char *p;
378 int option;
379
380 popt->map = 'n';
381 popt->rock = 1;
382 popt->joliet = 1;
383 popt->cruft = 0;
384 popt->hide = 0;
385 popt->showassoc = 0;
386 popt->check = 'u';
387 popt->nocompress = 0;
388 popt->blocksize = 1024;
389 popt->fmode = popt->dmode = ISOFS_INVALID_MODE;
390 popt->uid_set = 0;
391 popt->gid_set = 0;
392 popt->gid = GLOBAL_ROOT_GID;
393 popt->uid = GLOBAL_ROOT_UID;
394 popt->iocharset = NULL;
395 popt->utf8 = 0;
396 popt->overriderockperm = 0;
397 popt->session=-1;
398 popt->sbsector=-1;
399 if (!options)
400 return 1;
401
402 while ((p = strsep(&options, ",")) != NULL) {
403 int token;
404 substring_t args[MAX_OPT_ARGS];
405 unsigned n;
406
407 if (!*p)
408 continue;
409
410 token = match_token(p, tokens, args);
411 switch (token) {
412 case Opt_norock:
413 popt->rock = 0;
414 break;
415 case Opt_nojoliet:
416 popt->joliet = 0;
417 break;
418 case Opt_hide:
419 popt->hide = 1;
420 break;
421 case Opt_unhide:
422 case Opt_showassoc:
423 popt->showassoc = 1;
424 break;
425 case Opt_cruft:
426 popt->cruft = 1;
427 break;
428 case Opt_utf8:
429 popt->utf8 = 1;
430 break;
431#ifdef CONFIG_JOLIET
432 case Opt_iocharset:
433 popt->iocharset = match_strdup(&args[0]);
434 break;
435#endif
436 case Opt_map_a:
437 popt->map = 'a';
438 break;
439 case Opt_map_o:
440 popt->map = 'o';
441 break;
442 case Opt_map_n:
443 popt->map = 'n';
444 break;
445 case Opt_session:
446 if (match_int(&args[0], &option))
447 return 0;
448 n = option;
449 if (n > 99)
450 return 0;
451 popt->session = n + 1;
452 break;
453 case Opt_sb:
454 if (match_int(&args[0], &option))
455 return 0;
456 popt->sbsector = option;
457 break;
458 case Opt_check_r:
459 popt->check = 'r';
460 break;
461 case Opt_check_s:
462 popt->check = 's';
463 break;
464 case Opt_ignore:
465 break;
466 case Opt_uid:
467 if (match_int(&args[0], &option))
468 return 0;
469 popt->uid = make_kuid(current_user_ns(), option);
470 if (!uid_valid(popt->uid))
471 return 0;
472 popt->uid_set = 1;
473 break;
474 case Opt_gid:
475 if (match_int(&args[0], &option))
476 return 0;
477 popt->gid = make_kgid(current_user_ns(), option);
478 if (!gid_valid(popt->gid))
479 return 0;
480 popt->gid_set = 1;
481 break;
482 case Opt_mode:
483 if (match_int(&args[0], &option))
484 return 0;
485 popt->fmode = option;
486 break;
487 case Opt_dmode:
488 if (match_int(&args[0], &option))
489 return 0;
490 popt->dmode = option;
491 break;
492 case Opt_overriderockperm:
493 popt->overriderockperm = 1;
494 break;
495 case Opt_block:
496 if (match_int(&args[0], &option))
497 return 0;
498 n = option;
499 if (n != 512 && n != 1024 && n != 2048)
500 return 0;
501 popt->blocksize = n;
502 break;
503 case Opt_nocompress:
504 popt->nocompress = 1;
505 break;
506 default:
507 return 0;
508 }
509 }
510 return 1;
511}
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529#define WE_OBEY_THE_WRITTEN_STANDARDS 1
530
531static unsigned int isofs_get_last_session(struct super_block *sb, s32 session)
532{
533 struct cdrom_multisession ms_info;
534 unsigned int vol_desc_start;
535 struct block_device *bdev = sb->s_bdev;
536 int i;
537
538 vol_desc_start=0;
539 ms_info.addr_format=CDROM_LBA;
540 if(session >= 0 && session <= 99) {
541 struct cdrom_tocentry Te;
542 Te.cdte_track=session;
543 Te.cdte_format=CDROM_LBA;
544 i = ioctl_by_bdev(bdev, CDROMREADTOCENTRY, (unsigned long) &Te);
545 if (!i) {
546 printk(KERN_DEBUG "ISOFS: Session %d start %d type %d\n",
547 session, Te.cdte_addr.lba,
548 Te.cdte_ctrl&CDROM_DATA_TRACK);
549 if ((Te.cdte_ctrl&CDROM_DATA_TRACK) == 4)
550 return Te.cdte_addr.lba;
551 }
552
553 printk(KERN_ERR "ISOFS: Invalid session number or type of track\n");
554 }
555 i = ioctl_by_bdev(bdev, CDROMMULTISESSION, (unsigned long) &ms_info);
556 if (session > 0)
557 printk(KERN_ERR "ISOFS: Invalid session number\n");
558#if 0
559 printk(KERN_DEBUG "isofs.inode: CDROMMULTISESSION: rc=%d\n",i);
560 if (i==0) {
561 printk(KERN_DEBUG "isofs.inode: XA disk: %s\n",ms_info.xa_flag?"yes":"no");
562 printk(KERN_DEBUG "isofs.inode: vol_desc_start = %d\n", ms_info.addr.lba);
563 }
564#endif
565 if (i==0)
566#if WE_OBEY_THE_WRITTEN_STANDARDS
567 if (ms_info.xa_flag)
568#endif
569 vol_desc_start=ms_info.addr.lba;
570 return vol_desc_start;
571}
572
573
574
575
576
577
578
579
580static bool rootdir_empty(struct super_block *sb, unsigned long block)
581{
582 int offset = 0, files = 0, de_len;
583 struct iso_directory_record *de;
584 struct buffer_head *bh;
585
586 bh = sb_bread(sb, block);
587 if (!bh)
588 return true;
589 while (files < 3) {
590 de = (struct iso_directory_record *) (bh->b_data + offset);
591 de_len = *(unsigned char *) de;
592 if (de_len == 0)
593 break;
594 files++;
595 offset += de_len;
596 }
597 brelse(bh);
598 return files < 3;
599}
600
601
602
603
604
605
606
607static int isofs_fill_super(struct super_block *s, void *data, int silent)
608{
609 struct buffer_head *bh = NULL, *pri_bh = NULL;
610 struct hs_primary_descriptor *h_pri = NULL;
611 struct iso_primary_descriptor *pri = NULL;
612 struct iso_supplementary_descriptor *sec = NULL;
613 struct iso_directory_record *rootp;
614 struct inode *inode;
615 struct iso9660_options opt;
616 struct isofs_sb_info *sbi;
617 unsigned long first_data_zone;
618 int joliet_level = 0;
619 int iso_blknum, block;
620 int orig_zonesize;
621 int table, error = -EINVAL;
622 unsigned int vol_desc_start;
623
624 save_mount_options(s, data);
625
626 sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
627 if (!sbi)
628 return -ENOMEM;
629 s->s_fs_info = sbi;
630
631 if (!parse_options((char *)data, &opt))
632 goto out_freesbi;
633
634
635
636
637
638
639
640
641
642
643 opt.blocksize = sb_min_blocksize(s, opt.blocksize);
644
645 sbi->s_high_sierra = 0;
646
647 vol_desc_start = (opt.sbsector != -1) ?
648 opt.sbsector : isofs_get_last_session(s,opt.session);
649
650 for (iso_blknum = vol_desc_start+16;
651 iso_blknum < vol_desc_start+100; iso_blknum++) {
652 struct hs_volume_descriptor *hdp;
653 struct iso_volume_descriptor *vdp;
654
655 block = iso_blknum << (ISOFS_BLOCK_BITS - s->s_blocksize_bits);
656 if (!(bh = sb_bread(s, block)))
657 goto out_no_read;
658
659 vdp = (struct iso_volume_descriptor *)bh->b_data;
660 hdp = (struct hs_volume_descriptor *)bh->b_data;
661
662
663
664
665
666
667 if (strncmp (vdp->id, ISO_STANDARD_ID, sizeof vdp->id) == 0) {
668 if (isonum_711(vdp->type) == ISO_VD_END)
669 break;
670 if (isonum_711(vdp->type) == ISO_VD_PRIMARY) {
671 if (pri == NULL) {
672 pri = (struct iso_primary_descriptor *)vdp;
673
674 pri_bh = bh;
675 bh = NULL;
676 }
677 }
678#ifdef CONFIG_JOLIET
679 else if (isonum_711(vdp->type) == ISO_VD_SUPPLEMENTARY) {
680 sec = (struct iso_supplementary_descriptor *)vdp;
681 if (sec->escape[0] == 0x25 && sec->escape[1] == 0x2f) {
682 if (opt.joliet) {
683 if (sec->escape[2] == 0x40)
684 joliet_level = 1;
685 else if (sec->escape[2] == 0x43)
686 joliet_level = 2;
687 else if (sec->escape[2] == 0x45)
688 joliet_level = 3;
689
690 printk(KERN_DEBUG "ISO 9660 Extensions: "
691 "Microsoft Joliet Level %d\n",
692 joliet_level);
693 }
694 goto root_found;
695 } else {
696
697 sec = NULL;
698 }
699 }
700#endif
701 } else {
702 if (strncmp (hdp->id, HS_STANDARD_ID, sizeof hdp->id) == 0) {
703 if (isonum_711(hdp->type) != ISO_VD_PRIMARY)
704 goto out_freebh;
705
706 sbi->s_high_sierra = 1;
707 opt.rock = 0;
708 h_pri = (struct hs_primary_descriptor *)vdp;
709 goto root_found;
710 }
711 }
712
713
714
715 brelse(bh);
716 bh = NULL;
717 }
718
719
720
721
722 if (!pri)
723 goto out_unknown_format;
724 brelse(bh);
725 bh = pri_bh;
726 pri_bh = NULL;
727
728root_found:
729
730 if (joliet_level && (pri == NULL || !opt.rock)) {
731
732
733
734 pri = (struct iso_primary_descriptor *) sec;
735 }
736
737 if(sbi->s_high_sierra){
738 rootp = (struct iso_directory_record *) h_pri->root_directory_record;
739 sbi->s_nzones = isonum_733(h_pri->volume_space_size);
740 sbi->s_log_zone_size = isonum_723(h_pri->logical_block_size);
741 sbi->s_max_size = isonum_733(h_pri->volume_space_size);
742 } else {
743 if (!pri)
744 goto out_freebh;
745 rootp = (struct iso_directory_record *) pri->root_directory_record;
746 sbi->s_nzones = isonum_733(pri->volume_space_size);
747 sbi->s_log_zone_size = isonum_723(pri->logical_block_size);
748 sbi->s_max_size = isonum_733(pri->volume_space_size);
749 }
750
751 sbi->s_ninodes = 0;
752
753 orig_zonesize = sbi->s_log_zone_size;
754
755
756
757
758
759
760
761 if (orig_zonesize < opt.blocksize)
762 goto out_bad_size;
763
764
765 switch (sbi->s_log_zone_size) {
766 case 512: sbi->s_log_zone_size = 9; break;
767 case 1024: sbi->s_log_zone_size = 10; break;
768 case 2048: sbi->s_log_zone_size = 11; break;
769
770 default:
771 goto out_bad_zone_size;
772 }
773
774 s->s_magic = ISOFS_SUPER_MAGIC;
775
776
777
778
779
780 s->s_maxbytes = 0x80000000000LL;
781
782
783
784
785
786
787
788
789 s->s_flags |= MS_RDONLY ;
790
791
792
793
794 first_data_zone = isonum_733(rootp->extent) +
795 isonum_711(rootp->ext_attr_length);
796 sbi->s_firstdatazone = first_data_zone;
797#ifndef BEQUIET
798 printk(KERN_DEBUG "ISOFS: Max size:%ld Log zone size:%ld\n",
799 sbi->s_max_size, 1UL << sbi->s_log_zone_size);
800 printk(KERN_DEBUG "ISOFS: First datazone:%ld\n", sbi->s_firstdatazone);
801 if(sbi->s_high_sierra)
802 printk(KERN_DEBUG "ISOFS: Disc in High Sierra format.\n");
803#endif
804
805
806
807
808
809
810
811
812
813 if (joliet_level) {
814 pri = (struct iso_primary_descriptor *) sec;
815 rootp = (struct iso_directory_record *)
816 pri->root_directory_record;
817 first_data_zone = isonum_733(rootp->extent) +
818 isonum_711(rootp->ext_attr_length);
819 }
820
821
822
823
824
825 brelse(pri_bh);
826 brelse(bh);
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845 sb_set_blocksize(s, orig_zonesize);
846
847 sbi->s_nls_iocharset = NULL;
848
849#ifdef CONFIG_JOLIET
850 if (joliet_level && opt.utf8 == 0) {
851 char *p = opt.iocharset ? opt.iocharset : CONFIG_NLS_DEFAULT;
852 sbi->s_nls_iocharset = load_nls(p);
853 if (! sbi->s_nls_iocharset) {
854
855 if (opt.iocharset)
856 goto out_freesbi;
857 sbi->s_nls_iocharset = load_nls_default();
858 }
859 }
860#endif
861 s->s_op = &isofs_sops;
862 s->s_export_op = &isofs_export_ops;
863 sbi->s_mapping = opt.map;
864 sbi->s_rock = (opt.rock ? 2 : 0);
865 sbi->s_rock_offset = -1;
866 sbi->s_cruft = opt.cruft;
867 sbi->s_hide = opt.hide;
868 sbi->s_showassoc = opt.showassoc;
869 sbi->s_uid = opt.uid;
870 sbi->s_gid = opt.gid;
871 sbi->s_uid_set = opt.uid_set;
872 sbi->s_gid_set = opt.gid_set;
873 sbi->s_utf8 = opt.utf8;
874 sbi->s_nocompress = opt.nocompress;
875 sbi->s_overriderockperm = opt.overriderockperm;
876
877
878
879
880
881 if (opt.fmode != ISOFS_INVALID_MODE)
882 sbi->s_fmode = opt.fmode & 0777;
883 else
884 sbi->s_fmode = ISOFS_INVALID_MODE;
885 if (opt.dmode != ISOFS_INVALID_MODE)
886 sbi->s_dmode = opt.dmode & 0777;
887 else
888 sbi->s_dmode = ISOFS_INVALID_MODE;
889
890
891
892
893
894
895 inode = isofs_iget(s, sbi->s_firstdatazone, 0);
896 if (IS_ERR(inode))
897 goto out_no_root;
898
899
900
901
902
903 if (sbi->s_rock == 1 && joliet_level &&
904 rootdir_empty(s, sbi->s_firstdatazone)) {
905 printk(KERN_NOTICE
906 "ISOFS: primary root directory is empty. "
907 "Disabling Rock Ridge and switching to Joliet.");
908 sbi->s_rock = 0;
909 }
910
911
912
913
914
915
916
917
918
919 if (sbi->s_rock == 1) {
920 joliet_level = 0;
921 } else if (joliet_level) {
922 sbi->s_rock = 0;
923 if (sbi->s_firstdatazone != first_data_zone) {
924 sbi->s_firstdatazone = first_data_zone;
925 printk(KERN_DEBUG
926 "ISOFS: changing to secondary root\n");
927 iput(inode);
928 inode = isofs_iget(s, sbi->s_firstdatazone, 0);
929 if (IS_ERR(inode))
930 goto out_no_root;
931 }
932 }
933
934 if (opt.check == 'u') {
935
936 if (joliet_level)
937 opt.check = 'r';
938 else
939 opt.check = 's';
940 }
941 sbi->s_joliet_level = joliet_level;
942
943
944 if (!S_ISDIR(inode->i_mode)) {
945 printk(KERN_WARNING
946 "isofs_fill_super: root inode is not a directory. "
947 "Corrupted media?\n");
948 goto out_iput;
949 }
950
951 table = 0;
952 if (joliet_level)
953 table += 2;
954 if (opt.check == 'r')
955 table++;
956
957 s->s_d_op = &isofs_dentry_ops[table];
958
959
960 s->s_root = d_make_root(inode);
961 if (!(s->s_root)) {
962 error = -ENOMEM;
963 goto out_no_inode;
964 }
965
966 kfree(opt.iocharset);
967
968 return 0;
969
970
971
972
973out_iput:
974 iput(inode);
975 goto out_no_inode;
976out_no_root:
977 error = PTR_ERR(inode);
978 if (error != -ENOMEM)
979 printk(KERN_WARNING "%s: get root inode failed\n", __func__);
980out_no_inode:
981#ifdef CONFIG_JOLIET
982 unload_nls(sbi->s_nls_iocharset);
983#endif
984 goto out_freesbi;
985out_no_read:
986 printk(KERN_WARNING "%s: bread failed, dev=%s, iso_blknum=%d, block=%d\n",
987 __func__, s->s_id, iso_blknum, block);
988 goto out_freebh;
989out_bad_zone_size:
990 printk(KERN_WARNING "ISOFS: Bad logical zone size %ld\n",
991 sbi->s_log_zone_size);
992 goto out_freebh;
993out_bad_size:
994 printk(KERN_WARNING "ISOFS: Logical zone size(%d) < hardware blocksize(%u)\n",
995 orig_zonesize, opt.blocksize);
996 goto out_freebh;
997out_unknown_format:
998 if (!silent)
999 printk(KERN_WARNING "ISOFS: Unable to identify CD-ROM format.\n");
1000
1001out_freebh:
1002 brelse(bh);
1003 brelse(pri_bh);
1004out_freesbi:
1005 kfree(opt.iocharset);
1006 kfree(sbi);
1007 s->s_fs_info = NULL;
1008 return error;
1009}
1010
1011static int isofs_statfs (struct dentry *dentry, struct kstatfs *buf)
1012{
1013 struct super_block *sb = dentry->d_sb;
1014 u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
1015
1016 buf->f_type = ISOFS_SUPER_MAGIC;
1017 buf->f_bsize = sb->s_blocksize;
1018 buf->f_blocks = (ISOFS_SB(sb)->s_nzones
1019 << (ISOFS_SB(sb)->s_log_zone_size - sb->s_blocksize_bits));
1020 buf->f_bfree = 0;
1021 buf->f_bavail = 0;
1022 buf->f_files = ISOFS_SB(sb)->s_ninodes;
1023 buf->f_ffree = 0;
1024 buf->f_fsid.val[0] = (u32)id;
1025 buf->f_fsid.val[1] = (u32)(id >> 32);
1026 buf->f_namelen = NAME_MAX;
1027 return 0;
1028}
1029
1030
1031
1032
1033
1034
1035int isofs_get_blocks(struct inode *inode, sector_t iblock,
1036 struct buffer_head **bh, unsigned long nblocks)
1037{
1038 unsigned long b_off = iblock;
1039 unsigned offset, sect_size;
1040 unsigned int firstext;
1041 unsigned long nextblk, nextoff;
1042 int section, rv, error;
1043 struct iso_inode_info *ei = ISOFS_I(inode);
1044
1045 error = -EIO;
1046 rv = 0;
1047 if (iblock != b_off) {
1048 printk(KERN_DEBUG "%s: block number too large\n", __func__);
1049 goto abort;
1050 }
1051
1052
1053 offset = 0;
1054 firstext = ei->i_first_extent;
1055 sect_size = ei->i_section_size >> ISOFS_BUFFER_BITS(inode);
1056 nextblk = ei->i_next_section_block;
1057 nextoff = ei->i_next_section_offset;
1058 section = 0;
1059
1060 while (nblocks) {
1061
1062
1063
1064
1065
1066
1067
1068 if (b_off > ((inode->i_size + PAGE_CACHE_SIZE - 1) >> ISOFS_BUFFER_BITS(inode))) {
1069 printk(KERN_DEBUG "%s: block >= EOF (%lu, %llu)\n",
1070 __func__, b_off,
1071 (unsigned long long)inode->i_size);
1072 goto abort;
1073 }
1074
1075
1076
1077
1078
1079 while (nextblk && (b_off >= (offset + sect_size))) {
1080 struct inode *ninode;
1081
1082 offset += sect_size;
1083 ninode = isofs_iget(inode->i_sb, nextblk, nextoff);
1084 if (IS_ERR(ninode)) {
1085 error = PTR_ERR(ninode);
1086 goto abort;
1087 }
1088 firstext = ISOFS_I(ninode)->i_first_extent;
1089 sect_size = ISOFS_I(ninode)->i_section_size >> ISOFS_BUFFER_BITS(ninode);
1090 nextblk = ISOFS_I(ninode)->i_next_section_block;
1091 nextoff = ISOFS_I(ninode)->i_next_section_offset;
1092 iput(ninode);
1093
1094 if (++section > 100) {
1095 printk(KERN_DEBUG "%s: More than 100 file sections ?!?"
1096 " aborting...\n", __func__);
1097 printk(KERN_DEBUG "%s: block=%lu firstext=%u sect_size=%u "
1098 "nextblk=%lu nextoff=%lu\n", __func__,
1099 b_off, firstext, (unsigned) sect_size,
1100 nextblk, nextoff);
1101 goto abort;
1102 }
1103 }
1104
1105 if (*bh) {
1106 map_bh(*bh, inode->i_sb, firstext + b_off - offset);
1107 } else {
1108 *bh = sb_getblk(inode->i_sb, firstext+b_off-offset);
1109 if (!*bh)
1110 goto abort;
1111 }
1112 bh++;
1113 b_off++;
1114 nblocks--;
1115 rv++;
1116 }
1117
1118 error = 0;
1119abort:
1120 return rv != 0 ? rv : error;
1121}
1122
1123
1124
1125
1126static int isofs_get_block(struct inode *inode, sector_t iblock,
1127 struct buffer_head *bh_result, int create)
1128{
1129 int ret;
1130
1131 if (create) {
1132 printk(KERN_DEBUG "%s: Kernel tries to allocate a block\n", __func__);
1133 return -EROFS;
1134 }
1135
1136 ret = isofs_get_blocks(inode, iblock, &bh_result, 1);
1137 return ret < 0 ? ret : 0;
1138}
1139
1140static int isofs_bmap(struct inode *inode, sector_t block)
1141{
1142 struct buffer_head dummy;
1143 int error;
1144
1145 dummy.b_state = 0;
1146 dummy.b_blocknr = -1000;
1147 error = isofs_get_block(inode, block, &dummy, 0);
1148 if (!error)
1149 return dummy.b_blocknr;
1150 return 0;
1151}
1152
1153struct buffer_head *isofs_bread(struct inode *inode, sector_t block)
1154{
1155 sector_t blknr = isofs_bmap(inode, block);
1156 if (!blknr)
1157 return NULL;
1158 return sb_bread(inode->i_sb, blknr);
1159}
1160
1161static int isofs_readpage(struct file *file, struct page *page)
1162{
1163 return mpage_readpage(page, isofs_get_block);
1164}
1165
1166static int isofs_readpages(struct file *file, struct address_space *mapping,
1167 struct list_head *pages, unsigned nr_pages)
1168{
1169 return mpage_readpages(mapping, pages, nr_pages, isofs_get_block);
1170}
1171
1172static sector_t _isofs_bmap(struct address_space *mapping, sector_t block)
1173{
1174 return generic_block_bmap(mapping,block,isofs_get_block);
1175}
1176
1177static const struct address_space_operations isofs_aops = {
1178 .readpage = isofs_readpage,
1179 .readpages = isofs_readpages,
1180 .bmap = _isofs_bmap
1181};
1182
1183static int isofs_read_level3_size(struct inode *inode)
1184{
1185 unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
1186 int high_sierra = ISOFS_SB(inode->i_sb)->s_high_sierra;
1187 struct buffer_head *bh = NULL;
1188 unsigned long block, offset, block_saved, offset_saved;
1189 int i = 0;
1190 int more_entries = 0;
1191 struct iso_directory_record *tmpde = NULL;
1192 struct iso_inode_info *ei = ISOFS_I(inode);
1193
1194 inode->i_size = 0;
1195
1196
1197
1198
1199 ei->i_next_section_block = 0;
1200 ei->i_next_section_offset = 0;
1201
1202 block = ei->i_iget5_block;
1203 offset = ei->i_iget5_offset;
1204
1205 do {
1206 struct iso_directory_record *de;
1207 unsigned int de_len;
1208
1209 if (!bh) {
1210 bh = sb_bread(inode->i_sb, block);
1211 if (!bh)
1212 goto out_noread;
1213 }
1214 de = (struct iso_directory_record *) (bh->b_data + offset);
1215 de_len = *(unsigned char *) de;
1216
1217 if (de_len == 0) {
1218 brelse(bh);
1219 bh = NULL;
1220 ++block;
1221 offset = 0;
1222 continue;
1223 }
1224
1225 block_saved = block;
1226 offset_saved = offset;
1227 offset += de_len;
1228
1229
1230 if (offset >= bufsize) {
1231 int slop = bufsize - offset + de_len;
1232 if (!tmpde) {
1233 tmpde = kmalloc(256, GFP_KERNEL);
1234 if (!tmpde)
1235 goto out_nomem;
1236 }
1237 memcpy(tmpde, de, slop);
1238 offset &= bufsize - 1;
1239 block++;
1240 brelse(bh);
1241 bh = NULL;
1242 if (offset) {
1243 bh = sb_bread(inode->i_sb, block);
1244 if (!bh)
1245 goto out_noread;
1246 memcpy((void *)tmpde+slop, bh->b_data, offset);
1247 }
1248 de = tmpde;
1249 }
1250
1251 inode->i_size += isonum_733(de->size);
1252 if (i == 1) {
1253 ei->i_next_section_block = block_saved;
1254 ei->i_next_section_offset = offset_saved;
1255 }
1256
1257 more_entries = de->flags[-high_sierra] & 0x80;
1258
1259 i++;
1260 if (i > 100)
1261 goto out_toomany;
1262 } while (more_entries);
1263out:
1264 kfree(tmpde);
1265 if (bh)
1266 brelse(bh);
1267 return 0;
1268
1269out_nomem:
1270 if (bh)
1271 brelse(bh);
1272 return -ENOMEM;
1273
1274out_noread:
1275 printk(KERN_INFO "ISOFS: unable to read i-node block %lu\n", block);
1276 kfree(tmpde);
1277 return -EIO;
1278
1279out_toomany:
1280 printk(KERN_INFO "%s: More than 100 file sections ?!?, aborting...\n"
1281 "isofs_read_level3_size: inode=%lu\n",
1282 __func__, inode->i_ino);
1283 goto out;
1284}
1285
1286static int isofs_read_inode(struct inode *inode)
1287{
1288 struct super_block *sb = inode->i_sb;
1289 struct isofs_sb_info *sbi = ISOFS_SB(sb);
1290 unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
1291 unsigned long block;
1292 int high_sierra = sbi->s_high_sierra;
1293 struct buffer_head *bh = NULL;
1294 struct iso_directory_record *de;
1295 struct iso_directory_record *tmpde = NULL;
1296 unsigned int de_len;
1297 unsigned long offset;
1298 struct iso_inode_info *ei = ISOFS_I(inode);
1299 int ret = -EIO;
1300
1301 block = ei->i_iget5_block;
1302 bh = sb_bread(inode->i_sb, block);
1303 if (!bh)
1304 goto out_badread;
1305
1306 offset = ei->i_iget5_offset;
1307
1308 de = (struct iso_directory_record *) (bh->b_data + offset);
1309 de_len = *(unsigned char *) de;
1310
1311 if (offset + de_len > bufsize) {
1312 int frag1 = bufsize - offset;
1313
1314 tmpde = kmalloc(de_len, GFP_KERNEL);
1315 if (tmpde == NULL) {
1316 printk(KERN_INFO "%s: out of memory\n", __func__);
1317 ret = -ENOMEM;
1318 goto fail;
1319 }
1320 memcpy(tmpde, bh->b_data + offset, frag1);
1321 brelse(bh);
1322 bh = sb_bread(inode->i_sb, ++block);
1323 if (!bh)
1324 goto out_badread;
1325 memcpy((char *)tmpde+frag1, bh->b_data, de_len - frag1);
1326 de = tmpde;
1327 }
1328
1329 inode->i_ino = isofs_get_ino(ei->i_iget5_block,
1330 ei->i_iget5_offset,
1331 ISOFS_BUFFER_BITS(inode));
1332
1333
1334 ei->i_file_format = isofs_file_normal;
1335
1336 if (de->flags[-high_sierra] & 2) {
1337 if (sbi->s_dmode != ISOFS_INVALID_MODE)
1338 inode->i_mode = S_IFDIR | sbi->s_dmode;
1339 else
1340 inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO;
1341 set_nlink(inode, 1);
1342
1343
1344
1345
1346
1347
1348 } else {
1349 if (sbi->s_fmode != ISOFS_INVALID_MODE) {
1350 inode->i_mode = S_IFREG | sbi->s_fmode;
1351 } else {
1352
1353
1354
1355
1356
1357 inode->i_mode = S_IFREG | S_IRUGO | S_IXUGO;
1358 }
1359 set_nlink(inode, 1);
1360 }
1361 inode->i_uid = sbi->s_uid;
1362 inode->i_gid = sbi->s_gid;
1363 inode->i_blocks = 0;
1364
1365 ei->i_format_parm[0] = 0;
1366 ei->i_format_parm[1] = 0;
1367 ei->i_format_parm[2] = 0;
1368
1369 ei->i_section_size = isonum_733(de->size);
1370 if (de->flags[-high_sierra] & 0x80) {
1371 ret = isofs_read_level3_size(inode);
1372 if (ret < 0)
1373 goto fail;
1374 ret = -EIO;
1375 } else {
1376 ei->i_next_section_block = 0;
1377 ei->i_next_section_offset = 0;
1378 inode->i_size = isonum_733(de->size);
1379 }
1380
1381
1382
1383
1384
1385
1386
1387 if (sbi->s_cruft)
1388 inode->i_size &= 0x00ffffff;
1389
1390 if (de->interleave[0]) {
1391 printk(KERN_DEBUG "ISOFS: Interleaved files not (yet) supported.\n");
1392 inode->i_size = 0;
1393 }
1394
1395
1396
1397 if (de->file_unit_size[0] != 0) {
1398 printk(KERN_DEBUG "ISOFS: File unit size != 0 for ISO file (%ld).\n",
1399 inode->i_ino);
1400 }
1401
1402
1403
1404#ifdef DEBUG
1405 if((de->flags[-high_sierra] & ~2)!= 0){
1406 printk(KERN_DEBUG "ISOFS: Unusual flag settings for ISO file "
1407 "(%ld %x).\n",
1408 inode->i_ino, de->flags[-high_sierra]);
1409 }
1410#endif
1411
1412 inode->i_mtime.tv_sec =
1413 inode->i_atime.tv_sec =
1414 inode->i_ctime.tv_sec = iso_date(de->date, high_sierra);
1415 inode->i_mtime.tv_nsec =
1416 inode->i_atime.tv_nsec =
1417 inode->i_ctime.tv_nsec = 0;
1418
1419 ei->i_first_extent = (isonum_733(de->extent) +
1420 isonum_711(de->ext_attr_length));
1421
1422
1423 inode->i_blocks = (inode->i_size + 511) >> 9;
1424
1425
1426
1427
1428
1429
1430 if (!high_sierra) {
1431 parse_rock_ridge_inode(de, inode);
1432
1433 if (sbi->s_uid_set)
1434 inode->i_uid = sbi->s_uid;
1435 if (sbi->s_gid_set)
1436 inode->i_gid = sbi->s_gid;
1437 }
1438
1439 if (S_ISDIR(inode->i_mode) && sbi->s_overriderockperm &&
1440 sbi->s_dmode != ISOFS_INVALID_MODE)
1441 inode->i_mode = S_IFDIR | sbi->s_dmode;
1442 if (S_ISREG(inode->i_mode) && sbi->s_overriderockperm &&
1443 sbi->s_fmode != ISOFS_INVALID_MODE)
1444 inode->i_mode = S_IFREG | sbi->s_fmode;
1445
1446
1447 if (S_ISREG(inode->i_mode)) {
1448 inode->i_fop = &generic_ro_fops;
1449 switch (ei->i_file_format) {
1450#ifdef CONFIG_ZISOFS
1451 case isofs_file_compressed:
1452 inode->i_data.a_ops = &zisofs_aops;
1453 break;
1454#endif
1455 default:
1456 inode->i_data.a_ops = &isofs_aops;
1457 break;
1458 }
1459 } else if (S_ISDIR(inode->i_mode)) {
1460 inode->i_op = &isofs_dir_inode_operations;
1461 inode->i_fop = &isofs_dir_operations;
1462 } else if (S_ISLNK(inode->i_mode)) {
1463 inode->i_op = &page_symlink_inode_operations;
1464 inode->i_data.a_ops = &isofs_symlink_aops;
1465 } else
1466
1467 init_special_inode(inode, inode->i_mode, inode->i_rdev);
1468
1469 ret = 0;
1470out:
1471 kfree(tmpde);
1472 if (bh)
1473 brelse(bh);
1474 return ret;
1475
1476out_badread:
1477 printk(KERN_WARNING "ISOFS: unable to read i-node block\n");
1478fail:
1479 goto out;
1480}
1481
1482struct isofs_iget5_callback_data {
1483 unsigned long block;
1484 unsigned long offset;
1485};
1486
1487static int isofs_iget5_test(struct inode *ino, void *data)
1488{
1489 struct iso_inode_info *i = ISOFS_I(ino);
1490 struct isofs_iget5_callback_data *d =
1491 (struct isofs_iget5_callback_data*)data;
1492 return (i->i_iget5_block == d->block)
1493 && (i->i_iget5_offset == d->offset);
1494}
1495
1496static int isofs_iget5_set(struct inode *ino, void *data)
1497{
1498 struct iso_inode_info *i = ISOFS_I(ino);
1499 struct isofs_iget5_callback_data *d =
1500 (struct isofs_iget5_callback_data*)data;
1501 i->i_iget5_block = d->block;
1502 i->i_iget5_offset = d->offset;
1503 return 0;
1504}
1505
1506
1507
1508
1509
1510struct inode *isofs_iget(struct super_block *sb,
1511 unsigned long block,
1512 unsigned long offset)
1513{
1514 unsigned long hashval;
1515 struct inode *inode;
1516 struct isofs_iget5_callback_data data;
1517 long ret;
1518
1519 if (offset >= 1ul << sb->s_blocksize_bits)
1520 return ERR_PTR(-EINVAL);
1521
1522 data.block = block;
1523 data.offset = offset;
1524
1525 hashval = (block << sb->s_blocksize_bits) | offset;
1526
1527 inode = iget5_locked(sb, hashval, &isofs_iget5_test,
1528 &isofs_iget5_set, &data);
1529
1530 if (!inode)
1531 return ERR_PTR(-ENOMEM);
1532
1533 if (inode->i_state & I_NEW) {
1534 ret = isofs_read_inode(inode);
1535 if (ret < 0) {
1536 iget_failed(inode);
1537 inode = ERR_PTR(ret);
1538 } else {
1539 unlock_new_inode(inode);
1540 }
1541 }
1542
1543 return inode;
1544}
1545
1546static struct dentry *isofs_mount(struct file_system_type *fs_type,
1547 int flags, const char *dev_name, void *data)
1548{
1549 return mount_bdev(fs_type, flags, dev_name, data, isofs_fill_super);
1550}
1551
1552static struct file_system_type iso9660_fs_type = {
1553 .owner = THIS_MODULE,
1554 .name = "iso9660",
1555 .mount = isofs_mount,
1556 .kill_sb = kill_block_super,
1557 .fs_flags = FS_REQUIRES_DEV,
1558};
1559MODULE_ALIAS_FS("iso9660");
1560MODULE_ALIAS("iso9660");
1561
1562static int __init init_iso9660_fs(void)
1563{
1564 int err = init_inodecache();
1565 if (err)
1566 goto out;
1567#ifdef CONFIG_ZISOFS
1568 err = zisofs_init();
1569 if (err)
1570 goto out1;
1571#endif
1572 err = register_filesystem(&iso9660_fs_type);
1573 if (err)
1574 goto out2;
1575 return 0;
1576out2:
1577#ifdef CONFIG_ZISOFS
1578 zisofs_cleanup();
1579out1:
1580#endif
1581 destroy_inodecache();
1582out:
1583 return err;
1584}
1585
1586static void __exit exit_iso9660_fs(void)
1587{
1588 unregister_filesystem(&iso9660_fs_type);
1589#ifdef CONFIG_ZISOFS
1590 zisofs_cleanup();
1591#endif
1592 destroy_inodecache();
1593}
1594
1595module_init(init_iso9660_fs)
1596module_exit(exit_iso9660_fs)
1597MODULE_LICENSE("GPL");
1598