void make_empty_dir_item(char *body, __le32 dirid, __le32 objid,
__le32 par_dirid, __le32 par_objid)
{
struct reiserfs_de_head *deh;
memset(body, 0, EMPTY_DIR_SIZE);
deh = (struct reiserfs_de_head *)body;
put_deh_offset(&(deh[0]), DOT_OFFSET);
deh[0].deh_dir_id = dirid;
deh[0].deh_objectid = objid;
deh[0].deh_state = 0;
put_deh_location(&(deh[0]), EMPTY_DIR_SIZE - ROUND_UP(strlen(".")));
mark_de_visible(&(deh[0]));
put_deh_offset(&(deh[1]), DOT_DOT_OFFSET);
deh[1].deh_dir_id = par_dirid;
deh[1].deh_objectid = par_objid;
deh[1].deh_state = 0;
put_deh_location(&(deh[1]),
deh_location(&(deh[0])) - ROUND_UP(strlen("..")));
mark_de_visible(&(deh[1]));
memcpy(body + deh_location(&(deh[0])), ".", 1);
memcpy(body + deh_location(&(deh[1])), "..", 2);
}
/* compose directory item containing "." and ".." entries */
void make_empty_dir_item (char * body, __u32 dirid, __u32 objid,
__u32 par_dirid, __u32 par_objid)
{
struct reiserfs_de_head * deh;
memset (body, 0, EMPTY_DIR_SIZE);
deh = (struct reiserfs_de_head *)body;
/* direntry header of "." */
put_deh_offset( &(deh[0]), DOT_OFFSET );
/* these two are from make_le_item_head, and are are LE */
deh[0].deh_dir_id = dirid;
deh[0].deh_objectid = objid;
deh[0].deh_state = 0; /* Endian safe if 0 */
put_deh_location( &(deh[0]), EMPTY_DIR_SIZE - ROUND_UP( strlen( "." ) ) );
mark_de_visible(&(deh[0]));
/* direntry header of ".." */
put_deh_offset( &(deh[1]), DOT_DOT_OFFSET );
/* key of ".." for the root directory */
/* these two are from the inode, and are are LE */
deh[1].deh_dir_id = par_dirid;
deh[1].deh_objectid = par_objid;
deh[1].deh_state = 0; /* Endian safe if 0 */
put_deh_location( &(deh[1]), deh_location( &(deh[0])) - ROUND_UP( strlen( ".." ) ) );
mark_de_visible(&(deh[1]));
/* copy ".." and "." */
memcpy (body + deh_location( &(deh[0]) ), ".", 1);
memcpy (body + deh_location( &(deh[1]) ), "..", 2);
}
/*
* compose directory item containing "." and ".." entries (entries are
* not aligned to 4 byte boundary)
*/
void make_empty_dir_item_v1(char *body, __le32 dirid, __le32 objid,
__le32 par_dirid, __le32 par_objid)
{
struct reiserfs_de_head *dot, *dotdot;
memset(body, 0, EMPTY_DIR_SIZE_V1);
dot = (struct reiserfs_de_head *)body;
dotdot = dot + 1;
/* direntry header of "." */
put_deh_offset(dot, DOT_OFFSET);
/* these two are from make_le_item_head, and are are LE */
dot->deh_dir_id = dirid;
dot->deh_objectid = objid;
dot->deh_state = 0; /* Endian safe if 0 */
put_deh_location(dot, EMPTY_DIR_SIZE_V1 - strlen("."));
mark_de_visible(dot);
/* direntry header of ".." */
put_deh_offset(dotdot, DOT_DOT_OFFSET);
/* key of ".." for the root directory */
/* these two are from the inode, and are are LE */
dotdot->deh_dir_id = par_dirid;
dotdot->deh_objectid = par_objid;
dotdot->deh_state = 0; /* Endian safe if 0 */
put_deh_location(dotdot, deh_location(dot) - strlen(".."));
mark_de_visible(dotdot);
/* copy ".." and "." */
memcpy(body + deh_location(dot), ".", 1);
memcpy(body + deh_location(dotdot), "..", 2);
}
/* compose directory entry: dir entry head and name itself */
char * make_entry (char * entry, char * name, struct key * key, __u32 offset)
{
struct reiserfs_de_head * deh;
if (!entry)
entry = getmem (DEH_SIZE + ROUND_UP (strlen (name)));
memset (entry, 0, DEH_SIZE + ROUND_UP (strlen (name)));
deh = (struct reiserfs_de_head *)entry;
deh->deh_location = 0; /* Safe if 0 */
set_deh_offset(deh, offset);
deh->deh_state = 0; /* Safe if 0 */
mark_de_visible (deh);
/* key of object entry will point to */
deh->deh_dir_id = key->k_dir_id; /* both little endian */
deh->deh_objectid = key->k_objectid; /* both little endian */
memcpy ((char *)(deh + 1), name, strlen (name));
return entry;
}
static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
struct inode *dir, const char *name, int namelen,
struct inode *inode, int visible)
{
struct cpu_key entry_key;
struct reiserfs_de_head *deh;
INITIALIZE_PATH(path);
struct reiserfs_dir_entry de;
DECLARE_BITMAP(bit_string, MAX_GENERATION_NUMBER + 1);
int gen_number;
char small_buf[32 + DEH_SIZE]; /* 48 bytes now and we avoid kmalloc
if we create file with short name */
char *buffer;
int buflen, paste_size;
int retval;
BUG_ON(!th->t_trans_id);
/* cannot allow items to be added into a busy deleted directory */
if (!namelen)
return -EINVAL;
if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize))
return -ENAMETOOLONG;
/* each entry has unique key. compose it */
make_cpu_key(&entry_key, dir,
get_third_component(dir->i_sb, name, namelen),
TYPE_DIRENTRY, 3);
/* get memory for composing the entry */
buflen = DEH_SIZE + ROUND_UP(namelen);
if (buflen > sizeof(small_buf)) {
buffer = kmalloc(buflen, GFP_NOFS);
if (!buffer)
return -ENOMEM;
} else
buffer = small_buf;
paste_size =
(get_inode_sd_version(dir) ==
STAT_DATA_V1) ? (DEH_SIZE + namelen) : buflen;
/* fill buffer : directory entry head, name[, dir objectid | , stat data | ,stat data, dir objectid ] */
deh = (struct reiserfs_de_head *)buffer;
deh->deh_location = 0; /* JDM Endian safe if 0 */
put_deh_offset(deh, cpu_key_k_offset(&entry_key));
deh->deh_state = 0; /* JDM Endian safe if 0 */
/* put key (ino analog) to de */
deh->deh_dir_id = INODE_PKEY(inode)->k_dir_id; /* safe: k_dir_id is le */
deh->deh_objectid = INODE_PKEY(inode)->k_objectid; /* safe: k_objectid is le */
/* copy name */
memcpy((char *)(deh + 1), name, namelen);
/* padd by 0s to the 4 byte boundary */
padd_item((char *)(deh + 1), ROUND_UP(namelen), namelen);
/* entry is ready to be pasted into tree, set 'visibility' and 'stat data in entry' attributes */
mark_de_without_sd(deh);
visible ? mark_de_visible(deh) : mark_de_hidden(deh);
/* find the proper place for the new entry */
memset(bit_string, 0, sizeof(bit_string));
de.de_gen_number_bit_string = bit_string;
retval = reiserfs_find_entry(dir, name, namelen, &path, &de);
if (retval != NAME_NOT_FOUND) {
if (buffer != small_buf)
kfree(buffer);
pathrelse(&path);
if (retval == IO_ERROR) {
return -EIO;
}
if (retval != NAME_FOUND) {
reiserfs_error(dir->i_sb, "zam-7002",
"reiserfs_find_entry() returned "
"unexpected value (%d)", retval);
}
return -EEXIST;
}
gen_number =
find_first_zero_bit(bit_string,
MAX_GENERATION_NUMBER + 1);
if (gen_number > MAX_GENERATION_NUMBER) {
/* there is no free generation number */
reiserfs_warning(dir->i_sb, "reiserfs-7010",
"Congratulations! we have got hash function "
"screwed up");
if (buffer != small_buf)
kfree(buffer);
pathrelse(&path);
return -EBUSY;
}
/* adjust offset of directory enrty */
put_deh_offset(deh, SET_GENERATION_NUMBER(deh_offset(deh), gen_number));
set_cpu_key_k_offset(&entry_key, deh_offset(deh));
/* update max-hash-collisions counter in reiserfs_sb_info */
PROC_INFO_MAX(th->t_super, max_hash_collisions, gen_number);
if (gen_number != 0) { /* we need to re-search for the insertion point */
if (search_by_entry_key(dir->i_sb, &entry_key, &path, &de) !=
NAME_NOT_FOUND) {
reiserfs_warning(dir->i_sb, "vs-7032",
"entry with this key (%K) already "
"exists", &entry_key);
if (buffer != small_buf)
kfree(buffer);
pathrelse(&path);
return -EBUSY;
}
}
/* perform the insertion of the entry that we have prepared */
retval =
reiserfs_paste_into_item(th, &path, &entry_key, dir, buffer,
paste_size);
if (buffer != small_buf)
kfree(buffer);
if (retval) {
reiserfs_check_path(&path);
return retval;
}
dir->i_size += paste_size;
dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
if (!S_ISDIR(inode->i_mode) && visible)
// reiserfs_mkdir or reiserfs_rename will do that by itself
reiserfs_update_sd(th, dir);
reiserfs_check_path(&path);
return 0;
}
/*
* process, that is going to call fix_nodes/do_balance must hold only
* one path. If it holds 2 or more, it can get into endless waiting in
* get_empty_nodes or its clones
*/
static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
struct inode *new_dir, struct dentry *new_dentry)
{
int retval;
INITIALIZE_PATH(old_entry_path);
INITIALIZE_PATH(new_entry_path);
INITIALIZE_PATH(dot_dot_entry_path);
struct item_head new_entry_ih, old_entry_ih, dot_dot_ih;
struct reiserfs_dir_entry old_de, new_de, dot_dot_de;
struct inode *old_inode, *new_dentry_inode;
struct reiserfs_transaction_handle th;
int jbegin_count;
umode_t old_inode_mode;
unsigned long savelink = 1;
struct timespec ctime;
/* three balancings: (1) old name removal, (2) new name insertion
and (3) maybe "save" link insertion
stat data updates: (1) old directory,
(2) new directory and (3) maybe old object stat data (when it is
directory) and (4) maybe stat data of object to which new entry
pointed initially and (5) maybe block containing ".." of
renamed directory
quota updates: two parent directories */
jbegin_count =
JOURNAL_PER_BALANCE_CNT * 3 + 5 +
4 * REISERFS_QUOTA_TRANS_BLOCKS(old_dir->i_sb);
dquot_initialize(old_dir);
dquot_initialize(new_dir);
old_inode = old_dentry->d_inode;
new_dentry_inode = new_dentry->d_inode;
// make sure, that oldname still exists and points to an object we
// are going to rename
old_de.de_gen_number_bit_string = NULL;
reiserfs_write_lock(old_dir->i_sb);
retval =
reiserfs_find_entry(old_dir, old_dentry->d_name.name,
old_dentry->d_name.len, &old_entry_path,
&old_de);
pathrelse(&old_entry_path);
if (retval == IO_ERROR) {
reiserfs_write_unlock(old_dir->i_sb);
return -EIO;
}
if (retval != NAME_FOUND || old_de.de_objectid != old_inode->i_ino) {
reiserfs_write_unlock(old_dir->i_sb);
return -ENOENT;
}
old_inode_mode = old_inode->i_mode;
if (S_ISDIR(old_inode_mode)) {
// make sure, that directory being renamed has correct ".."
// and that its new parent directory has not too many links
// already
if (new_dentry_inode) {
if (!reiserfs_empty_dir(new_dentry_inode)) {
reiserfs_write_unlock(old_dir->i_sb);
return -ENOTEMPTY;
}
}
/* directory is renamed, its parent directory will be changed,
** so find ".." entry
*/
dot_dot_de.de_gen_number_bit_string = NULL;
retval =
reiserfs_find_entry(old_inode, "..", 2, &dot_dot_entry_path,
&dot_dot_de);
pathrelse(&dot_dot_entry_path);
if (retval != NAME_FOUND) {
reiserfs_write_unlock(old_dir->i_sb);
return -EIO;
}
/* inode number of .. must equal old_dir->i_ino */
if (dot_dot_de.de_objectid != old_dir->i_ino) {
reiserfs_write_unlock(old_dir->i_sb);
return -EIO;
}
}
retval = journal_begin(&th, old_dir->i_sb, jbegin_count);
if (retval) {
reiserfs_write_unlock(old_dir->i_sb);
return retval;
}
/* add new entry (or find the existing one) */
retval =
reiserfs_add_entry(&th, new_dir, new_dentry->d_name.name,
new_dentry->d_name.len, old_inode, 0);
if (retval == -EEXIST) {
if (!new_dentry_inode) {
reiserfs_panic(old_dir->i_sb, "vs-7050",
"new entry is found, new inode == 0");
}
} else if (retval) {
int err = journal_end(&th, old_dir->i_sb, jbegin_count);
reiserfs_write_unlock(old_dir->i_sb);
return err ? err : retval;
}
reiserfs_update_inode_transaction(old_dir);
reiserfs_update_inode_transaction(new_dir);
/* this makes it so an fsync on an open fd for the old name will
** commit the rename operation
*/
reiserfs_update_inode_transaction(old_inode);
if (new_dentry_inode)
reiserfs_update_inode_transaction(new_dentry_inode);
while (1) {
// look for old name using corresponding entry key (found by reiserfs_find_entry)
if ((retval =
search_by_entry_key(new_dir->i_sb, &old_de.de_entry_key,
&old_entry_path,
&old_de)) != NAME_FOUND) {
pathrelse(&old_entry_path);
journal_end(&th, old_dir->i_sb, jbegin_count);
reiserfs_write_unlock(old_dir->i_sb);
return -EIO;
}
copy_item_head(&old_entry_ih, get_ih(&old_entry_path));
reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1);
// look for new name by reiserfs_find_entry
new_de.de_gen_number_bit_string = NULL;
retval =
reiserfs_find_entry(new_dir, new_dentry->d_name.name,
new_dentry->d_name.len, &new_entry_path,
&new_de);
// reiserfs_add_entry should not return IO_ERROR, because it is called with essentially same parameters from
// reiserfs_add_entry above, and we'll catch any i/o errors before we get here.
if (retval != NAME_FOUND_INVISIBLE && retval != NAME_FOUND) {
pathrelse(&new_entry_path);
pathrelse(&old_entry_path);
journal_end(&th, old_dir->i_sb, jbegin_count);
reiserfs_write_unlock(old_dir->i_sb);
return -EIO;
}
copy_item_head(&new_entry_ih, get_ih(&new_entry_path));
reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1);
if (S_ISDIR(old_inode->i_mode)) {
if ((retval =
search_by_entry_key(new_dir->i_sb,
&dot_dot_de.de_entry_key,
&dot_dot_entry_path,
&dot_dot_de)) != NAME_FOUND) {
pathrelse(&dot_dot_entry_path);
pathrelse(&new_entry_path);
pathrelse(&old_entry_path);
journal_end(&th, old_dir->i_sb, jbegin_count);
reiserfs_write_unlock(old_dir->i_sb);
return -EIO;
}
copy_item_head(&dot_dot_ih,
get_ih(&dot_dot_entry_path));
// node containing ".." gets into transaction
reiserfs_prepare_for_journal(old_inode->i_sb,
dot_dot_de.de_bh, 1);
}
/* we should check seals here, not do
this stuff, yes? Then, having
gathered everything into RAM we
should lock the buffers, yes? -Hans */
/* probably. our rename needs to hold more
** than one path at once. The seals would
** have to be written to deal with multi-path
** issues -chris
*/
/* sanity checking before doing the rename - avoid races many
** of the above checks could have scheduled. We have to be
** sure our items haven't been shifted by another process.
*/
if (item_moved(&new_entry_ih, &new_entry_path) ||
!entry_points_to_object(new_dentry->d_name.name,
new_dentry->d_name.len,
&new_de, new_dentry_inode) ||
item_moved(&old_entry_ih, &old_entry_path) ||
!entry_points_to_object(old_dentry->d_name.name,
old_dentry->d_name.len,
&old_de, old_inode)) {
reiserfs_restore_prepared_buffer(old_inode->i_sb,
new_de.de_bh);
reiserfs_restore_prepared_buffer(old_inode->i_sb,
old_de.de_bh);
if (S_ISDIR(old_inode_mode))
reiserfs_restore_prepared_buffer(old_inode->
i_sb,
dot_dot_de.
de_bh);
continue;
}
if (S_ISDIR(old_inode_mode)) {
if (item_moved(&dot_dot_ih, &dot_dot_entry_path) ||
!entry_points_to_object("..", 2, &dot_dot_de,
old_dir)) {
reiserfs_restore_prepared_buffer(old_inode->
i_sb,
old_de.de_bh);
reiserfs_restore_prepared_buffer(old_inode->
i_sb,
new_de.de_bh);
reiserfs_restore_prepared_buffer(old_inode->
i_sb,
dot_dot_de.
de_bh);
continue;
}
}
RFALSE(S_ISDIR(old_inode_mode) &&
!buffer_journal_prepared(dot_dot_de.de_bh), "");
break;
}
/* ok, all the changes can be done in one fell swoop when we
have claimed all the buffers needed. */
mark_de_visible(new_de.de_deh + new_de.de_entry_num);
set_ino_in_dir_entry(&new_de, INODE_PKEY(old_inode));
journal_mark_dirty(&th, old_dir->i_sb, new_de.de_bh);
mark_de_hidden(old_de.de_deh + old_de.de_entry_num);
journal_mark_dirty(&th, old_dir->i_sb, old_de.de_bh);
ctime = CURRENT_TIME_SEC;
old_dir->i_ctime = old_dir->i_mtime = ctime;
new_dir->i_ctime = new_dir->i_mtime = ctime;
/* thanks to Alex Adriaanse <*****@*****.**> for patch which adds ctime update of
renamed object */
old_inode->i_ctime = ctime;
if (new_dentry_inode) {
// adjust link number of the victim
if (S_ISDIR(new_dentry_inode->i_mode)) {
clear_nlink(new_dentry_inode);
} else {
drop_nlink(new_dentry_inode);
}
new_dentry_inode->i_ctime = ctime;
savelink = new_dentry_inode->i_nlink;
}
if (S_ISDIR(old_inode_mode)) {
/* adjust ".." of renamed directory */
set_ino_in_dir_entry(&dot_dot_de, INODE_PKEY(new_dir));
journal_mark_dirty(&th, new_dir->i_sb, dot_dot_de.de_bh);
if (!new_dentry_inode)
/* there (in new_dir) was no directory, so it got new link
(".." of renamed directory) */
INC_DIR_INODE_NLINK(new_dir);
/* old directory lost one link - ".. " of renamed directory */
DEC_DIR_INODE_NLINK(old_dir);
}
// looks like in 2.3.99pre3 brelse is atomic. so we can use pathrelse
pathrelse(&new_entry_path);
pathrelse(&dot_dot_entry_path);
// FIXME: this reiserfs_cut_from_item's return value may screw up
// anybody, but it will panic if will not be able to find the
// entry. This needs one more clean up
if (reiserfs_cut_from_item
(&th, &old_entry_path, &(old_de.de_entry_key), old_dir, NULL,
0) < 0)
reiserfs_error(old_dir->i_sb, "vs-7060",
"couldn't not cut old name. Fsck later?");
old_dir->i_size -= DEH_SIZE + old_de.de_entrylen;
reiserfs_update_sd(&th, old_dir);
reiserfs_update_sd(&th, new_dir);
reiserfs_update_sd(&th, old_inode);
if (new_dentry_inode) {
if (savelink == 0)
add_save_link(&th, new_dentry_inode,
0 /* not truncate */ );
reiserfs_update_sd(&th, new_dentry_inode);
}
retval = journal_end(&th, old_dir->i_sb, jbegin_count);
reiserfs_write_unlock(old_dir->i_sb);
return retval;
}
/*
* process, that is going to call fix_nodes/do_balance must hold only
* one path. If it holds 2 or more, it can get into endless waiting in
* get_empty_nodes or its clones
*/
static int do_reiserfs_rename (struct reiserfs_transaction_handle *th, struct inode * old_dir, struct dentry *old_dentry,
struct inode * new_dir, struct dentry *new_dentry)
{
int retval;
struct path old_entry_path, new_entry_path, dot_dot_entry_path;
struct reiserfs_dir_entry old_de, new_de, dot_dot_de;
struct inode * old_inode, * new_inode;
int new_entry_added = 0;
init_path (&old_entry_path);
init_path (&new_entry_path);
init_path (&dot_dot_entry_path);
goto start_up;
try_again:
current->policy |= SCHED_YIELD;
schedule();
start_up:
old_inode = new_inode = NULL;
dot_dot_de.de_bh = 0;
new_de.de_bh = 0;
/*
* look for the old name in old directory
*/
retval = -ENOENT;
old_de.de_gen_number_bit_string = 0;
if (reiserfs_find_entry (old_dir, old_dentry->d_name.name, old_dentry->d_name.len, &old_entry_path, &old_de) == POSITION_NOT_FOUND)
goto end_rename;
pathrelse (&old_entry_path);
old_inode = old_dentry->d_inode;
retval = -EPERM;
if ((old_dir->i_mode & S_ISVTX) &&
current->fsuid != old_inode->i_uid &&
current->fsuid != old_dir->i_uid && !fsuser())
goto end_rename;
new_inode = new_dentry->d_inode;
/* look for the new entry in target directory */
new_de.de_gen_number_bit_string = 0;
if (reiserfs_find_entry (new_dir, new_dentry->d_name.name, new_dentry->d_name.len, &new_entry_path, &new_de) == POSITION_FOUND) {
if (!new_inode) {
printk ("do_reiserfs_rename: new entry found, inode == 0 though\n");
}
/* this entry already exists, we can just set key of object */
new_entry_added = 1;
} else {
#ifdef REISERFS_CHECK
if (new_entry_added) {
if (new_de.de_namelen != new_dentry->d_name.len || memcmp (new_de.de_name, new_dentry->d_name.name, new_de.de_namelen) ||
de_visible (new_de.de_deh))
reiserfs_panic (old_dir->i_sb, "vs-7045: reiserfs_rename: suspicious entry found");
}
#endif /* REISERFS_CHECK */
}
pathrelse (&new_entry_path);
if (new_inode == old_inode) {
retval = 0;
goto end_rename;
}
if (new_inode && S_ISDIR(new_inode->i_mode)) {
/* new name exists and points to directory */
retval = -EISDIR;
if (!S_ISDIR(old_inode->i_mode))
goto end_rename;
retval = -EINVAL;
if (is_subdir (new_dentry, old_dentry))
goto end_rename;
retval = -ENOTEMPTY;
if (!reiserfs_empty_dir (new_inode))
goto end_rename;
retval = -EBUSY;
if (new_inode->i_count > 1)
goto end_rename;
}
retval = -EPERM;
if (new_inode && (new_dir->i_mode & S_ISVTX) &&
current->fsuid != new_inode->i_uid &&
current->fsuid != new_dir->i_uid && !fsuser())
goto end_rename;
if (S_ISDIR(old_inode->i_mode)) {
/* old name points to directory */
retval = -ENOTDIR;
if (new_inode && !S_ISDIR(new_inode->i_mode))
goto end_rename;
retval = -EINVAL;
if (is_subdir(new_dentry, old_dentry))
goto end_rename;
retval = -EIO;
/* directory is renamed, its parent directory will be changed, so find ".." entry */
dot_dot_de.de_gen_number_bit_string = 0;
if (reiserfs_find_entry (old_inode, "..", 2, &dot_dot_entry_path, &dot_dot_de) == POSITION_NOT_FOUND)
goto end_rename;
if (dot_dot_de.de_objectid != old_dir->i_ino)
goto end_rename;
pathrelse (&dot_dot_entry_path);
retval = -EMLINK;
if (!new_inode && new_dir->i_nlink >= REISERFS_LINK_MAX)
goto end_rename;
}
if (new_entry_added == 0) {
/* add new entry if we did not do it, but do not mark it as visible */
retval = reiserfs_add_entry (th, new_dir, new_dentry->d_name.name, new_dentry->d_name.len, INODE_PKEY (old_inode), &new_de, 0);
if (retval)
goto end_rename;
if_in_ram_update_sd (th, new_dir);
new_entry_added = 1;
goto try_again;
}
/*
* look for old name, new name and ".." when renaming directories again
*/
if (reiserfs_find_entry (old_dir, old_dentry->d_name.name, old_dentry->d_name.len, &old_entry_path, &old_de) == POSITION_NOT_FOUND)
reiserfs_panic (old_dir->i_sb, "vs-7050: reiserfs_rename: old name not found");
if (reiserfs_find_entry (new_dir, new_dentry->d_name.name, new_dentry->d_name.len, &new_entry_path, &new_de) == POSITION_NOT_FOUND)
reiserfs_panic (old_dir->i_sb, "vs-7055: reiserfs_rename: new name not found");
if (S_ISDIR(old_inode->i_mode) && reiserfs_find_entry (old_inode, "..", 2, &dot_dot_entry_path, &dot_dot_de) == POSITION_NOT_FOUND)
reiserfs_panic (old_dir->i_sb, "vs-7060: reiserfs_rename: \"..\" name not found");
/* sanity checking before doing the rename - avoid races */
if (!entry_points_to_object (new_dentry->d_name.name, new_dentry->d_name.len, &new_de, new_inode))
goto try_again;
if (!entry_points_to_object (old_dentry->d_name.name, old_dentry->d_name.len, &old_de, old_inode))
/* go to re-looking for old entry */
goto try_again;
if (S_ISDIR(old_inode->i_mode) && !entry_points_to_object ("..", 2, &dot_dot_de, old_dir))
/* go to re-looking for ".." entry of renamed directory */
goto try_again;
/* ok, all the changes can be done in one fell swoop when we have
claimed all the buffers needed.*/
/* make old name hidden */
mark_de_hidden (old_de.de_deh);
journal_mark_dirty(th, old_dir->i_sb, old_de.de_bh) ;
/* make new name visible and set key of old object (if entry
existed, it is already visible, if not, key is correct already) */
mark_de_visible (new_de.de_deh);
new_de.de_deh->deh_dir_id = INODE_PKEY (old_inode)->k_dir_id;
new_de.de_deh->deh_objectid = INODE_PKEY (old_inode)->k_objectid;
journal_mark_dirty(th, old_dir->i_sb, new_de.de_bh) ;
old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
if_in_ram_update_sd (th, old_dir);
new_dir->i_ctime = new_dir->i_mtime = CURRENT_TIME;
if_in_ram_update_sd (th, new_dir);
if (new_inode) {
new_inode->i_nlink--;
new_inode->i_ctime = CURRENT_TIME;
if_in_ram_update_sd (th, new_inode);
}
if (dot_dot_de.de_bh) {
set_ino_in_dir_entry (&dot_dot_de, INODE_PKEY (new_dir));
journal_mark_dirty(th, old_dir->i_sb, dot_dot_de.de_bh) ;
old_dir->i_nlink--;
if_in_ram_update_sd (th, old_dir);
if (new_inode) {
new_inode->i_nlink--;
if_in_ram_update_sd (th, new_inode);
} else {
new_dir->i_nlink++;
if_in_ram_update_sd (th, new_dir);
}
}
/* ok, renaming done */
decrement_counters_in_path (&new_entry_path);
decrement_counters_in_path (&dot_dot_entry_path);
/* remove old name (it is hidden now) */
if (reiserfs_cut_from_item (th, old_dir, old_dir->i_sb, &old_entry_path, &(old_de.de_entry_num),
&(old_de.de_entry_key), 0, PRESERVE_RENAMING) == 0)
printk ("reiserfs_rename: could not remove old name\n");
else {
old_dir->i_size -= DEH_SIZE + old_de.de_entrylen;
old_dir->i_blocks = old_dir->i_size / 512 + ((old_dir->i_size % 512) ? 1 : 0);
if_in_ram_update_sd (th, old_dir);
}
/* Update the dcache */
d_move(old_dentry, new_dentry);
retval = 0;
end_rename:
pathrelse (&old_entry_path);
return retval;
}
/* add entry to the directory (entry can be hidden). Does not mark dir
inode dirty, do it after successesfull call to it */
static int reiserfs_add_entry (struct reiserfs_transaction_handle *th, struct inode * dir,
const char * name, int namelen, struct key * object_key, struct reiserfs_dir_entry * de,
int visible
)
{
struct key entry_key;
char * buffer;
int buflen;
struct reiserfs_de_head * deh;
struct path path;
char bit_string [MAX_GEN_NUMBER / 8 + 1];
int gen_number;
int repeat;
#ifdef REISERFS_ALIGNED
int aligned_namelen = (namelen+3) & ~3;
#endif
init_path (&path);
if (!dir || !dir->i_sb)
return -ENOENT;
if ((unsigned int)namelen > REISERFS_MAX_NAME_LEN (dir->i_sb->s_blocksize))
return -ENAMETOOLONG;
/* each entry has unique key. compose it */
copy_key (&entry_key, INODE_PKEY(dir));
entry_key.k_offset = get_third_component (name, namelen);
entry_key.k_uniqueness = DIRENTRY_UNIQUENESS;
/* get memory for composing the entry */
#ifdef REISERFS_ALIGNED
buflen = DEH_SIZE + aligned_namelen;
#else
buflen = DEH_SIZE + namelen;
#endif
buffer = reiserfs_kmalloc (buflen, GFP_KERNEL, dir->i_sb);
if (buffer == 0)
return -ENOMEM;
/* fill buffer : directory entry head, name[, dir objectid | , stat data | ,stat data, dir objectid ] */
deh = (struct reiserfs_de_head *)buffer;
deh->deh_location = 0;
deh->deh_offset = entry_key.k_offset;
deh->deh_state = 0;
/* put key (ino analog) to de */
deh->deh_dir_id = object_key->k_dir_id;
deh->deh_objectid = object_key->k_objectid;
/* copy name */
#ifdef REISERFS_ALIGNED
memset( (char*)(deh+1), '\0', aligned_namelen );
#endif
memcpy ((char *)(deh + 1), name, namelen);
/* entry is ready to be pasted into tree, set 'visibility' and 'stat data in entry' attributes */
mark_de_without_sd (deh);
visible ? mark_de_visible (deh) : mark_de_hidden (deh);
/* find the proper place for the new entry */
memset (bit_string, 0, sizeof (bit_string));
de->de_gen_number_bit_string = bit_string;
if (reiserfs_find_entry (dir, name, namelen, &path, de) == POSITION_FOUND) {
reiserfs_panic (dir->i_sb, "vs-7030: reiserfs_add_entry: entry with this key %k already exists",
&entry_key);
}
if (find_first_nonzero_bit (bit_string, MAX_GEN_NUMBER + 1) < MAX_GEN_NUMBER + 1) {
/* there are few names with given hash value */
gen_number = find_first_zero_bit (bit_string, MAX_GEN_NUMBER + 1);
if (gen_number > MAX_GEN_NUMBER) {
/* there is no free generation number */
reiserfs_kfree (buffer, buflen, dir->i_sb);
pathrelse (&path);
return -EHASHCOLLISION;
}
/* adjust offset of directory enrty */
deh->deh_offset = SET_GENERATION_NUMBER (deh->deh_offset, gen_number);
entry_key.k_offset = deh->deh_offset;
/* find place for new entry */
if (search_by_entry_key (dir->i_sb, &entry_key, &path, &(de->de_entry_num), &repeat)) {
reiserfs_panic (dir->i_sb, "reiserfs_add_entry: 7032: entry with this key (%k) already exists", &entry_key);
}
} else {
deh->deh_offset = SET_GENERATION_NUMBER (deh->deh_offset, 0);
entry_key.k_offset = deh->deh_offset;
}
/* perform the insertion of the entry that we have prepared */
if (reiserfs_paste_into_item (th, dir->i_sb, &path, &(de->de_entry_num), &entry_key, buffer,
buflen, REISERFS_KERNEL_MEM, 0) == -1) {
reiserfs_kfree (buffer, buflen, dir->i_sb);
return -ENOSPC;
}
reiserfs_kfree (buffer, buflen, dir->i_sb);
dir->i_size += buflen;
dir->i_mtime = dir->i_ctime = CURRENT_TIME;
return 0;
}
/* 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
}
