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;
}
