blob: d800d59ffcda1ba8318492307435d19585f714f3 [file] [log] [blame]
/*
* linux/fs/isofs/inode.c
*
* (C) 1992 Eric Youngdale Modified for ISO9660 filesystem.
*
* (C) 1991 Linus Torvalds - minix filesystem
*/
#include <linux/config.h>
#include <linux/stat.h>
#include <linux/sched.h>
#include <linux/iso_fs.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/mm.h>
#include <linux/string.h>
#include <linux/locks.h>
#include <linux/malloc.h>
#include <linux/errno.h>
#include <asm/system.h>
#include <asm/segment.h>
#if defined(CONFIG_BLK_DEV_SR)
extern int check_cdrom_media_change(int, int);
#endif
#if defined(CONFIG_CDU31A)
extern int check_cdu31a_media_change(int, int);
#endif
#if defined(CONFIG_MCD)
extern int check_mcd_media_change(int, int);
#endif
#if defined (CONFIG_SBPCD)
extern int check_sbpcd_media_change(int, int);
#endif CONFIG_SBPCD
#ifdef LEAK_CHECK
static int check_malloc = 0;
static int check_bread = 0;
#endif
void isofs_put_super(struct super_block *sb)
{
lock_super(sb);
#ifdef LEAK_CHECK
printk("Outstanding mallocs:%d, outstanding buffers: %d\n",
check_malloc, check_bread);
#endif
sb->s_dev = 0;
unlock_super(sb);
return;
}
static struct super_operations isofs_sops = {
isofs_read_inode,
NULL, /* notify_change */
NULL, /* write_inode */
NULL, /* put_inode */
isofs_put_super,
NULL, /* write_super */
isofs_statfs,
NULL
};
static int parse_options(char *options,char *map,char *conversion, char * rock, char * cruft, unsigned int * blocksize)
{
char *this_char,*value;
*map = 'n';
*rock = 'y';
*cruft = 'n';
*conversion = 'a';
*blocksize = 1024;
if (!options) return 1;
for (this_char = strtok(options,","); this_char; this_char = strtok(NULL,",")) {
if (strncmp(this_char,"norock",6) == 0) {
*rock = 'n';
continue;
};
if (strncmp(this_char,"cruft",5) == 0) {
*cruft = 'y';
continue;
};
if ((value = strchr(this_char,'=')) != NULL)
*value++ = 0;
if (!strcmp(this_char,"map") && value) {
if (value[0] && !value[1] && strchr("on",*value))
*map = *value;
else if (!strcmp(value,"off")) *map = 'o';
else if (!strcmp(value,"normal")) *map = 'n';
else return 0;
}
else if (!strcmp(this_char,"conv") && value) {
if (value[0] && !value[1] && strchr("bta",*value))
*conversion = *value;
else if (!strcmp(value,"binary")) *conversion = 'b';
else if (!strcmp(value,"text")) *conversion = 't';
else if (!strcmp(value,"mtext")) *conversion = 'm';
else if (!strcmp(value,"auto")) *conversion = 'a';
else return 0;
}
else if (!strcmp(this_char,"block") && value) {
char * vpnt = value;
unsigned int ivalue;
ivalue = 0;
while(*vpnt){
if(*vpnt < '0' || *vpnt > '9') break;
ivalue = ivalue * 10 + (*vpnt - '0');
vpnt++;
};
if (*vpnt) return 0;
if (ivalue != 1024 && ivalue != 2048) return 0;
*blocksize = ivalue;
}
else return 0;
}
return 1;
}
struct super_block *isofs_read_super(struct super_block *s,void *data,
int silent)
{
struct buffer_head *bh;
int iso_blknum;
unsigned int blocksize, blocksize_bits;
int high_sierra;
int dev=s->s_dev;
struct iso_volume_descriptor *vdp;
struct hs_volume_descriptor *hdp;
struct iso_primary_descriptor *pri = NULL;
struct hs_primary_descriptor *h_pri = NULL;
struct iso_directory_record *rootp;
char map, conversion, rock, cruft;
if (!parse_options((char *) data,&map,&conversion, &rock, &cruft, &blocksize)) {
s->s_dev = 0;
return NULL;
}
blocksize_bits = 0;
{
int i = blocksize;
while (i != 1){
blocksize_bits++;
i >>=1;
};
};
set_blocksize(dev, blocksize);
lock_super(s);
s->u.isofs_sb.s_high_sierra = high_sierra = 0; /* default is iso9660 */
for (iso_blknum = 16; iso_blknum < 100; iso_blknum++) {
if (!(bh = bread(dev, iso_blknum << (ISOFS_BLOCK_BITS-blocksize_bits), blocksize))) {
s->s_dev=0;
printk("isofs_read_super: bread failed, dev 0x%x iso_blknum %d\n",
dev, iso_blknum);
unlock_super(s);
return NULL;
}
vdp = (struct iso_volume_descriptor *)bh->b_data;
hdp = (struct hs_volume_descriptor *)bh->b_data;
if (strncmp (hdp->id, HS_STANDARD_ID, sizeof hdp->id) == 0) {
if (isonum_711 (hdp->type) != ISO_VD_PRIMARY)
goto out;
if (isonum_711 (hdp->type) == ISO_VD_END)
goto out;
s->u.isofs_sb.s_high_sierra = 1;
high_sierra = 1;
rock = 'n';
h_pri = (struct hs_primary_descriptor *)vdp;
break;
};
if (strncmp (vdp->id, ISO_STANDARD_ID, sizeof vdp->id) == 0) {
if (isonum_711 (vdp->type) != ISO_VD_PRIMARY)
goto out;
if (isonum_711 (vdp->type) == ISO_VD_END)
goto out;
pri = (struct iso_primary_descriptor *)vdp;
break;
};
brelse(bh);
}
if(iso_blknum == 100) {
if (!silent)
printk("Unable to identify CD-ROM format.\n");
s->s_dev = 0;
unlock_super(s);
return NULL;
};
if(high_sierra){
rootp = (struct iso_directory_record *) h_pri->root_directory_record;
if (isonum_723 (h_pri->volume_set_size) != 1) {
printk("Multi-volume disks not (yet) supported.\n");
goto out;
};
s->u.isofs_sb.s_nzones = isonum_733 (h_pri->volume_space_size);
s->u.isofs_sb.s_log_zone_size = isonum_723 (h_pri->logical_block_size);
s->u.isofs_sb.s_max_size = isonum_733(h_pri->volume_space_size);
} else {
rootp = (struct iso_directory_record *) pri->root_directory_record;
if (isonum_723 (pri->volume_set_size) != 1) {
printk("Multi-volume disks not (yet) supported.\n");
goto out;
};
s->u.isofs_sb.s_nzones = isonum_733 (pri->volume_space_size);
s->u.isofs_sb.s_log_zone_size = isonum_723 (pri->logical_block_size);
s->u.isofs_sb.s_max_size = isonum_733(pri->volume_space_size);
}
s->u.isofs_sb.s_ninodes = 0; /* No way to figure this out easily */
s->u.isofs_sb.s_firstdatazone = isonum_733( rootp->extent) <<
(ISOFS_BLOCK_BITS - blocksize_bits);
s->s_magic = ISOFS_SUPER_MAGIC;
/* The CDROM is read-only, has no nodes (devices) on it, and since
all of the files appear to be owned by root, we really do not want
to allow suid. (suid or devices will not show up unless we have
Rock Ridge extensions) */
s->s_flags = MS_RDONLY /* | MS_NODEV | MS_NOSUID */;
if(s->u.isofs_sb.s_log_zone_size != (1 << ISOFS_BLOCK_BITS)) {
printk("1 <<Block bits != Block size\n");
goto out;
};
brelse(bh);
printk("Max size:%ld Log zone size:%ld\n",
s->u.isofs_sb.s_max_size,
s->u.isofs_sb.s_log_zone_size);
printk("First datazone:%ld Root inode number %d\n",
s->u.isofs_sb.s_firstdatazone,
isonum_733 (rootp->extent) << ISOFS_BLOCK_BITS);
if(high_sierra) printk("Disc in High Sierra format.\n");
unlock_super(s);
/* set up enough so that it can read an inode */
s->s_dev = dev;
s->s_op = &isofs_sops;
s->u.isofs_sb.s_mapping = map;
s->u.isofs_sb.s_rock = (rock == 'y' ? 1 : 0);
s->u.isofs_sb.s_conversion = conversion;
s->u.isofs_sb.s_cruft = cruft;
s->s_blocksize = blocksize;
s->s_blocksize_bits = blocksize_bits;
s->s_mounted = iget(s, isonum_733 (rootp->extent) << ISOFS_BLOCK_BITS);
unlock_super(s);
if (!(s->s_mounted)) {
s->s_dev=0;
printk("get root inode failed\n");
return NULL;
}
#if defined(CONFIG_BLK_DEV_SR) && defined(CONFIG_SCSI)
if (MAJOR(s->s_dev) == SCSI_CDROM_MAJOR) {
/* Check this one more time. */
if(check_cdrom_media_change(s->s_dev, 0))
goto out;
}
#endif
#if defined(CONFIG_CDU31A)
if (MAJOR(s->s_dev) == CDU31A_CDROM_MAJOR) {
/* Check this one more time. */
if(check_cdu31a_media_change(s->s_dev, 0))
goto out;
}
#endif
#if defined(CONFIG_MCD)
if (MAJOR(s->s_dev) == MITSUMI_CDROM_MAJOR) {
/* Check this one more time. */
if(check_mcd_media_change(s->s_dev, 0))
goto out;
}
#endif
#if defined(CONFIG_SBPCD)
if (MAJOR(s->s_dev) == MATSUSHITA_CDROM_MAJOR) {
if (check_sbpcd_media_change(s->s_dev,0))
goto out;
};
#endif CONFIG_SBPCD
return s;
out: /* Kick out for various error conditions */
brelse(bh);
s->s_dev = 0;
unlock_super(s);
return NULL;
}
void isofs_statfs (struct super_block *sb, struct statfs *buf)
{
put_fs_long(ISOFS_SUPER_MAGIC, &buf->f_type);
put_fs_long(1 << ISOFS_BLOCK_BITS, &buf->f_bsize);
put_fs_long(sb->u.isofs_sb.s_nzones, &buf->f_blocks);
put_fs_long(0, &buf->f_bfree);
put_fs_long(0, &buf->f_bavail);
put_fs_long(sb->u.isofs_sb.s_ninodes, &buf->f_files);
put_fs_long(0, &buf->f_ffree);
put_fs_long(NAME_MAX, &buf->f_namelen);
/* Don't know what value to put in buf->f_fsid */
}
int isofs_bmap(struct inode * inode,int block)
{
if (block<0) {
printk("_isofs_bmap: block<0");
return 0;
}
return inode->u.isofs_i.i_first_extent + block;
}
void isofs_read_inode(struct inode * inode)
{
unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
struct buffer_head * bh;
struct iso_directory_record * raw_inode;
unsigned char *pnt = NULL;
void *cpnt = NULL;
int high_sierra;
int block;
int i;
block = inode->i_ino >> ISOFS_BUFFER_BITS(inode);
if (!(bh=bread(inode->i_dev,block, bufsize))) {
printk("unable to read i-node block");
goto fail;
};
pnt = ((unsigned char *) bh->b_data
+ (inode->i_ino & (bufsize - 1)));
raw_inode = ((struct iso_directory_record *) pnt);
high_sierra = inode->i_sb->u.isofs_sb.s_high_sierra;
if ((inode->i_ino & (bufsize - 1)) + *pnt > bufsize){
cpnt = kmalloc(1 << ISOFS_BLOCK_BITS, GFP_KERNEL);
memcpy(cpnt, bh->b_data, bufsize);
brelse(bh);
if (!(bh = bread(inode->i_dev,++block, bufsize))) {
kfree_s (cpnt, 1 << ISOFS_BLOCK_BITS);
printk("unable to read i-node block");
goto fail;
};
memcpy((char *)cpnt + bufsize, bh->b_data, bufsize);
pnt = ((unsigned char *) cpnt
+ (inode->i_ino & (bufsize - 1)));
raw_inode = ((struct iso_directory_record *) pnt);
};
inode->i_mode = S_IRUGO; /* Everybody gets to read the file. */
inode->i_nlink = 1;
if (raw_inode->flags[-high_sierra] & 2) {
inode->i_mode = S_IRUGO | S_IXUGO | S_IFDIR;
inode->i_nlink = 2; /* There are always at least 2. It is
hard to figure out what is correct*/
} else {
inode->i_mode = S_IRUGO; /* Everybody gets to read the file. */
inode->i_nlink = 1;
inode->i_mode |= S_IFREG;
/* If there are no periods in the name, then set the execute permission bit */
for(i=0; i< raw_inode->name_len[0]; i++)
if(raw_inode->name[i]=='.' || raw_inode->name[i]==';')
break;
if(i == raw_inode->name_len[0] || raw_inode->name[i] == ';')
inode->i_mode |= S_IXUGO; /* execute permission */
};
inode->i_uid = 0;
inode->i_gid = 0;
inode->i_size = isonum_733 (raw_inode->size);
/* There are defective discs out there - we do this to protect
ourselves. A cdrom will never contain more than 700Mb */
if((inode->i_size < 0 || inode->i_size > 700000000) &&
inode->i_sb->u.isofs_sb.s_cruft == 'n') {
printk("Warning: defective cdrom. Enabling \"cruft\" mount option.\n");
inode->i_sb->u.isofs_sb.s_cruft = 'y';
};
/* Some dipshit decided to store some other bit of information in the high
byte of the file length. Catch this and holler. WARNING: this will make
it impossible for a file to be > 16Mb on the CDROM!!!*/
if(inode->i_sb->u.isofs_sb.s_cruft == 'y' &&
inode->i_size & 0xff000000){
/* printk("Illegal format on cdrom. Pester manufacturer.\n"); */
inode->i_size &= 0x00ffffff;
};
if (raw_inode->interleave[0]) {
printk("Interleaved files not (yet) supported.\n");
inode->i_size = 0;
};
#ifdef DEBUG
/* I have no idea what extended attributes are used for, so
we will flag it for now */
if(raw_inode->ext_attr_length[0] != 0){
printk("Extended attributes present for ISO file (%ld).\n",
inode->i_ino);
}
#endif
/* I have no idea what file_unit_size is used for, so
we will flag it for now */
if(raw_inode->file_unit_size[0] != 0){
printk("File unit size != 0 for ISO file (%ld).\n",inode->i_ino);
}
/* I have no idea what other flag bits are used for, so
we will flag it for now */
if((raw_inode->flags[-high_sierra] & ~2)!= 0){
printk("Unusual flag settings for ISO file (%ld %x).\n",
inode->i_ino, raw_inode->flags[-high_sierra]);
}
#ifdef DEBUG
printk("Get inode %d: %d %d: %d\n",inode->i_ino, block,
((int)pnt) & 0x3ff, inode->i_size);
#endif
inode->i_mtime = inode->i_atime = inode->i_ctime =
iso_date(raw_inode->date, high_sierra);
inode->u.isofs_i.i_first_extent = isonum_733 (raw_inode->extent) <<
(ISOFS_BLOCK_BITS - ISOFS_BUFFER_BITS(inode));
inode->u.isofs_i.i_backlink = 0xffffffff; /* Will be used for previous directory */
switch (inode->i_sb->u.isofs_sb.s_conversion){
case 'a':
inode->u.isofs_i.i_file_format = ISOFS_FILE_UNKNOWN; /* File type */
break;
case 'b':
inode->u.isofs_i.i_file_format = ISOFS_FILE_BINARY; /* File type */
break;
case 't':
inode->u.isofs_i.i_file_format = ISOFS_FILE_TEXT; /* File type */
break;
case 'm':
inode->u.isofs_i.i_file_format = ISOFS_FILE_TEXT_M; /* File type */
break;
};
/* Now test for possible Rock Ridge extensions which will override some of
these numbers in the inode structure. */
if (!high_sierra)
parse_rock_ridge_inode(raw_inode, inode);
#ifdef DEBUG
printk("Inode: %x extent: %x\n",inode->i_ino, inode->u.isofs_i.i_first_extent);
#endif
brelse(bh);
if (cpnt) {
kfree_s (cpnt, 1 << ISOFS_BLOCK_BITS);
cpnt = NULL;
};
inode->i_op = NULL;
if (inode->i_sb->u.isofs_sb.s_cruft != 'y' &&
isonum_723 (raw_inode->volume_sequence_number) != 1) {
printk("Multi volume CD somehow got mounted.\n");
} else {
if (S_ISREG(inode->i_mode))
inode->i_op = &isofs_file_inode_operations;
else if (S_ISDIR(inode->i_mode))
inode->i_op = &isofs_dir_inode_operations;
else if (S_ISLNK(inode->i_mode))
inode->i_op = &isofs_symlink_inode_operations;
else if (S_ISCHR(inode->i_mode))
inode->i_op = &chrdev_inode_operations;
else if (S_ISBLK(inode->i_mode))
inode->i_op = &blkdev_inode_operations;
else if (S_ISFIFO(inode->i_mode))
init_fifo(inode);
}
return;
fail:
/* With a data error we return this information */
inode->i_mtime = inode->i_atime = inode->i_ctime = 0;
inode->u.isofs_i.i_first_extent = 0;
inode->u.isofs_i.i_backlink = 0xffffffff;
inode->i_size = 0;
inode->i_nlink = 1;
inode->i_uid = inode->i_gid = 0;
inode->i_mode = S_IFREG; /*Regular file, noone gets to read*/
inode->i_op = NULL;
return;
}
/* There are times when we need to know the inode number of a parent of
a particular directory. When control passes through a routine that
has access to the parent information, it fills it into the inode structure,
but sometimes the inode gets flushed out of the queue, and someone
remmembers the number. When they try to open up again, we have lost
the information. The '..' entry on the disc points to the data area
for a particular inode, so we can follow these links back up, but since
we do not know the inode number, we do not actually know how large the
directory is. The disc is almost always correct, and there is
enough error checking on the drive itself, but an open ended search
makes me a little nervous.
The bsd iso filesystem uses the extent number for an inode, and this
would work really nicely for us except that the read_inode function
would not have any clean way of finding the actual directory record
that goes with the file. If we had such info, then it would pay
to change the inode numbers and eliminate this function.
*/
int isofs_lookup_grandparent(struct inode * parent, int extent)
{
unsigned long bufsize = ISOFS_BUFFER_SIZE(parent);
unsigned char bufbits = ISOFS_BUFFER_BITS(parent);
unsigned int block,offset;
int parent_dir, inode_number;
int old_offset;
void * cpnt = NULL;
int result;
struct buffer_head * bh;
struct iso_directory_record * de;
offset = 0;
block = extent << (ISOFS_BLOCK_BITS - bufbits);
if (!(bh = bread(parent->i_dev, block, bufsize))) return -1;
while (1 == 1) {
de = (struct iso_directory_record *) (bh->b_data + offset);
if (*((unsigned char *) de) == 0)
{
brelse(bh);
return -1;
}
offset += *((unsigned char *) de);
if (offset >= bufsize)
{
printk(".. Directory not in first block"
" of directory.\n");
brelse(bh);
return -1;
}
if (de->name_len[0] == 1 && de->name[0] == 1)
{
parent_dir = find_rock_ridge_relocation(de, parent);
brelse(bh);
break;
}
}
#ifdef DEBUG
printk("Parent dir:%x\n",parent_dir);
#endif
/* Now we know the extent where the parent dir starts on. We have no
idea how long it is, so we just start reading until we either find
it or we find some kind of unreasonable circumstance. */
result = -1;
offset = 0;
block = parent_dir << (ISOFS_BLOCK_BITS - bufbits);
if (!block || !(bh = bread(parent->i_dev,block, bufsize)))
return -1;
for(;;)
{
de = (struct iso_directory_record *) (bh->b_data + offset);
inode_number = (block << bufbits)+(offset & (bufsize - 1));
/* If the length byte is zero, we should move on to the next
CDROM sector. If we are at the end of the directory, we
kick out of the while loop. */
if (*((unsigned char *) de) == 0)
{
brelse(bh);
offset = 0;
block++;
if(block & 1) return -1;
if (!block
|| !(bh = bread(parent->i_dev,block, bufsize)))
return -1;
continue;
}
/* Make sure that the entire directory record is in the current
bh block. If not, we malloc a buffer, and put the two
halves together, so that we can cleanly read the block. */
old_offset = offset;
offset += *((unsigned char *) de);
if (offset >= bufsize)
{
if((block & 1) != 0) return -1;
cpnt = kmalloc(1<<ISOFS_BLOCK_BITS,GFP_KERNEL);
memcpy(cpnt, bh->b_data, bufsize);
de = (struct iso_directory_record *)
((char *)cpnt + old_offset);
brelse(bh);
offset -= bufsize;
block++;
if (!(bh = bread(parent->i_dev,block,bufsize))) {
kfree_s(cpnt, 1 << ISOFS_BLOCK_BITS);
return -1;
};
memcpy((char *)cpnt+bufsize, bh->b_data, bufsize);
}
if (find_rock_ridge_relocation(de, parent) == extent){
result = inode_number;
goto out;
}
if (cpnt) {
kfree_s(cpnt, 1 << ISOFS_BLOCK_BITS);
cpnt = NULL;
}
}
/* We go here for any condition we cannot handle.
We also drop through to here at the end of the directory. */
out:
if (cpnt) {
kfree_s(cpnt, 1 << ISOFS_BLOCK_BITS);
cpnt = NULL;
}
brelse(bh);
#ifdef DEBUG
printk("Resultant Inode %d\n",result);
#endif
return result;
}
#ifdef LEAK_CHECK
#undef malloc
#undef free_s
#undef bread
#undef brelse
void * leak_check_malloc(unsigned int size){
void * tmp;
check_malloc++;
tmp = kmalloc(size, GFP_KERNEL);
return tmp;
}
void leak_check_free_s(void * obj, int size){
check_malloc--;
return kfree_s(obj, size);
}
struct buffer_head * leak_check_bread(int dev, int block, int size){
check_bread++;
return bread(dev, block, size);
}
void leak_check_brelse(struct buffer_head * bh){
check_bread--;
return brelse(bh);
}
#endif