2 * linux/fs/isofs/inode.c
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
14 #include <linux/config.h>
15 #include <linux/module.h>
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>
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>
43 static int check_malloc
;
44 static int check_bread
;
47 static int isofs_hashi(struct dentry
*parent
, struct qstr
*qstr
);
48 static int isofs_hash(struct dentry
*parent
, struct qstr
*qstr
);
49 static int isofs_dentry_cmpi(struct dentry
*dentry
, struct qstr
*a
, struct qstr
*b
);
50 static int isofs_dentry_cmp(struct dentry
*dentry
, struct qstr
*a
, struct qstr
*b
);
53 static int isofs_hashi_ms(struct dentry
*parent
, struct qstr
*qstr
);
54 static int isofs_hash_ms(struct dentry
*parent
, struct qstr
*qstr
);
55 static int isofs_dentry_cmpi_ms(struct dentry
*dentry
, struct qstr
*a
, struct qstr
*b
);
56 static int isofs_dentry_cmp_ms(struct dentry
*dentry
, struct qstr
*a
, struct qstr
*b
);
59 static void isofs_put_super(struct super_block
*sb
)
61 struct isofs_sb_info
*sbi
= ISOFS_SB(sb
);
63 if (sbi
->s_nls_iocharset
) {
64 unload_nls(sbi
->s_nls_iocharset
);
65 sbi
->s_nls_iocharset
= NULL
;
70 printk("Outstanding mallocs:%d, outstanding buffers: %d\n",
71 check_malloc
, check_bread
);
79 static void isofs_read_inode(struct inode
*);
80 static int isofs_statfs (struct super_block
*, struct kstatfs
*);
82 static kmem_cache_t
*isofs_inode_cachep
;
84 static struct inode
*isofs_alloc_inode(struct super_block
*sb
)
86 struct iso_inode_info
*ei
;
87 ei
= (struct iso_inode_info
*)kmem_cache_alloc(isofs_inode_cachep
, SLAB_KERNEL
);
90 return &ei
->vfs_inode
;
93 static void isofs_destroy_inode(struct inode
*inode
)
95 kmem_cache_free(isofs_inode_cachep
, ISOFS_I(inode
));
98 static void init_once(void * foo
, kmem_cache_t
* cachep
, unsigned long flags
)
100 struct iso_inode_info
*ei
= (struct iso_inode_info
*) foo
;
102 if ((flags
& (SLAB_CTOR_VERIFY
|SLAB_CTOR_CONSTRUCTOR
)) ==
103 SLAB_CTOR_CONSTRUCTOR
)
104 inode_init_once(&ei
->vfs_inode
);
107 static int init_inodecache(void)
109 isofs_inode_cachep
= kmem_cache_create("isofs_inode_cache",
110 sizeof(struct iso_inode_info
),
111 0, SLAB_RECLAIM_ACCOUNT
,
113 if (isofs_inode_cachep
== NULL
)
118 static void destroy_inodecache(void)
120 if (kmem_cache_destroy(isofs_inode_cachep
))
121 printk(KERN_INFO
"iso_inode_cache: not all structures were freed\n");
124 static int isofs_remount(struct super_block
*sb
, int *flags
, char *data
)
126 /* we probably want a lot more here */
131 static 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
,
141 static struct dentry_operations isofs_dentry_ops
[] = {
143 .d_hash
= isofs_hash
,
144 .d_compare
= isofs_dentry_cmp
,
147 .d_hash
= isofs_hashi
,
148 .d_compare
= isofs_dentry_cmpi
,
152 .d_hash
= isofs_hash_ms
,
153 .d_compare
= isofs_dentry_cmp_ms
,
156 .d_hash
= isofs_hashi_ms
,
157 .d_compare
= isofs_dentry_cmpi_ms
,
162 struct iso9660_options
{
170 unsigned int blocksize
;
182 * Compute the hash for the isofs name corresponding to the dentry.
185 isofs_hash_common(struct dentry
*dentry
, struct qstr
*qstr
, int ms
)
193 while (len
&& name
[len
-1] == '.')
197 qstr
->hash
= full_name_hash(name
, len
);
203 * Compute the hash for the isofs name corresponding to the dentry.
206 isofs_hashi_common(struct dentry
*dentry
, struct qstr
*qstr
, int ms
)
216 while (len
&& name
[len
-1] == '.')
220 hash
= init_name_hash();
222 c
= tolower(*name
++);
223 hash
= partial_name_hash(tolower(c
), hash
);
225 qstr
->hash
= end_name_hash(hash
);
231 * Case insensitive compare of two isofs names.
234 isofs_dentry_cmpi_common(struct dentry
*dentry
,struct qstr
*a
,struct qstr
*b
,int ms
)
238 /* A filename cannot end in '.' or we treat it like it has none */
242 while (alen
&& a
->name
[alen
-1] == '.')
244 while (blen
&& b
->name
[blen
-1] == '.')
248 if (strnicmp(a
->name
, b
->name
, alen
) == 0)
255 * Case sensitive compare of two isofs names.
258 isofs_dentry_cmp_common(struct dentry
*dentry
,struct qstr
*a
,struct qstr
*b
,int ms
)
262 /* A filename cannot end in '.' or we treat it like it has none */
266 while (alen
&& a
->name
[alen
-1] == '.')
268 while (blen
&& b
->name
[blen
-1] == '.')
272 if (strncmp(a
->name
, b
->name
, alen
) == 0)
279 isofs_hash(struct dentry
*dentry
, struct qstr
*qstr
)
281 return isofs_hash_common(dentry
, qstr
, 0);
285 isofs_hashi(struct dentry
*dentry
, struct qstr
*qstr
)
287 return isofs_hashi_common(dentry
, qstr
, 0);
291 isofs_dentry_cmp(struct dentry
*dentry
,struct qstr
*a
,struct qstr
*b
)
293 return isofs_dentry_cmp_common(dentry
, a
, b
, 0);
297 isofs_dentry_cmpi(struct dentry
*dentry
,struct qstr
*a
,struct qstr
*b
)
299 return isofs_dentry_cmpi_common(dentry
, a
, b
, 0);
304 isofs_hash_ms(struct dentry
*dentry
, struct qstr
*qstr
)
306 return isofs_hash_common(dentry
, qstr
, 1);
310 isofs_hashi_ms(struct dentry
*dentry
, struct qstr
*qstr
)
312 return isofs_hashi_common(dentry
, qstr
, 1);
316 isofs_dentry_cmp_ms(struct dentry
*dentry
,struct qstr
*a
,struct qstr
*b
)
318 return isofs_dentry_cmp_common(dentry
, a
, b
, 1);
322 isofs_dentry_cmpi_ms(struct dentry
*dentry
,struct qstr
*a
,struct qstr
*b
)
324 return isofs_dentry_cmpi_common(dentry
, a
, b
, 1);
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
,
335 static match_table_t tokens
= {
336 {Opt_norock
, "norock"},
337 {Opt_nojoliet
, "nojoliet"},
338 {Opt_unhide
, "unhide"},
339 {Opt_cruft
, "cruft"},
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"},
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"},
370 static int parse_options(char *options
, struct iso9660_options
* popt
)
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. */
389 popt
->iocharset
= NULL
;
396 while ((p
= strsep(&options
, ",")) != NULL
) {
398 substring_t args
[MAX_OPT_ARGS
];
404 token
= match_token(p
, tokens
, args
);
423 popt
->iocharset
= match_strdup(&args
[0]);
436 if (match_int(&args
[0], &option
))
441 popt
->session
= n
+ 1;
444 if (match_int(&args
[0], &option
))
446 popt
->sbsector
= option
;
457 if (match_int(&args
[0], &option
))
462 if (match_int(&args
[0], &option
))
467 if (match_int(&args
[0], &option
))
472 if (match_int(&args
[0], &option
))
475 if (n
!= 512 && n
!= 1024 && n
!= 2048)
480 popt
->nocompress
= 1;
490 * look if the driver can tell the multi session redirection value
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.
500 * A broken CDwriter software or drive firmware does not set new standards,
501 * at least not if conflicting with the existing ones.
505 #define WE_OBEY_THE_WRITTEN_STANDARDS 1
507 static unsigned int isofs_get_last_session(struct super_block
*sb
,s32 session
)
509 struct cdrom_multisession ms_info
;
510 unsigned int vol_desc_start
;
511 struct block_device
*bdev
= sb
->s_bdev
;
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
);
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
;
529 printk(KERN_ERR
"Invalid session number or type of track\n");
531 i
= ioctl_by_bdev(bdev
, CDROMMULTISESSION
, (unsigned long) &ms_info
);
532 if(session
> 0) printk(KERN_ERR
"Invalid session number\n");
534 printk("isofs.inode: CDROMMULTISESSION: rc=%d\n",i
);
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
);
541 #if WE_OBEY_THE_WRITTEN_STANDARDS
542 if (ms_info
.xa_flag
) /* necessary for a valid ms_info.addr */
544 vol_desc_start
=ms_info
.addr
.lba
;
545 return vol_desc_start
;
549 * Initialize the superblock and read the root inode.
551 * Note: a check_disk_change() has been done immediately prior
552 * to this call, so we don't need to check again.
554 static int isofs_fill_super(struct super_block
*s
, void *data
, int silent
)
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
;
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
;
571 sbi
= kmalloc(sizeof(struct isofs_sb_info
), GFP_KERNEL
);
575 memset(sbi
, 0, sizeof(struct isofs_sb_info
));
577 if (!parse_options((char *) data
, &opt
))
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
587 * What if bugger tells us to go beyond page size?
589 opt
.blocksize
= sb_min_blocksize(s
, opt
.blocksize
);
591 sbi
->s_high_sierra
= 0; /* default is iso9660 */
593 vol_desc_start
= (opt
.sbsector
!= -1) ?
594 opt
.sbsector
: isofs_get_last_session(s
,opt
.session
);
596 for (iso_blknum
= vol_desc_start
+16;
597 iso_blknum
< vol_desc_start
+100; iso_blknum
++)
599 struct hs_volume_descriptor
* hdp
;
600 struct iso_volume_descriptor
* vdp
;
602 block
= iso_blknum
<< (ISOFS_BLOCK_BITS
- s
->s_blocksize_bits
);
603 if (!(bh
= sb_bread(s
, block
)))
606 vdp
= (struct iso_volume_descriptor
*)bh
->b_data
;
607 hdp
= (struct hs_volume_descriptor
*)bh
->b_data
;
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.
613 if (strncmp (vdp
->id
, ISO_STANDARD_ID
, sizeof vdp
->id
) == 0) {
614 if (isonum_711 (vdp
->type
) == ISO_VD_END
)
616 if (isonum_711 (vdp
->type
) == ISO_VD_PRIMARY
) {
618 pri
= (struct iso_primary_descriptor
*)vdp
;
619 /* Save the buffer in case we need it ... */
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) {
631 } else if (sec
->escape
[2] == 0x43) {
633 } else if (sec
->escape
[2] == 0x45) {
636 printk(KERN_DEBUG
"ISO 9660 Extensions: Microsoft Joliet Level %d\n",
641 /* Unknown supplementary volume descriptor */
647 if (strncmp (hdp
->id
, HS_STANDARD_ID
, sizeof hdp
->id
) == 0) {
648 if (isonum_711 (hdp
->type
) != ISO_VD_PRIMARY
)
651 sbi
->s_high_sierra
= 1;
653 h_pri
= (struct hs_primary_descriptor
*)vdp
;
658 /* Just skip any volume descriptors we don't recognize */
664 * If we fall through, either no volume descriptor was found,
665 * or else we passed a primary descriptor looking for others.
668 goto out_unknown_format
;
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
679 pri
= (struct iso_primary_descriptor
*) sec
;
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
);
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
);
696 sbi
->s_ninodes
= 0; /* No way to figure this out easily */
698 orig_zonesize
= sbi
->s_log_zone_size
;
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
706 if(orig_zonesize
< opt
.blocksize
)
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;
716 goto out_bad_zone_size
;
719 s
->s_magic
= ISOFS_SUPER_MAGIC
;
720 s
->s_maxbytes
= 0xffffffff; /* We can handle files up to 4 GB */
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) */
727 s
->s_flags
|= MS_RDONLY
/* | MS_NODEV | MS_NOSUID */;
729 /* Set this for reference. Its not currently used except on write
730 which we don't have .. */
732 first_data_zone
= isonum_733 (rootp
->extent
) +
733 isonum_711 (rootp
->ext_attr_length
);
734 sbi
->s_firstdatazone
= first_data_zone
;
736 printk(KERN_DEBUG
"Max size:%ld Log zone size:%ld\n",
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");
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.
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
);
761 * We're all done using the volume descriptor, and may need
762 * to change the device blocksize, so release the buffer now.
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
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.
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.
784 sb_set_blocksize(s
, orig_zonesize
);
786 sbi
->s_nls_iocharset
= NULL
;
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 */
796 sbi
->s_nls_iocharset
= load_nls_default();
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
;
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
816 sbi
->s_mode
= opt
.mode
& 0777;
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.
823 inode
= isofs_iget(s
, sbi
->s_firstdatazone
, 0);
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.
833 if (sbi
->s_rock
== 1) {
835 } else if (joliet_level
) {
837 if (sbi
->s_firstdatazone
!= first_data_zone
) {
838 sbi
->s_firstdatazone
= first_data_zone
;
840 "ISOFS: changing to secondary root\n");
842 inode
= isofs_iget(s
, sbi
->s_firstdatazone
, 0);
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';
851 sbi
->s_joliet_level
= joliet_level
;
853 /* check the root inode */
858 /* get the root dentry */
859 s
->s_root
= d_alloc_root(inode
);
864 if (joliet_level
) table
+= 2;
865 if (opt
.check
== 'r') table
++;
866 s
->s_root
->d_op
= &isofs_dentry_ops
[table
];
869 kfree(opt
.iocharset
);
874 * Display error messages and free resources.
877 printk(KERN_WARNING
"isofs_fill_super: root inode not initialized\n");
880 printk(KERN_WARNING
"isofs_fill_super: get root inode failed\n");
884 if (sbi
->s_nls_iocharset
)
885 unload_nls(sbi
->s_nls_iocharset
);
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
);
894 printk(KERN_WARNING
"Bad logical zone size %ld\n",
895 sbi
->s_log_zone_size
);
898 printk(KERN_WARNING
"Logical zone size(%d) < hardware blocksize(%u)\n",
899 orig_zonesize
, opt
.blocksize
);
903 printk(KERN_WARNING
"Unable to identify CD-ROM format.\n");
909 kfree(opt
.iocharset
);
915 static int isofs_statfs (struct super_block
*sb
, struct kstatfs
*buf
)
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
));
923 buf
->f_files
= ISOFS_SB(sb
)->s_ninodes
;
925 buf
->f_namelen
= NAME_MAX
;
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
934 int isofs_get_blocks(struct inode
*inode
, sector_t iblock_s
,
935 struct buffer_head
**bh
, unsigned long nblocks
)
938 unsigned offset
, sect_size
;
939 unsigned int firstext
;
940 unsigned long nextblk
, nextoff
;
941 long iblock
= (long)iblock_s
;
943 struct iso_inode_info
*ei
= ISOFS_I(inode
);
948 if (iblock
< 0 || iblock
!= iblock_s
) {
949 printk("isofs_get_blocks: block number too large\n");
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
;
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
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
);
977 while (b_off
>= (offset
+ sect_size
)) {
978 struct inode
*ninode
;
983 ninode
= isofs_iget(inode
->i_sb
, nextblk
, nextoff
);
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
;
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
,
1004 map_bh(*bh
, inode
->i_sb
, firstext
+ b_off
- offset
);
1006 *bh
= sb_getblk(inode
->i_sb
, firstext
+b_off
-offset
);
1010 bh
++; /* Next buffer head */
1011 b_off
++; /* Next buffer offset */
1023 * Used by the standard interfaces.
1025 static int isofs_get_block(struct inode
*inode
, sector_t iblock
,
1026 struct buffer_head
*bh_result
, int create
)
1029 printk("isofs_get_block: Kernel tries to allocate a block\n");
1033 return isofs_get_blocks(inode
, iblock
, &bh_result
, 1) ? 0 : -EIO
;
1036 static int isofs_bmap(struct inode
*inode
, sector_t block
)
1038 struct buffer_head dummy
;
1042 dummy
.b_blocknr
= -1000;
1043 error
= isofs_get_block(inode
, block
, &dummy
, 0);
1045 return dummy
.b_blocknr
;
1049 struct buffer_head
*isofs_bread(struct inode
*inode
, sector_t block
)
1051 sector_t blknr
= isofs_bmap(inode
, block
);
1054 return sb_bread(inode
->i_sb
, blknr
);
1057 static int isofs_readpage(struct file
*file
, struct page
*page
)
1059 return block_read_full_page(page
,isofs_get_block
);
1062 static sector_t
_isofs_bmap(struct address_space
*mapping
, sector_t block
)
1064 return generic_block_bmap(mapping
,block
,isofs_get_block
);
1067 static struct address_space_operations isofs_aops
= {
1068 .readpage
= isofs_readpage
,
1069 .sync_page
= block_sync_page
,
1073 static inline void test_and_set_uid(uid_t
*p
, uid_t value
)
1080 static inline void test_and_set_gid(gid_t
*p
, gid_t value
)
1087 static int isofs_read_level3_size(struct inode
* inode
)
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
;
1094 int more_entries
= 0;
1095 struct iso_directory_record
* tmpde
= NULL
;
1096 struct iso_inode_info
*ei
= ISOFS_I(inode
);
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;
1106 block
= ei
->i_iget5_block
;
1107 offset
= ei
->i_iget5_offset
;
1110 struct iso_directory_record
* de
;
1111 unsigned int de_len
;
1114 bh
= sb_bread(inode
->i_sb
, block
);
1118 de
= (struct iso_directory_record
*) (bh
->b_data
+ offset
);
1119 de_len
= *(unsigned char *) de
;
1129 block_saved
= block
;
1130 offset_saved
= offset
;
1133 /* Make sure we have a full directory entry */
1134 if (offset
>= bufsize
) {
1135 int slop
= bufsize
- offset
+ de_len
;
1137 tmpde
= kmalloc(256, GFP_KERNEL
);
1141 memcpy(tmpde
, de
, slop
);
1142 offset
&= bufsize
- 1;
1147 bh
= sb_bread(inode
->i_sb
, block
);
1150 memcpy((void *) tmpde
+ slop
, bh
->b_data
, offset
);
1155 inode
->i_size
+= isonum_733(de
->size
);
1157 ei
->i_next_section_block
= block_saved
;
1158 ei
->i_next_section_offset
= offset_saved
;
1161 more_entries
= de
->flags
[-high_sierra
] & 0x80;
1166 } while(more_entries
);
1180 printk(KERN_INFO
"ISOFS: unable to read i-node block %lu\n", block
);
1186 printk(KERN_INFO
"isofs_read_level3_size: "
1187 "More than 100 file sections ?!?, aborting...\n"
1188 "isofs_read_level3_size: inode=%lu\n",
1193 static void isofs_read_inode(struct inode
* inode
)
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
);
1207 block
= ei
->i_iget5_block
;
1208 bh
= sb_bread(inode
->i_sb
, block
);
1212 offset
= ei
->i_iget5_offset
;
1214 de
= (struct iso_directory_record
*) (bh
->b_data
+ offset
);
1215 de_len
= *(unsigned char *) de
;
1217 if (offset
+ de_len
> bufsize
) {
1218 int frag1
= bufsize
- offset
;
1220 tmpde
= kmalloc(de_len
, GFP_KERNEL
);
1221 if (tmpde
== NULL
) {
1222 printk(KERN_INFO
"isofs_read_inode: out of memory\n");
1225 memcpy(tmpde
, bh
->b_data
+ offset
, frag1
);
1227 bh
= sb_bread(inode
->i_sb
, ++block
);
1230 memcpy((char *)tmpde
+frag1
, bh
->b_data
, de_len
- frag1
);
1234 inode
->i_ino
= isofs_get_ino(ei
->i_iget5_block
,
1236 ISOFS_BUFFER_BITS(inode
));
1238 /* Assume it is a normal-format file unless told otherwise */
1239 ei
->i_file_format
= isofs_file_normal
;
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. */
1249 /* Everybody gets to read the file. */
1250 inode
->i_mode
= sbi
->s_mode
;
1252 inode
->i_mode
|= S_IFREG
;
1254 inode
->i_uid
= sbi
->s_uid
;
1255 inode
->i_gid
= sbi
->s_gid
;
1256 inode
->i_blocks
= inode
->i_blksize
= 0;
1258 ei
->i_format_parm
[0] = 0;
1259 ei
->i_format_parm
[1] = 0;
1260 ei
->i_format_parm
[2] = 0;
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
;
1266 ei
->i_next_section_block
= 0;
1267 ei
->i_next_section_offset
= 0;
1268 inode
->i_size
= isonum_733 (de
->size
);
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.
1277 if (sbi
->s_cruft
== 'y')
1278 inode
->i_size
&= 0x00ffffff;
1280 if (de
->interleave
[0]) {
1281 printk("Interleaved files not (yet) supported.\n");
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",
1292 /* I have no idea what other flag bits are used for, so
1293 we will flag it for now */
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
]);
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;
1308 ei
->i_first_extent
= (isonum_733 (de
->extent
) +
1309 isonum_711 (de
->ext_attr_length
));
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;
1316 * Now test for possible Rock Ridge extensions which will override
1317 * some of these numbers in the inode structure.
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
);
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
;
1337 inode
->i_data
.a_ops
= &isofs_aops
;
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
;
1347 /* XXX - parse_rock_ridge_inode() had already set i_rdev. */
1348 init_special_inode(inode
, inode
->i_mode
, inode
->i_rdev
);
1358 printk(KERN_WARNING
"ISOFS: unable to read i-node block\n");
1360 make_bad_inode(inode
);
1364 struct isofs_iget5_callback_data
{
1365 unsigned long block
;
1366 unsigned long offset
;
1369 static int isofs_iget5_test(struct inode
*ino
, void *data
)
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
);
1378 static int isofs_iget5_set(struct inode
*ino
, void *data
)
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
;
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 */
1392 struct inode
*isofs_iget(struct super_block
*sb
,
1393 unsigned long block
,
1394 unsigned long offset
)
1396 unsigned long hashval
;
1397 struct inode
*inode
;
1398 struct isofs_iget5_callback_data data
;
1400 if (offset
>= 1ul << sb
->s_blocksize_bits
)
1404 data
.offset
= offset
;
1406 hashval
= (block
<< sb
->s_blocksize_bits
) | offset
;
1408 inode
= iget5_locked(sb
,
1414 if (inode
&& (inode
->i_state
& I_NEW
)) {
1415 sb
->s_op
->read_inode(inode
);
1416 unlock_new_inode(inode
);
1428 void * leak_check_malloc(unsigned int size
){
1431 tmp
= kmalloc(size
, GFP_KERNEL
);
1435 void leak_check_free_s(void * obj
, int size
){
1440 struct buffer_head
* leak_check_bread(struct super_block
*sb
, int block
){
1442 return sb_bread(sb
, block
);
1445 void leak_check_brelse(struct buffer_head
* bh
){
1452 static struct super_block
*isofs_get_sb(struct file_system_type
*fs_type
,
1453 int flags
, const char *dev_name
, void *data
)
1455 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, isofs_fill_super
);
1458 static struct file_system_type iso9660_fs_type
= {
1459 .owner
= THIS_MODULE
,
1461 .get_sb
= isofs_get_sb
,
1462 .kill_sb
= kill_block_super
,
1463 .fs_flags
= FS_REQUIRES_DEV
,
1466 static int __init
init_iso9660_fs(void)
1468 int err
= init_inodecache();
1471 #ifdef CONFIG_ZISOFS
1472 err
= zisofs_init();
1476 err
= register_filesystem(&iso9660_fs_type
);
1481 #ifdef CONFIG_ZISOFS
1485 destroy_inodecache();
1490 static void __exit
exit_iso9660_fs(void)
1492 unregister_filesystem(&iso9660_fs_type
);
1493 #ifdef CONFIG_ZISOFS
1496 destroy_inodecache();
1499 module_init(init_iso9660_fs
)
1500 module_exit(exit_iso9660_fs
)
1501 MODULE_LICENSE("GPL");
1502 /* Actual filesystem name is iso9660, as requested in filesystems.c */
1503 MODULE_ALIAS("iso9660");