static int parent_inode_number(struct inode * inode, struct iso_directory_record * de)
{
int inode_number = inode->i_ino;
if ((inode->i_sb->u.isofs_sb.s_firstdatazone) != inode->i_ino)
inode_number = inode->u.isofs_i.i_backlink;
if (inode_number != -1)
return inode_number;
/* This should never happen, but who knows. Try to be forgiving */
return isofs_lookup_grandparent(inode, find_rock_ridge_relocation(de, inode));
}
/*
* isofs_find_entry()
*
* finds an entry in the specified directory with the wanted name. It
* returns the cache buffer in which the entry was found, and the entry
* itself (as an inode number). It does NOT read the inode of the
* entry - you'll have to do that yourself if you want to.
*/
static struct buffer_head *
isofs_find_entry(struct inode *dir, struct dentry *dentry, unsigned long *ino)
{
unsigned long bufsize = ISOFS_BUFFER_SIZE(dir);
unsigned char bufbits = ISOFS_BUFFER_BITS(dir);
unsigned int block, i, f_pos, offset,
inode_number = 0; /* shut gcc up */
struct buffer_head * bh , * retval = NULL;
unsigned int old_offset;
int dlen, match;
char * dpnt;
unsigned char *page = NULL;
struct iso_directory_record * de = NULL; /* shut gcc up */
char de_not_in_buf = 0; /* true if de is in kmalloc'd memory */
char c;
*ino = 0;
if (!dir) return NULL;
if (!(block = dir->u.isofs_i.i_first_extent)) return NULL;
f_pos = 0;
offset = f_pos & (bufsize - 1);
block = isofs_bmap(dir,f_pos >> bufbits);
if (!block || !(bh = bread(dir->i_dev,block,bufsize))) return NULL;
while (f_pos < dir->i_size) {
/* if de is in kmalloc'd memory, do not point to the
next de, instead we will move to the next sector */
if(!de_not_in_buf) {
de = (struct iso_directory_record *)
(bh->b_data + offset);
}
inode_number = (block << bufbits) + (offset & (bufsize - 1));
/* If byte is zero, or we had to fetch this de past
the end of the buffer, this is the end of file, or
time to move to the next sector. Usually 2048 byte
boundaries. */
if (*((unsigned char *) de) == 0 || de_not_in_buf) {
if(de_not_in_buf) {
/* [email protected]: Since we slopped
past the end of the last buffer, we
must start some way into the new
one */
de_not_in_buf = 0;
kfree(de);
f_pos += offset;
}
else {
offset = 0;
f_pos = ((f_pos & ~(ISOFS_BLOCK_SIZE - 1))
+ ISOFS_BLOCK_SIZE);
}
brelse(bh);
bh = NULL;
if (f_pos >= dir->i_size)
break;
block = isofs_bmap(dir,f_pos>>bufbits);
if (!block || !(bh = bread(dir->i_dev,block,bufsize)))
break;
continue; /* Will kick out if past end of directory */
}
old_offset = offset;
offset += *((unsigned char *) de);
f_pos += *((unsigned char *) de);
/* [email protected]: new code to handle case where the
directory entry spans two blocks. Usually 1024
byte boundaries */
if (offset >= bufsize) {
struct buffer_head *bh_next;
/* [email protected]: read the next block, and
copy the split de into a newly kmalloc'd
buffer */
block = isofs_bmap(dir,f_pos>>bufbits);
if (!block ||
!(bh_next = bread(dir->i_dev,block,bufsize)))
break;
de = (struct iso_directory_record *)
kmalloc(offset - old_offset, GFP_KERNEL);
memcpy((char *)de, bh->b_data + old_offset,
bufsize - old_offset);
memcpy((char *)de + bufsize - old_offset,
bh_next->b_data, offset - bufsize);
brelse(bh_next);
de_not_in_buf = 1;
offset -= bufsize;
}
dlen = de->name_len[0];
dpnt = de->name;
if (dir->i_sb->u.isofs_sb.s_rock ||
dir->i_sb->u.isofs_sb.s_joliet_level ||
dir->i_sb->u.isofs_sb.s_mapping == 'n' ||
dir->i_sb->u.isofs_sb.s_mapping == 'a') {
if (! page) {
page = (unsigned char *)
__get_free_page(GFP_KERNEL);
if (!page) break;
}
}
if (dir->i_sb->u.isofs_sb.s_rock &&
((i = get_rock_ridge_filename(de, page, dir)))) {
dlen = i;
dpnt = page;
#ifdef CONFIG_JOLIET
} else if (dir->i_sb->u.isofs_sb.s_joliet_level) {
dlen = get_joliet_filename(de, dir, page);
dpnt = page;
#endif
} else if (dir->i_sb->u.isofs_sb.s_mapping == 'a') {
dlen = get_acorn_filename(de, page, dir);
dpnt = page;
} else if (dir->i_sb->u.isofs_sb.s_mapping == 'n') {
for (i = 0; i < dlen; i++) {
c = dpnt[i];
/* lower case */
if (c >= 'A' && c <= 'Z') c |= 0x20;
if (c == ';' && i == dlen-2 && dpnt[i+1] == '1') {
dlen -= 2;
break;
}
if (c == ';') c = '.';
page[i] = c;
}
/* This allows us to match with and without
* a trailing period. */
if(page[dlen-1] == '.' && dentry->d_name.len == dlen-1)
dlen--;
dpnt = page;
}
/*
* Skip hidden or associated files unless unhide is set
*/
match = 0;
if ((!(de->flags[-dir->i_sb->u.isofs_sb.s_high_sierra] & 5)
|| dir->i_sb->u.isofs_sb.s_unhide == 'y') && dlen)
{
match = (isofs_cmp(dentry,dpnt,dlen) == 0);
}
if (match) {
if(inode_number == -1) {
/* Should only happen for the '..' entry */
inode_number =
isofs_lookup_grandparent(dir,
find_rock_ridge_relocation(de,dir));
}
*ino = inode_number;
retval = bh;
bh = NULL;
break;
}
}
if (page) free_page((unsigned long) page);
if (bh) brelse(bh);
if(de_not_in_buf)
kfree(de);
return retval;
}
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;
int directory_size;
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);
directory_size = isonum_733 (de->size);
brelse(bh);
break;
}
}
#ifdef DEBUG
printk("Parent dir:%x\n",parent_dir);
#endif
/* Now we know the extent where the parent dir starts on. */
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++;
directory_size -= bufsize;
if(directory_size < 0) return -1;
if((block & 1) && (ISOFS_BLOCK_BITS - bufbits))
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)
{
unsigned int frag1;
frag1 = bufsize - old_offset;
cpnt = kmalloc(*((unsigned char *) de),GFP_KERNEL);
memcpy(cpnt, bh->b_data + old_offset, frag1);
de = (struct iso_directory_record *) ((char *)cpnt);
brelse(bh);
offset -= bufsize;
directory_size -= bufsize;
if(directory_size < 0) return -1;
block++;
if(!(bh = bread(parent->i_dev,block,bufsize))) {
kfree(cpnt);
return -1;
};
memcpy((char *)cpnt+frag1, bh->b_data, offset);
}
if (find_rock_ridge_relocation(de, parent) == extent){
result = inode_number;
goto out;
}
if (cpnt) {
kfree(cpnt);
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(cpnt);
cpnt = NULL;
}
brelse(bh);
#ifdef DEBUG
printk("Resultant Inode %d\n",result);
#endif
return result;
}
