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
12 #include <linux/config.h>
13 #include <linux/module.h>
15 #include <linux/stat.h>
16 #include <linux/time.h>
17 #include <linux/iso_fs.h>
18 #include <linux/kernel.h>
19 #include <linux/major.h>
21 #include <linux/string.h>
22 #include <linux/slab.h>
23 #include <linux/errno.h>
24 #include <linux/cdrom.h>
25 #include <linux/init.h>
26 #include <linux/nls.h>
27 #include <linux/ctype.h>
28 #include <linux/smp_lock.h>
29 #include <linux/blkdev.h>
30 #include <linux/buffer_head.h>
31 #include <linux/vfs.h>
32 #include <linux/parser.h>
33 #include <asm/system.h>
34 #include <asm/uaccess.h>
41 static int check_malloc;
42 static int check_bread;
45 static int isofs_hashi(struct dentry *parent, struct qstr *qstr);
46 static int isofs_hash(struct dentry *parent, struct qstr *qstr);
47 static int isofs_dentry_cmpi(struct dentry *dentry, struct qstr *a, struct qstr *b);
48 static int isofs_dentry_cmp(struct dentry *dentry, struct qstr *a, struct qstr *b);
51 static int isofs_hashi_ms(struct dentry *parent, struct qstr *qstr);
52 static int isofs_hash_ms(struct dentry *parent, struct qstr *qstr);
53 static int isofs_dentry_cmpi_ms(struct dentry *dentry, struct qstr *a, struct qstr *b);
54 static int isofs_dentry_cmp_ms(struct dentry *dentry, struct qstr *a, struct qstr *b);
57 static void isofs_put_super(struct super_block *sb)
59 struct isofs_sb_info *sbi = ISOFS_SB(sb);
61 if (sbi->s_nls_iocharset) {
62 unload_nls(sbi->s_nls_iocharset);
63 sbi->s_nls_iocharset = NULL;
68 printk("Outstanding mallocs:%d, outstanding buffers: %d\n",
69 check_malloc, check_bread);
77 static void isofs_read_inode(struct inode *);
78 static int isofs_statfs (struct super_block *, struct kstatfs *);
80 static kmem_cache_t *isofs_inode_cachep;
82 static struct inode *isofs_alloc_inode(struct super_block *sb)
84 struct iso_inode_info *ei;
85 ei = (struct iso_inode_info *)kmem_cache_alloc(isofs_inode_cachep, SLAB_KERNEL);
88 return &ei->vfs_inode;
91 static void isofs_destroy_inode(struct inode *inode)
93 kmem_cache_free(isofs_inode_cachep, ISOFS_I(inode));
96 static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
98 struct iso_inode_info *ei = (struct iso_inode_info *) foo;
100 if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
101 SLAB_CTOR_CONSTRUCTOR)
102 inode_init_once(&ei->vfs_inode);
105 static int init_inodecache(void)
107 isofs_inode_cachep = kmem_cache_create("isofs_inode_cache",
108 sizeof(struct iso_inode_info),
109 0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT,
111 if (isofs_inode_cachep == NULL)
116 static void destroy_inodecache(void)
118 if (kmem_cache_destroy(isofs_inode_cachep))
119 printk(KERN_INFO "iso_inode_cache: not all structures were freed\n");
122 static int isofs_remount(struct super_block *sb, int *flags, char *data)
124 /* we probably want a lot more here */
129 static struct super_operations isofs_sops = {
130 .alloc_inode = isofs_alloc_inode,
131 .destroy_inode = isofs_destroy_inode,
132 .read_inode = isofs_read_inode,
133 .put_super = isofs_put_super,
134 .statfs = isofs_statfs,
135 .remount_fs = isofs_remount,
138 /* the export_operations structure for describing
139 * how to export (e.g. via kNFSd) is deliberately
141 * This means that the filesystem want to use iget
142 * to map an inode number into an inode.
143 * The lack of a get_parent operation means that
144 * if something isn't in the cache, then you cannot
146 * It should be possible to write a get_parent,
147 * but it would be a bit hairy...
149 static struct export_operations isofs_export_ops = {
153 static struct dentry_operations isofs_dentry_ops[] = {
155 .d_hash = isofs_hash,
156 .d_compare = isofs_dentry_cmp,
159 .d_hash = isofs_hashi,
160 .d_compare = isofs_dentry_cmpi,
164 .d_hash = isofs_hash_ms,
165 .d_compare = isofs_dentry_cmp_ms,
168 .d_hash = isofs_hashi_ms,
169 .d_compare = isofs_dentry_cmpi_ms,
174 struct iso9660_options{
182 unsigned int blocksize;
194 * Compute the hash for the isofs name corresponding to the dentry.
197 isofs_hash_common(struct dentry *dentry, struct qstr *qstr, int ms)
205 while (len && name[len-1] == '.')
209 qstr->hash = full_name_hash(name, len);
215 * Compute the hash for the isofs name corresponding to the dentry.
218 isofs_hashi_common(struct dentry *dentry, struct qstr *qstr, int ms)
228 while (len && name[len-1] == '.')
232 hash = init_name_hash();
234 c = tolower(*name++);
235 hash = partial_name_hash(tolower(c), hash);
237 qstr->hash = end_name_hash(hash);
243 * Case insensitive compare of two isofs names.
246 isofs_dentry_cmpi_common(struct dentry *dentry,struct qstr *a,struct qstr *b,int ms)
250 /* A filename cannot end in '.' or we treat it like it has none */
254 while (alen && a->name[alen-1] == '.')
256 while (blen && b->name[blen-1] == '.')
260 if (strnicmp(a->name, b->name, alen) == 0)
267 * Case sensitive compare of two isofs names.
270 isofs_dentry_cmp_common(struct dentry *dentry,struct qstr *a,struct qstr *b,int ms)
274 /* A filename cannot end in '.' or we treat it like it has none */
278 while (alen && a->name[alen-1] == '.')
280 while (blen && b->name[blen-1] == '.')
284 if (strncmp(a->name, b->name, alen) == 0)
291 isofs_hash(struct dentry *dentry, struct qstr *qstr)
293 return isofs_hash_common(dentry, qstr, 0);
297 isofs_hashi(struct dentry *dentry, struct qstr *qstr)
299 return isofs_hashi_common(dentry, qstr, 0);
303 isofs_dentry_cmp(struct dentry *dentry,struct qstr *a,struct qstr *b)
305 return isofs_dentry_cmp_common(dentry, a, b, 0);
309 isofs_dentry_cmpi(struct dentry *dentry,struct qstr *a,struct qstr *b)
311 return isofs_dentry_cmpi_common(dentry, a, b, 0);
316 isofs_hash_ms(struct dentry *dentry, struct qstr *qstr)
318 return isofs_hash_common(dentry, qstr, 1);
322 isofs_hashi_ms(struct dentry *dentry, struct qstr *qstr)
324 return isofs_hashi_common(dentry, qstr, 1);
328 isofs_dentry_cmp_ms(struct dentry *dentry,struct qstr *a,struct qstr *b)
330 return isofs_dentry_cmp_common(dentry, a, b, 1);
334 isofs_dentry_cmpi_ms(struct dentry *dentry,struct qstr *a,struct qstr *b)
336 return isofs_dentry_cmpi_common(dentry, a, b, 1);
341 Opt_block, Opt_check_r, Opt_check_s, Opt_cruft, Opt_gid, Opt_ignore,
342 Opt_iocharset, Opt_map_a, Opt_map_n, Opt_map_o, Opt_mode, Opt_nojoliet,
343 Opt_norock, Opt_sb, Opt_session, Opt_uid, Opt_unhide, Opt_utf8, Opt_err,
347 static match_table_t tokens = {
348 {Opt_norock, "norock"},
349 {Opt_nojoliet, "nojoliet"},
350 {Opt_unhide, "unhide"},
351 {Opt_cruft, "cruft"},
353 {Opt_iocharset, "iocharset=%s"},
354 {Opt_map_a, "map=acorn"},
355 {Opt_map_a, "map=a"},
356 {Opt_map_n, "map=normal"},
357 {Opt_map_n, "map=n"},
358 {Opt_map_o, "map=off"},
359 {Opt_map_o, "map=o"},
360 {Opt_session, "session=%u"},
361 {Opt_sb, "sbsector=%u"},
362 {Opt_check_r, "check=relaxed"},
363 {Opt_check_r, "check=r"},
364 {Opt_check_s, "check=strict"},
365 {Opt_check_s, "check=s"},
368 {Opt_mode, "mode=%u"},
369 {Opt_block, "block=%u"},
370 {Opt_ignore, "conv=binary"},
371 {Opt_ignore, "conv=b"},
372 {Opt_ignore, "conv=text"},
373 {Opt_ignore, "conv=t"},
374 {Opt_ignore, "conv=mtext"},
375 {Opt_ignore, "conv=m"},
376 {Opt_ignore, "conv=auto"},
377 {Opt_ignore, "conv=a"},
378 {Opt_nocompress, "nocompress"},
382 static int parse_options(char *options, struct iso9660_options * popt)
392 popt->check = 'u'; /* unset */
393 popt->nocompress = 0;
394 popt->blocksize = 1024;
395 popt->mode = S_IRUGO | S_IXUGO; /* r-x for all. The disc could
396 be shared with DOS machines so
397 virtually anything could be
398 a valid executable. */
401 popt->iocharset = NULL;
408 while ((p = strsep(&options, ",")) != NULL) {
410 substring_t args[MAX_OPT_ARGS];
416 token = match_token(p, tokens, args);
435 popt->iocharset = match_strdup(&args[0]);
448 if (match_int(&args[0], &option))
453 popt->session = n + 1;
456 if (match_int(&args[0], &option))
458 popt->sbsector = option;
469 if (match_int(&args[0], &option))
474 if (match_int(&args[0], &option))
479 if (match_int(&args[0], &option))
484 if (match_int(&args[0], &option))
487 if (n != 512 && n != 1024 && n != 2048)
492 popt->nocompress = 1;
502 * look if the driver can tell the multi session redirection value
504 * don't change this if you don't know what you do, please!
505 * Multisession is legal only with XA disks.
506 * A non-XA disk with more than one volume descriptor may do it right, but
507 * usually is written in a nowhere standardized "multi-partition" manner.
508 * Multisession uses absolute addressing (solely the first frame of the whole
509 * track is #0), multi-partition uses relative addressing (each first frame of
510 * each track is #0), and a track is not a session.
512 * A broken CDwriter software or drive firmware does not set new standards,
513 * at least not if conflicting with the existing ones.
517 #define WE_OBEY_THE_WRITTEN_STANDARDS 1
519 static unsigned int isofs_get_last_session(struct super_block *sb,s32 session )
521 struct cdrom_multisession ms_info;
522 unsigned int vol_desc_start;
523 struct block_device *bdev = sb->s_bdev;
527 ms_info.addr_format=CDROM_LBA;
528 if(session >= 0 && session <= 99) {
529 struct cdrom_tocentry Te;
530 Te.cdte_track=session;
531 Te.cdte_format=CDROM_LBA;
532 i = ioctl_by_bdev(bdev, CDROMREADTOCENTRY, (unsigned long) &Te);
534 printk(KERN_DEBUG "Session %d start %d type %d\n",
535 session, Te.cdte_addr.lba,
536 Te.cdte_ctrl&CDROM_DATA_TRACK);
537 if ((Te.cdte_ctrl&CDROM_DATA_TRACK) == 4)
538 return Te.cdte_addr.lba;
541 printk(KERN_ERR "Invalid session number or type of track\n");
543 i = ioctl_by_bdev(bdev, CDROMMULTISESSION, (unsigned long) &ms_info);
544 if(session > 0) printk(KERN_ERR "Invalid session number\n");
546 printk("isofs.inode: CDROMMULTISESSION: rc=%d\n",i);
548 printk("isofs.inode: XA disk: %s\n",ms_info.xa_flag?"yes":"no");
549 printk("isofs.inode: vol_desc_start = %d\n", ms_info.addr.lba);
553 #if WE_OBEY_THE_WRITTEN_STANDARDS
554 if (ms_info.xa_flag) /* necessary for a valid ms_info.addr */
556 vol_desc_start=ms_info.addr.lba;
557 return vol_desc_start;
561 * Initialize the superblock and read the root inode.
563 * Note: a check_disk_change() has been done immediately prior
564 * to this call, so we don't need to check again.
566 static int isofs_fill_super(struct super_block *s, void *data, int silent)
568 struct buffer_head * bh = NULL, *pri_bh = NULL;
569 struct hs_primary_descriptor * h_pri = NULL;
570 struct iso_primary_descriptor * pri = NULL;
571 struct iso_supplementary_descriptor *sec = NULL;
572 struct iso_directory_record * rootp;
573 int joliet_level = 0;
574 int iso_blknum, block;
577 unsigned int vol_desc_start;
578 unsigned long first_data_zone;
579 struct inode * inode;
580 struct iso9660_options opt;
581 struct isofs_sb_info * sbi;
583 sbi = kmalloc(sizeof(struct isofs_sb_info), GFP_KERNEL);
587 memset(sbi, 0, sizeof(struct isofs_sb_info));
589 if (!parse_options((char *) data, &opt))
593 * First of all, get the hardware blocksize for this device.
594 * If we don't know what it is, or the hardware blocksize is
595 * larger than the blocksize the user specified, then use
599 * What if bugger tells us to go beyond page size?
601 opt.blocksize = sb_min_blocksize(s, opt.blocksize);
603 sbi->s_high_sierra = 0; /* default is iso9660 */
605 vol_desc_start = (opt.sbsector != -1) ?
606 opt.sbsector : isofs_get_last_session(s,opt.session);
608 for (iso_blknum = vol_desc_start+16;
609 iso_blknum < vol_desc_start+100; iso_blknum++)
611 struct hs_volume_descriptor * hdp;
612 struct iso_volume_descriptor * vdp;
614 block = iso_blknum << (ISOFS_BLOCK_BITS - s->s_blocksize_bits);
615 if (!(bh = sb_bread(s, block)))
618 vdp = (struct iso_volume_descriptor *)bh->b_data;
619 hdp = (struct hs_volume_descriptor *)bh->b_data;
621 /* Due to the overlapping physical location of the descriptors,
622 * ISO CDs can match hdp->id==HS_STANDARD_ID as well. To ensure
623 * proper identification in this case, we first check for ISO.
625 if (strncmp (vdp->id, ISO_STANDARD_ID, sizeof vdp->id) == 0) {
626 if (isonum_711 (vdp->type) == ISO_VD_END)
628 if (isonum_711 (vdp->type) == ISO_VD_PRIMARY) {
630 pri = (struct iso_primary_descriptor *)vdp;
631 /* Save the buffer in case we need it ... */
637 else if (isonum_711 (vdp->type) == ISO_VD_SUPPLEMENTARY) {
638 sec = (struct iso_supplementary_descriptor *)vdp;
639 if (sec->escape[0] == 0x25 && sec->escape[1] == 0x2f) {
640 if (opt.joliet == 'y') {
641 if (sec->escape[2] == 0x40) {
643 } else if (sec->escape[2] == 0x43) {
645 } else if (sec->escape[2] == 0x45) {
648 printk(KERN_DEBUG"ISO 9660 Extensions: Microsoft Joliet Level %d\n",
653 /* Unknown supplementary volume descriptor */
659 if (strncmp (hdp->id, HS_STANDARD_ID, sizeof hdp->id) == 0) {
660 if (isonum_711 (hdp->type) != ISO_VD_PRIMARY)
663 sbi->s_high_sierra = 1;
665 h_pri = (struct hs_primary_descriptor *)vdp;
670 /* Just skip any volume descriptors we don't recognize */
676 * If we fall through, either no volume descriptor was found,
677 * or else we passed a primary descriptor looking for others.
680 goto out_unknown_format;
687 if (joliet_level && (pri == NULL || opt.rock == 'n')) {
688 /* This is the case of Joliet with the norock mount flag.
689 * A disc with both Joliet and Rock Ridge is handled later
691 pri = (struct iso_primary_descriptor *) sec;
694 if(sbi->s_high_sierra){
695 rootp = (struct iso_directory_record *) h_pri->root_directory_record;
696 sbi->s_nzones = isonum_733 (h_pri->volume_space_size);
697 sbi->s_log_zone_size = isonum_723 (h_pri->logical_block_size);
698 sbi->s_max_size = isonum_733(h_pri->volume_space_size);
700 rootp = (struct iso_directory_record *) pri->root_directory_record;
701 sbi->s_nzones = isonum_733 (pri->volume_space_size);
702 sbi->s_log_zone_size = isonum_723 (pri->logical_block_size);
703 sbi->s_max_size = isonum_733(pri->volume_space_size);
706 sbi->s_ninodes = 0; /* No way to figure this out easily */
708 orig_zonesize = sbi->s_log_zone_size;
710 * If the zone size is smaller than the hardware sector size,
711 * this is a fatal error. This would occur if the disc drive
712 * had sectors that were 2048 bytes, but the filesystem had
713 * blocks that were 512 bytes (which should only very rarely
716 if(orig_zonesize < opt.blocksize)
719 /* RDE: convert log zone size to bit shift */
720 switch (sbi->s_log_zone_size)
721 { case 512: sbi->s_log_zone_size = 9; break;
722 case 1024: sbi->s_log_zone_size = 10; break;
723 case 2048: sbi->s_log_zone_size = 11; break;
726 goto out_bad_zone_size;
729 s->s_magic = ISOFS_SUPER_MAGIC;
731 /* The CDROM is read-only, has no nodes (devices) on it, and since
732 all of the files appear to be owned by root, we really do not want
733 to allow suid. (suid or devices will not show up unless we have
734 Rock Ridge extensions) */
736 s->s_flags |= MS_RDONLY /* | MS_NODEV | MS_NOSUID */;
738 /* Set this for reference. Its not currently used except on write
739 which we don't have .. */
741 /* RDE: data zone now byte offset! */
743 first_data_zone = ((isonum_733 (rootp->extent) +
744 isonum_711 (rootp->ext_attr_length))
745 << sbi->s_log_zone_size);
746 sbi->s_firstdatazone = first_data_zone;
748 printk(KERN_DEBUG "Max size:%ld Log zone size:%ld\n",
750 1UL << sbi->s_log_zone_size);
751 printk(KERN_DEBUG "First datazone:%ld Root inode number:%ld\n",
752 sbi->s_firstdatazone >> sbi->s_log_zone_size,
753 sbi->s_firstdatazone);
754 if(sbi->s_high_sierra)
755 printk(KERN_DEBUG "Disc in High Sierra format.\n");
759 * If the Joliet level is set, we _may_ decide to use the
760 * secondary descriptor, but can't be sure until after we
761 * read the root inode. But before reading the root inode
762 * we may need to change the device blocksize, and would
763 * rather release the old buffer first. So, we cache the
764 * first_data_zone value from the secondary descriptor.
767 pri = (struct iso_primary_descriptor *) sec;
768 rootp = (struct iso_directory_record *)
769 pri->root_directory_record;
770 first_data_zone = ((isonum_733 (rootp->extent) +
771 isonum_711 (rootp->ext_attr_length))
772 << sbi->s_log_zone_size);
776 * We're all done using the volume descriptor, and may need
777 * to change the device blocksize, so release the buffer now.
783 * Force the blocksize to 512 for 512 byte sectors. The file
784 * read primitives really get it wrong in a bad way if we don't
787 * Note - we should never be setting the blocksize to something
788 * less than the hardware sector size for the device. If we
789 * do, we would end up having to read larger buffers and split
790 * out portions to satisfy requests.
792 * Note2- the idea here is that we want to deal with the optimal
793 * zonesize in the filesystem. If we have it set to something less,
794 * then we have horrible problems with trying to piece together
795 * bits of adjacent blocks in order to properly read directory
796 * entries. By forcing the blocksize in this way, we ensure
797 * that we will never be required to do this.
799 sb_set_blocksize(s, orig_zonesize);
801 sbi->s_nls_iocharset = NULL;
804 if (joliet_level && opt.utf8 == 0) {
805 char * p = opt.iocharset ? opt.iocharset : CONFIG_NLS_DEFAULT;
806 sbi->s_nls_iocharset = load_nls(p);
807 if (! sbi->s_nls_iocharset) {
808 /* Fail only if explicit charset specified */
811 sbi->s_nls_iocharset = load_nls_default();
815 s->s_op = &isofs_sops;
816 s->s_export_op = &isofs_export_ops;
817 sbi->s_mapping = opt.map;
818 sbi->s_rock = (opt.rock == 'y' ? 2 : 0);
819 sbi->s_rock_offset = -1; /* initial offset, will guess until SP is found*/
820 sbi->s_cruft = opt.cruft;
821 sbi->s_unhide = opt.unhide;
822 sbi->s_uid = opt.uid;
823 sbi->s_gid = opt.gid;
824 sbi->s_utf8 = opt.utf8;
825 sbi->s_nocompress = opt.nocompress;
827 * It would be incredibly stupid to allow people to mark every file
828 * on the disk as suid, so we merely allow them to set the default
831 sbi->s_mode = opt.mode & 0777;
834 * Read the root inode, which _may_ result in changing
835 * the s_rock flag. Once we have the final s_rock value,
836 * we then decide whether to use the Joliet descriptor.
838 inode = iget(s, sbi->s_firstdatazone);
841 * If this disk has both Rock Ridge and Joliet on it, then we
842 * want to use Rock Ridge by default. This can be overridden
843 * by using the norock mount option. There is still one other
844 * possibility that is not taken into account: a Rock Ridge
845 * CD with Unicode names. Until someone sees such a beast, it
846 * will not be supported.
848 if (sbi->s_rock == 1) {
850 } else if (joliet_level) {
852 if (sbi->s_firstdatazone != first_data_zone) {
853 sbi->s_firstdatazone = first_data_zone;
855 "ISOFS: changing to secondary root\n");
857 inode = iget(s, sbi->s_firstdatazone);
861 if (opt.check == 'u') {
862 /* Only Joliet is case insensitive by default */
863 if (joliet_level) opt.check = 'r';
864 else opt.check = 's';
866 sbi->s_joliet_level = joliet_level;
868 /* check the root inode */
873 /* get the root dentry */
874 s->s_root = d_alloc_root(inode);
879 if (joliet_level) table += 2;
880 if (opt.check == 'r') table++;
881 s->s_root->d_op = &isofs_dentry_ops[table];
884 kfree(opt.iocharset);
889 * Display error messages and free resources.
892 printk(KERN_WARNING "isofs_fill_super: root inode not initialized\n");
895 printk(KERN_WARNING "isofs_fill_super: get root inode failed\n");
899 if (sbi->s_nls_iocharset)
900 unload_nls(sbi->s_nls_iocharset);
904 printk(KERN_WARNING "isofs_fill_super: "
905 "bread failed, dev=%s, iso_blknum=%d, block=%d\n",
906 s->s_id, iso_blknum, block);
909 printk(KERN_WARNING "Bad logical zone size %ld\n",
910 sbi->s_log_zone_size);
913 printk(KERN_WARNING "Logical zone size(%d) < hardware blocksize(%u)\n",
914 orig_zonesize, opt.blocksize);
918 printk(KERN_WARNING "Unable to identify CD-ROM format.\n");
924 kfree(opt.iocharset);
930 static int isofs_statfs (struct super_block *sb, struct kstatfs *buf)
932 buf->f_type = ISOFS_SUPER_MAGIC;
933 buf->f_bsize = sb->s_blocksize;
934 buf->f_blocks = (ISOFS_SB(sb)->s_nzones
935 << (ISOFS_SB(sb)->s_log_zone_size - sb->s_blocksize_bits));
938 buf->f_files = ISOFS_SB(sb)->s_ninodes;
940 buf->f_namelen = NAME_MAX;
945 * Get a set of blocks; filling in buffer_heads if already allocated
946 * or getblk() if they are not. Returns the number of blocks inserted
949 int isofs_get_blocks(struct inode *inode, sector_t iblock_s,
950 struct buffer_head **bh, unsigned long nblocks)
953 unsigned offset, sect_size;
954 unsigned int firstext;
955 unsigned long nextino;
956 long iblock = (long)iblock_s;
958 struct iso_inode_info *ei = ISOFS_I(inode);
963 if (iblock < 0 || iblock != iblock_s) {
964 printk("isofs_get_blocks: block number too large\n");
971 firstext = ei->i_first_extent;
972 sect_size = ei->i_section_size >> ISOFS_BUFFER_BITS(inode);
973 nextino = ei->i_next_section_ino;
977 /* If we are *way* beyond the end of the file, print a message.
978 * Access beyond the end of the file up to the next page boundary
979 * is normal, however because of the way the page cache works.
980 * In this case, we just return 0 so that we can properly fill
981 * the page with useless information without generating any
984 if (b_off > ((inode->i_size + PAGE_CACHE_SIZE - 1) >> ISOFS_BUFFER_BITS(inode))) {
985 printk("isofs_get_blocks: block >= EOF (%ld, %ld)\n",
986 iblock, (unsigned long) inode->i_size);
991 while (b_off >= (offset + sect_size)) {
992 struct inode *ninode;
997 ninode = iget(inode->i_sb, nextino);
1000 firstext = ISOFS_I(ninode)->i_first_extent;
1001 sect_size = ISOFS_I(ninode)->i_section_size;
1002 nextino = ISOFS_I(ninode)->i_next_section_ino;
1005 if (++section > 100) {
1006 printk("isofs_get_blocks: More than 100 file sections ?!?, aborting...\n");
1007 printk("isofs_get_blocks: ino=%lu block=%ld firstext=%u sect_size=%u nextino=%lu\n",
1008 inode->i_ino, iblock, firstext, (unsigned) sect_size, nextino);
1015 map_bh(*bh, inode->i_sb, firstext + b_off - offset);
1017 *bh = sb_getblk(inode->i_sb, firstext+b_off-offset);
1021 bh++; /* Next buffer head */
1022 b_off++; /* Next buffer offset */
1034 * Used by the standard interfaces.
1036 static int isofs_get_block(struct inode *inode, sector_t iblock,
1037 struct buffer_head *bh_result, int create)
1040 printk("isofs_get_block: Kernel tries to allocate a block\n");
1044 return isofs_get_blocks(inode, iblock, &bh_result, 1) ? 0 : -EIO;
1047 static int isofs_bmap(struct inode *inode, int block)
1049 struct buffer_head dummy;
1053 dummy.b_blocknr = -1000;
1054 error = isofs_get_block(inode, block, &dummy, 0);
1056 return dummy.b_blocknr;
1060 struct buffer_head *isofs_bread(struct inode *inode, sector_t block)
1062 sector_t blknr = isofs_bmap(inode, block);
1065 return sb_bread(inode->i_sb, blknr);
1068 static int isofs_readpage(struct file *file, struct page *page)
1070 return block_read_full_page(page,isofs_get_block);
1073 static sector_t _isofs_bmap(struct address_space *mapping, sector_t block)
1075 return generic_block_bmap(mapping,block,isofs_get_block);
1078 static struct address_space_operations isofs_aops = {
1079 .readpage = isofs_readpage,
1080 .sync_page = block_sync_page,
1084 static inline void test_and_set_uid(uid_t *p, uid_t value)
1091 static inline void test_and_set_gid(gid_t *p, gid_t value)
1098 static int isofs_read_level3_size(struct inode * inode)
1100 unsigned long f_pos = inode->i_ino;
1101 unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
1102 int high_sierra = ISOFS_SB(inode->i_sb)->s_high_sierra;
1103 struct buffer_head * bh = NULL;
1104 unsigned long block, offset;
1106 int more_entries = 0;
1107 struct iso_directory_record * tmpde = NULL;
1108 struct iso_inode_info *ei = ISOFS_I(inode);
1111 ei->i_next_section_ino = 0;
1113 block = f_pos >> ISOFS_BUFFER_BITS(inode);
1114 offset = f_pos & (bufsize-1);
1117 struct iso_directory_record * de;
1118 unsigned int de_len;
1121 bh = sb_bread(inode->i_sb, block);
1125 de = (struct iso_directory_record *) (bh->b_data + offset);
1126 de_len = *(unsigned char *) de;
1131 f_pos = (f_pos + ISOFS_BLOCK_SIZE) & ~(ISOFS_BLOCK_SIZE - 1);
1132 block = f_pos >> ISOFS_BUFFER_BITS(inode);
1139 /* Make sure we have a full directory entry */
1140 if (offset >= bufsize) {
1141 int slop = bufsize - offset + de_len;
1143 tmpde = kmalloc(256, GFP_KERNEL);
1147 memcpy(tmpde, de, slop);
1148 offset &= bufsize - 1;
1153 bh = sb_bread(inode->i_sb, block);
1156 memcpy((void *) tmpde + slop, bh->b_data, offset);
1161 inode->i_size += isonum_733(de->size);
1163 ei->i_next_section_ino = f_pos;
1165 more_entries = de->flags[-high_sierra] & 0x80;
1171 } while(more_entries);
1185 printk(KERN_INFO "ISOFS: unable to read i-node block %lu\n", block);
1191 printk(KERN_INFO "isofs_read_level3_size: "
1192 "More than 100 file sections ?!?, aborting...\n"
1193 "isofs_read_level3_size: inode=%lu ino=%lu\n",
1194 inode->i_ino, f_pos);
1198 static void isofs_read_inode(struct inode * inode)
1200 struct super_block *sb = inode->i_sb;
1201 struct isofs_sb_info *sbi = ISOFS_SB(sb);
1202 unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
1203 int block = inode->i_ino >> ISOFS_BUFFER_BITS(inode);
1204 int high_sierra = sbi->s_high_sierra;
1205 struct buffer_head * bh = NULL;
1206 struct iso_directory_record * de;
1207 struct iso_directory_record * tmpde = NULL;
1208 unsigned int de_len;
1209 unsigned long offset;
1210 int volume_seq_no, i;
1211 struct iso_inode_info *ei = ISOFS_I(inode);
1213 bh = sb_bread(inode->i_sb, block);
1217 offset = (inode->i_ino & (bufsize - 1));
1218 de = (struct iso_directory_record *) (bh->b_data + offset);
1219 de_len = *(unsigned char *) de;
1221 if (offset + de_len > bufsize) {
1222 int frag1 = bufsize - offset;
1224 tmpde = kmalloc(de_len, GFP_KERNEL);
1225 if (tmpde == NULL) {
1226 printk(KERN_INFO "isofs_read_inode: out of memory\n");
1229 memcpy(tmpde, bh->b_data + offset, frag1);
1231 bh = sb_bread(inode->i_sb, ++block);
1234 memcpy((char *)tmpde+frag1, bh->b_data, de_len - frag1);
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;
1253 /* If there are no periods in the name,
1254 * then set the execute permission bit
1256 for(i=0; i< de->name_len[0]; i++)
1257 if(de->name[i]=='.' || de->name[i]==';')
1259 if(i == de->name_len[0] || de->name[i] == ';')
1260 inode->i_mode |= S_IXUGO; /* execute permission */
1262 inode->i_uid = sbi->s_uid;
1263 inode->i_gid = sbi->s_gid;
1264 inode->i_blocks = inode->i_blksize = 0;
1266 ei->i_format_parm[0] = 0;
1267 ei->i_format_parm[1] = 0;
1268 ei->i_format_parm[2] = 0;
1270 ei->i_section_size = isonum_733 (de->size);
1271 if(de->flags[-high_sierra] & 0x80) {
1272 if(isofs_read_level3_size(inode)) goto fail;
1274 ei->i_next_section_ino = 0;
1275 inode->i_size = isonum_733 (de->size);
1279 * The ISO-9660 filesystem only stores 32 bits for file size.
1280 * mkisofs handles files up to 2GB-2 = 2147483646 = 0x7FFFFFFE bytes
1281 * in size. This is according to the large file summit paper from 1996.
1282 * WARNING: ISO-9660 filesystems > 1 GB and even > 2 GB are fully
1283 * legal. Do not prevent to use DVD's schilling@fokus.gmd.de
1285 if ((inode->i_size < 0 || inode->i_size > 0x7FFFFFFE) &&
1286 sbi->s_cruft == 'n') {
1287 printk(KERN_WARNING "Warning: defective CD-ROM. "
1288 "Enabling \"cruft\" mount option.\n");
1293 * Some dipshit decided to store some other bit of information
1294 * in the high byte of the file length. Catch this and holler.
1295 * WARNING: this will make it impossible for a file to be > 16MB
1299 if (sbi->s_cruft == 'y' &&
1300 inode->i_size & 0xff000000) {
1301 inode->i_size &= 0x00ffffff;
1304 if (de->interleave[0]) {
1305 printk("Interleaved files not (yet) supported.\n");
1309 /* I have no idea what file_unit_size is used for, so
1310 we will flag it for now */
1311 if (de->file_unit_size[0] != 0) {
1312 printk("File unit size != 0 for ISO file (%ld).\n",
1316 /* I have no idea what other flag bits are used for, so
1317 we will flag it for now */
1319 if((de->flags[-high_sierra] & ~2)!= 0){
1320 printk("Unusual flag settings for ISO file (%ld %x).\n",
1321 inode->i_ino, de->flags[-high_sierra]);
1325 inode->i_mtime.tv_sec =
1326 inode->i_atime.tv_sec =
1327 inode->i_ctime.tv_sec = iso_date(de->date, high_sierra);
1328 inode->i_mtime.tv_nsec =
1329 inode->i_atime.tv_nsec =
1330 inode->i_ctime.tv_nsec = 0;
1332 ei->i_first_extent = (isonum_733 (de->extent) +
1333 isonum_711 (de->ext_attr_length));
1335 /* Set the number of blocks for stat() - should be done before RR */
1336 inode->i_blksize = PAGE_CACHE_SIZE; /* For stat() only */
1337 inode->i_blocks = (inode->i_size + 511) >> 9;
1340 * Now test for possible Rock Ridge extensions which will override
1341 * some of these numbers in the inode structure.
1345 parse_rock_ridge_inode(de, inode);
1346 /* if we want uid/gid set, override the rock ridge setting */
1347 test_and_set_uid(&inode->i_uid, sbi->s_uid);
1348 test_and_set_gid(&inode->i_gid, sbi->s_gid);
1351 /* get the volume sequence number */
1352 volume_seq_no = isonum_723 (de->volume_sequence_number) ;
1354 /* Install the inode operations vector */
1355 if (S_ISREG(inode->i_mode)) {
1356 inode->i_fop = &generic_ro_fops;
1357 switch ( ei->i_file_format ) {
1358 #ifdef CONFIG_ZISOFS
1359 case isofs_file_compressed:
1360 inode->i_data.a_ops = &zisofs_aops;
1364 inode->i_data.a_ops = &isofs_aops;
1367 } else if (S_ISDIR(inode->i_mode)) {
1368 inode->i_op = &isofs_dir_inode_operations;
1369 inode->i_fop = &isofs_dir_operations;
1370 } else if (S_ISLNK(inode->i_mode)) {
1371 inode->i_op = &page_symlink_inode_operations;
1372 inode->i_data.a_ops = &isofs_symlink_aops;
1374 /* XXX - parse_rock_ridge_inode() had already set i_rdev. */
1375 init_special_inode(inode, inode->i_mode, inode->i_rdev);
1385 printk(KERN_WARNING "ISOFS: unable to read i-node block\n");
1387 make_bad_inode(inode);
1397 void * leak_check_malloc(unsigned int size){
1400 tmp = kmalloc(size, GFP_KERNEL);
1404 void leak_check_free_s(void * obj, int size){
1409 struct buffer_head * leak_check_bread(struct super_block *sb, int block){
1411 return sb_bread(sb, block);
1414 void leak_check_brelse(struct buffer_head * bh){
1421 static struct super_block *isofs_get_sb(struct file_system_type *fs_type,
1422 int flags, const char *dev_name, void *data)
1424 return get_sb_bdev(fs_type, flags, dev_name, data, isofs_fill_super);
1427 static struct file_system_type iso9660_fs_type = {
1428 .owner = THIS_MODULE,
1430 .get_sb = isofs_get_sb,
1431 .kill_sb = kill_block_super,
1432 .fs_flags = FS_REQUIRES_DEV,
1435 static int __init init_iso9660_fs(void)
1437 int err = init_inodecache();
1440 #ifdef CONFIG_ZISOFS
1441 err = zisofs_init();
1445 err = register_filesystem(&iso9660_fs_type);
1450 #ifdef CONFIG_ZISOFS
1454 destroy_inodecache();
1459 static void __exit exit_iso9660_fs(void)
1461 unregister_filesystem(&iso9660_fs_type);
1462 #ifdef CONFIG_ZISOFS
1465 destroy_inodecache();
1468 module_init(init_iso9660_fs)
1469 module_exit(exit_iso9660_fs)
1470 MODULE_LICENSE("GPL");
1471 /* Actual filesystem name is iso9660, as requested in filesystems.c */
1472 MODULE_ALIAS("iso9660");