/* first calls search_by_key, then, if item is not found looks for the entry inside directory item indicated by
search_by_key. (We assign a key to each directory item, and place multiple entries in a single directory item.)
Fills the path to the entry, and to the entry position in the item */
int search_by_entry_key (struct super_block * sb, struct key * key, struct path * path, int * pos_in_item, int * repeat)
{
/* search for a directory item using key of entry */
if (search_by_key (sb, key, path, repeat, DISK_LEAF_NODE_LEVEL, READ_BLOCKS) == ITEM_FOUND) {
*pos_in_item = 0;
return POSITION_FOUND;
}
#ifdef REISERFS_CHECK
if (!PATH_LAST_POSITION (path))
reiserfs_panic (sb, "vs-7000: search_by_entry_key: search_by_key returned item position == 0");
#endif /* REISERFS_CHECK */
PATH_LAST_POSITION (path) --;
#ifdef REISERFS_CHECK
{
struct item_head * ih = B_N_PITEM_HEAD (PATH_PLAST_BUFFER (path), PATH_LAST_POSITION (path));
if (!I_IS_DIRECTORY_ITEM (ih) || COMP_SHORT_KEYS (&(ih->ih_key), key)) {
print_block (PATH_PLAST_BUFFER (path), 0, -1, -1);
reiserfs_panic (sb, "vs-7005: search_by_entry_key: found item %h is not directory item or "
"does not belong to the same directory as key %k", ih, key);
}
}
#endif /* REISERFS_CHECK */
/* binary search in directory item by third component of the key */
return bin_search_in_dir_item (PATH_PITEM_HEAD (path), B_I_DEH (PATH_PLAST_BUFFER (path), PATH_PITEM_HEAD (path)), key, pos_in_item);
}
// comment? maybe something like set de to point to what the path points to?
static inline void set_de_item_location (struct reiserfs_dir_entry * de, struct path * path)
{
de->de_bh = get_last_bh (path);
de->de_ih = get_ih (path);
de->de_deh = B_I_DEH (de->de_bh, de->de_ih);
de->de_item_num = PATH_LAST_POSITION (path);
}
/* fills the structure with various parameters of directory entry,
including key of the pointed object */
static void get_entry_attributes (struct reiserfs_dir_entry * de, int entry_num)
{
#ifdef REISERFS_CHECK
if (I_ENTRY_COUNT (de->de_ih) < entry_num)
reiserfs_panic (0, "yr-7006: get_entry_attributes: no such entry (%d-th) in the item (%d)",
entry_num, I_ENTRY_COUNT (de->de_ih));
if (de->de_deh != B_I_DEH (de->de_bh, de->de_ih) + entry_num)
reiserfs_panic (0, "yr-7008: get_entry_attributes: dir entry header not found");
#endif /* REISERFS_CHECK */
/* few fields are set already (de_bh, de_item_num, de_deh) */
de->de_entrylen = I_DEH_N_ENTRY_LENGTH (de->de_ih, de->de_deh, entry_num);
de->de_namelen = de->de_entrylen - (de_with_sd (de->de_deh) ? SD_SIZE : 0);
de->de_name = B_I_PITEM (de->de_bh, de->de_ih) + de->de_deh->deh_location;
#ifdef REISERFS_ALIGNED
if ( de->de_name[ de->de_namelen-1 ] == '\0' )
de->de_namelen = strlen(de->de_name);
#endif
/* key of object pointed by entry */
de->de_dir_id = de->de_deh->deh_dir_id;
de->de_objectid = de->de_deh->deh_objectid;
/* key of the entry */
memcpy (&(de->de_entry_key.k_dir_id), &(de->de_ih->ih_key), SHORT_KEY_SIZE);
de->de_entry_key.k_offset = de->de_deh->deh_offset;
de->de_entry_key.k_uniqueness = DIRENTRY_UNIQUENESS;
}
int reiserfs_remove_entry (reiserfs_filsys_t fs, struct key * key)
{
struct path path;
struct tree_balance tb;
struct item_head * ih;
struct reiserfs_de_head * deh;
if (_search_by_entry_key (fs, key, &path) != POSITION_FOUND) {
pathrelse (&path);
return 1;
}
ih = get_ih (&path);
if (ih_entry_count (ih) == 1) {
_init_tb_struct (&tb, fs, &path, -(IH_SIZE + ih_item_len (ih)));
if (fix_nodes (M_DELETE, &tb, 0) != CARRY_ON) {
unfix_nodes (&tb);
return 1;
}
do_balance (&tb, 0, 0, M_DELETE, 0);
return 0;
}
deh = B_I_DEH (get_bh (&path), ih) + path.pos_in_item;
_init_tb_struct (&tb, fs, &path, -(DEH_SIZE + entry_length (ih, deh, path.pos_in_item)));
if (fix_nodes (M_CUT, &tb, 0) != CARRY_ON) {
unfix_nodes (&tb);
return 1;
}
do_balance (&tb, 0, 0, M_CUT, 0);
return 0;
}
static void check_directory_item (struct item_head * ih, struct buffer_head * bh)
{
int i;
struct reiserfs_de_head * deh;
for (i = 0, deh = B_I_DEH (bh, ih); i < ih_entry_count (ih) - 1; i ++)
if (deh_offset(&deh[i]) > deh_offset(&deh[i + 1]))
die ("check_directory_item: entries are not sorted properly");
}
static int reiserfs_find_entry (struct inode * dir, const char * name, int namelen, struct path * path_to_entry, struct reiserfs_dir_entry * de)
{
struct key key_to_search;
int repeat;
int retval;
if (!dir || !dir->i_sb)
return POSITION_NOT_FOUND;
if ((unsigned int)namelen > REISERFS_MAX_NAME_LEN (dir->i_sb->s_blocksize))
return POSITION_NOT_FOUND;
/* there are no entries having the same third component of key, so
fourth key component is not used */
copy_key (&key_to_search, INODE_PKEY (dir));
key_to_search.k_offset = get_third_component (name, namelen);
key_to_search.k_uniqueness = DIRENTRY_UNIQUENESS;
while (1) {
/* search for a directory item using the formed key */
if (search_by_key (dir->i_sb, &key_to_search, path_to_entry, &repeat, DISK_LEAF_NODE_LEVEL, READ_BLOCKS) == ITEM_NOT_FOUND) {
/* take previous item */
#ifdef REISERFS_CHECK
if (!PATH_LAST_POSITION (path_to_entry))
reiserfs_panic (dir->i_sb, "vs-7010: reiserfs_find_entry: search_by_key returned bad position == 0");
#endif /* REISERFS_CHECK */
PATH_LAST_POSITION (path_to_entry) --;
}
de->de_bh = PATH_PLAST_BUFFER (path_to_entry);
de->de_item_num = PATH_LAST_POSITION (path_to_entry);
de->de_ih = B_N_PITEM_HEAD (de->de_bh, de->de_item_num);
de->de_deh = B_I_DEH (de->de_bh, de->de_ih);
#ifdef REISERFS_CHECK
if (!I_IS_DIRECTORY_ITEM (de->de_ih) || COMP_SHORT_KEYS (&(de->de_ih->ih_key), INODE_PKEY (dir)))
reiserfs_panic (dir->i_sb, "vs-7020: reiserfs_find_entry: item must be an item of the same directory item as inode");
#endif /* REISERFS_CHECK */
/* we do not check whether bin_search_in_dir_item found the given key, even if so, we still have
to compare names */
bin_search_in_dir_item (de->de_ih, de->de_deh, &key_to_search, &(de->de_entry_num));
/* compare names for all entries having given hash value */
retval = linear_search_in_dir_item (&key_to_search, de, name, namelen);
if (retval != GOTO_PREVIOUS_ITEM)
/* there is no need to scan directory anymore. Given entry found or does not exist */
return retval;
/* there is left neighboring item of this directory and given entry can be there */
key_to_search.k_offset = de->de_ih->ih_key.k_offset - 1;
pathrelse (path_to_entry);
} /* while (1) */
}
static int de_still_valid (const char * name, int len, struct reiserfs_dir_entry * de)
{
struct item_head * ih;
struct reiserfs_de_head * deh;
if (!de || !de->de_bh)
return 0;
deh = B_I_DEH (de->de_bh, ih = B_N_PITEM_HEAD (de->de_bh, de->de_item_num));
/* compare dir entry headers, record loacation and names */
if (memcmp (&(deh[de->de_entry_num]), de->de_deh, DEH_SIZE) ||
B_I_E_NAME (de->de_entry_num, de->de_bh, ih) != de->de_name ||
memcmp (name, de->de_name, len))
return 0;
return 1;
}
/* after this function de_entry_num is set correctly only if name
found or there was no entries with given hash value */
static int linear_search_in_dir_item (struct key * key, struct reiserfs_dir_entry * de, const char * name, int namelen)
{
int retval;
int i;
i = de->de_entry_num;
if (i == I_ENTRY_COUNT (de->de_ih) ||
GET_HASH_VALUE (de->de_deh[i].deh_offset) != GET_HASH_VALUE (key->k_offset)) {
i --;
}
#ifdef REISERFS_CHECK
if (de->de_deh != B_I_DEH (de->de_bh, de->de_ih))
reiserfs_panic (0, "vs-7010: linear_search_in_dir_item: array of entry headers not found");
#endif /* REISERFS_CHECK */
de->de_deh += i;
for (; i >= 0; i --, de->de_deh --) {
if (GET_HASH_VALUE (de->de_deh->deh_offset) != GET_HASH_VALUE (key->k_offset)) {
return POSITION_NOT_FOUND;
}
/* mark, that this generation number is used */
if (de->de_gen_number_bit_string)
set_bit (GET_GENERATION_NUMBER (de->de_deh->deh_offset), de->de_gen_number_bit_string);
/* de_bh, de_item_num, de_ih, de_deh are already set. Set others fields */
get_entry_attributes (de, i);
if ((retval = try_name (de, name, namelen)) != POSITION_NOT_FOUND) {
de->de_entry_num = i;
return retval;
}
}
if (GET_GENERATION_NUMBER (de->de_ih->ih_key.k_offset) == 0)
return POSITION_NOT_FOUND;
#ifdef REISERFS_CHECK
if (de->de_ih->ih_key.k_offset <= DOT_DOT_OFFSET || de->de_item_num != 0)
reiserfs_panic (0, "vs-7015: linear_search_in_dir_item: item must be 0-th item in block (%d)", de->de_item_num);
#endif /* REISERFS_CHECK */
return GOTO_PREVIOUS_ITEM;
}
void print_directory_item (FILE * fp, reiserfs_filsys_t fs,
struct buffer_head * bh, struct item_head * ih)
{
int i;
int namelen;
struct reiserfs_de_head * deh;
char * name;
/* static char namebuf [80];*/
if (!I_IS_DIRECTORY_ITEM (ih))
return;
//printk ("\n%2%-25s%-30s%-15s%-15s%-15s\n", " Name", "length", "Object key", "Hash", "Gen number", "Status");
reiserfs_warning (fp, "%3s: %-25s%s%-22s%-12s%s\n", "###", "Name", "length", " Object key", " Hash", "Gen number");
deh = B_I_DEH (bh, ih);
for (i = 0; i < ih_entry_count (ih); i ++, deh ++) {
if (dir_entry_bad_location (deh, ih, i == 0 ? 1 : 0)) {
reiserfs_warning (fp, "%3d: wrong entry location %u, deh_offset %u\n",
i, deh_location (deh), deh_offset (deh));
continue;
}
if (i && dir_entry_bad_location (deh - 1, ih, ((i - 1) == 0) ? 1 : 0))
/* previous entry has bad location so we can not calculate entry
length */
namelen = 25;
else
namelen = name_length (ih, deh, i);
name = name_in_entry (deh, i);
reiserfs_warning (fp, "%3d: \"%-25.*s\"(%3d)%20K%12d%5d, loc %u, state %x %s\n",
i, namelen, name, namelen,
/* this gets converted in print_short_key() */
(struct key *)&(deh->deh_dir_id),
GET_HASH_VALUE (deh_offset(deh)),
GET_GENERATION_NUMBER (deh_offset(deh)),
deh_location (deh), deh_state(deh),
fs ? (is_properly_hashed (fs, name, namelen, deh_offset (deh)) ? "" : "(BROKEN)") : "??");
}
}
int
reiserfs_readdir(struct vop_readdir_args /* {
struct vnode *a_vp;
struct uio *a_uio;
struct ucred *a_cred;
int *a_eofflag;
int *a_ncookies;
u_long **a_cookies;
} */*ap)
{
int error = 0;
struct dirent dstdp;
struct uio *uio = ap->a_uio;
off_t next_pos;
struct buf *bp;
struct item_head *ih;
struct cpu_key pos_key;
const struct key *rkey;
struct reiserfs_node *ip;
struct reiserfs_dir_entry de;
INITIALIZE_PATH(path_to_entry);
int entry_num, item_num, search_res;
/* The NFS part */
int ncookies = 0;
u_long *cookies = NULL;
/*
* Form key for search the next directory entry using f_pos field of
* file structure
*/
ip = VTOI(ap->a_vp);
make_cpu_key(&pos_key,
ip, uio->uio_offset ? uio->uio_offset : DOT_OFFSET,
TYPE_DIRENTRY, 3);
next_pos = cpu_key_k_offset(&pos_key);
reiserfs_log(LOG_DEBUG, "listing entries for "
"(objectid=%d, dirid=%d)\n",
pos_key.on_disk_key.k_objectid, pos_key.on_disk_key.k_dir_id);
reiserfs_log(LOG_DEBUG, "uio_offset = %jd, uio_resid = %d\n",
(intmax_t)uio->uio_offset, uio->uio_resid);
if (ap->a_ncookies && ap->a_cookies) {
cookies = (u_long *)malloc(
uio->uio_resid / 16 * sizeof(u_long),
M_REISERFSCOOKIES, M_WAITOK);
}
while (1) {
//research:
/*
* Search the directory item, containing entry with
* specified key
*/
reiserfs_log(LOG_DEBUG, "search directory to read\n");
search_res = search_by_entry_key(ip->i_reiserfs, &pos_key,
&path_to_entry, &de);
if (search_res == IO_ERROR) {
error = EIO;
goto out;
}
entry_num = de.de_entry_num;
item_num = de.de_item_num;
bp = de.de_bp;
ih = de.de_ih;
if (search_res == POSITION_FOUND ||
entry_num < I_ENTRY_COUNT(ih)) {
/*
* Go through all entries in the directory item
* beginning from the entry, that has been found.
*/
struct reiserfs_de_head *deh = B_I_DEH(bp, ih) +
entry_num;
if (ap->a_ncookies == NULL) {
cookies = NULL;
} else {
//ncookies =
}
reiserfs_log(LOG_DEBUG,
"walking through directory entries\n");
for (; entry_num < I_ENTRY_COUNT(ih);
entry_num++, deh++) {
int d_namlen;
char *d_name;
off_t d_off;
ino_t d_ino;
if (!de_visible(deh)) {
/* It is hidden entry */
continue;
}
d_namlen = entry_length(bp, ih, entry_num);
d_name = B_I_DEH_ENTRY_FILE_NAME(bp, ih, deh);
if (!d_name[d_namlen - 1])
d_namlen = strlen(d_name);
reiserfs_log(LOG_DEBUG, " - `%s' (len=%d)\n",
d_name, d_namlen);
if (d_namlen > REISERFS_MAX_NAME(
ip->i_reiserfs->s_blocksize)) {
/* Too big to send back to VFS */
continue;
}
#if 0
/* Ignore the .reiserfs_priv entry */
if (reiserfs_xattrs(ip->i_reiserfs) &&
!old_format_only(ip->i_reiserfs) &&
filp->f_dentry == ip->i_reiserfs->s_root &&
REISERFS_SB(ip->i_reiserfs)->priv_root &&
REISERFS_SB(ip->i_reiserfs)->priv_root->d_inode &&
deh_objectid(deh) ==
le32toh(INODE_PKEY(REISERFS_SB(
ip->i_reiserfs)->priv_root->d_inode)->k_objectid)) {
continue;
}
#endif
d_off = deh_offset(deh);
d_ino = deh_objectid(deh);
uio->uio_offset = d_off;
/* Copy to user land */
dstdp.d_fileno = d_ino;
dstdp.d_type = DT_UNKNOWN;
dstdp.d_namlen = d_namlen;
dstdp.d_reclen = GENERIC_DIRSIZ(&dstdp);
bcopy(d_name, dstdp.d_name, dstdp.d_namlen);
bzero(dstdp.d_name + dstdp.d_namlen,
dstdp.d_reclen -
offsetof(struct dirent, d_name) -
dstdp.d_namlen);
if (d_namlen > 0) {
if (dstdp.d_reclen <= uio->uio_resid) {
reiserfs_log(LOG_DEBUG, " copying to user land\n");
error = uiomove(&dstdp,
dstdp.d_reclen, uio);
if (error)
goto end;
if (cookies != NULL) {
cookies[ncookies] =
d_off;
ncookies++;
}
} else
break;
} else {
error = EIO;
break;
}
next_pos = deh_offset(deh) + 1;
}
reiserfs_log(LOG_DEBUG, "...done\n");
}
reiserfs_log(LOG_DEBUG, "checking item num (%d == %d ?)\n",
item_num, B_NR_ITEMS(bp) - 1);
if (item_num != B_NR_ITEMS(bp) - 1) {
/* End of directory has been reached */
reiserfs_log(LOG_DEBUG, "end reached\n");
if (ap->a_eofflag)
*ap->a_eofflag = 1;
goto end;
}
/*
* Item we went through is last item of node. Using right
* delimiting key check is it directory end
*/
reiserfs_log(LOG_DEBUG, "get right key\n");
rkey = get_rkey(&path_to_entry, ip->i_reiserfs);
reiserfs_log(LOG_DEBUG, "right key = (objectid=%d, dirid=%d)\n",
rkey->k_objectid, rkey->k_dir_id);
reiserfs_log(LOG_DEBUG, "compare it to MIN_KEY\n");
reiserfs_log(LOG_DEBUG, "MIN KEY = (objectid=%d, dirid=%d)\n",
MIN_KEY.k_objectid, MIN_KEY.k_dir_id);
if (comp_le_keys(rkey, &MIN_KEY) == 0) {
/* Set pos_key to key, that is the smallest and greater
* that key of the last entry in the item */
reiserfs_log(LOG_DEBUG, "continuing on the right\n");
set_cpu_key_k_offset(&pos_key, next_pos);
continue;
}
reiserfs_log(LOG_DEBUG, "compare it to pos_key\n");
reiserfs_log(LOG_DEBUG, "pos key = (objectid=%d, dirid=%d)\n",
pos_key.on_disk_key.k_objectid,
pos_key.on_disk_key.k_dir_id);
if (COMP_SHORT_KEYS(rkey, &pos_key)) {
/* End of directory has been reached */
reiserfs_log(LOG_DEBUG, "end reached (right)\n");
if (ap->a_eofflag)
*ap->a_eofflag = 1;
goto end;
}
/* Directory continues in the right neighboring block */
reiserfs_log(LOG_DEBUG, "continuing with a new offset\n");
set_cpu_key_k_offset(&pos_key,
le_key_k_offset(KEY_FORMAT_3_5, rkey));
reiserfs_log(LOG_DEBUG,
"new pos key = (objectid=%d, dirid=%d)\n",
pos_key.on_disk_key.k_objectid,
pos_key.on_disk_key.k_dir_id);
}
end:
uio->uio_offset = next_pos;
pathrelse(&path_to_entry);
reiserfs_check_path(&path_to_entry);
out:
if (error && cookies != NULL) {
free(cookies, M_REISERFSCOOKIES);
} else if (ap->a_ncookies != NULL && ap->a_cookies != NULL) {
*ap->a_ncookies = ncookies;
*ap->a_cookies = cookies;
}
return (error);
}
int reiserfs_readdir_dentry(struct dentry *dentry, void *dirent,
filldir_t filldir, loff_t *pos)
{
struct inode *inode = dentry->d_inode;
struct cpu_key pos_key; /* key of current position in the directory (key of directory entry) */
INITIALIZE_PATH(path_to_entry);
struct buffer_head *bh;
int item_num, entry_num;
const struct reiserfs_key *rkey;
struct item_head *ih, tmp_ih;
int search_res;
char *local_buf;
loff_t next_pos;
char small_buf[32]; /* avoid kmalloc if we can */
struct reiserfs_dir_entry de;
int ret = 0;
reiserfs_write_lock(inode->i_sb);
reiserfs_check_lock_depth(inode->i_sb, "readdir");
/* form key for search the next directory entry using f_pos field of
file structure */
make_cpu_key(&pos_key, inode, *pos ?: DOT_OFFSET, TYPE_DIRENTRY, 3);
next_pos = cpu_key_k_offset(&pos_key);
path_to_entry.reada = PATH_READA;
while (1) {
research:
/* search the directory item, containing entry with specified key */
search_res =
search_by_entry_key(inode->i_sb, &pos_key, &path_to_entry,
&de);
if (search_res == IO_ERROR) {
// FIXME: we could just skip part of directory which could
// not be read
ret = -EIO;
goto out;
}
entry_num = de.de_entry_num;
bh = de.de_bh;
item_num = de.de_item_num;
ih = de.de_ih;
store_ih(&tmp_ih, ih);
/* we must have found item, that is item of this directory, */
RFALSE(COMP_SHORT_KEYS(&(ih->ih_key), &pos_key),
"vs-9000: found item %h does not match to dir we readdir %K",
ih, &pos_key);
RFALSE(item_num > B_NR_ITEMS(bh) - 1,
"vs-9005 item_num == %d, item amount == %d",
item_num, B_NR_ITEMS(bh));
/* and entry must be not more than number of entries in the item */
RFALSE(I_ENTRY_COUNT(ih) < entry_num,
"vs-9010: entry number is too big %d (%d)",
entry_num, I_ENTRY_COUNT(ih));
if (search_res == POSITION_FOUND
|| entry_num < I_ENTRY_COUNT(ih)) {
/* go through all entries in the directory item beginning from the entry, that has been found */
struct reiserfs_de_head *deh =
B_I_DEH(bh, ih) + entry_num;
for (; entry_num < I_ENTRY_COUNT(ih);
entry_num++, deh++) {
int d_reclen;
char *d_name;
off_t d_off;
ino_t d_ino;
loff_t cur_pos = deh_offset(deh);
if (!de_visible(deh))
/* it is hidden entry */
continue;
d_reclen = entry_length(bh, ih, entry_num);
d_name = B_I_DEH_ENTRY_FILE_NAME(bh, ih, deh);
if (d_reclen <= 0 ||
d_name + d_reclen > bh->b_data + bh->b_size) {
/* There is corrupted data in entry,
* We'd better stop here */
pathrelse(&path_to_entry);
ret = -EIO;
goto out;
}
if (!d_name[d_reclen - 1])
d_reclen = strlen(d_name);
if (d_reclen >
REISERFS_MAX_NAME(inode->i_sb->
s_blocksize)) {
/* too big to send back to VFS */
continue;
}
/* Ignore the .reiserfs_priv entry */
if (is_privroot_deh(dentry, deh))
continue;
d_off = deh_offset(deh);
*pos = d_off;
d_ino = deh_objectid(deh);
if (d_reclen <= 32) {
local_buf = small_buf;
} else {
local_buf = kmalloc(d_reclen,
GFP_NOFS);
if (!local_buf) {
pathrelse(&path_to_entry);
ret = -ENOMEM;
goto out;
}
if (item_moved(&tmp_ih, &path_to_entry)) {
kfree(local_buf);
goto research;
}
}
// Note, that we copy name to user space via temporary
// buffer (local_buf) because filldir will block if
// user space buffer is swapped out. At that time
// entry can move to somewhere else
memcpy(local_buf, d_name, d_reclen);
/*
* Since filldir might sleep, we can release
* the write lock here for other waiters
*/
reiserfs_write_unlock(inode->i_sb);
if (filldir
(dirent, local_buf, d_reclen, d_off, d_ino,
DT_UNKNOWN) < 0) {
reiserfs_write_lock(inode->i_sb);
if (local_buf != small_buf) {
kfree(local_buf);
}
goto end;
}
reiserfs_write_lock(inode->i_sb);
if (local_buf != small_buf) {
kfree(local_buf);
}
/* deh_offset(deh) may be invalid now. */
next_pos = cur_pos + 1;
if (item_moved(&tmp_ih, &path_to_entry)) {
set_cpu_key_k_offset(&pos_key,
next_pos);
goto research;
}
} /* for */
}
if (item_num != B_NR_ITEMS(bh) - 1)
// end of directory has been reached
goto end;
/* item we went through is last item of node. Using right
delimiting key check is it directory end */
rkey = get_rkey(&path_to_entry, inode->i_sb);
if (!comp_le_keys(rkey, &MIN_KEY)) {
/* set pos_key to key, that is the smallest and greater
that key of the last entry in the item */
set_cpu_key_k_offset(&pos_key, next_pos);
continue;
}
if (COMP_SHORT_KEYS(rkey, &pos_key)) {
// end of directory has been reached
goto end;
}
/* directory continues in the right neighboring block */
set_cpu_key_k_offset(&pos_key,
le_key_k_offset(KEY_FORMAT_3_5, rkey));
} /* while */
end:
*pos = next_pos;
pathrelse(&path_to_entry);
reiserfs_check_path(&path_to_entry);
out:
reiserfs_write_unlock(inode->i_sb);
return ret;
}
/* returns 0 if name is not found in a directory and objectid of
pointed object otherwise and returns minimal not used generation
counter. dies if found object is not a directory. */
int reiserfs_find_entry (reiserfs_filsys_t fs, struct key * dir, char * name,
int * min_gen_counter)
{
struct key entry_key;
int retval;
int i;
INITIALIZE_PATH (path);
struct item_head * ih;
struct reiserfs_de_head * deh;
struct key * rdkey;
__u32 hash;
entry_key.k_dir_id = cpu_to_le32(dir->k_dir_id);
entry_key.k_objectid = cpu_to_le32(dir->k_objectid);
hash = hash_value (fs, name);
set_type_and_offset (KEY_FORMAT_1, &entry_key, hash, TYPE_DIRENTRY);
*min_gen_counter = 0;
if (_search_by_entry_key (fs, &entry_key, &path) == DIRECTORY_NOT_FOUND) {
pathrelse (&path);
return 0;
}
do {
ih = get_ih (&path);
deh = B_I_DEH (get_bh (&path), ih) + path.pos_in_item;
for (i = path.pos_in_item; i < ih_entry_count (ih); i ++, deh ++) {
if (GET_HASH_VALUE (deh_offset (deh)) != GET_HASH_VALUE (hash)) {
/* all entries having the same hash were scanned */
pathrelse (&path);
return 0;
}
if (GET_GENERATION_NUMBER (deh_offset (deh)) == *min_gen_counter)
(*min_gen_counter) ++;
if (!memcmp (name_in_entry (deh, i), name, strlen (name))) {
pathrelse (&path);
return deh_objectid (deh) ? deh_objectid (deh) : 1;
}
}
rdkey = _get_rkey (&path);
if (!rdkey || not_of_one_file (rdkey, dir)) {
pathrelse (&path);
return 0;
}
if (!is_direntry_key (rdkey))
reiserfs_panic ("reiserfs_find_entry: can not find name in broken directory yet");
/* next item is the item of the directory we are looking name in */
if (GET_HASH_VALUE (get_offset (rdkey)) != hash) {
/* but there is no names with given hash */
pathrelse (&path);
return 0;
}
/* first name of that item may be a name we are looking for */
entry_key = *rdkey;
pathrelse (&path);
retval = _search_by_entry_key (fs, &entry_key, &path);
if (retval != POSITION_FOUND)
reiserfs_panic ("reiserfs_find_entry: wrong delimiting key in the tree");
} while (1);
return 0;
}
/* NOTE: this only should be used to look for keys who exists */
int _search_by_entry_key (reiserfs_filsys_t fs, struct key * key,
struct path * path)
{
struct buffer_head * bh;
int item_pos;
struct item_head * ih;
struct key tmpkey;
if (_search_by_key (fs, key, path) == ITEM_FOUND) {
path->pos_in_item = 0;
return POSITION_FOUND;
}
bh = get_bh (path);
item_pos = get_item_pos (path);
ih = get_ih (path);
if (item_pos == 0) {
/* key is less than the smallest key in the tree */
if (not_of_one_file (&(ih->ih_key), key))
/* there are no items of that directory */
return DIRECTORY_NOT_FOUND;
if (!is_direntry_ih (ih))
reiserfs_panic ("_search_by_entry_key: found item is not of directory type %H",
ih);
/* key we looked for should be here */
path->pos_in_item = 0;
return POSITION_NOT_FOUND;
}
/* take previous item */
item_pos --;
ih --;
PATH_LAST_POSITION (path) --;
if (not_of_one_file (&(ih->ih_key), key) || !is_direntry_ih (ih)) {
/* previous item belongs to another object or is stat data, check next
item */
item_pos ++;
PATH_LAST_POSITION (path) ++;
if (item_pos < B_NR_ITEMS (bh)) {
/* next item is in the same node */
ih ++;
if (not_of_one_file (&(ih->ih_key), key)) {
/* there are no items of that directory */
path->pos_in_item = 0;
return DIRECTORY_NOT_FOUND;
}
if (!is_direntry_ih (ih))
reiserfs_panic ("_search_by_entry_key: %k is not a directory",
key);
} else {
/* next item is in right neighboring node */
struct key * next_key = _get_rkey (path);
if (next_key == 0 || not_of_one_file (next_key, key)) {
/* there are no items of that directory */
path->pos_in_item = 0;
return DIRECTORY_NOT_FOUND;
}
if (!is_direntry_key (next_key))
reiserfs_panic ("_search_by_entry_key: %k is not a directory",
key);
/* we got right delimiting key - search for it - the entry will be
pasted in position 0 */
copy_key (&tmpkey, next_key);
pathrelse (path);
if (_search_by_key (fs, &tmpkey, path) != ITEM_FOUND || PATH_LAST_POSITION (path) != 0)
reiserfs_panic ("_search_by_entry_key: item corresponding to delimiting key %k not found",
&tmpkey);
}
/* next item is the part of this directory */
path->pos_in_item = 0;
return POSITION_NOT_FOUND;
}
/* previous item is part of desired directory */
if (_bin_search (&(key->u.k_offset_v1.k_offset), B_I_DEH (bh, ih), ih_entry_count (ih),
DEH_SIZE, &(path->pos_in_item), comp_dir_entries) == ITEM_FOUND)
return POSITION_FOUND;
return POSITION_NOT_FOUND;
}
/* check directory item and try to recover something */
static int verify_directory_item (reiserfs_filsys_t fs, struct buffer_head * bh,
int item_num)
{
struct item_head * ih;
struct item_head tmp;
char * item;
struct reiserfs_de_head * deh;
char * name;
int name_len;
int bad;
int i, j;
#if 0
int bad_entries; /* how many bad neighboring entries */
int total_entry_len;
char * entries, * end;
#endif
int dirty;
int entry_count;
int hash_code;
int bad_locations;
#ifdef DEBUG_VERIFY_DENTRY
char * direntries;
#endif
ih = B_N_PITEM_HEAD (bh, item_num);
item = B_I_PITEM (bh,ih);
deh = (struct reiserfs_de_head *)item;
dirty = 0;
bad_locations = 0;
entry_count = ih_entry_count (ih);
/* check deh_location */
for (i = 0; i < ih_entry_count (ih); i ++) {
/* silently fix deh_state */
if (deh [i].deh_state != (1 << DEH_Visible)) {
deh [i].deh_state = cpu_to_le16 (1 << DEH_Visible);
mark_buffer_dirty (bh);
}
if (dir_entry_bad_location (deh + i, ih, !i))
mark_de_bad_location (deh + i);
}
#ifdef DEBUG_VERIFY_DENTRY
direntries = getmem (ih_entry_count (ih) * sizeof (int));
printf ("entries with bad locations: ");
for (i = 0; i < ih_entry_count (ih); i ++) {
if (de_bad_location (deh + i))
printf ("%d ", i);
}
printf ("\n");
#endif /* DEBUG_VERIFY_DENTRY */
/* find entries names in which have mismatching deh_offset */
for (i = ih_entry_count (ih) - 1; i >= 0; i --) {
if (de_bad (deh + i))
/* bad location */
continue;
if (i) {
if (deh_location (deh + i - 1) < deh_location (deh + i))
mark_de_bad_location (deh + i - 1);
}
name = name_in_entry (deh + i, i);
/* we found a name, but we not always we can get its length as
it depends on deh_location of previous entry */
name_len = try_to_get_name_length (ih, deh + i, i);
#ifdef DEBUG_VERIFY_DENTRY
if (name_len == 0)
printf ("trying to find name length for %d-th entry\n", i);
#endif /* DEBUG_VERIFY_DENTRY */
if (is_dot (name, name_len)) {
if (i != 0)
fsck_log ("block %lu: item %d: \".\" is %d-th entry\n",
bh->b_blocknr, item_num, i);
/* check and fix "." */
if (deh_offset (deh + i) != DOT_OFFSET) {
set_deh_offset(&(deh[i]), DOT_OFFSET);
mark_buffer_dirty (bh);
}
/* "." must point to the directory it is in */
if (not_of_one_file (&(deh[i].deh_dir_id), &(ih->ih_key))) { /* endian safe */
fsck_log ("verify_direntry: block %lu, item %H has entry \".\" "
"pointing to (%K) instead of (%K)\n",
bh->b_blocknr, ih,
&(deh[i].deh_dir_id), &(ih->ih_key));
deh[i].deh_dir_id = ih->ih_key.k_dir_id; /* both LE */
deh[i].deh_objectid = ih->ih_key.k_objectid; /* both LE */
mark_buffer_dirty (bh);
}
} else if (is_dot_dot (name, name_len)) {
if (i != 1)
fsck_log ("block %lu: item %d: \"..\" is %d-th entry\n",
bh->b_blocknr, item_num, i);
/* check and fix ".." */
if (deh_offset (deh + i) != DOT_DOT_OFFSET)
set_deh_offset(&(deh[i]), DOT_DOT_OFFSET);
} else {
int min_length, max_length;
/* check other name */
if (name_len == 0) {
/* we do not know the length of name - we will try to find it */
min_length = 1;
max_length = item + ih_item_len (ih) - name;
} else
/* we kow name length, so we will try only one name length */
min_length = max_length = name_len;
for (j = min_length; j <= max_length; j ++) {
hash_code = find_hash_in_use (name, j,
GET_HASH_VALUE (deh_offset (deh + i)),
rs_hash (fs->s_rs));
add_hash_hit (fs, hash_code);
if (code2func (hash_code) != 0) {
/* deh_offset matches to some hash of the name */
if (!name_len) {
fsck_log ("pass0: block %lu, item %H: entry %d. found a name \"%.*s\" "
"matching to deh_offset %u. FIXME: should set deh_location "
"of previous entry (not ready)\n",
bh->b_blocknr, ih, i, j, name, deh_offset (deh + i));
/* FIXME: if next byte is 0 we think that the name is aligned to 8 byte boundary */
if (i) {
set_deh_location( &(deh[i - 1]),
deh_location (deh + i) +
((name[j] || SB_VERSION (fs) ==
REISERFS_VERSION_1) ? j : ROUND_UP (j)));
mark_de_good_location (deh + i - 1);
mark_buffer_dirty (bh);
}
}
break;
}
}
if (j == max_length + 1) {
/* deh_offset does not match to anything. it will be
deleted for now, but maybe we could just fix a
deh_offset if it is in ordeer */
mark_de_bad_offset (deh + i);
}
}
} /* for */
#if 0
/* find entries names in which have mismatching deh_offset */
for (i = 0; i < ih_entry_count (ih); i ++) {
if (de_bad (deh + i))
/* bad location */
continue;
name = name_in_entry (deh + i, i);
/* we found a name, but we not always we can get its length as
it depends on deh_location of previous entry */
name_len = try_to_get_name_length (ih, deh + i, i);
if (i == 0 && is_dot (name, name_len)) {
/* check and fix "." */
if (deh_offset (deh + i) != DOT_OFFSET) {
deh[i].deh_offset = cpu_to_le32 (DOT_OFFSET);
}
/* "." must point to the directory it is in */
if (not_of_one_file (&(deh[i].deh_dir_id), &(ih->ih_key))) {
fsck_log ("verify_direntry: block %lu, item %H has entry \".\" "
"pointing to (%K) instead of (%K)\n",
bh->b_blocknr, ih,
&(deh[i].deh_dir_id), &(ih->ih_key));
deh[i].deh_dir_id = ih->ih_key.k_dir_id; /* both 32 bit LE */
deh[i].deh_objectid = ih->ih_key.k_objectid; /* both 32 bit LE */
mark_buffer_dirty (bh);
}
} else if (i == 1 && is_dot_dot (name, name_len)) {
/* check and fix ".." */
if (deh_offset (deh + i) != DOT_DOT_OFFSET)
deh[i].deh_offset = cpu_to_le32 (DOT_DOT_OFFSET);
} else {
int min_length, max_length;
/* check other name */
if (name_len == 0) {
/* we do not know the length of name - we will try to find it */
min_length = 1;
max_length = item + ih_item_len (ih) - name;
} else
/* we kow name length, so we will try only one name length */
min_length = max_length = name_len;
for (j = min_length; j <= max_length; j ++) {
hash_code = find_hash_in_use (name, j,
GET_HASH_VALUE (deh_offset (deh + i)),
rs_hash (fs->s_rs));
add_hash_hit (fs, hash_code);
if (code2func (hash_code) != 0) {
/* deh_offset matches to some hash of the name */
if (!name_len) {
fsck_log ("pass0: block %lu, item %H: entry %d. found a name \"%.*s\" "
"matching to deh_offset %u. FIXME: should set deh_location "
"of previous entry (not ready)\n",
bh->b_blocknr, ih, i, j, name, deh_offset (deh + i));
/* FIXME: if next byte is 0 we think that the name is aligned to 8 byte boundary */
deh[i - 1].deh_location = cpu_to_le16 (deh_location (deh + i) +
((name[j] || SB_VERSION (fs) == REISERFS_VERSION_1) ? j : ROUND_UP (j)));
}
break;
}
}
if (j == max_length + 1) {
/* deh_offset does not match to anything. it will be
deleted for now, but maybe we could just fix a
deh_offset if it is in ordeer */
mark_de_bad_offset (deh + i);
}
}
}
#endif
#ifdef DEBUG_VERIFY_DENTRY
printf ("entries with mismatching deh_offsets: ");
for (i = 0; i < ih_entry_count (ih); i ++) {
if (de_bad_offset (deh + i))
printf ("%d ", i);
}
printf ("\n");
#endif /* DEBUG_VERIFY_DENTRY */
/* correct deh_locations such that code cutting entries will not get
screwed up */
{
int prev_loc;
int loc_fixed;
prev_loc = ih_item_len (ih);
for (i = 0; i < ih_entry_count (ih); i ++) {
loc_fixed = 0;
if (de_bad_location (deh + i)) {
set_deh_location(&(deh[i]), prev_loc/* - 1*/);
mark_buffer_dirty (bh);
loc_fixed = 1;
} else {
if (deh_location (deh + i) >= prev_loc) {
set_deh_location(&(deh[i]), prev_loc/* - 1*/);
mark_buffer_dirty (bh);
loc_fixed = 1;
}
}
prev_loc = deh_location (deh + i);
if (i == ih_entry_count (ih) - 1) {
/* last entry starts right after an array of dir entry headers */
if (!de_bad (deh + i) &&
deh_location (deh + i) != (DEH_SIZE * ih_entry_count (ih))) {
/* free space in the directory item */
fsck_log ("verify_direntry: block %lu, item %H has free
pace\n",
bh->b_blocknr, ih);
cut_entry (fs, bh, item_num, ih_entry_count (ih), 0);
}
if (deh_location (deh + i) != (DEH_SIZE * ih_entry_count (ih)))
{
set_deh_location(&(deh[i]), DEH_SIZE * ih_entry_count (ih));
loc_fixed = 1;
mark_buffer_dirty (bh);
}
}
#ifdef DEBUG_VERIFY_DENTRY
if (loc_fixed)
direntries [i] = 1;
#endif
} /* for */
#ifdef DEBUG_VERIFY_DENTRY
printf ("entries with fixed deh_locations: ");
for (i = 0; i < ih_entry_count (ih); i ++) {
if (direntries [i])
printf ("%d ", i);
}
printf ("\n");
#endif /* DEBUG_VERIFY_DENTRY */
}
#ifdef DEBUG_VERIFY_DENTRY
printf (" N location name\n");
for (i = 0; i < ih_entry_count (ih); i ++) {
if (de_bad (deh + i) ||
(i && de_bad (deh + i - 1)) || /* previous entry marked bad */
(i < ih_entry_count (ih) - 1 && de_bad (deh + i + 1))) { /* next
ntry is marked bad */
/* print only entries to be deleted and their nearest neighbors */
printf ("%3d: %8d ", i, deh_location (deh + i));
if (de_bad (deh + i))
printf ("will be deleted\n");
else
printf ("\"%.*s\"\n", name_length (ih, deh + i, i),
name_in_entry (deh + i, i));
}
}
#endif
bad = 0;
tmp = *ih;
/* delete entries which are marked bad */
for (i = 0; i < ih_entry_count (ih); i ++) {
deh = B_I_DEH (bh, ih) + i;
if (de_bad (deh)) {
bad ++;
if (ih_entry_count (ih) == 1) {
delete_item (fs, bh, item_num);
break;
} else {
cut_entry (fs, bh, item_num, i, 1);
}
i --;
}
}
if (bad == ih_entry_count (&tmp)) {
fsck_log ("pass0: block %lu, item %H - all entries were deleted\n", bh->b_blocknr, &tmp);
return 0;
}
deh = B_I_DEH (bh, ih);
if (get_offset (&ih->ih_key) != deh_offset (deh)) {
fsck_log ("verify_direntry: block %lu, item %H: k_offset and deh_offset %u mismatched\n",
bh->b_blocknr, ih, deh_offset (deh));
set_offset (KEY_FORMAT_1, &ih->ih_key, deh_offset (deh));
mark_buffer_dirty (bh);
}
if (bad)
fsck_log ("pass0: block %lu, item %H: %d entries were deleted of \n",
bh->b_blocknr, &tmp, bad);
return 0;
#if 0
/* FIXME: temporary */
if (bad_locations > ih_entry_count (ih) / 2) {
fsck_log ("pass0: block %u: item %d (%H) had too bad directory - deleted\n",
bh->b_blocknr, item_num, ih);
delete_item (fs, bh, item_num);
return 0;
}
if (!dirty)
return 0;
/* something is broken */
fsck_log ("pass0: block %lu: %d-th item (%H) has %d bad entries..",
bh->b_blocknr, item_num, ih, dirty);
if (get_offset (&ih->ih_key) == DOT_OFFSET) {
/* first item of directory - make sure that "." and ".." are in place */
if (deh_offset (deh) != DOT_OFFSET || name_in_entry (deh, 0)[0] != '.') {
set_deh_offset(deh, DOT_OFFSET);
name_in_entry (deh, 0)[0] = '.';
}
if (deh_offset (deh + 1) != DOT_DOT_OFFSET ||
name_in_entry (deh + 1, 1)[0] != '.' || name_in_entry (deh + 1, 1)[1] != '.') {
set_deh_offset((deh + 1), DOT_DOT_OFFSET);
name_in_entry (deh + 1, 1)[0] = '.';
name_in_entry (deh + 1, 1)[1] = '.';
}
}
end = item + ih_item_len (ih);
deh += ih_entry_count (ih);
entries = (char *)deh;
total_entry_len = ih_item_len (ih) - DEH_SIZE * ih_entry_count (ih);
i = ih_entry_count (ih);
bad_entries = 0;
do {
i --;
deh --;
name_len = prob_name (fs, &entries, total_entry_len, deh_offset (deh));
if (!name_len) {
if (!bad_entries) {
set_deh_location(deh, entries - item);
} else {
set_deh_location(deh, deh_location((deh + 1)) + 1 );
}
bad_entries ++;
/*fsck_log ("verify_directory_item: entry %d: in string \'%s\' there is no substring matching hash %ld\n",
i, bad_name (entries, total_entry_len), masked_offset);*/
mark_de_bad (deh);
continue;
}
bad_entries = 0;
/*fsck_log ("verify_directory_item: entry %d: found \"%s\" name matching hash %ld\n",
i, bad_name (entries, name_len), masked_offset);*/
/* 'entries' points now to the name which match given offset -
so, set deh_location */
set_deh_location(deh, entries - item);
deh->deh_state = 0;
mark_de_visible (deh);
entries += name_len;
total_entry_len = end - entries;
/* skip padding zeros */
while (!*entries) {
entries ++;
total_entry_len --;
}
/* 'entries' points now at the place where next (previous)
entry should start */
} while ((char *)deh != item);
/* fixme: this will not work if all entries are to be deleted */
for (i = 0; i < ih_entry_count (ih); i ++, deh ++) {
deh = (struct reiserfs_de_head *)B_I_PITEM (bh, ih) + i;
if (de_bad (deh)) {
if (ih_entry_count (ih) == 1) {
delete_item (fs, bh, i);
break;
} else {
cut_entry (fs, bh, item_num, i);
}
i --;
}
/*
fsck_log ("verify_directory_item: %d-th entry is to be deleted: "
"\"%s\" does not match to hash %lu\n",
i, bad_name (name_in_entry (deh, i), name_length (ih, deh, i)),
deh_offset (deh));
*/
}
fsck_log ("%d entries were deleted\n", entry_count - ih_entry_count (ih));
mark_buffer_dirty (bh);
return 0;
#endif
}
static int linear_search_in_dir_item(struct cpu_key *key,
struct reiserfs_dir_entry *de,
const char *name, int namelen)
{
struct reiserfs_de_head *deh = de->de_deh;
int retval;
int i;
i = de->de_entry_num;
if (i == I_ENTRY_COUNT(de->de_ih) ||
GET_HASH_VALUE(deh_offset(deh + i)) !=
GET_HASH_VALUE(cpu_key_k_offset(key))) {
i--;
}
RFALSE(de->de_deh != B_I_DEH(de->de_bh, de->de_ih),
"vs-7010: array of entry headers not found");
deh += i;
for (; i >= 0; i--, deh--) {
if (GET_HASH_VALUE(deh_offset(deh)) !=
GET_HASH_VALUE(cpu_key_k_offset(key))) {
// hash value does not match, no need to check whole name
return NAME_NOT_FOUND;
}
/* mark, that this generation number is used */
if (de->de_gen_number_bit_string)
set_bit(GET_GENERATION_NUMBER(deh_offset(deh)),
de->de_gen_number_bit_string);
// calculate pointer to name and namelen
de->de_entry_num = i;
set_de_name_and_namelen(de);
if ((retval =
reiserfs_match(de, name, namelen)) != NAME_NOT_FOUND) {
// de's de_name, de_namelen, de_recordlen are set. Fill the rest:
// key of pointed object
set_de_object_key(de);
store_de_entry_key(de);
// retval can be NAME_FOUND or NAME_FOUND_INVISIBLE
return retval;
}
}
if (GET_GENERATION_NUMBER(le_ih_k_offset(de->de_ih)) == 0)
/* we have reached left most entry in the node. In common we
have to go to the left neighbor, but if generation counter
is 0 already, we know for sure, that there is no name with
the same hash value */
// FIXME: this work correctly only because hash value can not
// be 0. Btw, in case of Yura's hash it is probably possible,
// so, this is a bug
return NAME_NOT_FOUND;
RFALSE(de->de_item_num,
"vs-7015: two diritems of the same directory in one node?");
return GOTO_PREVIOUS_ITEM;
}
static int reiserfs_readdir (struct file * filp, void * dirent, filldir_t filldir)
{
struct inode *inode = filp->f_dentry->d_inode;
struct cpu_key pos_key; /* key of current position in the directory (key of directory entry) */
INITIALIZE_PATH (path_to_entry);
struct buffer_head * bh;
int item_num, entry_num;
const struct key * rkey;
struct item_head * ih, tmp_ih;
int search_res;
char * local_buf;
loff_t next_pos;
char small_buf[32] ; /* avoid kmalloc if we can */
struct reiserfs_dir_entry de;
reiserfs_check_lock_depth("readdir") ;
/* form key for search the next directory entry using f_pos field of
file structure */
make_cpu_key (&pos_key, inode, (filp->f_pos) ? (filp->f_pos) : DOT_OFFSET,
TYPE_DIRENTRY, 3);
next_pos = cpu_key_k_offset (&pos_key);
/* reiserfs_warning ("reiserfs_readdir 1: f_pos = %Ld\n", filp->f_pos);*/
while (1) {
research:
/* search the directory item, containing entry with specified key */
search_res = search_by_entry_key (inode->i_sb, &pos_key, &path_to_entry, &de);
if (search_res == IO_ERROR) {
// FIXME: we could just skip part of directory which could
// not be read
return -EIO;
}
entry_num = de.de_entry_num;
bh = de.de_bh;
item_num = de.de_item_num;
ih = de.de_ih;
store_ih (&tmp_ih, ih);
/* we must have found item, that is item of this directory, */
RFALSE( COMP_SHORT_KEYS (&(ih->ih_key), &pos_key),
"vs-9000: found item %h does not match to dir we readdir %K",
ih, &pos_key);
RFALSE( item_num > B_NR_ITEMS (bh) - 1,
"vs-9005 item_num == %d, item amount == %d",
item_num, B_NR_ITEMS (bh));
/* and entry must be not more than number of entries in the item */
RFALSE( I_ENTRY_COUNT (ih) < entry_num,
"vs-9010: entry number is too big %d (%d)",
entry_num, I_ENTRY_COUNT (ih));
if (search_res == POSITION_FOUND || entry_num < I_ENTRY_COUNT (ih)) {
/* go through all entries in the directory item beginning from the entry, that has been found */
struct reiserfs_de_head * deh = B_I_DEH (bh, ih) + entry_num;
for (; entry_num < I_ENTRY_COUNT (ih); entry_num ++, deh ++) {
int d_reclen;
char * d_name;
off_t d_off;
ino_t d_ino;
if (!de_visible (deh))
/* it is hidden entry */
continue;
d_reclen = entry_length (bh, ih, entry_num);
d_name = B_I_DEH_ENTRY_FILE_NAME (bh, ih, deh);
if (!d_name[d_reclen - 1])
d_reclen = strlen (d_name);
if (d_reclen > REISERFS_MAX_NAME_LEN(inode->i_sb->s_blocksize)){
/* too big to send back to VFS */
continue ;
}
d_off = deh_offset (deh);
filp->f_pos = d_off ;
d_ino = deh_objectid (deh);
if (d_reclen <= 32) {
local_buf = small_buf ;
} else {
local_buf = reiserfs_kmalloc(d_reclen, GFP_NOFS, inode->i_sb) ;
if (!local_buf) {
pathrelse (&path_to_entry);
return -ENOMEM ;
}
if (item_moved (&tmp_ih, &path_to_entry)) {
reiserfs_kfree(local_buf, d_reclen, inode->i_sb) ;
goto research;
}
}
// Note, that we copy name to user space via temporary
// buffer (local_buf) because filldir will block if
// user space buffer is swapped out. At that time
// entry can move to somewhere else
memcpy (local_buf, d_name, d_reclen);
if (filldir (dirent, local_buf, d_reclen, d_off, d_ino,
DT_UNKNOWN) < 0) {
if (local_buf != small_buf) {
reiserfs_kfree(local_buf, d_reclen, inode->i_sb) ;
}
goto end;
}
if (local_buf != small_buf) {
reiserfs_kfree(local_buf, d_reclen, inode->i_sb) ;
}
// next entry should be looked for with such offset
next_pos = deh_offset (deh) + 1;
if (item_moved (&tmp_ih, &path_to_entry)) {
goto research;
}
} /* for */
}
if (item_num != B_NR_ITEMS (bh) - 1)
// end of directory has been reached
goto end;
/* item we went through is last item of node. Using right
delimiting key check is it directory end */
rkey = get_rkey (&path_to_entry, inode->i_sb);
if (! comp_le_keys (rkey, &MIN_KEY)) {
/* set pos_key to key, that is the smallest and greater
that key of the last entry in the item */
set_cpu_key_k_offset (&pos_key, next_pos);
continue;
}
if ( COMP_SHORT_KEYS (rkey, &pos_key)) {
// end of directory has been reached
goto end;
}
/* directory continues in the right neighboring block */
set_cpu_key_k_offset (&pos_key, le_key_k_offset (KEY_FORMAT_3_5, rkey));
} /* while */
end:
// FIXME: ext2_readdir does not reset f_pos
filp->f_pos = next_pos;
pathrelse (&path_to_entry);
reiserfs_check_path(&path_to_entry) ;
UPDATE_ATIME(inode) ;
return 0;
}
int reiserfs_readdir_dentry(struct dentry *dentry, void *dirent,
filldir_t filldir, loff_t *pos)
{
struct inode *inode = dentry->d_inode;
struct cpu_key pos_key;
INITIALIZE_PATH(path_to_entry);
struct buffer_head *bh;
int item_num, entry_num;
const struct reiserfs_key *rkey;
struct item_head *ih, tmp_ih;
int search_res;
char *local_buf;
loff_t next_pos;
char small_buf[32];
struct reiserfs_dir_entry de;
int ret = 0;
reiserfs_write_lock(inode->i_sb);
reiserfs_check_lock_depth(inode->i_sb, "readdir");
make_cpu_key(&pos_key, inode, *pos ?: DOT_OFFSET, TYPE_DIRENTRY, 3);
next_pos = cpu_key_k_offset(&pos_key);
path_to_entry.reada = PATH_READA;
while (1) {
research:
search_res =
search_by_entry_key(inode->i_sb, &pos_key, &path_to_entry,
&de);
if (search_res == IO_ERROR) {
ret = -EIO;
goto out;
}
entry_num = de.de_entry_num;
bh = de.de_bh;
item_num = de.de_item_num;
ih = de.de_ih;
store_ih(&tmp_ih, ih);
RFALSE(COMP_SHORT_KEYS(&(ih->ih_key), &pos_key),
"vs-9000: found item %h does not match to dir we readdir %K",
ih, &pos_key);
RFALSE(item_num > B_NR_ITEMS(bh) - 1,
"vs-9005 item_num == %d, item amount == %d",
item_num, B_NR_ITEMS(bh));
RFALSE(I_ENTRY_COUNT(ih) < entry_num,
"vs-9010: entry number is too big %d (%d)",
entry_num, I_ENTRY_COUNT(ih));
if (search_res == POSITION_FOUND
|| entry_num < I_ENTRY_COUNT(ih)) {
struct reiserfs_de_head *deh =
B_I_DEH(bh, ih) + entry_num;
for (; entry_num < I_ENTRY_COUNT(ih);
entry_num++, deh++) {
int d_reclen;
char *d_name;
off_t d_off;
ino_t d_ino;
if (!de_visible(deh))
continue;
d_reclen = entry_length(bh, ih, entry_num);
d_name = B_I_DEH_ENTRY_FILE_NAME(bh, ih, deh);
if (d_reclen <= 0 ||
d_name + d_reclen > bh->b_data + bh->b_size) {
pathrelse(&path_to_entry);
ret = -EIO;
goto out;
}
if (!d_name[d_reclen - 1])
d_reclen = strlen(d_name);
if (d_reclen >
REISERFS_MAX_NAME(inode->i_sb->
s_blocksize)) {
continue;
}
if (is_privroot_deh(dentry, deh))
continue;
d_off = deh_offset(deh);
*pos = d_off;
d_ino = deh_objectid(deh);
if (d_reclen <= 32) {
local_buf = small_buf;
} else {
local_buf = kmalloc(d_reclen,
GFP_NOFS);
if (!local_buf) {
pathrelse(&path_to_entry);
ret = -ENOMEM;
goto out;
}
if (item_moved(&tmp_ih, &path_to_entry)) {
kfree(local_buf);
goto research;
}
}
memcpy(local_buf, d_name, d_reclen);
reiserfs_write_unlock(inode->i_sb);
if (filldir
(dirent, local_buf, d_reclen, d_off, d_ino,
DT_UNKNOWN) < 0) {
reiserfs_write_lock(inode->i_sb);
if (local_buf != small_buf) {
kfree(local_buf);
}
goto end;
}
reiserfs_write_lock(inode->i_sb);
if (local_buf != small_buf) {
kfree(local_buf);
}
next_pos = deh_offset(deh) + 1;
if (item_moved(&tmp_ih, &path_to_entry)) {
goto research;
}
}
}
if (item_num != B_NR_ITEMS(bh) - 1)
goto end;
rkey = get_rkey(&path_to_entry, inode->i_sb);
if (!comp_le_keys(rkey, &MIN_KEY)) {
set_cpu_key_k_offset(&pos_key, next_pos);
continue;
}
if (COMP_SHORT_KEYS(rkey, &pos_key)) {
goto end;
}
set_cpu_key_k_offset(&pos_key,
le_key_k_offset(KEY_FORMAT_3_5, rkey));
}
end:
*pos = next_pos;
pathrelse(&path_to_entry);
reiserfs_check_path(&path_to_entry);
out:
reiserfs_write_unlock(inode->i_sb);
return ret;
}
