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_HWCACHE_ALIGN|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;
719 /* The CDROM is read-only, has no nodes (devices) on it, and since
720 all of the files appear to be owned by root, we really do not want
721 to allow suid. (suid or devices will not show up unless we have
722 Rock Ridge extensions) */
724 s->s_flags |= MS_RDONLY /* | MS_NODEV | MS_NOSUID */;
726 /* Set this for reference. Its not currently used except on write
727 which we don't have .. */
729 first_data_zone = isonum_733 (rootp->extent) +
730 isonum_711 (rootp->ext_attr_length);
731 sbi->s_firstdatazone = first_data_zone;
733 printk(KERN_DEBUG "Max size:%ld Log zone size:%ld\n",
735 1UL << sbi->s_log_zone_size);
736 printk(KERN_DEBUG "First datazone:%ld\n", sbi->s_firstdatazone);
737 if(sbi->s_high_sierra)
738 printk(KERN_DEBUG "Disc in High Sierra format.\n");
742 * If the Joliet level is set, we _may_ decide to use the
743 * secondary descriptor, but can't be sure until after we
744 * read the root inode. But before reading the root inode
745 * we may need to change the device blocksize, and would
746 * rather release the old buffer first. So, we cache the
747 * first_data_zone value from the secondary descriptor.
750 pri = (struct iso_primary_descriptor *) sec;
751 rootp = (struct iso_directory_record *)
752 pri->root_directory_record;
753 first_data_zone = isonum_733 (rootp->extent) +
754 isonum_711 (rootp->ext_attr_length);
758 * We're all done using the volume descriptor, and may need
759 * to change the device blocksize, so release the buffer now.
765 * Force the blocksize to 512 for 512 byte sectors. The file
766 * read primitives really get it wrong in a bad way if we don't
769 * Note - we should never be setting the blocksize to something
770 * less than the hardware sector size for the device. If we
771 * do, we would end up having to read larger buffers and split
772 * out portions to satisfy requests.
774 * Note2- the idea here is that we want to deal with the optimal
775 * zonesize in the filesystem. If we have it set to something less,
776 * then we have horrible problems with trying to piece together
777 * bits of adjacent blocks in order to properly read directory
778 * entries. By forcing the blocksize in this way, we ensure
779 * that we will never be required to do this.
781 sb_set_blocksize(s, orig_zonesize);
783 sbi->s_nls_iocharset = NULL;
786 if (joliet_level && opt.utf8 == 0) {
787 char * p = opt.iocharset ? opt.iocharset : CONFIG_NLS_DEFAULT;
788 sbi->s_nls_iocharset = load_nls(p);
789 if (! sbi->s_nls_iocharset) {
790 /* Fail only if explicit charset specified */
793 sbi->s_nls_iocharset = load_nls_default();
797 s->s_op = &isofs_sops;
798 s->s_export_op = &isofs_export_ops;
799 sbi->s_mapping = opt.map;
800 sbi->s_rock = (opt.rock == 'y' ? 2 : 0);
801 sbi->s_rock_offset = -1; /* initial offset, will guess until SP is found*/
802 sbi->s_cruft = opt.cruft;
803 sbi->s_unhide = opt.unhide;
804 sbi->s_uid = opt.uid;
805 sbi->s_gid = opt.gid;
806 sbi->s_utf8 = opt.utf8;
807 sbi->s_nocompress = opt.nocompress;
809 * It would be incredibly stupid to allow people to mark every file
810 * on the disk as suid, so we merely allow them to set the default
813 sbi->s_mode = opt.mode & 0777;
816 * Read the root inode, which _may_ result in changing
817 * the s_rock flag. Once we have the final s_rock value,
818 * we then decide whether to use the Joliet descriptor.
820 inode = isofs_iget(s, sbi->s_firstdatazone, 0);
823 * If this disk has both Rock Ridge and Joliet on it, then we
824 * want to use Rock Ridge by default. This can be overridden
825 * by using the norock mount option. There is still one other
826 * possibility that is not taken into account: a Rock Ridge
827 * CD with Unicode names. Until someone sees such a beast, it
828 * will not be supported.
830 if (sbi->s_rock == 1) {
832 } else if (joliet_level) {
834 if (sbi->s_firstdatazone != first_data_zone) {
835 sbi->s_firstdatazone = first_data_zone;
837 "ISOFS: changing to secondary root\n");
839 inode = isofs_iget(s, sbi->s_firstdatazone, 0);
843 if (opt.check == 'u') {
844 /* Only Joliet is case insensitive by default */
845 if (joliet_level) opt.check = 'r';
846 else opt.check = 's';
848 sbi->s_joliet_level = joliet_level;
850 /* check the root inode */
855 /* get the root dentry */
856 s->s_root = d_alloc_root(inode);
861 if (joliet_level) table += 2;
862 if (opt.check == 'r') table++;
863 s->s_root->d_op = &isofs_dentry_ops[table];
866 kfree(opt.iocharset);
871 * Display error messages and free resources.
874 printk(KERN_WARNING "isofs_fill_super: root inode not initialized\n");
877 printk(KERN_WARNING "isofs_fill_super: get root inode failed\n");
881 if (sbi->s_nls_iocharset)
882 unload_nls(sbi->s_nls_iocharset);
886 printk(KERN_WARNING "isofs_fill_super: "
887 "bread failed, dev=%s, iso_blknum=%d, block=%d\n",
888 s->s_id, iso_blknum, block);
891 printk(KERN_WARNING "Bad logical zone size %ld\n",
892 sbi->s_log_zone_size);
895 printk(KERN_WARNING "Logical zone size(%d) < hardware blocksize(%u)\n",
896 orig_zonesize, opt.blocksize);
900 printk(KERN_WARNING "Unable to identify CD-ROM format.\n");
906 kfree(opt.iocharset);
912 static int isofs_statfs (struct super_block *sb, struct kstatfs *buf)
914 buf->f_type = ISOFS_SUPER_MAGIC;
915 buf->f_bsize = sb->s_blocksize;
916 buf->f_blocks = (ISOFS_SB(sb)->s_nzones
917 << (ISOFS_SB(sb)->s_log_zone_size - sb->s_blocksize_bits));
920 buf->f_files = ISOFS_SB(sb)->s_ninodes;
922 buf->f_namelen = NAME_MAX;
927 * Get a set of blocks; filling in buffer_heads if already allocated
928 * or getblk() if they are not. Returns the number of blocks inserted
931 int isofs_get_blocks(struct inode *inode, sector_t iblock_s,
932 struct buffer_head **bh, unsigned long nblocks)
935 unsigned offset, sect_size;
936 unsigned int firstext;
937 unsigned long nextblk, nextoff;
938 long iblock = (long)iblock_s;
940 struct iso_inode_info *ei = ISOFS_I(inode);
945 if (iblock < 0 || iblock != iblock_s) {
946 printk("isofs_get_blocks: block number too large\n");
953 firstext = ei->i_first_extent;
954 sect_size = ei->i_section_size >> ISOFS_BUFFER_BITS(inode);
955 nextblk = ei->i_next_section_block;
956 nextoff = ei->i_next_section_offset;
960 /* If we are *way* beyond the end of the file, print a message.
961 * Access beyond the end of the file up to the next page boundary
962 * is normal, however because of the way the page cache works.
963 * In this case, we just return 0 so that we can properly fill
964 * the page with useless information without generating any
967 if (b_off > ((inode->i_size + PAGE_CACHE_SIZE - 1) >> ISOFS_BUFFER_BITS(inode))) {
968 printk("isofs_get_blocks: block >= EOF (%ld, %ld)\n",
969 iblock, (unsigned long) inode->i_size);
974 while (b_off >= (offset + sect_size)) {
975 struct inode *ninode;
980 ninode = isofs_iget(inode->i_sb, nextblk, nextoff);
983 firstext = ISOFS_I(ninode)->i_first_extent;
984 sect_size = ISOFS_I(ninode)->i_section_size >> ISOFS_BUFFER_BITS(ninode);
985 nextblk = ISOFS_I(ninode)->i_next_section_block;
986 nextoff = ISOFS_I(ninode)->i_next_section_offset;
989 if (++section > 100) {
990 printk("isofs_get_blocks: More than 100 file sections ?!?, aborting...\n");
991 printk("isofs_get_blocks: block=%ld firstext=%u sect_size=%u "
992 "nextblk=%lu nextoff=%lu\n",
993 iblock, firstext, (unsigned) sect_size,
1001 map_bh(*bh, inode->i_sb, firstext + b_off - offset);
1003 *bh = sb_getblk(inode->i_sb, firstext+b_off-offset);
1007 bh++; /* Next buffer head */
1008 b_off++; /* Next buffer offset */
1020 * Used by the standard interfaces.
1022 static int isofs_get_block(struct inode *inode, sector_t iblock,
1023 struct buffer_head *bh_result, int create)
1026 printk("isofs_get_block: Kernel tries to allocate a block\n");
1030 return isofs_get_blocks(inode, iblock, &bh_result, 1) ? 0 : -EIO;
1033 static int isofs_bmap(struct inode *inode, sector_t block)
1035 struct buffer_head dummy;
1039 dummy.b_blocknr = -1000;
1040 error = isofs_get_block(inode, block, &dummy, 0);
1042 return dummy.b_blocknr;
1046 struct buffer_head *isofs_bread(struct inode *inode, sector_t block)
1048 sector_t blknr = isofs_bmap(inode, block);
1051 return sb_bread(inode->i_sb, blknr);
1054 static int isofs_readpage(struct file *file, struct page *page)
1056 return block_read_full_page(page,isofs_get_block);
1059 static sector_t _isofs_bmap(struct address_space *mapping, sector_t block)
1061 return generic_block_bmap(mapping,block,isofs_get_block);
1064 static struct address_space_operations isofs_aops = {
1065 .readpage = isofs_readpage,
1066 .sync_page = block_sync_page,
1070 static inline void test_and_set_uid(uid_t *p, uid_t value)
1077 static inline void test_and_set_gid(gid_t *p, gid_t value)
1084 static int isofs_read_level3_size(struct inode * inode)
1086 unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
1087 int high_sierra = ISOFS_SB(inode->i_sb)->s_high_sierra;
1088 struct buffer_head * bh = NULL;
1089 unsigned long block, offset, block_saved, offset_saved;
1091 int more_entries = 0;
1092 struct iso_directory_record * tmpde = NULL;
1093 struct iso_inode_info *ei = ISOFS_I(inode);
1097 /* The first 16 blocks are reserved as the System Area. Thus,
1098 * no inodes can appear in block 0. We use this to flag that
1099 * this is the last section. */
1100 ei->i_next_section_block = 0;
1101 ei->i_next_section_offset = 0;
1103 block = ei->i_iget5_block;
1104 offset = ei->i_iget5_offset;
1107 struct iso_directory_record * de;
1108 unsigned int de_len;
1111 bh = sb_bread(inode->i_sb, block);
1115 de = (struct iso_directory_record *) (bh->b_data + offset);
1116 de_len = *(unsigned char *) de;
1126 block_saved = block;
1127 offset_saved = offset;
1130 /* Make sure we have a full directory entry */
1131 if (offset >= bufsize) {
1132 int slop = bufsize - offset + de_len;
1134 tmpde = kmalloc(256, GFP_KERNEL);
1138 memcpy(tmpde, de, slop);
1139 offset &= bufsize - 1;
1144 bh = sb_bread(inode->i_sb, block);
1147 memcpy((void *) tmpde + slop, bh->b_data, offset);
1152 inode->i_size += isonum_733(de->size);
1154 ei->i_next_section_block = block_saved;
1155 ei->i_next_section_offset = offset_saved;
1158 more_entries = de->flags[-high_sierra] & 0x80;
1163 } while(more_entries);
1177 printk(KERN_INFO "ISOFS: unable to read i-node block %lu\n", block);
1183 printk(KERN_INFO "isofs_read_level3_size: "
1184 "More than 100 file sections ?!?, aborting...\n"
1185 "isofs_read_level3_size: inode=%lu\n",
1190 static void isofs_read_inode(struct inode * inode)
1192 struct super_block *sb = inode->i_sb;
1193 struct isofs_sb_info *sbi = ISOFS_SB(sb);
1194 unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
1195 unsigned long block;
1196 int high_sierra = sbi->s_high_sierra;
1197 struct buffer_head * bh = NULL;
1198 struct iso_directory_record * de;
1199 struct iso_directory_record * tmpde = NULL;
1200 unsigned int de_len;
1201 unsigned long offset;
1202 struct iso_inode_info *ei = ISOFS_I(inode);
1204 block = ei->i_iget5_block;
1205 bh = sb_bread(inode->i_sb, block);
1209 offset = ei->i_iget5_offset;
1211 de = (struct iso_directory_record *) (bh->b_data + offset);
1212 de_len = *(unsigned char *) de;
1214 if (offset + de_len > bufsize) {
1215 int frag1 = bufsize - offset;
1217 tmpde = kmalloc(de_len, GFP_KERNEL);
1218 if (tmpde == NULL) {
1219 printk(KERN_INFO "isofs_read_inode: out of memory\n");
1222 memcpy(tmpde, bh->b_data + offset, frag1);
1224 bh = sb_bread(inode->i_sb, ++block);
1227 memcpy((char *)tmpde+frag1, bh->b_data, de_len - frag1);
1231 inode->i_ino = isofs_get_ino(ei->i_iget5_block,
1233 ISOFS_BUFFER_BITS(inode));
1235 /* Assume it is a normal-format file unless told otherwise */
1236 ei->i_file_format = isofs_file_normal;
1238 if (de->flags[-high_sierra] & 2) {
1239 inode->i_mode = S_IRUGO | S_IXUGO | S_IFDIR;
1240 inode->i_nlink = 1; /* Set to 1. We know there are 2, but
1241 the find utility tries to optimize
1242 if it is 2, and it screws up. It is
1243 easier to give 1 which tells find to
1244 do it the hard way. */
1246 /* Everybody gets to read the file. */
1247 inode->i_mode = sbi->s_mode;
1249 inode->i_mode |= S_IFREG;
1251 inode->i_uid = sbi->s_uid;
1252 inode->i_gid = sbi->s_gid;
1253 inode->i_blocks = inode->i_blksize = 0;
1255 ei->i_format_parm[0] = 0;
1256 ei->i_format_parm[1] = 0;
1257 ei->i_format_parm[2] = 0;
1259 ei->i_section_size = isonum_733 (de->size);
1260 if(de->flags[-high_sierra] & 0x80) {
1261 if(isofs_read_level3_size(inode)) goto fail;
1263 ei->i_next_section_block = 0;
1264 ei->i_next_section_offset = 0;
1265 inode->i_size = isonum_733 (de->size);
1269 * The ISO-9660 filesystem only stores 32 bits for file size.
1270 * mkisofs handles files up to 2GB-2 = 2147483646 = 0x7FFFFFFE bytes
1271 * in size. This is according to the large file summit paper from 1996.
1272 * WARNING: ISO-9660 filesystems > 1 GB and even > 2 GB are fully
1273 * legal. Do not prevent to use DVD's schilling@fokus.gmd.de
1275 if ((inode->i_size < 0 || inode->i_size > 0x7FFFFFFE) &&
1276 sbi->s_cruft == 'n') {
1277 printk(KERN_WARNING "Warning: defective CD-ROM. "
1278 "Enabling \"cruft\" mount option.\n");
1283 * Some dipshit decided to store some other bit of information
1284 * in the high byte of the file length. Catch this and holler.
1285 * WARNING: this will make it impossible for a file to be > 16MB
1289 if (sbi->s_cruft == 'y' &&
1290 inode->i_size & 0xff000000) {
1291 inode->i_size &= 0x00ffffff;
1294 if (de->interleave[0]) {
1295 printk("Interleaved files not (yet) supported.\n");
1299 /* I have no idea what file_unit_size is used for, so
1300 we will flag it for now */
1301 if (de->file_unit_size[0] != 0) {
1302 printk("File unit size != 0 for ISO file (%ld).\n",
1306 /* I have no idea what other flag bits are used for, so
1307 we will flag it for now */
1309 if((de->flags[-high_sierra] & ~2)!= 0){
1310 printk("Unusual flag settings for ISO file (%ld %x).\n",
1311 inode->i_ino, de->flags[-high_sierra]);
1315 inode->i_mtime.tv_sec =
1316 inode->i_atime.tv_sec =
1317 inode->i_ctime.tv_sec = iso_date(de->date, high_sierra);
1318 inode->i_mtime.tv_nsec =
1319 inode->i_atime.tv_nsec =
1320 inode->i_ctime.tv_nsec = 0;
1322 ei->i_first_extent = (isonum_733 (de->extent) +
1323 isonum_711 (de->ext_attr_length));
1325 /* Set the number of blocks for stat() - should be done before RR */
1326 inode->i_blksize = PAGE_CACHE_SIZE; /* For stat() only */
1327 inode->i_blocks = (inode->i_size + 511) >> 9;
1330 * Now test for possible Rock Ridge extensions which will override
1331 * some of these numbers in the inode structure.
1335 parse_rock_ridge_inode(de, inode);
1336 /* if we want uid/gid set, override the rock ridge setting */
1337 test_and_set_uid(&inode->i_uid, sbi->s_uid);
1338 test_and_set_gid(&inode->i_gid, sbi->s_gid);
1341 /* Install the inode operations vector */
1342 if (S_ISREG(inode->i_mode)) {
1343 inode->i_fop = &generic_ro_fops;
1344 switch ( ei->i_file_format ) {
1345 #ifdef CONFIG_ZISOFS
1346 case isofs_file_compressed:
1347 inode->i_data.a_ops = &zisofs_aops;
1351 inode->i_data.a_ops = &isofs_aops;
1354 } else if (S_ISDIR(inode->i_mode)) {
1355 inode->i_op = &isofs_dir_inode_operations;
1356 inode->i_fop = &isofs_dir_operations;
1357 } else if (S_ISLNK(inode->i_mode)) {
1358 inode->i_op = &page_symlink_inode_operations;
1359 inode->i_data.a_ops = &isofs_symlink_aops;
1361 /* XXX - parse_rock_ridge_inode() had already set i_rdev. */
1362 init_special_inode(inode, inode->i_mode, inode->i_rdev);
1372 printk(KERN_WARNING "ISOFS: unable to read i-node block\n");
1374 make_bad_inode(inode);
1378 struct isofs_iget5_callback_data {
1379 unsigned long block;
1380 unsigned long offset;
1383 static int isofs_iget5_test(struct inode *ino, void *data)
1385 struct iso_inode_info *i = ISOFS_I(ino);
1386 struct isofs_iget5_callback_data *d =
1387 (struct isofs_iget5_callback_data*)data;
1388 return (i->i_iget5_block == d->block)
1389 && (i->i_iget5_offset == d->offset);
1392 static int isofs_iget5_set(struct inode *ino, void *data)
1394 struct iso_inode_info *i = ISOFS_I(ino);
1395 struct isofs_iget5_callback_data *d =
1396 (struct isofs_iget5_callback_data*)data;
1397 i->i_iget5_block = d->block;
1398 i->i_iget5_offset = d->offset;
1402 /* Store, in the inode's containing structure, the block and block
1403 * offset that point to the underlying meta-data for the inode. The
1404 * code below is otherwise similar to the iget() code in
1405 * include/linux/fs.h */
1406 struct inode *isofs_iget(struct super_block *sb,
1407 unsigned long block,
1408 unsigned long offset)
1410 unsigned long hashval;
1411 struct inode *inode;
1412 struct isofs_iget5_callback_data data;
1415 data.offset = offset;
1417 hashval = (block << sb->s_blocksize_bits) | offset;
1419 inode = iget5_locked(sb,
1425 if (inode && (inode->i_state & I_NEW)) {
1426 sb->s_op->read_inode(inode);
1427 unlock_new_inode(inode);
1439 void * leak_check_malloc(unsigned int size){
1442 tmp = kmalloc(size, GFP_KERNEL);
1446 void leak_check_free_s(void * obj, int size){
1451 struct buffer_head * leak_check_bread(struct super_block *sb, int block){
1453 return sb_bread(sb, block);
1456 void leak_check_brelse(struct buffer_head * bh){
1463 static struct super_block *isofs_get_sb(struct file_system_type *fs_type,
1464 int flags, const char *dev_name, void *data)
1466 return get_sb_bdev(fs_type, flags, dev_name, data, isofs_fill_super);
1469 static struct file_system_type iso9660_fs_type = {
1470 .owner = THIS_MODULE,
1472 .get_sb = isofs_get_sb,
1473 .kill_sb = kill_block_super,
1474 .fs_flags = FS_REQUIRES_DEV,
1477 static int __init init_iso9660_fs(void)
1479 int err = init_inodecache();
1482 #ifdef CONFIG_ZISOFS
1483 err = zisofs_init();
1487 err = register_filesystem(&iso9660_fs_type);
1492 #ifdef CONFIG_ZISOFS
1496 destroy_inodecache();
1501 static void __exit exit_iso9660_fs(void)
1503 unregister_filesystem(&iso9660_fs_type);
1504 #ifdef CONFIG_ZISOFS
1507 destroy_inodecache();
1510 module_init(init_iso9660_fs)
1511 module_exit(exit_iso9660_fs)
1512 MODULE_LICENSE("GPL");
1513 /* Actual filesystem name is iso9660, as requested in filesystems.c */
1514 MODULE_ALIAS("iso9660");