static inline void displace_large_file(reiserfs_blocknr_hint_t *hint)
{
if ( TEST_OPTION(displace_based_on_dirid, hint->th->t_super))
hint->search_start = hint->beg + keyed_hash((char *)(&INODE_PKEY(hint->inode)->k_dir_id), 4) % (hint->end - hint->beg);
else
hint->search_start = hint->beg + keyed_hash((char *)(&INODE_PKEY(hint->inode)->k_objectid), 4) % (hint->end - hint->beg);
}
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 inline void hash_formatted_node(reiserfs_blocknr_hint_t *hint)
{
char * hash_in;
if (!hint->inode)
hash_in = (char*)&hint->key.k_dir_id;
else if ( TEST_OPTION(displace_based_on_dirid, hint->th->t_super))
hash_in = (char *)(&INODE_PKEY(hint->inode)->k_dir_id);
else
hash_in = (char *)(&INODE_PKEY(hint->inode)->k_objectid);
hint->search_start = hint->beg + keyed_hash(hash_in, 4) % (hint->end - hint->beg);
}
static struct dentry *open_xa_dir(const struct inode *inode, int flags)
{
struct dentry *xaroot, *xadir;
char namebuf[17];
xaroot = open_xa_root(inode->i_sb, flags);
if (IS_ERR(xaroot))
return xaroot;
snprintf(namebuf, sizeof(namebuf), "%X.%X",
le32_to_cpu(INODE_PKEY(inode)->k_objectid),
inode->i_generation);
mutex_lock_nested(&xaroot->d_inode->i_mutex, I_MUTEX_XATTR);
xadir = lookup_one_len(namebuf, xaroot, strlen(namebuf));
if (!IS_ERR(xadir) && !xadir->d_inode) {
int err = -ENODATA;
if (xattr_may_create(flags))
err = xattr_mkdir(xaroot->d_inode, xadir, 0700);
if (err) {
dput(xadir);
xadir = ERR_PTR(err);
}
}
mutex_unlock(&xaroot->d_inode->i_mutex);
dput(xaroot);
return xadir;
}
/*
* the packing is returned in disk byte order
*/
u32 reiserfs_choose_packing(struct inode *dir) {
u32 packing;
if (TEST_OPTION(packing_groups, dir->i_sb)) {
u32 parent_dir = le32_to_cpu(INODE_PKEY(dir)->k_dir_id);
/*
* some versions of reiserfsck expect packing locality 1 to be
* special
*/
if (parent_dir == 1 || block_group_used(dir->i_sb,parent_dir))
packing = INODE_PKEY(dir)->k_objectid;
else
packing = INODE_PKEY(dir)->k_dir_id;
} else
packing = INODE_PKEY(dir)->k_objectid;
return packing;
}
static inline bool is_privroot_deh(struct dentry *dir,
struct reiserfs_de_head *deh)
{
struct dentry *privroot = REISERFS_SB(dir->d_sb)->priv_root;
return (dir == dir->d_parent && privroot->d_inode &&
deh->deh_objectid == INODE_PKEY(privroot->d_inode)->k_objectid);
}
static void inline new_hashed_relocation (reiserfs_blocknr_hint_t * hint)
{
char * hash_in;
if (hint->formatted_node) {
hash_in = (char*)&hint->key.k_dir_id;
} else {
if (!hint->inode) {
//hint->search_start = hint->beg;
hash_in = (char*)&hint->key.k_dir_id;
} else if ( TEST_OPTION(displace_based_on_dirid, hint->th->t_super))
hash_in = (char *)(&INODE_PKEY(hint->inode)->k_dir_id);
else
hash_in = (char *)(&INODE_PKEY(hint->inode)->k_objectid);
}
hint->search_start = hint->beg + keyed_hash(hash_in, 4) % (hint->end - hint->beg);
}
int reiserfs_link (struct dentry * old_dentry, struct inode * dir, struct dentry * dentry)
{
struct inode *inode = old_dentry->d_inode;
struct path path_to_entry;
struct reiserfs_dir_entry de;
int error;
int windex ;
struct reiserfs_transaction_handle th ;
int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3;
init_path (&path_to_entry);
/* object must not be directory */
if (S_ISDIR(inode->i_mode)) {
return -EPERM;
}
/* file has too many links */
if (inode->i_nlink >= REISERFS_LINK_MAX) {
return -EMLINK;
}
journal_begin(&th, dir->i_sb, jbegin_count) ;
windex = push_journal_writer("reiserfs_link") ;
reiserfs_update_inode_transaction(inode) ;
reiserfs_update_inode_transaction(dir) ;
de.de_gen_number_bit_string = 0;
if (reiserfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &path_to_entry, &de) == POSITION_FOUND) {
pathrelse (&path_to_entry);
pop_journal_writer(windex) ;
journal_end(&th, dir->i_sb, jbegin_count) ;
return -EEXIST;
}
pathrelse (&path_to_entry);
/* free preserve list if we should */
/* maybe_free_preserve_list (dir->i_sb);*/
/* create new entry */
error = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len, INODE_PKEY (inode), &de, 1);
if (error) {
pop_journal_writer(windex) ;
journal_end(&th, dir->i_sb, jbegin_count) ;
return error;
}
inode->i_nlink++;
inode->i_ctime = CURRENT_TIME;
if_in_ram_update_sd (&th, inode);
if_in_ram_update_sd (&th, dir);
inode->i_count++;
d_instantiate(dentry, inode);
pop_journal_writer(windex) ;
journal_end(&th, dir->i_sb, jbegin_count) ;
return 0;
}
/* utility function that does setup for reiserfs_new_inode.
** dquot_initialize needs lots of credits so it's better to have it
** outside of a transaction, so we had to pull some bits of
** reiserfs_new_inode out into this func.
*/
static int new_inode_init(struct inode *inode, struct inode *dir, umode_t mode)
{
/* Make inode invalid - just in case we are going to drop it before
* the initialization happens */
INODE_PKEY(inode)->k_objectid = 0;
/* the quota init calls have to know who to charge the quota to, so
** we have to set uid and gid here
*/
inode_init_owner(inode, dir, mode);
dquot_initialize(inode);
return 0;
}
static inline int old_way (reiserfs_blocknr_hint_t * hint)
{
b_blocknr_t border;
if (hint->formatted_node || hint->inode == NULL) {
return 0;
}
border = hint->beg + le32_to_cpu(INODE_PKEY(hint->inode)->k_dir_id) % (hint->end - hint->beg);
if (border > hint->search_start)
hint->search_start = border;
return 1;
}
static struct dentry *reiserfs_lookup(struct inode *dir, struct dentry *dentry,
struct nameidata *nd)
{
int retval;
struct inode *inode = NULL;
struct reiserfs_dir_entry de;
INITIALIZE_PATH(path_to_entry);
if (REISERFS_MAX_NAME(dir->i_sb->s_blocksize) < dentry->d_name.len)
return ERR_PTR(-ENAMETOOLONG);
reiserfs_write_lock(dir->i_sb);
de.de_gen_number_bit_string = NULL;
retval =
reiserfs_find_entry(dir, dentry->d_name.name, dentry->d_name.len,
&path_to_entry, &de);
pathrelse(&path_to_entry);
if (retval == NAME_FOUND) {
/* Hide the .reiserfs_priv directory */
if (reiserfs_xattrs(dir->i_sb) &&
!old_format_only(dir->i_sb) &&
REISERFS_SB(dir->i_sb)->priv_root &&
REISERFS_SB(dir->i_sb)->priv_root->d_inode &&
de.de_objectid ==
le32_to_cpu(INODE_PKEY
(REISERFS_SB(dir->i_sb)->priv_root->d_inode)->
k_objectid)) {
reiserfs_write_unlock(dir->i_sb);
return ERR_PTR(-EACCES);
}
inode =
reiserfs_iget(dir->i_sb, (struct cpu_key *)&(de.de_dir_id));
if (!inode || IS_ERR(inode)) {
reiserfs_write_unlock(dir->i_sb);
return ERR_PTR(-EACCES);
}
/* Propogate the priv_object flag so we know we're in the priv tree */
if (is_reiserfs_priv_object(dir))
reiserfs_mark_inode_private(inode);
}
reiserfs_write_unlock(dir->i_sb);
if (retval == IO_ERROR) {
return ERR_PTR(-EIO);
}
return d_splice_alias(inode, dentry);
}
/*
* Relocation based on oid, hashing them into a given bitmap block
* files. Formatted nodes are unaffected, a seperate policy covers them
*/
static void
oid_groups (reiserfs_blocknr_hint_t *hint)
{
if (hint->inode) {
unsigned long hash;
__u32 oid;
__u32 dirid;
int bm;
dirid = le32_to_cpu(INODE_PKEY(hint->inode)->k_dir_id);
/* keep the root dir and it's first set of subdirs close to
* the start of the disk
*/
if (dirid <= 2)
hash = (hint->inode->i_sb->s_blocksize << 3);
else {
oid = le32_to_cpu(INODE_PKEY(hint->inode)->k_objectid);
bm = bmap_hash_id(hint->inode->i_sb, oid);
hash = bm * (hint->inode->i_sb->s_blocksize << 3);
}
hint->search_start = hash;
}
}
static inline int old_hashed_relocation (reiserfs_blocknr_hint_t * hint)
{
b_blocknr_t border;
u32 hash_in;
if (hint->formatted_node || hint->inode == NULL) {
return 0;
}
hash_in = le32_to_cpu((INODE_PKEY(hint->inode))->k_dir_id);
border = hint->beg + (u32) keyed_hash(((char *) (&hash_in)), 4) % (hint->end - hint->beg - 1);
if (border > hint->search_start)
hint->search_start = border;
return 1;
}
int reiserfs_create (struct inode * dir, struct dentry *dentry, int mode)
{
int error;
struct inode * inode;
struct reiserfs_dir_entry de;
int windex ;
int jbegin_count = JOURNAL_PER_BALANCE_CNT * 2 ;
struct reiserfs_transaction_handle th ;
int err;
if (!dir)
return -ENOENT;
inode = get_empty_inode() ;
if (!inode) {
return -ENOSPC ;
}
journal_begin(&th, dir->i_sb, jbegin_count) ;
th.t_caller = "create" ;
windex = push_journal_writer("reiserfs_create") ;
inode = reiserfs_new_inode (&th, dir, mode, 0, dentry, inode, &err);
if (!inode) {
pop_journal_writer(windex) ;
journal_end(&th, dir->i_sb, jbegin_count) ;
return err;
}
reiserfs_update_inode_transaction(inode) ;
reiserfs_update_inode_transaction(dir) ;
inode->i_op = &reiserfs_file_inode_operations;
inode->i_mode = mode;
error = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len, INODE_PKEY (inode), &de, 1);
if (error) {
inode->i_nlink--;
if_in_ram_update_sd (&th, inode);
pop_journal_writer(windex) ;
journal_end(&th, dir->i_sb, jbegin_count) ;
iput (inode);
return error;
}
if_in_ram_update_sd (&th, dir);
d_instantiate(dentry, inode);
pop_journal_writer(windex) ;
journal_end(&th, dir->i_sb, jbegin_count) ;
return 0;
}
/*
* Relocation based on dirid, hashing them into a given bitmap block
* files. Formatted nodes are unaffected, a seperate policy covers them
*/
static void
dirid_groups (reiserfs_blocknr_hint_t *hint)
{
unsigned long hash;
__u32 dirid = 0;
int bm = 0;
struct super_block *sb = hint->th->t_super;
if (hint->inode)
dirid = le32_to_cpu(INODE_PKEY(hint->inode)->k_dir_id);
else if (hint->formatted_node)
dirid = hint->key.k_dir_id;
if (dirid) {
bm = bmap_hash_id(sb, dirid);
hash = bm * (sb->s_blocksize << 3);
/* give a portion of the block group to metadata */
if (hint->inode)
hash += sb->s_blocksize/2;
hint->search_start = hash;
}
}
/* utility function that does setup for reiserfs_new_inode.
** dquot_initialize needs lots of credits so it's better to have it
** outside of a transaction, so we had to pull some bits of
** reiserfs_new_inode out into this func.
*/
static int new_inode_init(struct inode *inode, struct inode *dir, int mode)
{
/* the quota init calls have to know who to charge the quota to, so
** we have to set uid and gid here
*/
inode->i_uid = current_fsuid();
inode->i_mode = mode;
/* Make inode invalid - just in case we are going to drop it before
* the initialization happens */
INODE_PKEY(inode)->k_objectid = 0;
if (dir->i_mode & S_ISGID) {
inode->i_gid = dir->i_gid;
if (S_ISDIR(mode))
inode->i_mode |= S_ISGID;
} else {
inode->i_gid = current_fsgid();
}
dquot_initialize(inode);
return 0;
}
/* this opens transaction unlike add_save_link */
void remove_save_link (struct inode * inode, int truncate)
{
struct reiserfs_transaction_handle th;
struct key key;
/* we are going to do one balancing only */
journal_begin (&th, inode->i_sb, JOURNAL_PER_BALANCE_CNT);
/* setup key of "save" link */
key.k_dir_id = cpu_to_le32 (MAX_KEY_OBJECTID);
key.k_objectid = INODE_PKEY (inode)->k_objectid;
if (!truncate) {
/* unlink, rmdir, rename */
set_le_key_k_offset (KEY_FORMAT_3_5, &key,
1 + inode->i_sb->s_blocksize);
set_le_key_k_type (KEY_FORMAT_3_5, &key, TYPE_DIRECT);
} else {
/* truncate */
set_le_key_k_offset (KEY_FORMAT_3_5, &key, 1);
set_le_key_k_type (KEY_FORMAT_3_5, &key, TYPE_INDIRECT);
}
if( ( truncate &&
( inode -> u.reiserfs_i.i_flags & i_link_saved_truncate_mask ) ) ||
( !truncate &&
( inode -> u.reiserfs_i.i_flags & i_link_saved_unlink_mask ) ) )
reiserfs_delete_solid_item (&th, &key);
if (!truncate) {
reiserfs_release_objectid (&th, inode->i_ino);
inode -> u.reiserfs_i.i_flags &= ~i_link_saved_unlink_mask;
} else
inode -> u.reiserfs_i.i_flags &= ~i_link_saved_truncate_mask;
journal_end (&th, inode->i_sb, JOURNAL_PER_BALANCE_CNT);
}
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);
}
static int reiserfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
{
struct inode *inode = filp->f_path.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,
(filp->f_pos) ? (filp->f_pos) : DOT_OFFSET, TYPE_DIRENTRY,
3);
next_pos = cpu_key_k_offset(&pos_key);
/* reiserfs_warning (inode->i_sb, "reiserfs_readdir 1: f_pos = %Ld", filp->f_pos); */
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;
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(inode->i_sb->
s_blocksize)) {
/* too big to send back to VFS */
continue;
}
/* Ignore the .reiserfs_priv entry */
if (reiserfs_xattrs(inode->i_sb) &&
!old_format_only(inode->i_sb) &&
filp->f_path.dentry == inode->i_sb->s_root &&
REISERFS_SB(inode->i_sb)->priv_root &&
REISERFS_SB(inode->i_sb)->priv_root->d_inode
&& deh_objectid(deh) ==
le32_to_cpu(INODE_PKEY
(REISERFS_SB(inode->i_sb)->
priv_root->d_inode)->
k_objectid)) {
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 = 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);
if (filldir
(dirent, local_buf, d_reclen, d_off, d_ino,
DT_UNKNOWN) < 0) {
if (local_buf != small_buf) {
kfree(local_buf);
}
goto end;
}
if (local_buf != small_buf) {
kfree(local_buf);
}
// 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:
filp->f_pos = next_pos;
pathrelse(&path_to_entry);
reiserfs_check_path(&path_to_entry);
out:
reiserfs_write_unlock(inode->i_sb);
return ret;
}
int reiserfs_unlink (struct inode * dir, struct dentry *dentry)
{
int retval;
struct inode * inode;
struct reiserfs_dir_entry de;
struct path path;
int windex ;
int call_journal_end = 1 ;
struct reiserfs_transaction_handle th ;
int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3;
init_path (&path);
retval = -ENOENT;
journal_begin(&th, dir->i_sb, jbegin_count) ;
windex = push_journal_writer("reiserfs_unlink") ;
/* free preserve list if we should */
/* maybe_free_preserve_list (dir->i_sb);*/
de.de_gen_number_bit_string = 0;
if (reiserfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &path, &de) == POSITION_NOT_FOUND) {
goto end_unlink;
}
inode = dentry->d_inode;
reiserfs_update_inode_transaction(inode) ;
reiserfs_update_inode_transaction(dir) ;
retval = -EPERM;
if (S_ISDIR (inode->i_mode)) {
goto end_unlink;
}
if ((dir->i_mode & S_ISVTX) && !fsuser() &&
current->fsuid != inode->i_uid &&
current->fsuid != dir->i_uid) {
goto end_unlink;
}
retval = -ENOENT;
if (comp_short_keys ((struct key *)&(de.de_dir_id), INODE_PKEY (inode))) {
goto end_unlink;
}
if (!inode->i_nlink) {
printk("reiserfs_unlink: deleting nonexistent file (%s:%lu), %d\n",
kdevname(inode->i_dev), inode->i_ino, inode->i_nlink);
inode->i_nlink = 1;
}
if (reiserfs_cut_from_item (&th, dir, dir->i_sb, &path, &(de.de_entry_num), &(de.de_entry_key), 0, NOTHING_SPECIAL) == 0) {
retval = -ENOENT;
goto end_unlink;
}
inode->i_nlink--;
inode->i_ctime = CURRENT_TIME;
if_in_ram_update_sd (&th, inode);
dir->i_size -= (de.de_entrylen + DEH_SIZE);
dir->i_ctime = dir->i_mtime = CURRENT_TIME;
if_in_ram_update_sd (&th, dir) ;
pop_journal_writer(windex) ;
journal_end(&th, dir->i_sb, jbegin_count) ;
call_journal_end = 0 ;
d_delete(dentry);
retval = 0;
end_unlink:
pathrelse (&path);
pop_journal_writer(windex) ;
if (call_journal_end)
journal_end(&th, dir->i_sb, jbegin_count) ;
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 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;
}
/*
* inode->i_mutex: down
*/
int
reiserfs_xattr_get(struct inode *inode, const char *name, void *buffer,
size_t buffer_size)
{
ssize_t err = 0;
struct dentry *dentry;
size_t isize;
size_t file_pos = 0;
size_t buffer_pos = 0;
struct page *page;
__u32 hash = 0;
if (name == NULL)
return -EINVAL;
/* We can't have xattrs attached to v1 items since they don't have
* generation numbers */
if (get_inode_sd_version(inode) == STAT_DATA_V1)
return -EOPNOTSUPP;
dentry = xattr_lookup(inode, name, XATTR_REPLACE);
if (IS_ERR(dentry)) {
err = PTR_ERR(dentry);
goto out;
}
down_read(&REISERFS_I(inode)->i_xattr_sem);
isize = i_size_read(dentry->d_inode);
/* Just return the size needed */
if (buffer == NULL) {
err = isize - sizeof(struct reiserfs_xattr_header);
goto out_unlock;
}
if (buffer_size < isize - sizeof(struct reiserfs_xattr_header)) {
err = -ERANGE;
goto out_unlock;
}
while (file_pos < isize) {
size_t chunk;
char *data;
size_t skip = 0;
if (isize - file_pos > PAGE_CACHE_SIZE)
chunk = PAGE_CACHE_SIZE;
else
chunk = isize - file_pos;
page = reiserfs_get_page(dentry->d_inode, file_pos);
if (IS_ERR(page)) {
err = PTR_ERR(page);
goto out_unlock;
}
lock_page(page);
data = page_address(page);
if (file_pos == 0) {
struct reiserfs_xattr_header *rxh =
(struct reiserfs_xattr_header *)data;
skip = file_pos = sizeof(struct reiserfs_xattr_header);
chunk -= skip;
/* Magic doesn't match up.. */
if (rxh->h_magic != cpu_to_le32(REISERFS_XATTR_MAGIC)) {
unlock_page(page);
reiserfs_put_page(page);
reiserfs_warning(inode->i_sb, "jdm-20001",
"Invalid magic for xattr (%s) "
"associated with %k", name,
INODE_PKEY(inode));
err = -EIO;
goto out_unlock;
}
hash = le32_to_cpu(rxh->h_hash);
}
memcpy(buffer + buffer_pos, data + skip, chunk);
unlock_page(page);
reiserfs_put_page(page);
file_pos += chunk;
buffer_pos += chunk;
skip = 0;
}
err = isize - sizeof(struct reiserfs_xattr_header);
if (xattr_hash(buffer, isize - sizeof(struct reiserfs_xattr_header)) !=
hash) {
reiserfs_warning(inode->i_sb, "jdm-20002",
"Invalid hash for xattr (%s) associated "
"with %k", name, INODE_PKEY(inode));
err = -EIO;
}
out_unlock:
up_read(&REISERFS_I(inode)->i_xattr_sem);
dput(dentry);
out:
return err;
}
/* 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;
}
int reiserfs_mknod (struct inode * dir, struct dentry *dentry, int mode, int rdev)
{
int error;
struct inode * inode;
struct path path_to_entry;
struct reiserfs_dir_entry de;
int windex ;
struct reiserfs_transaction_handle th ;
int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3;
int err;
if (!dir)
return -ENOENT;
init_path (&path_to_entry);
inode = get_empty_inode() ;
if (!inode) {
return -ENOSPC ;
}
journal_begin(&th, dir->i_sb, jbegin_count) ;
windex = push_journal_writer("reiserfs_mknod") ;
de.de_gen_number_bit_string = 0;
if (reiserfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &path_to_entry, &de) == POSITION_FOUND) {
pathrelse ( &path_to_entry);
pop_journal_writer(windex) ;
journal_end(&th, dir->i_sb, jbegin_count) ;
iput(inode) ;
return -EEXIST;
}
pathrelse ( &path_to_entry);
inode = reiserfs_new_inode (&th, dir, mode, 0, dentry, inode, &err);
if (!inode) {
pop_journal_writer(windex) ;
journal_end(&th, dir->i_sb, jbegin_count) ;
return err;
}
reiserfs_update_inode_transaction(inode) ;
reiserfs_update_inode_transaction(dir) ;
inode->i_uid = current->fsuid;
inode->i_mode = mode;
inode->i_op = NULL;
if (S_ISREG(inode->i_mode))
inode->i_op = &reiserfs_file_inode_operations;
else if (S_ISDIR(inode->i_mode)) {
inode->i_op = &reiserfs_dir_inode_operations;
if (dir->i_mode & S_ISGID)
inode->i_mode |= S_ISGID;
}
else if (S_ISLNK(inode->i_mode))
inode->i_op = &reiserfs_symlink_inode_operations;
else if (S_ISCHR(inode->i_mode))
inode->i_op = &chrdev_inode_operations;
else if (S_ISBLK(inode->i_mode))
inode->i_op = &blkdev_inode_operations;
else if (S_ISFIFO(inode->i_mode))
init_fifo(inode);
if (S_ISBLK(mode) || S_ISCHR(mode))
inode->i_rdev = to_kdev_t(rdev);
if_in_ram_update_sd (&th, inode);
error = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len, INODE_PKEY (inode), &de, 1);
if (error) {
inode->i_nlink--;
if_in_ram_update_sd (&th, inode);
pop_journal_writer(windex) ;
journal_end(&th, dir->i_sb, jbegin_count) ;
iput (inode);
return error;
}
if_in_ram_update_sd (&th, dir);
d_instantiate(dentry, inode);
pop_journal_writer(windex) ;
journal_end(&th, dir->i_sb, jbegin_count) ;
return 0;
}
int reiserfs_symlink (struct inode * dir, struct dentry * dentry, const char * symname)
{
struct inode * inode;
struct path path_to_entry;
struct reiserfs_dir_entry de;
int error;
int windex ;
struct reiserfs_transaction_handle th ;
int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3;
int err;
init_path (&path_to_entry);
if (strlen (symname) + 1 + SD_SIZE > MAX_ITEM_LEN (dir->i_sb->s_blocksize)) {
return -ENAMETOOLONG;
}
inode = get_empty_inode() ;
if (!inode) {
return -ENOSPC ;
}
journal_begin(&th, dir->i_sb, jbegin_count) ;
windex = push_journal_writer("reiserfs_symlink") ;
inode = reiserfs_new_inode (&th, dir, S_IFLNK, symname, dentry, inode, &err);
if (inode == 0) {
pop_journal_writer(windex) ;
journal_end(&th, dir->i_sb, jbegin_count) ;
return err;
}
reiserfs_update_inode_transaction(inode) ;
reiserfs_update_inode_transaction(dir) ;
inode->i_op = &reiserfs_symlink_inode_operations;
inode->i_size = strlen (symname);
inode->i_mode = S_IFLNK | 0777;
if_in_ram_update_sd (&th, inode);
de.de_gen_number_bit_string = 0;
if (reiserfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &path_to_entry, &de) == POSITION_FOUND) {
pathrelse (&path_to_entry);
inode->i_nlink--;
if_in_ram_update_sd (&th, inode);
pop_journal_writer(windex) ;
journal_end(&th, dir->i_sb, jbegin_count) ;
iput (inode);
return -EEXIST;
}
pathrelse (&path_to_entry);
error = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len, INODE_PKEY (inode), &de, 1);
if (error) {
inode->i_nlink--;
if_in_ram_update_sd (&th, inode);
pop_journal_writer(windex) ;
journal_end(&th, dir->i_sb, jbegin_count) ;
iput (inode);
return error;
}
if_in_ram_update_sd (&th, dir);
d_instantiate(dentry, inode);
pop_journal_writer(windex) ;
journal_end(&th, dir->i_sb, jbegin_count) ;
return 0;
}
/* to protect file being unlinked from getting lost we "safe" link files
being unlinked. This link will be deleted in the same transaction with last
item of file. mounting the filesytem we scan all these links and remove
files which almost got lost */
void add_save_link (struct reiserfs_transaction_handle * th,
struct inode * inode, int truncate)
{
INITIALIZE_PATH (path);
int retval;
struct cpu_key key;
struct item_head ih;
__u32 link;
/* file can only get one "save link" of each kind */
RFALSE( truncate &&
( inode -> u.reiserfs_i.i_flags & i_link_saved_truncate_mask ),
"saved link already exists for truncated inode %lx",
( long ) inode -> i_ino );
RFALSE( !truncate &&
( inode -> u.reiserfs_i.i_flags & i_link_saved_unlink_mask ),
"saved link already exists for unlinked inode %lx",
( long ) inode -> i_ino );
/* setup key of "save" link */
key.version = KEY_FORMAT_3_5;
key.on_disk_key.k_dir_id = MAX_KEY_OBJECTID;
key.on_disk_key.k_objectid = inode->i_ino;
if (!truncate) {
/* unlink, rmdir, rename */
set_cpu_key_k_offset (&key, 1 + inode->i_sb->s_blocksize);
set_cpu_key_k_type (&key, TYPE_DIRECT);
/* item head of "safe" link */
make_le_item_head (&ih, &key, key.version, 1 + inode->i_sb->s_blocksize, TYPE_DIRECT,
4/*length*/, 0xffff/*free space*/);
} else {
/* truncate */
if (S_ISDIR (inode->i_mode))
reiserfs_warning("green-2102: Adding a truncate savelink for a directory %k! Please report\n", INODE_PKEY(inode));
set_cpu_key_k_offset (&key, 1);
set_cpu_key_k_type (&key, TYPE_INDIRECT);
/* item head of "safe" link */
make_le_item_head (&ih, &key, key.version, 1, TYPE_INDIRECT,
4/*length*/, 0/*free space*/);
}
key.key_length = 3;
/* look for its place in the tree */
retval = search_item (inode->i_sb, &key, &path);
if (retval != ITEM_NOT_FOUND) {
if ( retval != -ENOSPC )
reiserfs_warning ("vs-2100: add_save_link:"
"search_by_key (%K) returned %d\n", &key, retval);
pathrelse (&path);
return;
}
/* body of "save" link */
link = cpu_to_le32 (INODE_PKEY (inode)->k_dir_id);
/* put "save" link inot tree */
retval = reiserfs_insert_item (th, &path, &key, &ih, (char *)&link);
if (retval) {
if (retval != -ENOSPC)
reiserfs_warning ("vs-2120: add_save_link: insert_item returned %d\n",
retval);
} else {
if( truncate )
inode -> u.reiserfs_i.i_flags |= i_link_saved_truncate_mask;
else
inode -> u.reiserfs_i.i_flags |= i_link_saved_unlink_mask;
}
}
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;
}
int
reiserfs_lookup(struct vop_cachedlookup_args *ap)
{
int error, retval;
struct vnode *vdp = ap->a_dvp;
struct vnode **vpp = ap->a_vpp;
struct componentname *cnp = ap->a_cnp;
int flags = cnp->cn_flags;
struct thread *td = cnp->cn_thread;
struct cpu_key *saved_ino;
struct vnode *vp;
struct vnode *pdp; /* Saved dp during symlink work */
struct reiserfs_node *dp;
struct reiserfs_dir_entry de;
INITIALIZE_PATH(path_to_entry);
char c = cnp->cn_nameptr[cnp->cn_namelen];
cnp->cn_nameptr[cnp->cn_namelen] = '\0';
reiserfs_log(LOG_DEBUG, "looking for `%s', %ld (%s)\n",
cnp->cn_nameptr, cnp->cn_namelen, cnp->cn_pnbuf);
cnp->cn_nameptr[cnp->cn_namelen] = c;
vp = NULL;
dp = VTOI(vdp);
if (REISERFS_MAX_NAME(dp->i_reiserfs->s_blocksize) < cnp->cn_namelen)
return (ENAMETOOLONG);
reiserfs_log(LOG_DEBUG, "searching entry\n");
de.de_gen_number_bit_string = 0;
retval = reiserfs_find_entry(dp, cnp->cn_nameptr, cnp->cn_namelen,
&path_to_entry, &de);
pathrelse(&path_to_entry);
if (retval == NAME_FOUND) {
reiserfs_log(LOG_DEBUG, "found\n");
} else {
reiserfs_log(LOG_DEBUG, "not found\n");
}
if (retval == NAME_FOUND) {
#if 0
/* Hide the .reiserfs_priv directory */
if (reiserfs_xattrs(dp->i_reiserfs) &&
!old_format_only(dp->i_reiserfs) &&
REISERFS_SB(dp->i_reiserfs)->priv_root &&
REISERFS_SB(dp->i_reiserfs)->priv_root->d_inode &&
de.de_objectid == le32toh(INODE_PKEY(REISERFS_SB(
dp->i_reiserfs)->priv_root->d_inode)->k_objectid)) {
return (EACCES);
}
#endif
reiserfs_log(LOG_DEBUG, "reading vnode\n");
pdp = vdp;
if (flags & ISDOTDOT) {
saved_ino = (struct cpu_key *)&(de.de_dir_id);
VOP_UNLOCK(pdp, 0);
error = reiserfs_iget(vdp->v_mount,
saved_ino, &vp, td);
vn_lock(pdp, LK_EXCLUSIVE | LK_RETRY);
if (error != 0)
return (error);
*vpp = vp;
} else if (de.de_objectid == dp->i_number &&
de.de_dir_id == dp->i_ino) {
VREF(vdp); /* We want ourself, ie "." */
*vpp = vdp;
} else {
if ((error = reiserfs_iget(vdp->v_mount,
(struct cpu_key *)&(de.de_dir_id), &vp, td)) != 0)
return (error);
*vpp = vp;
}
/*
* Propogate the priv_object flag so we know we're in the
* priv tree
*/
/*if (is_reiserfs_priv_object(dir))
REISERFS_I(inode)->i_flags |= i_priv_object;*/
} else {
if (retval == IO_ERROR) {
reiserfs_log(LOG_DEBUG, "IO error\n");
return (EIO);
}
return (ENOENT);
}
/* Insert name into cache if appropriate. */
if (cnp->cn_flags & MAKEENTRY)
cache_enter(vdp, *vpp, cnp);
reiserfs_log(LOG_DEBUG, "done\n");
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 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;
}
int reiserfs_mkdir (struct inode * dir, struct dentry *dentry, int mode)
{
int error;
struct inode * inode;
struct path path_to_entry;
struct reiserfs_dir_entry de;
int windex ;
struct reiserfs_transaction_handle th ;
int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3;
int err;
init_path (&path_to_entry);
if (!dir || !dir->i_sb) {
return -EINVAL;
}
inode = get_empty_inode() ;
if (!inode) {
return -ENOSPC ;
}
journal_begin(&th, dir->i_sb, jbegin_count) ;
windex = push_journal_writer("reiserfs_mkdir") ;
de.de_gen_number_bit_string = 0;
if (reiserfs_find_entry (dir, dentry->d_name.name, dentry->d_name.len, &path_to_entry, &de) == POSITION_FOUND) {
pathrelse (&path_to_entry);
pop_journal_writer(windex) ;
journal_end(&th, dir->i_sb, jbegin_count) ;
iput(inode) ;
return -EEXIST;
}
pathrelse (&path_to_entry);
if (dir->i_nlink >= REISERFS_LINK_MAX) {
pop_journal_writer(windex) ;
journal_end(&th, dir->i_sb, jbegin_count) ;
iput(inode) ;
return -EMLINK;
}
mode = S_IFDIR | (mode & 0777 & ~current->fs->umask);
if (dir->i_mode & S_ISGID)
mode |= S_ISGID;
inode = reiserfs_new_inode (&th, dir, mode, 0, dentry, inode, &err);
if (!inode) {
pop_journal_writer(windex) ;
journal_end(&th, dir->i_sb, jbegin_count) ;
return err;
}
reiserfs_update_inode_transaction(inode) ;
reiserfs_update_inode_transaction(dir) ;
inode->i_op = &reiserfs_dir_inode_operations;
/* new inode and stat data are uptodate. Inode is clean. */
error = reiserfs_add_entry (&th, dir, dentry->d_name.name, dentry->d_name.len, INODE_PKEY (inode), &de, 1);
if (error) {
inode->i_nlink = 0;
if_in_ram_update_sd (&th, inode);
pop_journal_writer(windex) ;
journal_end(&th, dir->i_sb, jbegin_count) ;
iput (inode);
return error;
}
/* update dir inode, reiserfs_add_entry does not do that */
dir->i_nlink ++;
if_in_ram_update_sd (&th, dir);
d_instantiate(dentry, inode);
pop_journal_writer(windex) ;
journal_end(&th, dir->i_sb, jbegin_count) ;
return 0;
}
