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/init.h>
16 #include <linux/module.h>
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>
31 static int isofs_hashi(struct dentry
*parent
, struct qstr
*qstr
);
32 static int isofs_hash(struct dentry
*parent
, struct qstr
*qstr
);
33 static int isofs_dentry_cmpi(struct dentry
*dentry
, struct qstr
*a
, struct qstr
*b
);
34 static int isofs_dentry_cmp(struct dentry
*dentry
, struct qstr
*a
, struct qstr
*b
);
37 static int isofs_hashi_ms(struct dentry
*parent
, struct qstr
*qstr
);
38 static int isofs_hash_ms(struct dentry
*parent
, struct qstr
*qstr
);
39 static int isofs_dentry_cmpi_ms(struct dentry
*dentry
, struct qstr
*a
, struct qstr
*b
);
40 static int isofs_dentry_cmp_ms(struct dentry
*dentry
, struct qstr
*a
, struct qstr
*b
);
43 static void isofs_put_super(struct super_block
*sb
)
45 struct isofs_sb_info
*sbi
= ISOFS_SB(sb
);
47 if (sbi
->s_nls_iocharset
) {
48 unload_nls(sbi
->s_nls_iocharset
);
49 sbi
->s_nls_iocharset
= NULL
;
58 static void isofs_read_inode(struct inode
*);
59 static int isofs_statfs (struct super_block
*, struct kstatfs
*);
61 static kmem_cache_t
*isofs_inode_cachep
;
63 static struct inode
*isofs_alloc_inode(struct super_block
*sb
)
65 struct iso_inode_info
*ei
;
66 ei
= kmem_cache_alloc(isofs_inode_cachep
, SLAB_KERNEL
);
69 return &ei
->vfs_inode
;
72 static void isofs_destroy_inode(struct inode
*inode
)
74 kmem_cache_free(isofs_inode_cachep
, ISOFS_I(inode
));
77 static void init_once(void *foo
, kmem_cache_t
* cachep
, unsigned long flags
)
79 struct iso_inode_info
*ei
= foo
;
81 if ((flags
& (SLAB_CTOR_VERIFY
|SLAB_CTOR_CONSTRUCTOR
)) ==
82 SLAB_CTOR_CONSTRUCTOR
)
83 inode_init_once(&ei
->vfs_inode
);
86 static int init_inodecache(void)
88 isofs_inode_cachep
= kmem_cache_create("isofs_inode_cache",
89 sizeof(struct iso_inode_info
),
90 0, SLAB_RECLAIM_ACCOUNT
,
92 if (isofs_inode_cachep
== NULL
)
97 static void destroy_inodecache(void)
99 if (kmem_cache_destroy(isofs_inode_cachep
))
100 printk(KERN_INFO
"iso_inode_cache: not all structures were "
104 static int isofs_remount(struct super_block
*sb
, int *flags
, char *data
)
106 /* we probably want a lot more here */
111 static struct super_operations isofs_sops
= {
112 .alloc_inode
= isofs_alloc_inode
,
113 .destroy_inode
= isofs_destroy_inode
,
114 .read_inode
= isofs_read_inode
,
115 .put_super
= isofs_put_super
,
116 .statfs
= isofs_statfs
,
117 .remount_fs
= isofs_remount
,
121 static struct dentry_operations isofs_dentry_ops
[] = {
123 .d_hash
= isofs_hash
,
124 .d_compare
= isofs_dentry_cmp
,
127 .d_hash
= isofs_hashi
,
128 .d_compare
= isofs_dentry_cmpi
,
132 .d_hash
= isofs_hash_ms
,
133 .d_compare
= isofs_dentry_cmp_ms
,
136 .d_hash
= isofs_hashi_ms
,
137 .d_compare
= isofs_dentry_cmpi_ms
,
142 struct iso9660_options
{
150 unsigned int blocksize
;
162 * Compute the hash for the isofs name corresponding to the dentry.
165 isofs_hash_common(struct dentry
*dentry
, struct qstr
*qstr
, int ms
)
173 while (len
&& name
[len
-1] == '.')
177 qstr
->hash
= full_name_hash(name
, len
);
183 * Compute the hash for the isofs name corresponding to the dentry.
186 isofs_hashi_common(struct dentry
*dentry
, struct qstr
*qstr
, int ms
)
196 while (len
&& name
[len
-1] == '.')
200 hash
= init_name_hash();
202 c
= tolower(*name
++);
203 hash
= partial_name_hash(tolower(c
), hash
);
205 qstr
->hash
= end_name_hash(hash
);
211 * Case insensitive compare of two isofs names.
213 static int isofs_dentry_cmpi_common(struct dentry
*dentry
, struct qstr
*a
,
214 struct qstr
*b
, int ms
)
218 /* A filename cannot end in '.' or we treat it like it has none */
222 while (alen
&& a
->name
[alen
-1] == '.')
224 while (blen
&& b
->name
[blen
-1] == '.')
228 if (strnicmp(a
->name
, b
->name
, alen
) == 0)
235 * Case sensitive compare of two isofs names.
237 static int isofs_dentry_cmp_common(struct dentry
*dentry
, struct qstr
*a
,
238 struct qstr
*b
, int ms
)
242 /* A filename cannot end in '.' or we treat it like it has none */
246 while (alen
&& a
->name
[alen
-1] == '.')
248 while (blen
&& b
->name
[blen
-1] == '.')
252 if (strncmp(a
->name
, b
->name
, alen
) == 0)
259 isofs_hash(struct dentry
*dentry
, struct qstr
*qstr
)
261 return isofs_hash_common(dentry
, qstr
, 0);
265 isofs_hashi(struct dentry
*dentry
, struct qstr
*qstr
)
267 return isofs_hashi_common(dentry
, qstr
, 0);
271 isofs_dentry_cmp(struct dentry
*dentry
,struct qstr
*a
,struct qstr
*b
)
273 return isofs_dentry_cmp_common(dentry
, a
, b
, 0);
277 isofs_dentry_cmpi(struct dentry
*dentry
,struct qstr
*a
,struct qstr
*b
)
279 return isofs_dentry_cmpi_common(dentry
, a
, b
, 0);
284 isofs_hash_ms(struct dentry
*dentry
, struct qstr
*qstr
)
286 return isofs_hash_common(dentry
, qstr
, 1);
290 isofs_hashi_ms(struct dentry
*dentry
, struct qstr
*qstr
)
292 return isofs_hashi_common(dentry
, qstr
, 1);
296 isofs_dentry_cmp_ms(struct dentry
*dentry
,struct qstr
*a
,struct qstr
*b
)
298 return isofs_dentry_cmp_common(dentry
, a
, b
, 1);
302 isofs_dentry_cmpi_ms(struct dentry
*dentry
,struct qstr
*a
,struct qstr
*b
)
304 return isofs_dentry_cmpi_common(dentry
, a
, b
, 1);
309 Opt_block
, Opt_check_r
, Opt_check_s
, Opt_cruft
, Opt_gid
, Opt_ignore
,
310 Opt_iocharset
, Opt_map_a
, Opt_map_n
, Opt_map_o
, Opt_mode
, Opt_nojoliet
,
311 Opt_norock
, Opt_sb
, Opt_session
, Opt_uid
, Opt_unhide
, Opt_utf8
, Opt_err
,
315 static match_table_t tokens
= {
316 {Opt_norock
, "norock"},
317 {Opt_nojoliet
, "nojoliet"},
318 {Opt_unhide
, "unhide"},
319 {Opt_cruft
, "cruft"},
321 {Opt_iocharset
, "iocharset=%s"},
322 {Opt_map_a
, "map=acorn"},
323 {Opt_map_a
, "map=a"},
324 {Opt_map_n
, "map=normal"},
325 {Opt_map_n
, "map=n"},
326 {Opt_map_o
, "map=off"},
327 {Opt_map_o
, "map=o"},
328 {Opt_session
, "session=%u"},
329 {Opt_sb
, "sbsector=%u"},
330 {Opt_check_r
, "check=relaxed"},
331 {Opt_check_r
, "check=r"},
332 {Opt_check_s
, "check=strict"},
333 {Opt_check_s
, "check=s"},
336 {Opt_mode
, "mode=%u"},
337 {Opt_block
, "block=%u"},
338 {Opt_ignore
, "conv=binary"},
339 {Opt_ignore
, "conv=b"},
340 {Opt_ignore
, "conv=text"},
341 {Opt_ignore
, "conv=t"},
342 {Opt_ignore
, "conv=mtext"},
343 {Opt_ignore
, "conv=m"},
344 {Opt_ignore
, "conv=auto"},
345 {Opt_ignore
, "conv=a"},
346 {Opt_nocompress
, "nocompress"},
350 static int parse_options(char *options
, struct iso9660_options
*popt
)
360 popt
->check
= 'u'; /* unset */
361 popt
->nocompress
= 0;
362 popt
->blocksize
= 1024;
363 popt
->mode
= S_IRUGO
| S_IXUGO
; /* r-x for all. The disc could
364 be shared with DOS machines so
365 virtually anything could be
366 a valid executable. */
369 popt
->iocharset
= NULL
;
376 while ((p
= strsep(&options
, ",")) != NULL
) {
378 substring_t args
[MAX_OPT_ARGS
];
384 token
= match_token(p
, tokens
, args
);
403 popt
->iocharset
= match_strdup(&args
[0]);
416 if (match_int(&args
[0], &option
))
421 popt
->session
= n
+ 1;
424 if (match_int(&args
[0], &option
))
426 popt
->sbsector
= option
;
437 if (match_int(&args
[0], &option
))
442 if (match_int(&args
[0], &option
))
447 if (match_int(&args
[0], &option
))
452 if (match_int(&args
[0], &option
))
455 if (n
!= 512 && n
!= 1024 && n
!= 2048)
460 popt
->nocompress
= 1;
470 * look if the driver can tell the multi session redirection value
472 * don't change this if you don't know what you do, please!
473 * Multisession is legal only with XA disks.
474 * A non-XA disk with more than one volume descriptor may do it right, but
475 * usually is written in a nowhere standardized "multi-partition" manner.
476 * Multisession uses absolute addressing (solely the first frame of the whole
477 * track is #0), multi-partition uses relative addressing (each first frame of
478 * each track is #0), and a track is not a session.
480 * A broken CDwriter software or drive firmware does not set new standards,
481 * at least not if conflicting with the existing ones.
485 #define WE_OBEY_THE_WRITTEN_STANDARDS 1
487 static unsigned int isofs_get_last_session(struct super_block
*sb
, s32 session
)
489 struct cdrom_multisession ms_info
;
490 unsigned int vol_desc_start
;
491 struct block_device
*bdev
= sb
->s_bdev
;
495 ms_info
.addr_format
=CDROM_LBA
;
496 if(session
>= 0 && session
<= 99) {
497 struct cdrom_tocentry Te
;
498 Te
.cdte_track
=session
;
499 Te
.cdte_format
=CDROM_LBA
;
500 i
= ioctl_by_bdev(bdev
, CDROMREADTOCENTRY
, (unsigned long) &Te
);
502 printk(KERN_DEBUG
"Session %d start %d type %d\n",
503 session
, Te
.cdte_addr
.lba
,
504 Te
.cdte_ctrl
&CDROM_DATA_TRACK
);
505 if ((Te
.cdte_ctrl
&CDROM_DATA_TRACK
) == 4)
506 return Te
.cdte_addr
.lba
;
509 printk(KERN_ERR
"Invalid session number or type of track\n");
511 i
= ioctl_by_bdev(bdev
, CDROMMULTISESSION
, (unsigned long) &ms_info
);
513 printk(KERN_ERR
"Invalid session number\n");
515 printk("isofs.inode: CDROMMULTISESSION: rc=%d\n",i
);
517 printk("isofs.inode: XA disk: %s\n",ms_info
.xa_flag
?"yes":"no");
518 printk("isofs.inode: vol_desc_start = %d\n", ms_info
.addr
.lba
);
522 #if WE_OBEY_THE_WRITTEN_STANDARDS
523 if (ms_info
.xa_flag
) /* necessary for a valid ms_info.addr */
525 vol_desc_start
=ms_info
.addr
.lba
;
526 return vol_desc_start
;
530 * Initialize the superblock and read the root inode.
532 * Note: a check_disk_change() has been done immediately prior
533 * to this call, so we don't need to check again.
535 static int isofs_fill_super(struct super_block
*s
, void *data
, int silent
)
537 struct buffer_head
* bh
= NULL
, *pri_bh
= NULL
;
538 struct hs_primary_descriptor
* h_pri
= NULL
;
539 struct iso_primary_descriptor
* pri
= NULL
;
540 struct iso_supplementary_descriptor
*sec
= NULL
;
541 struct iso_directory_record
* rootp
;
542 int joliet_level
= 0;
543 int iso_blknum
, block
;
546 unsigned int vol_desc_start
;
547 unsigned long first_data_zone
;
548 struct inode
* inode
;
549 struct iso9660_options opt
;
550 struct isofs_sb_info
* sbi
;
552 sbi
= kmalloc(sizeof(*sbi
), GFP_KERNEL
);
556 memset(sbi
, 0, sizeof(*sbi
));
558 if (!parse_options((char *)data
, &opt
))
562 * First of all, get the hardware blocksize for this device.
563 * If we don't know what it is, or the hardware blocksize is
564 * larger than the blocksize the user specified, then use
568 * What if bugger tells us to go beyond page size?
570 opt
.blocksize
= sb_min_blocksize(s
, opt
.blocksize
);
572 sbi
->s_high_sierra
= 0; /* default is iso9660 */
574 vol_desc_start
= (opt
.sbsector
!= -1) ?
575 opt
.sbsector
: isofs_get_last_session(s
,opt
.session
);
577 for (iso_blknum
= vol_desc_start
+16;
578 iso_blknum
< vol_desc_start
+100; iso_blknum
++)
580 struct hs_volume_descriptor
* hdp
;
581 struct iso_volume_descriptor
* vdp
;
583 block
= iso_blknum
<< (ISOFS_BLOCK_BITS
- s
->s_blocksize_bits
);
584 if (!(bh
= sb_bread(s
, block
)))
587 vdp
= (struct iso_volume_descriptor
*)bh
->b_data
;
588 hdp
= (struct hs_volume_descriptor
*)bh
->b_data
;
590 /* Due to the overlapping physical location of the descriptors,
591 * ISO CDs can match hdp->id==HS_STANDARD_ID as well. To ensure
592 * proper identification in this case, we first check for ISO.
594 if (strncmp (vdp
->id
, ISO_STANDARD_ID
, sizeof vdp
->id
) == 0) {
595 if (isonum_711 (vdp
->type
) == ISO_VD_END
)
597 if (isonum_711 (vdp
->type
) == ISO_VD_PRIMARY
) {
599 pri
= (struct iso_primary_descriptor
*)vdp
;
600 /* Save the buffer in case we need it ... */
606 else if (isonum_711 (vdp
->type
) == ISO_VD_SUPPLEMENTARY
) {
607 sec
= (struct iso_supplementary_descriptor
*)vdp
;
608 if (sec
->escape
[0] == 0x25 && sec
->escape
[1] == 0x2f) {
609 if (opt
.joliet
== 'y') {
610 if (sec
->escape
[2] == 0x40) {
612 } else if (sec
->escape
[2] == 0x43) {
614 } else if (sec
->escape
[2] == 0x45) {
617 printk(KERN_DEBUG
"ISO 9660 Extensions: Microsoft Joliet Level %d\n",
622 /* Unknown supplementary volume descriptor */
628 if (strncmp (hdp
->id
, HS_STANDARD_ID
, sizeof hdp
->id
) == 0) {
629 if (isonum_711 (hdp
->type
) != ISO_VD_PRIMARY
)
632 sbi
->s_high_sierra
= 1;
634 h_pri
= (struct hs_primary_descriptor
*)vdp
;
639 /* Just skip any volume descriptors we don't recognize */
645 * If we fall through, either no volume descriptor was found,
646 * or else we passed a primary descriptor looking for others.
649 goto out_unknown_format
;
656 if (joliet_level
&& (pri
== NULL
|| opt
.rock
== 'n')) {
657 /* This is the case of Joliet with the norock mount flag.
658 * A disc with both Joliet and Rock Ridge is handled later
660 pri
= (struct iso_primary_descriptor
*) sec
;
663 if(sbi
->s_high_sierra
){
664 rootp
= (struct iso_directory_record
*) h_pri
->root_directory_record
;
665 sbi
->s_nzones
= isonum_733 (h_pri
->volume_space_size
);
666 sbi
->s_log_zone_size
= isonum_723 (h_pri
->logical_block_size
);
667 sbi
->s_max_size
= isonum_733(h_pri
->volume_space_size
);
671 rootp
= (struct iso_directory_record
*) pri
->root_directory_record
;
672 sbi
->s_nzones
= isonum_733 (pri
->volume_space_size
);
673 sbi
->s_log_zone_size
= isonum_723 (pri
->logical_block_size
);
674 sbi
->s_max_size
= isonum_733(pri
->volume_space_size
);
677 sbi
->s_ninodes
= 0; /* No way to figure this out easily */
679 orig_zonesize
= sbi
->s_log_zone_size
;
681 * If the zone size is smaller than the hardware sector size,
682 * this is a fatal error. This would occur if the disc drive
683 * had sectors that were 2048 bytes, but the filesystem had
684 * blocks that were 512 bytes (which should only very rarely
687 if(orig_zonesize
< opt
.blocksize
)
690 /* RDE: convert log zone size to bit shift */
691 switch (sbi
->s_log_zone_size
)
692 { case 512: sbi
->s_log_zone_size
= 9; break;
693 case 1024: sbi
->s_log_zone_size
= 10; break;
694 case 2048: sbi
->s_log_zone_size
= 11; break;
697 goto out_bad_zone_size
;
700 s
->s_magic
= ISOFS_SUPER_MAGIC
;
701 s
->s_maxbytes
= 0xffffffff; /* We can handle files up to 4 GB */
703 /* The CDROM is read-only, has no nodes (devices) on it, and since
704 all of the files appear to be owned by root, we really do not want
705 to allow suid. (suid or devices will not show up unless we have
706 Rock Ridge extensions) */
708 s
->s_flags
|= MS_RDONLY
/* | MS_NODEV | MS_NOSUID */;
710 /* Set this for reference. Its not currently used except on write
711 which we don't have .. */
713 first_data_zone
= isonum_733 (rootp
->extent
) +
714 isonum_711 (rootp
->ext_attr_length
);
715 sbi
->s_firstdatazone
= first_data_zone
;
717 printk(KERN_DEBUG
"Max size:%ld Log zone size:%ld\n",
719 1UL << sbi
->s_log_zone_size
);
720 printk(KERN_DEBUG
"First datazone:%ld\n", sbi
->s_firstdatazone
);
721 if(sbi
->s_high_sierra
)
722 printk(KERN_DEBUG
"Disc in High Sierra format.\n");
726 * If the Joliet level is set, we _may_ decide to use the
727 * secondary descriptor, but can't be sure until after we
728 * read the root inode. But before reading the root inode
729 * we may need to change the device blocksize, and would
730 * rather release the old buffer first. So, we cache the
731 * first_data_zone value from the secondary descriptor.
734 pri
= (struct iso_primary_descriptor
*) sec
;
735 rootp
= (struct iso_directory_record
*)
736 pri
->root_directory_record
;
737 first_data_zone
= isonum_733 (rootp
->extent
) +
738 isonum_711 (rootp
->ext_attr_length
);
742 * We're all done using the volume descriptor, and may need
743 * to change the device blocksize, so release the buffer now.
749 * Force the blocksize to 512 for 512 byte sectors. The file
750 * read primitives really get it wrong in a bad way if we don't
753 * Note - we should never be setting the blocksize to something
754 * less than the hardware sector size for the device. If we
755 * do, we would end up having to read larger buffers and split
756 * out portions to satisfy requests.
758 * Note2- the idea here is that we want to deal with the optimal
759 * zonesize in the filesystem. If we have it set to something less,
760 * then we have horrible problems with trying to piece together
761 * bits of adjacent blocks in order to properly read directory
762 * entries. By forcing the blocksize in this way, we ensure
763 * that we will never be required to do this.
765 sb_set_blocksize(s
, orig_zonesize
);
767 sbi
->s_nls_iocharset
= NULL
;
770 if (joliet_level
&& opt
.utf8
== 0) {
771 char * p
= opt
.iocharset
? opt
.iocharset
: CONFIG_NLS_DEFAULT
;
772 sbi
->s_nls_iocharset
= load_nls(p
);
773 if (! sbi
->s_nls_iocharset
) {
774 /* Fail only if explicit charset specified */
777 sbi
->s_nls_iocharset
= load_nls_default();
781 s
->s_op
= &isofs_sops
;
782 s
->s_export_op
= &isofs_export_ops
;
783 sbi
->s_mapping
= opt
.map
;
784 sbi
->s_rock
= (opt
.rock
== 'y' ? 2 : 0);
785 sbi
->s_rock_offset
= -1; /* initial offset, will guess until SP is found*/
786 sbi
->s_cruft
= opt
.cruft
;
787 sbi
->s_unhide
= opt
.unhide
;
788 sbi
->s_uid
= opt
.uid
;
789 sbi
->s_gid
= opt
.gid
;
790 sbi
->s_utf8
= opt
.utf8
;
791 sbi
->s_nocompress
= opt
.nocompress
;
793 * It would be incredibly stupid to allow people to mark every file
794 * on the disk as suid, so we merely allow them to set the default
797 sbi
->s_mode
= opt
.mode
& 0777;
800 * Read the root inode, which _may_ result in changing
801 * the s_rock flag. Once we have the final s_rock value,
802 * we then decide whether to use the Joliet descriptor.
804 inode
= isofs_iget(s
, sbi
->s_firstdatazone
, 0);
807 * If this disk has both Rock Ridge and Joliet on it, then we
808 * want to use Rock Ridge by default. This can be overridden
809 * by using the norock mount option. There is still one other
810 * possibility that is not taken into account: a Rock Ridge
811 * CD with Unicode names. Until someone sees such a beast, it
812 * will not be supported.
814 if (sbi
->s_rock
== 1) {
816 } else if (joliet_level
) {
818 if (sbi
->s_firstdatazone
!= first_data_zone
) {
819 sbi
->s_firstdatazone
= first_data_zone
;
821 "ISOFS: changing to secondary root\n");
823 inode
= isofs_iget(s
, sbi
->s_firstdatazone
, 0);
827 if (opt
.check
== 'u') {
828 /* Only Joliet is case insensitive by default */
829 if (joliet_level
) opt
.check
= 'r';
830 else opt
.check
= 's';
832 sbi
->s_joliet_level
= joliet_level
;
834 /* check the root inode */
839 /* get the root dentry */
840 s
->s_root
= d_alloc_root(inode
);
845 if (joliet_level
) table
+= 2;
846 if (opt
.check
== 'r') table
++;
847 s
->s_root
->d_op
= &isofs_dentry_ops
[table
];
850 kfree(opt
.iocharset
);
855 * Display error messages and free resources.
858 printk(KERN_WARNING
"isofs_fill_super: root inode not initialized\n");
861 printk(KERN_WARNING
"isofs_fill_super: get root inode failed\n");
865 if (sbi
->s_nls_iocharset
)
866 unload_nls(sbi
->s_nls_iocharset
);
870 printk(KERN_WARNING
"isofs_fill_super: "
871 "bread failed, dev=%s, iso_blknum=%d, block=%d\n",
872 s
->s_id
, iso_blknum
, block
);
875 printk(KERN_WARNING
"Bad logical zone size %ld\n",
876 sbi
->s_log_zone_size
);
879 printk(KERN_WARNING
"Logical zone size(%d) < hardware blocksize(%u)\n",
880 orig_zonesize
, opt
.blocksize
);
884 printk(KERN_WARNING
"Unable to identify CD-ROM format.\n");
890 kfree(opt
.iocharset
);
896 static int isofs_statfs (struct super_block
*sb
, struct kstatfs
*buf
)
898 buf
->f_type
= ISOFS_SUPER_MAGIC
;
899 buf
->f_bsize
= sb
->s_blocksize
;
900 buf
->f_blocks
= (ISOFS_SB(sb
)->s_nzones
901 << (ISOFS_SB(sb
)->s_log_zone_size
- sb
->s_blocksize_bits
));
904 buf
->f_files
= ISOFS_SB(sb
)->s_ninodes
;
906 buf
->f_namelen
= NAME_MAX
;
911 * Get a set of blocks; filling in buffer_heads if already allocated
912 * or getblk() if they are not. Returns the number of blocks inserted
915 int isofs_get_blocks(struct inode
*inode
, sector_t iblock_s
,
916 struct buffer_head
**bh
, unsigned long nblocks
)
919 unsigned offset
, sect_size
;
920 unsigned int firstext
;
921 unsigned long nextblk
, nextoff
;
922 long iblock
= (long)iblock_s
;
924 struct iso_inode_info
*ei
= ISOFS_I(inode
);
929 if (iblock
< 0 || iblock
!= iblock_s
) {
930 printk("isofs_get_blocks: block number too large\n");
937 firstext
= ei
->i_first_extent
;
938 sect_size
= ei
->i_section_size
>> ISOFS_BUFFER_BITS(inode
);
939 nextblk
= ei
->i_next_section_block
;
940 nextoff
= ei
->i_next_section_offset
;
944 /* If we are *way* beyond the end of the file, print a message.
945 * Access beyond the end of the file up to the next page boundary
946 * is normal, however because of the way the page cache works.
947 * In this case, we just return 0 so that we can properly fill
948 * the page with useless information without generating any
951 if (b_off
> ((inode
->i_size
+ PAGE_CACHE_SIZE
- 1) >> ISOFS_BUFFER_BITS(inode
))) {
952 printk("isofs_get_blocks: block >= EOF (%ld, %ld)\n",
953 iblock
, (unsigned long) inode
->i_size
);
958 while (b_off
>= (offset
+ sect_size
)) {
959 struct inode
*ninode
;
964 ninode
= isofs_iget(inode
->i_sb
, nextblk
, nextoff
);
967 firstext
= ISOFS_I(ninode
)->i_first_extent
;
968 sect_size
= ISOFS_I(ninode
)->i_section_size
>> ISOFS_BUFFER_BITS(ninode
);
969 nextblk
= ISOFS_I(ninode
)->i_next_section_block
;
970 nextoff
= ISOFS_I(ninode
)->i_next_section_offset
;
973 if (++section
> 100) {
974 printk("isofs_get_blocks: More than 100 file sections ?!?, aborting...\n");
975 printk("isofs_get_blocks: block=%ld firstext=%u sect_size=%u "
976 "nextblk=%lu nextoff=%lu\n",
977 iblock
, firstext
, (unsigned) sect_size
,
985 map_bh(*bh
, inode
->i_sb
, firstext
+ b_off
- offset
);
987 *bh
= sb_getblk(inode
->i_sb
, firstext
+b_off
-offset
);
991 bh
++; /* Next buffer head */
992 b_off
++; /* Next buffer offset */
1003 * Used by the standard interfaces.
1005 static int isofs_get_block(struct inode
*inode
, sector_t iblock
,
1006 struct buffer_head
*bh_result
, int create
)
1009 printk("isofs_get_block: Kernel tries to allocate a block\n");
1013 return isofs_get_blocks(inode
, iblock
, &bh_result
, 1) ? 0 : -EIO
;
1016 static int isofs_bmap(struct inode
*inode
, sector_t block
)
1018 struct buffer_head dummy
;
1022 dummy
.b_blocknr
= -1000;
1023 error
= isofs_get_block(inode
, block
, &dummy
, 0);
1025 return dummy
.b_blocknr
;
1029 struct buffer_head
*isofs_bread(struct inode
*inode
, sector_t block
)
1031 sector_t blknr
= isofs_bmap(inode
, block
);
1034 return sb_bread(inode
->i_sb
, blknr
);
1037 static int isofs_readpage(struct file
*file
, struct page
*page
)
1039 return block_read_full_page(page
,isofs_get_block
);
1042 static sector_t
_isofs_bmap(struct address_space
*mapping
, sector_t block
)
1044 return generic_block_bmap(mapping
,block
,isofs_get_block
);
1047 static struct address_space_operations isofs_aops
= {
1048 .readpage
= isofs_readpage
,
1049 .sync_page
= block_sync_page
,
1053 static inline void test_and_set_uid(uid_t
*p
, uid_t value
)
1059 static inline void test_and_set_gid(gid_t
*p
, gid_t value
)
1065 static int isofs_read_level3_size(struct inode
*inode
)
1067 unsigned long bufsize
= ISOFS_BUFFER_SIZE(inode
);
1068 int high_sierra
= ISOFS_SB(inode
->i_sb
)->s_high_sierra
;
1069 struct buffer_head
* bh
= NULL
;
1070 unsigned long block
, offset
, block_saved
, offset_saved
;
1072 int more_entries
= 0;
1073 struct iso_directory_record
* tmpde
= NULL
;
1074 struct iso_inode_info
*ei
= ISOFS_I(inode
);
1078 /* The first 16 blocks are reserved as the System Area. Thus,
1079 * no inodes can appear in block 0. We use this to flag that
1080 * this is the last section. */
1081 ei
->i_next_section_block
= 0;
1082 ei
->i_next_section_offset
= 0;
1084 block
= ei
->i_iget5_block
;
1085 offset
= ei
->i_iget5_offset
;
1088 struct iso_directory_record
* de
;
1089 unsigned int de_len
;
1092 bh
= sb_bread(inode
->i_sb
, block
);
1096 de
= (struct iso_directory_record
*) (bh
->b_data
+ offset
);
1097 de_len
= *(unsigned char *) de
;
1107 block_saved
= block
;
1108 offset_saved
= offset
;
1111 /* Make sure we have a full directory entry */
1112 if (offset
>= bufsize
) {
1113 int slop
= bufsize
- offset
+ de_len
;
1115 tmpde
= kmalloc(256, GFP_KERNEL
);
1119 memcpy(tmpde
, de
, slop
);
1120 offset
&= bufsize
- 1;
1125 bh
= sb_bread(inode
->i_sb
, block
);
1128 memcpy((void *)tmpde
+slop
, bh
->b_data
, offset
);
1133 inode
->i_size
+= isonum_733(de
->size
);
1135 ei
->i_next_section_block
= block_saved
;
1136 ei
->i_next_section_offset
= offset_saved
;
1139 more_entries
= de
->flags
[-high_sierra
] & 0x80;
1144 } while (more_entries
);
1157 printk(KERN_INFO
"ISOFS: unable to read i-node block %lu\n", block
);
1163 printk(KERN_INFO
"isofs_read_level3_size: "
1164 "More than 100 file sections ?!?, aborting...\n"
1165 "isofs_read_level3_size: inode=%lu\n",
1170 static void isofs_read_inode(struct inode
*inode
)
1172 struct super_block
*sb
= inode
->i_sb
;
1173 struct isofs_sb_info
*sbi
= ISOFS_SB(sb
);
1174 unsigned long bufsize
= ISOFS_BUFFER_SIZE(inode
);
1175 unsigned long block
;
1176 int high_sierra
= sbi
->s_high_sierra
;
1177 struct buffer_head
* bh
= NULL
;
1178 struct iso_directory_record
* de
;
1179 struct iso_directory_record
* tmpde
= NULL
;
1180 unsigned int de_len
;
1181 unsigned long offset
;
1182 struct iso_inode_info
*ei
= ISOFS_I(inode
);
1184 block
= ei
->i_iget5_block
;
1185 bh
= sb_bread(inode
->i_sb
, block
);
1189 offset
= ei
->i_iget5_offset
;
1191 de
= (struct iso_directory_record
*) (bh
->b_data
+ offset
);
1192 de_len
= *(unsigned char *) de
;
1194 if (offset
+ de_len
> bufsize
) {
1195 int frag1
= bufsize
- offset
;
1197 tmpde
= kmalloc(de_len
, GFP_KERNEL
);
1198 if (tmpde
== NULL
) {
1199 printk(KERN_INFO
"isofs_read_inode: out of memory\n");
1202 memcpy(tmpde
, bh
->b_data
+ offset
, frag1
);
1204 bh
= sb_bread(inode
->i_sb
, ++block
);
1207 memcpy((char *)tmpde
+frag1
, bh
->b_data
, de_len
- frag1
);
1211 inode
->i_ino
= isofs_get_ino(ei
->i_iget5_block
,
1213 ISOFS_BUFFER_BITS(inode
));
1215 /* Assume it is a normal-format file unless told otherwise */
1216 ei
->i_file_format
= isofs_file_normal
;
1218 if (de
->flags
[-high_sierra
] & 2) {
1219 inode
->i_mode
= S_IRUGO
| S_IXUGO
| S_IFDIR
;
1220 inode
->i_nlink
= 1; /* Set to 1. We know there are 2, but
1221 the find utility tries to optimize
1222 if it is 2, and it screws up. It is
1223 easier to give 1 which tells find to
1224 do it the hard way. */
1226 /* Everybody gets to read the file. */
1227 inode
->i_mode
= sbi
->s_mode
;
1229 inode
->i_mode
|= S_IFREG
;
1231 inode
->i_uid
= sbi
->s_uid
;
1232 inode
->i_gid
= sbi
->s_gid
;
1233 inode
->i_blocks
= inode
->i_blksize
= 0;
1235 ei
->i_format_parm
[0] = 0;
1236 ei
->i_format_parm
[1] = 0;
1237 ei
->i_format_parm
[2] = 0;
1239 ei
->i_section_size
= isonum_733 (de
->size
);
1240 if (de
->flags
[-high_sierra
] & 0x80) {
1241 if(isofs_read_level3_size(inode
)) goto fail
;
1243 ei
->i_next_section_block
= 0;
1244 ei
->i_next_section_offset
= 0;
1245 inode
->i_size
= isonum_733 (de
->size
);
1249 * Some dipshit decided to store some other bit of information
1250 * in the high byte of the file length. Truncate size in case
1251 * this CDROM was mounted with the cruft option.
1254 if (sbi
->s_cruft
== 'y')
1255 inode
->i_size
&= 0x00ffffff;
1257 if (de
->interleave
[0]) {
1258 printk("Interleaved files not (yet) supported.\n");
1262 /* I have no idea what file_unit_size is used for, so
1263 we will flag it for now */
1264 if (de
->file_unit_size
[0] != 0) {
1265 printk("File unit size != 0 for ISO file (%ld).\n",
1269 /* I have no idea what other flag bits are used for, so
1270 we will flag it for now */
1272 if((de
->flags
[-high_sierra
] & ~2)!= 0){
1273 printk("Unusual flag settings for ISO file (%ld %x).\n",
1274 inode
->i_ino
, de
->flags
[-high_sierra
]);
1278 inode
->i_mtime
.tv_sec
=
1279 inode
->i_atime
.tv_sec
=
1280 inode
->i_ctime
.tv_sec
= iso_date(de
->date
, high_sierra
);
1281 inode
->i_mtime
.tv_nsec
=
1282 inode
->i_atime
.tv_nsec
=
1283 inode
->i_ctime
.tv_nsec
= 0;
1285 ei
->i_first_extent
= (isonum_733 (de
->extent
) +
1286 isonum_711 (de
->ext_attr_length
));
1288 /* Set the number of blocks for stat() - should be done before RR */
1289 inode
->i_blksize
= PAGE_CACHE_SIZE
; /* For stat() only */
1290 inode
->i_blocks
= (inode
->i_size
+ 511) >> 9;
1293 * Now test for possible Rock Ridge extensions which will override
1294 * some of these numbers in the inode structure.
1298 parse_rock_ridge_inode(de
, inode
);
1299 /* if we want uid/gid set, override the rock ridge setting */
1300 test_and_set_uid(&inode
->i_uid
, sbi
->s_uid
);
1301 test_and_set_gid(&inode
->i_gid
, sbi
->s_gid
);
1304 /* Install the inode operations vector */
1305 if (S_ISREG(inode
->i_mode
)) {
1306 inode
->i_fop
= &generic_ro_fops
;
1307 switch ( ei
->i_file_format
) {
1308 #ifdef CONFIG_ZISOFS
1309 case isofs_file_compressed
:
1310 inode
->i_data
.a_ops
= &zisofs_aops
;
1314 inode
->i_data
.a_ops
= &isofs_aops
;
1317 } else if (S_ISDIR(inode
->i_mode
)) {
1318 inode
->i_op
= &isofs_dir_inode_operations
;
1319 inode
->i_fop
= &isofs_dir_operations
;
1320 } else if (S_ISLNK(inode
->i_mode
)) {
1321 inode
->i_op
= &page_symlink_inode_operations
;
1322 inode
->i_data
.a_ops
= &isofs_symlink_aops
;
1324 /* XXX - parse_rock_ridge_inode() had already set i_rdev. */
1325 init_special_inode(inode
, inode
->i_mode
, inode
->i_rdev
);
1335 printk(KERN_WARNING
"ISOFS: unable to read i-node block\n");
1337 make_bad_inode(inode
);
1341 struct isofs_iget5_callback_data
{
1342 unsigned long block
;
1343 unsigned long offset
;
1346 static int isofs_iget5_test(struct inode
*ino
, void *data
)
1348 struct iso_inode_info
*i
= ISOFS_I(ino
);
1349 struct isofs_iget5_callback_data
*d
=
1350 (struct isofs_iget5_callback_data
*)data
;
1351 return (i
->i_iget5_block
== d
->block
)
1352 && (i
->i_iget5_offset
== d
->offset
);
1355 static int isofs_iget5_set(struct inode
*ino
, void *data
)
1357 struct iso_inode_info
*i
= ISOFS_I(ino
);
1358 struct isofs_iget5_callback_data
*d
=
1359 (struct isofs_iget5_callback_data
*)data
;
1360 i
->i_iget5_block
= d
->block
;
1361 i
->i_iget5_offset
= d
->offset
;
1365 /* Store, in the inode's containing structure, the block and block
1366 * offset that point to the underlying meta-data for the inode. The
1367 * code below is otherwise similar to the iget() code in
1368 * include/linux/fs.h */
1369 struct inode
*isofs_iget(struct super_block
*sb
,
1370 unsigned long block
,
1371 unsigned long offset
)
1373 unsigned long hashval
;
1374 struct inode
*inode
;
1375 struct isofs_iget5_callback_data data
;
1377 if (offset
>= 1ul << sb
->s_blocksize_bits
)
1381 data
.offset
= offset
;
1383 hashval
= (block
<< sb
->s_blocksize_bits
) | offset
;
1385 inode
= iget5_locked(sb
, hashval
, &isofs_iget5_test
,
1386 &isofs_iget5_set
, &data
);
1388 if (inode
&& (inode
->i_state
& I_NEW
)) {
1389 sb
->s_op
->read_inode(inode
);
1390 unlock_new_inode(inode
);
1396 static struct super_block
*isofs_get_sb(struct file_system_type
*fs_type
,
1397 int flags
, const char *dev_name
, void *data
)
1399 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, isofs_fill_super
);
1402 static struct file_system_type iso9660_fs_type
= {
1403 .owner
= THIS_MODULE
,
1405 .get_sb
= isofs_get_sb
,
1406 .kill_sb
= kill_block_super
,
1407 .fs_flags
= FS_REQUIRES_DEV
,
1410 static int __init
init_iso9660_fs(void)
1412 int err
= init_inodecache();
1415 #ifdef CONFIG_ZISOFS
1416 err
= zisofs_init();
1420 err
= register_filesystem(&iso9660_fs_type
);
1425 #ifdef CONFIG_ZISOFS
1429 destroy_inodecache();
1434 static void __exit
exit_iso9660_fs(void)
1436 unregister_filesystem(&iso9660_fs_type
);
1437 #ifdef CONFIG_ZISOFS
1440 destroy_inodecache();
1443 module_init(init_iso9660_fs
)
1444 module_exit(exit_iso9660_fs
)
1445 MODULE_LICENSE("GPL");
1446 /* Actual filesystem name is iso9660, as requested in filesystems.c */
1447 MODULE_ALIAS("iso9660");