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);
688 rootp = (struct iso_directory_record *) pri->root_directory_record;
689 sbi->s_nzones = isonum_733 (pri->volume_space_size);
690 sbi->s_log_zone_size = isonum_723 (pri->logical_block_size);
691 sbi->s_max_size = isonum_733(pri->volume_space_size);
694 sbi->s_ninodes = 0; /* No way to figure this out easily */
696 orig_zonesize = sbi->s_log_zone_size;
698 * If the zone size is smaller than the hardware sector size,
699 * this is a fatal error. This would occur if the disc drive
700 * had sectors that were 2048 bytes, but the filesystem had
701 * blocks that were 512 bytes (which should only very rarely
704 if(orig_zonesize < opt.blocksize)
707 /* RDE: convert log zone size to bit shift */
708 switch (sbi->s_log_zone_size)
709 { case 512: sbi->s_log_zone_size = 9; break;
710 case 1024: sbi->s_log_zone_size = 10; break;
711 case 2048: sbi->s_log_zone_size = 11; break;
714 goto out_bad_zone_size;
717 s->s_magic = ISOFS_SUPER_MAGIC;
718 s->s_maxbytes = 0xffffffff; /* We can handle files up to 4 GB */
720 /* The CDROM is read-only, has no nodes (devices) on it, and since
721 all of the files appear to be owned by root, we really do not want
722 to allow suid. (suid or devices will not show up unless we have
723 Rock Ridge extensions) */
725 s->s_flags |= MS_RDONLY /* | MS_NODEV | MS_NOSUID */;
727 /* Set this for reference. Its not currently used except on write
728 which we don't have .. */
730 first_data_zone = isonum_733 (rootp->extent) +
731 isonum_711 (rootp->ext_attr_length);
732 sbi->s_firstdatazone = first_data_zone;
734 printk(KERN_DEBUG "Max size:%ld Log zone size:%ld\n",
736 1UL << sbi->s_log_zone_size);
737 printk(KERN_DEBUG "First datazone:%ld\n", sbi->s_firstdatazone);
738 if(sbi->s_high_sierra)
739 printk(KERN_DEBUG "Disc in High Sierra format.\n");
743 * If the Joliet level is set, we _may_ decide to use the
744 * secondary descriptor, but can't be sure until after we
745 * read the root inode. But before reading the root inode
746 * we may need to change the device blocksize, and would
747 * rather release the old buffer first. So, we cache the
748 * first_data_zone value from the secondary descriptor.
751 pri = (struct iso_primary_descriptor *) sec;
752 rootp = (struct iso_directory_record *)
753 pri->root_directory_record;
754 first_data_zone = isonum_733 (rootp->extent) +
755 isonum_711 (rootp->ext_attr_length);
759 * We're all done using the volume descriptor, and may need
760 * to change the device blocksize, so release the buffer now.
766 * Force the blocksize to 512 for 512 byte sectors. The file
767 * read primitives really get it wrong in a bad way if we don't
770 * Note - we should never be setting the blocksize to something
771 * less than the hardware sector size for the device. If we
772 * do, we would end up having to read larger buffers and split
773 * out portions to satisfy requests.
775 * Note2- the idea here is that we want to deal with the optimal
776 * zonesize in the filesystem. If we have it set to something less,
777 * then we have horrible problems with trying to piece together
778 * bits of adjacent blocks in order to properly read directory
779 * entries. By forcing the blocksize in this way, we ensure
780 * that we will never be required to do this.
782 sb_set_blocksize(s, orig_zonesize);
784 sbi->s_nls_iocharset = NULL;
787 if (joliet_level && opt.utf8 == 0) {
788 char * p = opt.iocharset ? opt.iocharset : CONFIG_NLS_DEFAULT;
789 sbi->s_nls_iocharset = load_nls(p);
790 if (! sbi->s_nls_iocharset) {
791 /* Fail only if explicit charset specified */
794 sbi->s_nls_iocharset = load_nls_default();
798 s->s_op = &isofs_sops;
799 s->s_export_op = &isofs_export_ops;
800 sbi->s_mapping = opt.map;
801 sbi->s_rock = (opt.rock == 'y' ? 2 : 0);
802 sbi->s_rock_offset = -1; /* initial offset, will guess until SP is found*/
803 sbi->s_cruft = opt.cruft;
804 sbi->s_unhide = opt.unhide;
805 sbi->s_uid = opt.uid;
806 sbi->s_gid = opt.gid;
807 sbi->s_utf8 = opt.utf8;
808 sbi->s_nocompress = opt.nocompress;
810 * It would be incredibly stupid to allow people to mark every file
811 * on the disk as suid, so we merely allow them to set the default
814 sbi->s_mode = opt.mode & 0777;
817 * Read the root inode, which _may_ result in changing
818 * the s_rock flag. Once we have the final s_rock value,
819 * we then decide whether to use the Joliet descriptor.
821 inode = isofs_iget(s, sbi->s_firstdatazone, 0);
824 * If this disk has both Rock Ridge and Joliet on it, then we
825 * want to use Rock Ridge by default. This can be overridden
826 * by using the norock mount option. There is still one other
827 * possibility that is not taken into account: a Rock Ridge
828 * CD with Unicode names. Until someone sees such a beast, it
829 * will not be supported.
831 if (sbi->s_rock == 1) {
833 } else if (joliet_level) {
835 if (sbi->s_firstdatazone != first_data_zone) {
836 sbi->s_firstdatazone = first_data_zone;
838 "ISOFS: changing to secondary root\n");
840 inode = isofs_iget(s, sbi->s_firstdatazone, 0);
844 if (opt.check == 'u') {
845 /* Only Joliet is case insensitive by default */
846 if (joliet_level) opt.check = 'r';
847 else opt.check = 's';
849 sbi->s_joliet_level = joliet_level;
851 /* check the root inode */
856 /* get the root dentry */
857 s->s_root = d_alloc_root(inode);
862 if (joliet_level) table += 2;
863 if (opt.check == 'r') table++;
864 s->s_root->d_op = &isofs_dentry_ops[table];
867 kfree(opt.iocharset);
872 * Display error messages and free resources.
875 printk(KERN_WARNING "isofs_fill_super: root inode not initialized\n");
878 printk(KERN_WARNING "isofs_fill_super: get root inode failed\n");
882 if (sbi->s_nls_iocharset)
883 unload_nls(sbi->s_nls_iocharset);
887 printk(KERN_WARNING "isofs_fill_super: "
888 "bread failed, dev=%s, iso_blknum=%d, block=%d\n",
889 s->s_id, iso_blknum, block);
892 printk(KERN_WARNING "Bad logical zone size %ld\n",
893 sbi->s_log_zone_size);
896 printk(KERN_WARNING "Logical zone size(%d) < hardware blocksize(%u)\n",
897 orig_zonesize, opt.blocksize);
901 printk(KERN_WARNING "Unable to identify CD-ROM format.\n");
907 kfree(opt.iocharset);
913 static int isofs_statfs (struct super_block *sb, struct kstatfs *buf)
915 buf->f_type = ISOFS_SUPER_MAGIC;
916 buf->f_bsize = sb->s_blocksize;
917 buf->f_blocks = (ISOFS_SB(sb)->s_nzones
918 << (ISOFS_SB(sb)->s_log_zone_size - sb->s_blocksize_bits));
921 buf->f_files = ISOFS_SB(sb)->s_ninodes;
923 buf->f_namelen = NAME_MAX;
928 * Get a set of blocks; filling in buffer_heads if already allocated
929 * or getblk() if they are not. Returns the number of blocks inserted
932 int isofs_get_blocks(struct inode *inode, sector_t iblock_s,
933 struct buffer_head **bh, unsigned long nblocks)
936 unsigned offset, sect_size;
937 unsigned int firstext;
938 unsigned long nextblk, nextoff;
939 long iblock = (long)iblock_s;
941 struct iso_inode_info *ei = ISOFS_I(inode);
946 if (iblock < 0 || iblock != iblock_s) {
947 printk("isofs_get_blocks: block number too large\n");
954 firstext = ei->i_first_extent;
955 sect_size = ei->i_section_size >> ISOFS_BUFFER_BITS(inode);
956 nextblk = ei->i_next_section_block;
957 nextoff = ei->i_next_section_offset;
961 /* If we are *way* beyond the end of the file, print a message.
962 * Access beyond the end of the file up to the next page boundary
963 * is normal, however because of the way the page cache works.
964 * In this case, we just return 0 so that we can properly fill
965 * the page with useless information without generating any
968 if (b_off > ((inode->i_size + PAGE_CACHE_SIZE - 1) >> ISOFS_BUFFER_BITS(inode))) {
969 printk("isofs_get_blocks: block >= EOF (%ld, %ld)\n",
970 iblock, (unsigned long) inode->i_size);
975 while (b_off >= (offset + sect_size)) {
976 struct inode *ninode;
981 ninode = isofs_iget(inode->i_sb, nextblk, nextoff);
984 firstext = ISOFS_I(ninode)->i_first_extent;
985 sect_size = ISOFS_I(ninode)->i_section_size >> ISOFS_BUFFER_BITS(ninode);
986 nextblk = ISOFS_I(ninode)->i_next_section_block;
987 nextoff = ISOFS_I(ninode)->i_next_section_offset;
990 if (++section > 100) {
991 printk("isofs_get_blocks: More than 100 file sections ?!?, aborting...\n");
992 printk("isofs_get_blocks: block=%ld firstext=%u sect_size=%u "
993 "nextblk=%lu nextoff=%lu\n",
994 iblock, firstext, (unsigned) sect_size,
1002 map_bh(*bh, inode->i_sb, firstext + b_off - offset);
1004 *bh = sb_getblk(inode->i_sb, firstext+b_off-offset);
1008 bh++; /* Next buffer head */
1009 b_off++; /* Next buffer offset */
1021 * Used by the standard interfaces.
1023 static int isofs_get_block(struct inode *inode, sector_t iblock,
1024 struct buffer_head *bh_result, int create)
1027 printk("isofs_get_block: Kernel tries to allocate a block\n");
1031 return isofs_get_blocks(inode, iblock, &bh_result, 1) ? 0 : -EIO;
1034 static int isofs_bmap(struct inode *inode, sector_t block)
1036 struct buffer_head dummy;
1040 dummy.b_blocknr = -1000;
1041 error = isofs_get_block(inode, block, &dummy, 0);
1043 return dummy.b_blocknr;
1047 struct buffer_head *isofs_bread(struct inode *inode, sector_t block)
1049 sector_t blknr = isofs_bmap(inode, block);
1052 return sb_bread(inode->i_sb, blknr);
1055 static int isofs_readpage(struct file *file, struct page *page)
1057 return block_read_full_page(page,isofs_get_block);
1060 static sector_t _isofs_bmap(struct address_space *mapping, sector_t block)
1062 return generic_block_bmap(mapping,block,isofs_get_block);
1065 static struct address_space_operations isofs_aops = {
1066 .readpage = isofs_readpage,
1067 .sync_page = block_sync_page,
1071 static inline void test_and_set_uid(uid_t *p, uid_t value)
1078 static inline void test_and_set_gid(gid_t *p, gid_t value)
1085 static int isofs_read_level3_size(struct inode * inode)
1087 unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
1088 int high_sierra = ISOFS_SB(inode->i_sb)->s_high_sierra;
1089 struct buffer_head * bh = NULL;
1090 unsigned long block, offset, block_saved, offset_saved;
1092 int more_entries = 0;
1093 struct iso_directory_record * tmpde = NULL;
1094 struct iso_inode_info *ei = ISOFS_I(inode);
1098 /* The first 16 blocks are reserved as the System Area. Thus,
1099 * no inodes can appear in block 0. We use this to flag that
1100 * this is the last section. */
1101 ei->i_next_section_block = 0;
1102 ei->i_next_section_offset = 0;
1104 block = ei->i_iget5_block;
1105 offset = ei->i_iget5_offset;
1108 struct iso_directory_record * de;
1109 unsigned int de_len;
1112 bh = sb_bread(inode->i_sb, block);
1116 de = (struct iso_directory_record *) (bh->b_data + offset);
1117 de_len = *(unsigned char *) de;
1127 block_saved = block;
1128 offset_saved = offset;
1131 /* Make sure we have a full directory entry */
1132 if (offset >= bufsize) {
1133 int slop = bufsize - offset + de_len;
1135 tmpde = kmalloc(256, GFP_KERNEL);
1139 memcpy(tmpde, de, slop);
1140 offset &= bufsize - 1;
1145 bh = sb_bread(inode->i_sb, block);
1148 memcpy((void *) tmpde + slop, bh->b_data, offset);
1153 inode->i_size += isonum_733(de->size);
1155 ei->i_next_section_block = block_saved;
1156 ei->i_next_section_offset = offset_saved;
1159 more_entries = de->flags[-high_sierra] & 0x80;
1164 } while(more_entries);
1178 printk(KERN_INFO "ISOFS: unable to read i-node block %lu\n", block);
1184 printk(KERN_INFO "isofs_read_level3_size: "
1185 "More than 100 file sections ?!?, aborting...\n"
1186 "isofs_read_level3_size: inode=%lu\n",
1191 static void isofs_read_inode(struct inode * inode)
1193 struct super_block *sb = inode->i_sb;
1194 struct isofs_sb_info *sbi = ISOFS_SB(sb);
1195 unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
1196 unsigned long block;
1197 int high_sierra = sbi->s_high_sierra;
1198 struct buffer_head * bh = NULL;
1199 struct iso_directory_record * de;
1200 struct iso_directory_record * tmpde = NULL;
1201 unsigned int de_len;
1202 unsigned long offset;
1203 struct iso_inode_info *ei = ISOFS_I(inode);
1205 block = ei->i_iget5_block;
1206 bh = sb_bread(inode->i_sb, block);
1210 offset = ei->i_iget5_offset;
1212 de = (struct iso_directory_record *) (bh->b_data + offset);
1213 de_len = *(unsigned char *) de;
1215 if (offset + de_len > bufsize) {
1216 int frag1 = bufsize - offset;
1218 tmpde = kmalloc(de_len, GFP_KERNEL);
1219 if (tmpde == NULL) {
1220 printk(KERN_INFO "isofs_read_inode: out of memory\n");
1223 memcpy(tmpde, bh->b_data + offset, frag1);
1225 bh = sb_bread(inode->i_sb, ++block);
1228 memcpy((char *)tmpde+frag1, bh->b_data, de_len - frag1);
1232 inode->i_ino = isofs_get_ino(ei->i_iget5_block,
1234 ISOFS_BUFFER_BITS(inode));
1236 /* Assume it is a normal-format file unless told otherwise */
1237 ei->i_file_format = isofs_file_normal;
1239 if (de->flags[-high_sierra] & 2) {
1240 inode->i_mode = S_IRUGO | S_IXUGO | S_IFDIR;
1241 inode->i_nlink = 1; /* Set to 1. We know there are 2, but
1242 the find utility tries to optimize
1243 if it is 2, and it screws up. It is
1244 easier to give 1 which tells find to
1245 do it the hard way. */
1247 /* Everybody gets to read the file. */
1248 inode->i_mode = sbi->s_mode;
1250 inode->i_mode |= S_IFREG;
1252 inode->i_uid = sbi->s_uid;
1253 inode->i_gid = sbi->s_gid;
1254 inode->i_blocks = inode->i_blksize = 0;
1256 ei->i_format_parm[0] = 0;
1257 ei->i_format_parm[1] = 0;
1258 ei->i_format_parm[2] = 0;
1260 ei->i_section_size = isonum_733 (de->size);
1261 if(de->flags[-high_sierra] & 0x80) {
1262 if(isofs_read_level3_size(inode)) goto fail;
1264 ei->i_next_section_block = 0;
1265 ei->i_next_section_offset = 0;
1266 inode->i_size = isonum_733 (de->size);
1270 * Some dipshit decided to store some other bit of information
1271 * in the high byte of the file length. Truncate size in case
1272 * this CDROM was mounted with the cruft option.
1275 if (sbi->s_cruft == 'y')
1276 inode->i_size &= 0x00ffffff;
1278 if (de->interleave[0]) {
1279 printk("Interleaved files not (yet) supported.\n");
1283 /* I have no idea what file_unit_size is used for, so
1284 we will flag it for now */
1285 if (de->file_unit_size[0] != 0) {
1286 printk("File unit size != 0 for ISO file (%ld).\n",
1290 /* I have no idea what other flag bits are used for, so
1291 we will flag it for now */
1293 if((de->flags[-high_sierra] & ~2)!= 0){
1294 printk("Unusual flag settings for ISO file (%ld %x).\n",
1295 inode->i_ino, de->flags[-high_sierra]);
1299 inode->i_mtime.tv_sec =
1300 inode->i_atime.tv_sec =
1301 inode->i_ctime.tv_sec = iso_date(de->date, high_sierra);
1302 inode->i_mtime.tv_nsec =
1303 inode->i_atime.tv_nsec =
1304 inode->i_ctime.tv_nsec = 0;
1306 ei->i_first_extent = (isonum_733 (de->extent) +
1307 isonum_711 (de->ext_attr_length));
1309 /* Set the number of blocks for stat() - should be done before RR */
1310 inode->i_blksize = PAGE_CACHE_SIZE; /* For stat() only */
1311 inode->i_blocks = (inode->i_size + 511) >> 9;
1314 * Now test for possible Rock Ridge extensions which will override
1315 * some of these numbers in the inode structure.
1319 parse_rock_ridge_inode(de, inode);
1320 /* if we want uid/gid set, override the rock ridge setting */
1321 test_and_set_uid(&inode->i_uid, sbi->s_uid);
1322 test_and_set_gid(&inode->i_gid, sbi->s_gid);
1325 /* Install the inode operations vector */
1326 if (S_ISREG(inode->i_mode)) {
1327 inode->i_fop = &generic_ro_fops;
1328 switch ( ei->i_file_format ) {
1329 #ifdef CONFIG_ZISOFS
1330 case isofs_file_compressed:
1331 inode->i_data.a_ops = &zisofs_aops;
1335 inode->i_data.a_ops = &isofs_aops;
1338 } else if (S_ISDIR(inode->i_mode)) {
1339 inode->i_op = &isofs_dir_inode_operations;
1340 inode->i_fop = &isofs_dir_operations;
1341 } else if (S_ISLNK(inode->i_mode)) {
1342 inode->i_op = &page_symlink_inode_operations;
1343 inode->i_data.a_ops = &isofs_symlink_aops;
1345 /* XXX - parse_rock_ridge_inode() had already set i_rdev. */
1346 init_special_inode(inode, inode->i_mode, inode->i_rdev);
1356 printk(KERN_WARNING "ISOFS: unable to read i-node block\n");
1358 make_bad_inode(inode);
1362 struct isofs_iget5_callback_data {
1363 unsigned long block;
1364 unsigned long offset;
1367 static int isofs_iget5_test(struct inode *ino, void *data)
1369 struct iso_inode_info *i = ISOFS_I(ino);
1370 struct isofs_iget5_callback_data *d =
1371 (struct isofs_iget5_callback_data*)data;
1372 return (i->i_iget5_block == d->block)
1373 && (i->i_iget5_offset == d->offset);
1376 static int isofs_iget5_set(struct inode *ino, void *data)
1378 struct iso_inode_info *i = ISOFS_I(ino);
1379 struct isofs_iget5_callback_data *d =
1380 (struct isofs_iget5_callback_data*)data;
1381 i->i_iget5_block = d->block;
1382 i->i_iget5_offset = d->offset;
1386 /* Store, in the inode's containing structure, the block and block
1387 * offset that point to the underlying meta-data for the inode. The
1388 * code below is otherwise similar to the iget() code in
1389 * include/linux/fs.h */
1390 struct inode *isofs_iget(struct super_block *sb,
1391 unsigned long block,
1392 unsigned long offset)
1394 unsigned long hashval;
1395 struct inode *inode;
1396 struct isofs_iget5_callback_data data;
1399 data.offset = offset;
1401 hashval = (block << sb->s_blocksize_bits) | offset;
1403 inode = iget5_locked(sb,
1409 if (inode && (inode->i_state & I_NEW)) {
1410 sb->s_op->read_inode(inode);
1411 unlock_new_inode(inode);
1423 void * leak_check_malloc(unsigned int size){
1426 tmp = kmalloc(size, GFP_KERNEL);
1430 void leak_check_free_s(void * obj, int size){
1435 struct buffer_head * leak_check_bread(struct super_block *sb, int block){
1437 return sb_bread(sb, block);
1440 void leak_check_brelse(struct buffer_head * bh){
1447 static struct super_block *isofs_get_sb(struct file_system_type *fs_type,
1448 int flags, const char *dev_name, void *data)
1450 return get_sb_bdev(fs_type, flags, dev_name, data, isofs_fill_super);
1453 static struct file_system_type iso9660_fs_type = {
1454 .owner = THIS_MODULE,
1456 .get_sb = isofs_get_sb,
1457 .kill_sb = kill_block_super,
1458 .fs_flags = FS_REQUIRES_DEV,
1461 static int __init init_iso9660_fs(void)
1463 int err = init_inodecache();
1466 #ifdef CONFIG_ZISOFS
1467 err = zisofs_init();
1471 err = register_filesystem(&iso9660_fs_type);
1476 #ifdef CONFIG_ZISOFS
1480 destroy_inodecache();
1485 static void __exit exit_iso9660_fs(void)
1487 unregister_filesystem(&iso9660_fs_type);
1488 #ifdef CONFIG_ZISOFS
1491 destroy_inodecache();
1494 module_init(init_iso9660_fs)
1495 module_exit(exit_iso9660_fs)
1496 MODULE_LICENSE("GPL");
1497 /* Actual filesystem name is iso9660, as requested in filesystems.c */
1498 MODULE_ALIAS("iso9660");