/*
* unionfs_lookup is the only special function which takes a dentry, yet we
* do NOT want to call __unionfs_d_revalidate_chain because by definition,
* we don't have a valid dentry here yet.
*/
static struct dentry *unionfs_lookup(struct inode *dir,
struct dentry *dentry,
/* XXX: pass flags to lower? */
unsigned int flags_unused)
{
struct dentry *ret, *parent;
int err = 0;
unionfs_read_lock(dentry->d_sb, UNIONFS_SMUTEX_CHILD);
parent = unionfs_lock_parent(dentry, UNIONFS_DMUTEX_PARENT);
/*
* As long as we lock/dget the parent, then can skip validating the
* parent now; we may have to rebuild this dentry on the next
* ->d_revalidate, however.
*/
/* allocate dentry private data. We free it in ->d_release */
err = new_dentry_private_data(dentry, UNIONFS_DMUTEX_CHILD);
if (unlikely(err)) {
ret = ERR_PTR(err);
goto out;
}
ret = unionfs_lookup_full(dentry, parent, INTERPOSE_LOOKUP);
if (!IS_ERR(ret)) {
if (ret)
dentry = ret;
/* lookup_full can return multiple positive dentries */
if (dentry->d_inode && !S_ISDIR(dentry->d_inode->i_mode)) {
BUG_ON(dbstart(dentry) < 0);
unionfs_postcopyup_release(dentry);
}
unionfs_copy_attr_times(dentry->d_inode);
}
unionfs_check_inode(dir);
if (!IS_ERR(ret))
unionfs_check_dentry(dentry);
unionfs_check_dentry(parent);
unionfs_unlock_dentry(dentry); /* locked in new_dentry_private data */
out:
unionfs_unlock_parent(dentry, parent);
unionfs_read_unlock(dentry->d_sb);
return ret;
}
/*
* Copy up a dentry to a file of specified name.
*
* @dir: used to pull the ->i_sb to access other branches
* @dentry: the non-negative dentry whose lower_inode we should copy
* @bstart: the branch of the lower_inode to copy from
* @new_bindex: the branch to create the new file in
* @name: the name of the file to create
* @namelen: length of @name
* @copyup_file: the "struct file" to return (optional)
* @len: how many bytes to copy-up?
*/
int copyup_dentry(struct inode *dir, struct dentry *dentry, int bstart,
int new_bindex, const char *name, int namelen,
struct file **copyup_file, loff_t len)
{
struct dentry *new_lower_dentry;
struct dentry *old_lower_dentry = NULL;
struct super_block *sb;
int err = 0;
int old_bindex;
int old_bstart;
int old_bend;
struct dentry *new_lower_parent_dentry = NULL;
mm_segment_t oldfs;
char *symbuf = NULL;
verify_locked(dentry);
old_bindex = bstart;
old_bstart = dbstart(dentry);
old_bend = dbend(dentry);
BUG_ON(new_bindex < 0);
BUG_ON(new_bindex >= old_bindex);
sb = dir->i_sb;
err = is_robranch_super(sb, new_bindex);
if (err)
goto out;
/* Create the directory structure above this dentry. */
new_lower_dentry = create_parents(dir, dentry, name, new_bindex);
if (IS_ERR(new_lower_dentry)) {
err = PTR_ERR(new_lower_dentry);
goto out;
}
old_lower_dentry = unionfs_lower_dentry_idx(dentry, old_bindex);
/* we conditionally dput this old_lower_dentry at end of function */
dget(old_lower_dentry);
/* For symlinks, we must read the link before we lock the directory. */
if (S_ISLNK(old_lower_dentry->d_inode->i_mode)) {
symbuf = kmalloc(PATH_MAX, GFP_KERNEL);
if (unlikely(!symbuf)) {
__clear(dentry, old_lower_dentry,
old_bstart, old_bend,
new_lower_dentry, new_bindex);
err = -ENOMEM;
goto out_free;
}
oldfs = get_fs();
set_fs(KERNEL_DS);
err = old_lower_dentry->d_inode->i_op->readlink(
old_lower_dentry,
(char __user *)symbuf,
PATH_MAX);
set_fs(oldfs);
if (err < 0) {
__clear(dentry, old_lower_dentry,
old_bstart, old_bend,
new_lower_dentry, new_bindex);
goto out_free;
}
symbuf[err] = '\0';
}
/* Now we lock the parent, and create the object in the new branch. */
new_lower_parent_dentry = lock_parent(new_lower_dentry);
/* create the new inode */
err = __copyup_ndentry(old_lower_dentry, new_lower_dentry,
new_lower_parent_dentry, symbuf);
if (err) {
__clear(dentry, old_lower_dentry,
old_bstart, old_bend,
new_lower_dentry, new_bindex);
goto out_unlock;
}
/* We actually copyup the file here. */
if (S_ISREG(old_lower_dentry->d_inode->i_mode))
err = __copyup_reg_data(dentry, new_lower_dentry, new_bindex,
old_lower_dentry, old_bindex,
copyup_file, len);
if (err)
goto out_unlink;
/* Set permissions. */
err = copyup_permissions(sb, old_lower_dentry, new_lower_dentry);
if (err)
goto out_unlink;
#ifdef CONFIG_UNION_FS_XATTR
/* Selinux uses extended attributes for permissions. */
err = copyup_xattrs(old_lower_dentry, new_lower_dentry);
if (err)
goto out_unlink;
#endif /* CONFIG_UNION_FS_XATTR */
/* do not allow files getting deleted to be re-interposed */
if (!d_deleted(dentry))
unionfs_reinterpose(dentry);
goto out_unlock;
out_unlink:
/*
* copyup failed, because we possibly ran out of space or
* quota, or something else happened so let's unlink; we don't
* really care about the return value of vfs_unlink
*/
vfs_unlink(new_lower_parent_dentry->d_inode, new_lower_dentry);
if (copyup_file) {
/* need to close the file */
fput(*copyup_file);
branchput(sb, new_bindex);
}
/*
* TODO: should we reset the error to something like -EIO?
*
* If we don't reset, the user may get some nonsensical errors, but
* on the other hand, if we reset to EIO, we guarantee that the user
* will get a "confusing" error message.
*/
out_unlock:
unlock_dir(new_lower_parent_dentry);
out_free:
/*
* If old_lower_dentry was not a file, then we need to dput it. If
* it was a file, then it was already dput indirectly by other
* functions we call above which operate on regular files.
*/
if (old_lower_dentry && old_lower_dentry->d_inode &&
!S_ISREG(old_lower_dentry->d_inode->i_mode))
dput(old_lower_dentry);
kfree(symbuf);
if (err) {
/*
* if directory creation succeeded, but inode copyup failed,
* then purge new dentries.
*/
if (dbstart(dentry) < old_bstart &&
ibstart(dentry->d_inode) > dbstart(dentry))
__clear(dentry, NULL, old_bstart, old_bend,
unionfs_lower_dentry(dentry), dbstart(dentry));
goto out;
}
if (!S_ISDIR(dentry->d_inode->i_mode)) {
unionfs_postcopyup_release(dentry);
if (!unionfs_lower_inode(dentry->d_inode)) {
/*
* If we got here, then we copied up to an
* unlinked-open file, whose name is .unionfsXXXXX.
*/
struct inode *inode = new_lower_dentry->d_inode;
atomic_inc(&inode->i_count);
unionfs_set_lower_inode_idx(dentry->d_inode,
ibstart(dentry->d_inode),
inode);
}
}
unionfs_postcopyup_setmnt(dentry);
/* sync inode times from copied-up inode to our inode */
unionfs_copy_attr_times(dentry->d_inode);
unionfs_check_inode(dir);
unionfs_check_dentry(dentry);
out:
return err;
}
/*
* The locking rules in unionfs_rename are complex. We could use a simpler
* superblock-level name-space lock for renames and copy-ups.
*/
int unionfs_rename(struct inode *old_dir, struct dentry *old_dentry,
struct inode *new_dir, struct dentry *new_dentry)
{
int err = 0;
struct dentry *wh_dentry;
struct dentry *old_parent, *new_parent;
int valid = true;
unionfs_read_lock(old_dentry->d_sb, UNIONFS_SMUTEX_CHILD);
old_parent = dget_parent(old_dentry);
new_parent = dget_parent(new_dentry);
/* un/lock parent dentries only if they differ from old/new_dentry */
if (old_parent != old_dentry &&
old_parent != new_dentry)
unionfs_lock_dentry(old_parent, UNIONFS_DMUTEX_REVAL_PARENT);
if (new_parent != old_dentry &&
new_parent != new_dentry &&
new_parent != old_parent)
unionfs_lock_dentry(new_parent, UNIONFS_DMUTEX_REVAL_CHILD);
unionfs_double_lock_dentry(old_dentry, new_dentry);
valid = __unionfs_d_revalidate(old_dentry, old_parent, false);
if (!valid) {
err = -ESTALE;
goto out;
}
if (!d_deleted(new_dentry) && new_dentry->d_inode) {
valid = __unionfs_d_revalidate(new_dentry, new_parent, false);
if (!valid) {
err = -ESTALE;
goto out;
}
}
if (!S_ISDIR(old_dentry->d_inode->i_mode))
err = unionfs_partial_lookup(old_dentry, old_parent);
else
err = may_rename_dir(old_dentry, old_parent);
if (err)
goto out;
err = unionfs_partial_lookup(new_dentry, new_parent);
if (err)
goto out;
/*
* if new_dentry is already lower because of whiteout,
* simply override it even if the whited-out dir is not empty.
*/
wh_dentry = find_first_whiteout(new_dentry);
if (!IS_ERR(wh_dentry)) {
dput(wh_dentry);
} else if (new_dentry->d_inode) {
if (S_ISDIR(old_dentry->d_inode->i_mode) !=
S_ISDIR(new_dentry->d_inode->i_mode)) {
err = S_ISDIR(old_dentry->d_inode->i_mode) ?
-ENOTDIR : -EISDIR;
goto out;
}
if (S_ISDIR(new_dentry->d_inode->i_mode)) {
struct unionfs_dir_state *namelist = NULL;
/* check if this unionfs directory is empty or not */
err = check_empty(new_dentry, new_parent, &namelist);
if (err)
goto out;
if (!is_robranch(new_dentry))
err = delete_whiteouts(new_dentry,
dbstart(new_dentry),
namelist);
free_rdstate(namelist);
if (err)
goto out;
}
}
err = do_unionfs_rename(old_dir, old_dentry, old_parent,
new_dir, new_dentry, new_parent);
if (err)
goto out;
/*
* force re-lookup since the dir on ro branch is not renamed, and
* lower dentries still indicate the un-renamed ones.
*/
if (S_ISDIR(old_dentry->d_inode->i_mode))
atomic_dec(&UNIONFS_D(old_dentry)->generation);
else
unionfs_postcopyup_release(old_dentry);
if (new_dentry->d_inode && !S_ISDIR(new_dentry->d_inode->i_mode)) {
unionfs_postcopyup_release(new_dentry);
unionfs_postcopyup_setmnt(new_dentry);
if (!unionfs_lower_inode(new_dentry->d_inode)) {
/*
* If we get here, it means that no copyup was
* needed, and that a file by the old name already
* existing on the destination branch; that file got
* renamed earlier in this function, so all we need
* to do here is set the lower inode.
*/
struct inode *inode;
inode = unionfs_lower_inode(old_dentry->d_inode);
igrab(inode);
unionfs_set_lower_inode_idx(new_dentry->d_inode,
dbstart(new_dentry),
inode);
}
}
/* if all of this renaming succeeded, update our times */
unionfs_copy_attr_times(old_dentry->d_inode);
unionfs_copy_attr_times(new_dentry->d_inode);
unionfs_check_inode(old_dir);
unionfs_check_inode(new_dir);
unionfs_check_dentry(old_dentry);
unionfs_check_dentry(new_dentry);
out:
if (err) /* clear the new_dentry stuff created */
d_drop(new_dentry);
unionfs_double_unlock_dentry(old_dentry, new_dentry);
if (new_parent != old_dentry &&
new_parent != new_dentry &&
new_parent != old_parent)
unionfs_unlock_dentry(new_parent);
if (old_parent != old_dentry &&
old_parent != new_dentry)
unionfs_unlock_dentry(old_parent);
dput(new_parent);
dput(old_parent);
unionfs_read_unlock(old_dentry->d_sb);
return err;
}
