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/init.h>
15 #include <linux/module.h>
17 #include <linux/slab.h>
18 #include <linux/nls.h>
19 #include <linux/ctype.h>
20 #include <linux/smp_lock.h>
21 #include <linux/statfs.h>
22 #include <linux/cdrom.h>
23 #include <linux/parser.h>
30 static int isofs_hashi(struct dentry *parent, struct qstr *qstr);
31 static int isofs_hash(struct dentry *parent, struct qstr *qstr);
32 static int isofs_dentry_cmpi(struct dentry *dentry, struct qstr *a, struct qstr *b);
33 static int isofs_dentry_cmp(struct dentry *dentry, struct qstr *a, struct qstr *b);
36 static int isofs_hashi_ms(struct dentry *parent, struct qstr *qstr);
37 static int isofs_hash_ms(struct dentry *parent, struct qstr *qstr);
38 static int isofs_dentry_cmpi_ms(struct dentry *dentry, struct qstr *a, struct qstr *b);
39 static int isofs_dentry_cmp_ms(struct dentry *dentry, struct qstr *a, struct qstr *b);
42 static void isofs_put_super(struct super_block *sb)
44 struct isofs_sb_info *sbi = ISOFS_SB(sb);
46 if (sbi->s_nls_iocharset) {
47 unload_nls(sbi->s_nls_iocharset);
48 sbi->s_nls_iocharset = NULL;
57 static void isofs_read_inode(struct inode *);
58 static int isofs_statfs (struct dentry *, struct kstatfs *);
60 static kmem_cache_t *isofs_inode_cachep;
62 static struct inode *isofs_alloc_inode(struct super_block *sb)
64 struct iso_inode_info *ei;
65 ei = kmem_cache_alloc(isofs_inode_cachep, SLAB_KERNEL);
68 return &ei->vfs_inode;
71 static void isofs_destroy_inode(struct inode *inode)
73 kmem_cache_free(isofs_inode_cachep, ISOFS_I(inode));
76 static void init_once(void *foo, kmem_cache_t * cachep, unsigned long flags)
78 struct iso_inode_info *ei = foo;
80 if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
81 SLAB_CTOR_CONSTRUCTOR)
82 inode_init_once(&ei->vfs_inode);
85 static int init_inodecache(void)
87 isofs_inode_cachep = kmem_cache_create("isofs_inode_cache",
88 sizeof(struct iso_inode_info),
89 0, (SLAB_RECLAIM_ACCOUNT|
92 if (isofs_inode_cachep == NULL)
97 static void destroy_inodecache(void)
99 if (kmem_cache_destroy(isofs_inode_cachep))
100 printk(KERN_INFO "iso_inode_cache: not all structures were "
104 static int isofs_remount(struct super_block *sb, int *flags, char *data)
106 /* we probably want a lot more here */
111 static struct super_operations isofs_sops = {
112 .alloc_inode = isofs_alloc_inode,
113 .destroy_inode = isofs_destroy_inode,
114 .read_inode = isofs_read_inode,
115 .put_super = isofs_put_super,
116 .statfs = isofs_statfs,
117 .remount_fs = isofs_remount,
121 static struct dentry_operations isofs_dentry_ops[] = {
123 .d_hash = isofs_hash,
124 .d_compare = isofs_dentry_cmp,
127 .d_hash = isofs_hashi,
128 .d_compare = isofs_dentry_cmpi,
132 .d_hash = isofs_hash_ms,
133 .d_compare = isofs_dentry_cmp_ms,
136 .d_hash = isofs_hashi_ms,
137 .d_compare = isofs_dentry_cmpi_ms,
142 struct iso9660_options{
151 unsigned int blocksize;
163 * Compute the hash for the isofs name corresponding to the dentry.
166 isofs_hash_common(struct dentry *dentry, struct qstr *qstr, int ms)
174 while (len && name[len-1] == '.')
178 qstr->hash = full_name_hash(name, len);
184 * Compute the hash for the isofs name corresponding to the dentry.
187 isofs_hashi_common(struct dentry *dentry, struct qstr *qstr, int ms)
197 while (len && name[len-1] == '.')
201 hash = init_name_hash();
203 c = tolower(*name++);
204 hash = partial_name_hash(tolower(c), hash);
206 qstr->hash = end_name_hash(hash);
212 * Case insensitive compare of two isofs names.
214 static int isofs_dentry_cmpi_common(struct dentry *dentry, struct qstr *a,
215 struct qstr *b, int ms)
219 /* A filename cannot end in '.' or we treat it like it has none */
223 while (alen && a->name[alen-1] == '.')
225 while (blen && b->name[blen-1] == '.')
229 if (strnicmp(a->name, b->name, alen) == 0)
236 * Case sensitive compare of two isofs names.
238 static int isofs_dentry_cmp_common(struct dentry *dentry, struct qstr *a,
239 struct qstr *b, int ms)
243 /* A filename cannot end in '.' or we treat it like it has none */
247 while (alen && a->name[alen-1] == '.')
249 while (blen && b->name[blen-1] == '.')
253 if (strncmp(a->name, b->name, alen) == 0)
260 isofs_hash(struct dentry *dentry, struct qstr *qstr)
262 return isofs_hash_common(dentry, qstr, 0);
266 isofs_hashi(struct dentry *dentry, struct qstr *qstr)
268 return isofs_hashi_common(dentry, qstr, 0);
272 isofs_dentry_cmp(struct dentry *dentry,struct qstr *a,struct qstr *b)
274 return isofs_dentry_cmp_common(dentry, a, b, 0);
278 isofs_dentry_cmpi(struct dentry *dentry,struct qstr *a,struct qstr *b)
280 return isofs_dentry_cmpi_common(dentry, a, b, 0);
285 isofs_hash_ms(struct dentry *dentry, struct qstr *qstr)
287 return isofs_hash_common(dentry, qstr, 1);
291 isofs_hashi_ms(struct dentry *dentry, struct qstr *qstr)
293 return isofs_hashi_common(dentry, qstr, 1);
297 isofs_dentry_cmp_ms(struct dentry *dentry,struct qstr *a,struct qstr *b)
299 return isofs_dentry_cmp_common(dentry, a, b, 1);
303 isofs_dentry_cmpi_ms(struct dentry *dentry,struct qstr *a,struct qstr *b)
305 return isofs_dentry_cmpi_common(dentry, a, b, 1);
310 Opt_block, Opt_check_r, Opt_check_s, Opt_cruft, Opt_gid, Opt_ignore,
311 Opt_iocharset, Opt_map_a, Opt_map_n, Opt_map_o, Opt_mode, Opt_nojoliet,
312 Opt_norock, Opt_sb, Opt_session, Opt_uid, Opt_unhide, Opt_utf8, Opt_err,
313 Opt_nocompress, Opt_hide, Opt_showassoc,
316 static match_table_t tokens = {
317 {Opt_norock, "norock"},
318 {Opt_nojoliet, "nojoliet"},
319 {Opt_unhide, "unhide"},
321 {Opt_showassoc, "showassoc"},
322 {Opt_cruft, "cruft"},
324 {Opt_iocharset, "iocharset=%s"},
325 {Opt_map_a, "map=acorn"},
326 {Opt_map_a, "map=a"},
327 {Opt_map_n, "map=normal"},
328 {Opt_map_n, "map=n"},
329 {Opt_map_o, "map=off"},
330 {Opt_map_o, "map=o"},
331 {Opt_session, "session=%u"},
332 {Opt_sb, "sbsector=%u"},
333 {Opt_check_r, "check=relaxed"},
334 {Opt_check_r, "check=r"},
335 {Opt_check_s, "check=strict"},
336 {Opt_check_s, "check=s"},
339 {Opt_mode, "mode=%u"},
340 {Opt_block, "block=%u"},
341 {Opt_ignore, "conv=binary"},
342 {Opt_ignore, "conv=b"},
343 {Opt_ignore, "conv=text"},
344 {Opt_ignore, "conv=t"},
345 {Opt_ignore, "conv=mtext"},
346 {Opt_ignore, "conv=m"},
347 {Opt_ignore, "conv=auto"},
348 {Opt_ignore, "conv=a"},
349 {Opt_nocompress, "nocompress"},
353 static int parse_options(char *options, struct iso9660_options *popt)
363 popt->showassoc = 'n';
364 popt->check = 'u'; /* unset */
365 popt->nocompress = 0;
366 popt->blocksize = 1024;
367 popt->mode = S_IRUGO | S_IXUGO; /* r-x for all. The disc could
368 be shared with DOS machines so
369 virtually anything could be
370 a valid executable. */
373 popt->iocharset = NULL;
380 while ((p = strsep(&options, ",")) != NULL) {
382 substring_t args[MAX_OPT_ARGS];
388 token = match_token(p, tokens, args);
401 popt->showassoc = 'y';
411 popt->iocharset = match_strdup(&args[0]);
424 if (match_int(&args[0], &option))
429 popt->session = n + 1;
432 if (match_int(&args[0], &option))
434 popt->sbsector = option;
445 if (match_int(&args[0], &option))
450 if (match_int(&args[0], &option))
455 if (match_int(&args[0], &option))
460 if (match_int(&args[0], &option))
463 if (n != 512 && n != 1024 && n != 2048)
468 popt->nocompress = 1;
478 * look if the driver can tell the multi session redirection value
480 * don't change this if you don't know what you do, please!
481 * Multisession is legal only with XA disks.
482 * A non-XA disk with more than one volume descriptor may do it right, but
483 * usually is written in a nowhere standardized "multi-partition" manner.
484 * Multisession uses absolute addressing (solely the first frame of the whole
485 * track is #0), multi-partition uses relative addressing (each first frame of
486 * each track is #0), and a track is not a session.
488 * A broken CDwriter software or drive firmware does not set new standards,
489 * at least not if conflicting with the existing ones.
493 #define WE_OBEY_THE_WRITTEN_STANDARDS 1
495 static unsigned int isofs_get_last_session(struct super_block *sb, s32 session)
497 struct cdrom_multisession ms_info;
498 unsigned int vol_desc_start;
499 struct block_device *bdev = sb->s_bdev;
503 ms_info.addr_format=CDROM_LBA;
504 if(session >= 0 && session <= 99) {
505 struct cdrom_tocentry Te;
506 Te.cdte_track=session;
507 Te.cdte_format=CDROM_LBA;
508 i = ioctl_by_bdev(bdev, CDROMREADTOCENTRY, (unsigned long) &Te);
510 printk(KERN_DEBUG "Session %d start %d type %d\n",
511 session, Te.cdte_addr.lba,
512 Te.cdte_ctrl&CDROM_DATA_TRACK);
513 if ((Te.cdte_ctrl&CDROM_DATA_TRACK) == 4)
514 return Te.cdte_addr.lba;
517 printk(KERN_ERR "Invalid session number or type of track\n");
519 i = ioctl_by_bdev(bdev, CDROMMULTISESSION, (unsigned long) &ms_info);
521 printk(KERN_ERR "Invalid session number\n");
523 printk("isofs.inode: CDROMMULTISESSION: rc=%d\n",i);
525 printk("isofs.inode: XA disk: %s\n",ms_info.xa_flag?"yes":"no");
526 printk("isofs.inode: vol_desc_start = %d\n", ms_info.addr.lba);
530 #if WE_OBEY_THE_WRITTEN_STANDARDS
531 if (ms_info.xa_flag) /* necessary for a valid ms_info.addr */
533 vol_desc_start=ms_info.addr.lba;
534 return vol_desc_start;
538 * Initialize the superblock and read the root inode.
540 * Note: a check_disk_change() has been done immediately prior
541 * to this call, so we don't need to check again.
543 static int isofs_fill_super(struct super_block *s, void *data, int silent)
545 struct buffer_head * bh = NULL, *pri_bh = NULL;
546 struct hs_primary_descriptor * h_pri = NULL;
547 struct iso_primary_descriptor * pri = NULL;
548 struct iso_supplementary_descriptor *sec = NULL;
549 struct iso_directory_record * rootp;
550 int joliet_level = 0;
551 int iso_blknum, block;
554 unsigned int vol_desc_start;
555 unsigned long first_data_zone;
556 struct inode * inode;
557 struct iso9660_options opt;
558 struct isofs_sb_info * sbi;
560 sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
565 if (!parse_options((char *)data, &opt))
569 * First of all, get the hardware blocksize for this device.
570 * If we don't know what it is, or the hardware blocksize is
571 * larger than the blocksize the user specified, then use
575 * What if bugger tells us to go beyond page size?
577 opt.blocksize = sb_min_blocksize(s, opt.blocksize);
579 sbi->s_high_sierra = 0; /* default is iso9660 */
581 vol_desc_start = (opt.sbsector != -1) ?
582 opt.sbsector : isofs_get_last_session(s,opt.session);
584 for (iso_blknum = vol_desc_start+16;
585 iso_blknum < vol_desc_start+100; iso_blknum++)
587 struct hs_volume_descriptor * hdp;
588 struct iso_volume_descriptor * vdp;
590 block = iso_blknum << (ISOFS_BLOCK_BITS - s->s_blocksize_bits);
591 if (!(bh = sb_bread(s, block)))
594 vdp = (struct iso_volume_descriptor *)bh->b_data;
595 hdp = (struct hs_volume_descriptor *)bh->b_data;
597 /* Due to the overlapping physical location of the descriptors,
598 * ISO CDs can match hdp->id==HS_STANDARD_ID as well. To ensure
599 * proper identification in this case, we first check for ISO.
601 if (strncmp (vdp->id, ISO_STANDARD_ID, sizeof vdp->id) == 0) {
602 if (isonum_711 (vdp->type) == ISO_VD_END)
604 if (isonum_711 (vdp->type) == ISO_VD_PRIMARY) {
606 pri = (struct iso_primary_descriptor *)vdp;
607 /* Save the buffer in case we need it ... */
613 else if (isonum_711 (vdp->type) == ISO_VD_SUPPLEMENTARY) {
614 sec = (struct iso_supplementary_descriptor *)vdp;
615 if (sec->escape[0] == 0x25 && sec->escape[1] == 0x2f) {
616 if (opt.joliet == 'y') {
617 if (sec->escape[2] == 0x40) {
619 } else if (sec->escape[2] == 0x43) {
621 } else if (sec->escape[2] == 0x45) {
624 printk(KERN_DEBUG"ISO 9660 Extensions: Microsoft Joliet Level %d\n",
629 /* Unknown supplementary volume descriptor */
635 if (strncmp (hdp->id, HS_STANDARD_ID, sizeof hdp->id) == 0) {
636 if (isonum_711 (hdp->type) != ISO_VD_PRIMARY)
639 sbi->s_high_sierra = 1;
641 h_pri = (struct hs_primary_descriptor *)vdp;
646 /* Just skip any volume descriptors we don't recognize */
652 * If we fall through, either no volume descriptor was found,
653 * or else we passed a primary descriptor looking for others.
656 goto out_unknown_format;
663 if (joliet_level && (pri == NULL || opt.rock == 'n')) {
664 /* This is the case of Joliet with the norock mount flag.
665 * A disc with both Joliet and Rock Ridge is handled later
667 pri = (struct iso_primary_descriptor *) sec;
670 if(sbi->s_high_sierra){
671 rootp = (struct iso_directory_record *) h_pri->root_directory_record;
672 sbi->s_nzones = isonum_733 (h_pri->volume_space_size);
673 sbi->s_log_zone_size = isonum_723 (h_pri->logical_block_size);
674 sbi->s_max_size = isonum_733(h_pri->volume_space_size);
678 rootp = (struct iso_directory_record *) pri->root_directory_record;
679 sbi->s_nzones = isonum_733 (pri->volume_space_size);
680 sbi->s_log_zone_size = isonum_723 (pri->logical_block_size);
681 sbi->s_max_size = isonum_733(pri->volume_space_size);
684 sbi->s_ninodes = 0; /* No way to figure this out easily */
686 orig_zonesize = sbi->s_log_zone_size;
688 * If the zone size is smaller than the hardware sector size,
689 * this is a fatal error. This would occur if the disc drive
690 * had sectors that were 2048 bytes, but the filesystem had
691 * blocks that were 512 bytes (which should only very rarely
694 if(orig_zonesize < opt.blocksize)
697 /* RDE: convert log zone size to bit shift */
698 switch (sbi->s_log_zone_size)
699 { case 512: sbi->s_log_zone_size = 9; break;
700 case 1024: sbi->s_log_zone_size = 10; break;
701 case 2048: sbi->s_log_zone_size = 11; break;
704 goto out_bad_zone_size;
707 s->s_magic = ISOFS_SUPER_MAGIC;
708 s->s_maxbytes = 0xffffffff; /* We can handle files up to 4 GB */
710 /* The CDROM is read-only, has no nodes (devices) on it, and since
711 all of the files appear to be owned by root, we really do not want
712 to allow suid. (suid or devices will not show up unless we have
713 Rock Ridge extensions) */
715 s->s_flags |= MS_RDONLY /* | MS_NODEV | MS_NOSUID */;
717 /* Set this for reference. Its not currently used except on write
718 which we don't have .. */
720 first_data_zone = isonum_733 (rootp->extent) +
721 isonum_711 (rootp->ext_attr_length);
722 sbi->s_firstdatazone = first_data_zone;
724 printk(KERN_DEBUG "Max size:%ld Log zone size:%ld\n",
726 1UL << sbi->s_log_zone_size);
727 printk(KERN_DEBUG "First datazone:%ld\n", sbi->s_firstdatazone);
728 if(sbi->s_high_sierra)
729 printk(KERN_DEBUG "Disc in High Sierra format.\n");
733 * If the Joliet level is set, we _may_ decide to use the
734 * secondary descriptor, but can't be sure until after we
735 * read the root inode. But before reading the root inode
736 * we may need to change the device blocksize, and would
737 * rather release the old buffer first. So, we cache the
738 * first_data_zone value from the secondary descriptor.
741 pri = (struct iso_primary_descriptor *) sec;
742 rootp = (struct iso_directory_record *)
743 pri->root_directory_record;
744 first_data_zone = isonum_733 (rootp->extent) +
745 isonum_711 (rootp->ext_attr_length);
749 * We're all done using the volume descriptor, and may need
750 * to change the device blocksize, so release the buffer now.
756 * Force the blocksize to 512 for 512 byte sectors. The file
757 * read primitives really get it wrong in a bad way if we don't
760 * Note - we should never be setting the blocksize to something
761 * less than the hardware sector size for the device. If we
762 * do, we would end up having to read larger buffers and split
763 * out portions to satisfy requests.
765 * Note2- the idea here is that we want to deal with the optimal
766 * zonesize in the filesystem. If we have it set to something less,
767 * then we have horrible problems with trying to piece together
768 * bits of adjacent blocks in order to properly read directory
769 * entries. By forcing the blocksize in this way, we ensure
770 * that we will never be required to do this.
772 sb_set_blocksize(s, orig_zonesize);
774 sbi->s_nls_iocharset = NULL;
777 if (joliet_level && opt.utf8 == 0) {
778 char * p = opt.iocharset ? opt.iocharset : CONFIG_NLS_DEFAULT;
779 sbi->s_nls_iocharset = load_nls(p);
780 if (! sbi->s_nls_iocharset) {
781 /* Fail only if explicit charset specified */
784 sbi->s_nls_iocharset = load_nls_default();
788 s->s_op = &isofs_sops;
789 s->s_export_op = &isofs_export_ops;
790 sbi->s_mapping = opt.map;
791 sbi->s_rock = (opt.rock == 'y' ? 2 : 0);
792 sbi->s_rock_offset = -1; /* initial offset, will guess until SP is found*/
793 sbi->s_cruft = opt.cruft;
794 sbi->s_hide = opt.hide;
795 sbi->s_showassoc = opt.showassoc;
796 sbi->s_uid = opt.uid;
797 sbi->s_gid = opt.gid;
798 sbi->s_utf8 = opt.utf8;
799 sbi->s_nocompress = opt.nocompress;
801 * It would be incredibly stupid to allow people to mark every file
802 * on the disk as suid, so we merely allow them to set the default
805 sbi->s_mode = opt.mode & 0777;
808 * Read the root inode, which _may_ result in changing
809 * the s_rock flag. Once we have the final s_rock value,
810 * we then decide whether to use the Joliet descriptor.
812 inode = isofs_iget(s, sbi->s_firstdatazone, 0);
815 * If this disk has both Rock Ridge and Joliet on it, then we
816 * want to use Rock Ridge by default. This can be overridden
817 * by using the norock mount option. There is still one other
818 * possibility that is not taken into account: a Rock Ridge
819 * CD with Unicode names. Until someone sees such a beast, it
820 * will not be supported.
822 if (sbi->s_rock == 1) {
824 } else if (joliet_level) {
826 if (sbi->s_firstdatazone != first_data_zone) {
827 sbi->s_firstdatazone = first_data_zone;
829 "ISOFS: changing to secondary root\n");
831 inode = isofs_iget(s, sbi->s_firstdatazone, 0);
835 if (opt.check == 'u') {
836 /* Only Joliet is case insensitive by default */
837 if (joliet_level) opt.check = 'r';
838 else opt.check = 's';
840 sbi->s_joliet_level = joliet_level;
842 /* check the root inode */
847 /* get the root dentry */
848 s->s_root = d_alloc_root(inode);
853 if (joliet_level) table += 2;
854 if (opt.check == 'r') table++;
855 s->s_root->d_op = &isofs_dentry_ops[table];
857 kfree(opt.iocharset);
862 * Display error messages and free resources.
865 printk(KERN_WARNING "isofs_fill_super: root inode not initialized\n");
868 printk(KERN_WARNING "isofs_fill_super: get root inode failed\n");
872 if (sbi->s_nls_iocharset)
873 unload_nls(sbi->s_nls_iocharset);
877 printk(KERN_WARNING "isofs_fill_super: "
878 "bread failed, dev=%s, iso_blknum=%d, block=%d\n",
879 s->s_id, iso_blknum, block);
882 printk(KERN_WARNING "Bad logical zone size %ld\n",
883 sbi->s_log_zone_size);
886 printk(KERN_WARNING "Logical zone size(%d) < hardware blocksize(%u)\n",
887 orig_zonesize, opt.blocksize);
891 printk(KERN_WARNING "Unable to identify CD-ROM format.\n");
896 kfree(opt.iocharset);
902 static int isofs_statfs (struct dentry *dentry, struct kstatfs *buf)
904 struct super_block *sb = dentry->d_sb;
906 buf->f_type = ISOFS_SUPER_MAGIC;
907 buf->f_bsize = sb->s_blocksize;
908 buf->f_blocks = (ISOFS_SB(sb)->s_nzones
909 << (ISOFS_SB(sb)->s_log_zone_size - sb->s_blocksize_bits));
912 buf->f_files = ISOFS_SB(sb)->s_ninodes;
914 buf->f_namelen = NAME_MAX;
919 * Get a set of blocks; filling in buffer_heads if already allocated
920 * or getblk() if they are not. Returns the number of blocks inserted
923 int isofs_get_blocks(struct inode *inode, sector_t iblock_s,
924 struct buffer_head **bh, unsigned long nblocks)
927 unsigned offset, sect_size;
928 unsigned int firstext;
929 unsigned long nextblk, nextoff;
930 long iblock = (long)iblock_s;
932 struct iso_inode_info *ei = ISOFS_I(inode);
937 if (iblock < 0 || iblock != iblock_s) {
938 printk("isofs_get_blocks: block number too large\n");
945 firstext = ei->i_first_extent;
946 sect_size = ei->i_section_size >> ISOFS_BUFFER_BITS(inode);
947 nextblk = ei->i_next_section_block;
948 nextoff = ei->i_next_section_offset;
952 /* If we are *way* beyond the end of the file, print a message.
953 * Access beyond the end of the file up to the next page boundary
954 * is normal, however because of the way the page cache works.
955 * In this case, we just return 0 so that we can properly fill
956 * the page with useless information without generating any
959 if (b_off > ((inode->i_size + PAGE_CACHE_SIZE - 1) >> ISOFS_BUFFER_BITS(inode))) {
960 printk("isofs_get_blocks: block >= EOF (%ld, %ld)\n",
961 iblock, (unsigned long) inode->i_size);
966 while (b_off >= (offset + sect_size)) {
967 struct inode *ninode;
972 ninode = isofs_iget(inode->i_sb, nextblk, nextoff);
975 firstext = ISOFS_I(ninode)->i_first_extent;
976 sect_size = ISOFS_I(ninode)->i_section_size >> ISOFS_BUFFER_BITS(ninode);
977 nextblk = ISOFS_I(ninode)->i_next_section_block;
978 nextoff = ISOFS_I(ninode)->i_next_section_offset;
981 if (++section > 100) {
982 printk("isofs_get_blocks: More than 100 file sections ?!?, aborting...\n");
983 printk("isofs_get_blocks: block=%ld firstext=%u sect_size=%u "
984 "nextblk=%lu nextoff=%lu\n",
985 iblock, firstext, (unsigned) sect_size,
993 map_bh(*bh, inode->i_sb, firstext + b_off - offset);
995 *bh = sb_getblk(inode->i_sb, firstext+b_off-offset);
999 bh++; /* Next buffer head */
1000 b_off++; /* Next buffer offset */
1011 * Used by the standard interfaces.
1013 static int isofs_get_block(struct inode *inode, sector_t iblock,
1014 struct buffer_head *bh_result, int create)
1017 printk("isofs_get_block: Kernel tries to allocate a block\n");
1021 return isofs_get_blocks(inode, iblock, &bh_result, 1) ? 0 : -EIO;
1024 static int isofs_bmap(struct inode *inode, sector_t block)
1026 struct buffer_head dummy;
1030 dummy.b_blocknr = -1000;
1031 error = isofs_get_block(inode, block, &dummy, 0);
1033 return dummy.b_blocknr;
1037 struct buffer_head *isofs_bread(struct inode *inode, sector_t block)
1039 sector_t blknr = isofs_bmap(inode, block);
1042 return sb_bread(inode->i_sb, blknr);
1045 static int isofs_readpage(struct file *file, struct page *page)
1047 return block_read_full_page(page,isofs_get_block);
1050 static sector_t _isofs_bmap(struct address_space *mapping, sector_t block)
1052 return generic_block_bmap(mapping,block,isofs_get_block);
1055 static const struct address_space_operations isofs_aops = {
1056 .readpage = isofs_readpage,
1057 .sync_page = block_sync_page,
1061 static inline void test_and_set_uid(uid_t *p, uid_t value)
1067 static inline void test_and_set_gid(gid_t *p, gid_t value)
1073 static int isofs_read_level3_size(struct inode *inode)
1075 unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
1076 int high_sierra = ISOFS_SB(inode->i_sb)->s_high_sierra;
1077 struct buffer_head * bh = NULL;
1078 unsigned long block, offset, block_saved, offset_saved;
1080 int more_entries = 0;
1081 struct iso_directory_record * tmpde = NULL;
1082 struct iso_inode_info *ei = ISOFS_I(inode);
1086 /* The first 16 blocks are reserved as the System Area. Thus,
1087 * no inodes can appear in block 0. We use this to flag that
1088 * this is the last section. */
1089 ei->i_next_section_block = 0;
1090 ei->i_next_section_offset = 0;
1092 block = ei->i_iget5_block;
1093 offset = ei->i_iget5_offset;
1096 struct iso_directory_record * de;
1097 unsigned int de_len;
1100 bh = sb_bread(inode->i_sb, block);
1104 de = (struct iso_directory_record *) (bh->b_data + offset);
1105 de_len = *(unsigned char *) de;
1115 block_saved = block;
1116 offset_saved = offset;
1119 /* Make sure we have a full directory entry */
1120 if (offset >= bufsize) {
1121 int slop = bufsize - offset + de_len;
1123 tmpde = kmalloc(256, GFP_KERNEL);
1127 memcpy(tmpde, de, slop);
1128 offset &= bufsize - 1;
1133 bh = sb_bread(inode->i_sb, block);
1136 memcpy((void *)tmpde+slop, bh->b_data, offset);
1141 inode->i_size += isonum_733(de->size);
1143 ei->i_next_section_block = block_saved;
1144 ei->i_next_section_offset = offset_saved;
1147 more_entries = de->flags[-high_sierra] & 0x80;
1152 } while (more_entries);
1165 printk(KERN_INFO "ISOFS: unable to read i-node block %lu\n", block);
1170 printk(KERN_INFO "isofs_read_level3_size: "
1171 "More than 100 file sections ?!?, aborting...\n"
1172 "isofs_read_level3_size: inode=%lu\n",
1177 static void isofs_read_inode(struct inode *inode)
1179 struct super_block *sb = inode->i_sb;
1180 struct isofs_sb_info *sbi = ISOFS_SB(sb);
1181 unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
1182 unsigned long block;
1183 int high_sierra = sbi->s_high_sierra;
1184 struct buffer_head * bh = NULL;
1185 struct iso_directory_record * de;
1186 struct iso_directory_record * tmpde = NULL;
1187 unsigned int de_len;
1188 unsigned long offset;
1189 struct iso_inode_info *ei = ISOFS_I(inode);
1191 block = ei->i_iget5_block;
1192 bh = sb_bread(inode->i_sb, block);
1196 offset = ei->i_iget5_offset;
1198 de = (struct iso_directory_record *) (bh->b_data + offset);
1199 de_len = *(unsigned char *) de;
1201 if (offset + de_len > bufsize) {
1202 int frag1 = bufsize - offset;
1204 tmpde = kmalloc(de_len, GFP_KERNEL);
1205 if (tmpde == NULL) {
1206 printk(KERN_INFO "isofs_read_inode: out of memory\n");
1209 memcpy(tmpde, bh->b_data + offset, frag1);
1211 bh = sb_bread(inode->i_sb, ++block);
1214 memcpy((char *)tmpde+frag1, bh->b_data, de_len - frag1);
1218 inode->i_ino = isofs_get_ino(ei->i_iget5_block,
1220 ISOFS_BUFFER_BITS(inode));
1222 /* Assume it is a normal-format file unless told otherwise */
1223 ei->i_file_format = isofs_file_normal;
1225 if (de->flags[-high_sierra] & 2) {
1226 inode->i_mode = S_IRUGO | S_IXUGO | S_IFDIR;
1227 inode->i_nlink = 1; /* Set to 1. We know there are 2, but
1228 the find utility tries to optimize
1229 if it is 2, and it screws up. It is
1230 easier to give 1 which tells find to
1231 do it the hard way. */
1233 /* Everybody gets to read the file. */
1234 inode->i_mode = sbi->s_mode;
1236 inode->i_mode |= S_IFREG;
1238 inode->i_uid = sbi->s_uid;
1239 inode->i_gid = sbi->s_gid;
1240 inode->i_blocks = inode->i_blksize = 0;
1242 ei->i_format_parm[0] = 0;
1243 ei->i_format_parm[1] = 0;
1244 ei->i_format_parm[2] = 0;
1246 ei->i_section_size = isonum_733 (de->size);
1247 if (de->flags[-high_sierra] & 0x80) {
1248 if(isofs_read_level3_size(inode)) goto fail;
1250 ei->i_next_section_block = 0;
1251 ei->i_next_section_offset = 0;
1252 inode->i_size = isonum_733 (de->size);
1256 * Some dipshit decided to store some other bit of information
1257 * in the high byte of the file length. Truncate size in case
1258 * this CDROM was mounted with the cruft option.
1261 if (sbi->s_cruft == 'y')
1262 inode->i_size &= 0x00ffffff;
1264 if (de->interleave[0]) {
1265 printk("Interleaved files not (yet) supported.\n");
1269 /* I have no idea what file_unit_size is used for, so
1270 we will flag it for now */
1271 if (de->file_unit_size[0] != 0) {
1272 printk("File unit size != 0 for ISO file (%ld).\n",
1276 /* I have no idea what other flag bits are used for, so
1277 we will flag it for now */
1279 if((de->flags[-high_sierra] & ~2)!= 0){
1280 printk("Unusual flag settings for ISO file (%ld %x).\n",
1281 inode->i_ino, de->flags[-high_sierra]);
1285 inode->i_mtime.tv_sec =
1286 inode->i_atime.tv_sec =
1287 inode->i_ctime.tv_sec = iso_date(de->date, high_sierra);
1288 inode->i_mtime.tv_nsec =
1289 inode->i_atime.tv_nsec =
1290 inode->i_ctime.tv_nsec = 0;
1292 ei->i_first_extent = (isonum_733 (de->extent) +
1293 isonum_711 (de->ext_attr_length));
1295 /* Set the number of blocks for stat() - should be done before RR */
1296 inode->i_blksize = PAGE_CACHE_SIZE; /* For stat() only */
1297 inode->i_blocks = (inode->i_size + 511) >> 9;
1300 * Now test for possible Rock Ridge extensions which will override
1301 * some of these numbers in the inode structure.
1305 parse_rock_ridge_inode(de, inode);
1306 /* if we want uid/gid set, override the rock ridge setting */
1307 test_and_set_uid(&inode->i_uid, sbi->s_uid);
1308 test_and_set_gid(&inode->i_gid, sbi->s_gid);
1311 /* Install the inode operations vector */
1312 if (S_ISREG(inode->i_mode)) {
1313 inode->i_fop = &generic_ro_fops;
1314 switch ( ei->i_file_format ) {
1315 #ifdef CONFIG_ZISOFS
1316 case isofs_file_compressed:
1317 inode->i_data.a_ops = &zisofs_aops;
1321 inode->i_data.a_ops = &isofs_aops;
1324 } else if (S_ISDIR(inode->i_mode)) {
1325 inode->i_op = &isofs_dir_inode_operations;
1326 inode->i_fop = &isofs_dir_operations;
1327 } else if (S_ISLNK(inode->i_mode)) {
1328 inode->i_op = &page_symlink_inode_operations;
1329 inode->i_data.a_ops = &isofs_symlink_aops;
1331 /* XXX - parse_rock_ridge_inode() had already set i_rdev. */
1332 init_special_inode(inode, inode->i_mode, inode->i_rdev);
1341 printk(KERN_WARNING "ISOFS: unable to read i-node block\n");
1343 make_bad_inode(inode);
1347 struct isofs_iget5_callback_data {
1348 unsigned long block;
1349 unsigned long offset;
1352 static int isofs_iget5_test(struct inode *ino, void *data)
1354 struct iso_inode_info *i = ISOFS_I(ino);
1355 struct isofs_iget5_callback_data *d =
1356 (struct isofs_iget5_callback_data*)data;
1357 return (i->i_iget5_block == d->block)
1358 && (i->i_iget5_offset == d->offset);
1361 static int isofs_iget5_set(struct inode *ino, void *data)
1363 struct iso_inode_info *i = ISOFS_I(ino);
1364 struct isofs_iget5_callback_data *d =
1365 (struct isofs_iget5_callback_data*)data;
1366 i->i_iget5_block = d->block;
1367 i->i_iget5_offset = d->offset;
1371 /* Store, in the inode's containing structure, the block and block
1372 * offset that point to the underlying meta-data for the inode. The
1373 * code below is otherwise similar to the iget() code in
1374 * include/linux/fs.h */
1375 struct inode *isofs_iget(struct super_block *sb,
1376 unsigned long block,
1377 unsigned long offset)
1379 unsigned long hashval;
1380 struct inode *inode;
1381 struct isofs_iget5_callback_data data;
1383 if (offset >= 1ul << sb->s_blocksize_bits)
1387 data.offset = offset;
1389 hashval = (block << sb->s_blocksize_bits) | offset;
1391 inode = iget5_locked(sb, hashval, &isofs_iget5_test,
1392 &isofs_iget5_set, &data);
1394 if (inode && (inode->i_state & I_NEW)) {
1395 sb->s_op->read_inode(inode);
1396 unlock_new_inode(inode);
1402 static int isofs_get_sb(struct file_system_type *fs_type,
1403 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
1405 return get_sb_bdev(fs_type, flags, dev_name, data, isofs_fill_super,
1409 static struct file_system_type iso9660_fs_type = {
1410 .owner = THIS_MODULE,
1412 .get_sb = isofs_get_sb,
1413 .kill_sb = kill_block_super,
1414 .fs_flags = FS_REQUIRES_DEV,
1417 static int __init init_iso9660_fs(void)
1419 int err = init_inodecache();
1422 #ifdef CONFIG_ZISOFS
1423 err = zisofs_init();
1427 err = register_filesystem(&iso9660_fs_type);
1432 #ifdef CONFIG_ZISOFS
1436 destroy_inodecache();
1441 static void __exit exit_iso9660_fs(void)
1443 unregister_filesystem(&iso9660_fs_type);
1444 #ifdef CONFIG_ZISOFS
1447 destroy_inodecache();
1450 module_init(init_iso9660_fs)
1451 module_exit(exit_iso9660_fs)
1452 MODULE_LICENSE("GPL");
1453 /* Actual filesystem name is iso9660, as requested in filesystems.c */
1454 MODULE_ALIAS("iso9660");