/* 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;
}
static char * reiserfs_cpu_offset (struct cpu_key * key)
{
if (cpu_key_k_type(key) == TYPE_DIRENTRY)
sprintf (off_buf, "%Lu(%Lu)",
(unsigned long long)GET_HASH_VALUE (cpu_key_k_offset (key)),
(unsigned long long)GET_GENERATION_NUMBER (cpu_key_k_offset (key)));
else
sprintf (off_buf, "0x%Lx", (unsigned long long)cpu_key_k_offset (key));
return off_buf;
}
static char * le_offset (struct key * key)
{
int version;
version = le_key_version (key);
if (le_key_k_type (version, key) == TYPE_DIRENTRY)
sprintf (off_buf, "%Lu(%Lu)",
(unsigned long long)GET_HASH_VALUE (le_key_k_offset (version, key)),
(unsigned long long)GET_GENERATION_NUMBER (le_key_k_offset (version, key)));
else
sprintf (off_buf, "0x%Lx", (unsigned long long)le_key_k_offset (version, key));
return off_buf;
}
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)") : "??");
}
}
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;
}
/*
* de's de_bh, de_ih, de_deh, de_item_num, de_entry_num are set already
* Used when hash collisions exist
*/
static int
linear_search_in_dir_item(struct cpu_key *key, struct reiserfs_dir_entry *de,
const char *name, int namelen)
{
int i;
int retval;
struct reiserfs_de_head * deh = de->de_deh;
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
*/
reiserfs_log(LOG_DEBUG, "name `%s' not found\n", 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)),
(unsigned long *)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 */
reiserfs_log(LOG_DEBUG,
"reiserfs_match answered `%d'\n",
retval);
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);
}
/* 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;
}
