static int u2fs_symlink(struct inode *dir, struct dentry *dentry,
const char *symname)
{
int err = 0;
struct dentry *lower_dentry;
struct dentry *lower_parent_dentry = NULL;
struct path lower_path;
struct dentry *ret = NULL;
/* creating parent directories if destination is read-only */
if((U2FS_D(dentry)->lower_path[LEFT].dentry == NULL) &&
(U2FS_D(dentry)->lower_path[LEFT].mnt == NULL)){
ret = create_parents(dir, dentry,
dentry->d_name.name);
if (!ret || IS_ERR(ret)) {
err = PTR_ERR(ret);
if (!IS_COPYUP_ERR(err))
printk(KERN_ERR
"u2fs: create_parents for "
"u2fs_symlink failed"
"err=%d\n", err);
goto out_copyup;
}
u2fs_postcopyup_setmnt(dentry);
u2fs_put_reset_lower_path(dentry, RIGHT);
if(err)
goto out_copyup;
}
u2fs_get_lower_path(dentry, &lower_path, LEFT);
lower_dentry = lower_path.dentry;
lower_parent_dentry = lock_parent(lower_dentry);
err = mnt_want_write(lower_path.mnt);
if (err)
goto out_unlock;
err = vfs_symlink(lower_parent_dentry->d_inode, lower_dentry, symname);
if (err)
goto out;
err = u2fs_interpose(dentry, dir->i_sb, &lower_path, LEFT);
if (err)
goto out;
fsstack_copy_attr_times(dir, u2fs_lower_inode(dir, LEFT));
fsstack_copy_inode_size(dir, lower_parent_dentry->d_inode);
out:
mnt_drop_write(lower_path.mnt);
out_unlock:
unlock_dir(lower_parent_dentry);
u2fs_put_lower_path(dentry, &lower_path);
out_copyup:
return err;
}
/*
* Rename all occurences of source except for the leftmost destination
*/
static int __rename_all(struct inode *old_dir, struct dentry *old_dentry,
struct inode *new_dir, struct dentry *new_dentry,
fd_set * success_mask, struct rename_info *info)
{
int bindex;
int err = 0;
print_entry_location();
/* Loop through all the branches from right to left and rename all
* instances of source to destination, except the leftmost destination
*/
for (bindex = info->old_bend; bindex >= info->old_bstart; bindex--) {
/* We don't rename if there is no source. */
if (dtohd_index(old_dentry, bindex) == NULL)
continue;
/* we rename the bstart of destination only at the last of
* all operations, so that we don't lose it on error
*/
if (info->clobber && (bindex == info->new_bstart))
continue;
DPUT(info->wh_old);
info->bwh_old = bindex;
/* We shouldn't have a handle on this if there is no inode. */
err =
do_rename(old_dir, old_dentry, new_dir, new_dentry, bindex,
&info->wh_old);
if (!err) {
/* For reverting. */
FD_SET(bindex, success_mask);
/* So we know not to copyup on failures the right */
info->rename_ok = bindex;
} else if (IS_COPYUP_ERR(err)) {
if (info->isdir) {
err = -EXDEV;
break;
}
/* we need a whiteout... */
info->do_whiteout = bindex - 1;
if (bindex == info->old_bstart)
/* ...and a copyup */
info->do_copyup = bindex - 1;
err = 0; /* reset error */
} else
break; /* error is set by do_rename */
}
print_exit_status(err);
return err;
}
static int unionfs_unlink_whiteout(struct inode *dir, struct dentry *dentry)
{
struct dentry *hidden_dentry;
struct dentry *hidden_dir_dentry;
int bindex;
int err = 0;
print_entry_location();
if ((err = unionfs_partial_lookup(dentry)))
goto out;
bindex = dbstart(dentry);
hidden_dentry = dtohd_index(dentry, bindex);
if (!hidden_dentry)
goto out;
hidden_dir_dentry = lock_parent(hidden_dentry);
/* avoid destroying the hidden inode if the file is in use */
DGET(hidden_dentry);
if (!(err = is_robranch_super(dentry->d_sb, bindex)))
err = vfs_unlink(hidden_dir_dentry->d_inode, hidden_dentry);
DPUT(hidden_dentry);
fist_copy_attr_times(dir, hidden_dir_dentry->d_inode);
unlock_dir(hidden_dir_dentry);
if (err) {
if (!IS_COPYUP_ERR(err))
goto out;
}
if (err) {
if (dbstart(dentry) == 0) {
goto out;
}
err = create_whiteout(dentry, dbstart(dentry) - 1);
} else if (dbopaque(dentry) != -1) {
/* There is a hidden lower-priority file with the same name. */
err = create_whiteout(dentry, dbopaque(dentry));
} else {
err = create_whiteout(dentry, dbstart(dentry));
}
out:
if (!err)
dentry->d_inode->i_nlink--;
/* We don't want to leave negative leftover dentries for revalidate. */
if (!err && (dbopaque(dentry) != -1))
update_bstart(dentry);
print_exit_status(err);
return err;
}
int unionfs_rmdir(struct inode *dir, struct dentry *dentry)
{
int err = 0;
struct unionfs_dir_state *namelist = NULL;
print_entry_location();
lock_dentry(dentry);
fist_print_dentry("IN unionfs_rmdir: ", dentry);
/* check if this unionfs directory is empty or not */
err = check_empty(dentry, &namelist);
if (err) {
goto out;
}
if (IS_SET(dir->i_sb, DELETE_WHITEOUT)) {
/* Delete the first directory. */
err = unionfs_rmdir_first(dir, dentry, namelist);
/* create whiteout */
if (!err) {
err = create_whiteout(dentry, dbstart(dentry));
} else {
int new_err;
if (dbstart(dentry) == 0)
goto out;
/* exit if the error returned was NOT -EROFS */
if (!IS_COPYUP_ERR(err))
goto out;
new_err = create_whiteout(dentry, dbstart(dentry) - 1);
if (new_err != -EEXIST)
err = new_err;
}
} else {
/* delete all. */
err = unionfs_rmdir_all(dir, dentry, namelist);
}
out:
/* call d_drop so the system "forgets" about us */
if (!err)
d_drop(dentry);
if (namelist)
free_rdstate(namelist);
unlock_dentry(dentry);
print_exit_status(err);
return err;
}
/*
* Unlink all destinations (if they exist) to the left of the left-most
* source
*/
static int __rename_all_unlink(struct inode *old_dir, struct dentry *old_dentry,
struct inode *new_dir, struct dentry *new_dentry,
struct rename_info *info)
{
int bindex;
struct dentry *unlink_dentry;
struct dentry *unlink_dir_dentry;
int err = 0;
print_entry_location();
for (bindex = info->old_bstart - 1; bindex > info->new_bstart; bindex--) {
unlink_dentry = dtohd_index(new_dentry, bindex);
if (!unlink_dentry)
continue;
/* lock, unlink if possible, copyup times, unlock */
unlink_dir_dentry = lock_parent(unlink_dentry);
if (!(err = is_robranch_super(old_dir->i_sb, bindex)))
err =
vfs_unlink(unlink_dir_dentry->d_inode,
unlink_dentry);
fist_copy_attr_times(new_dentry->d_parent->d_inode,
unlink_dir_dentry->d_inode);
new_dentry->d_parent->d_inode->i_nlink =
get_nlinks(new_dentry->d_parent->d_inode);
unlock_dir(unlink_dir_dentry);
if (!err) {
if (bindex != info->new_bstart) {
DPUT(unlink_dentry);
set_dtohd_index(new_dentry, bindex, NULL);
}
} else if (IS_COPYUP_ERR(err)) {
if (info->isdir) {
err = -EXDEV;
break;
}
info->do_copyup = bindex - 1;
err = 0; /* reset error */
} else
break; /* err is set by is_ro_branch_super or vfs_unlink */
}
print_exit_status(err);
return err;
}
int unionfs_rmdir(struct inode *dir, struct dentry *dentry)
{
int err = 0;
struct unionfs_dir_state *namelist = NULL;
unionfs_lock_dentry(dentry);
/* check if this unionfs directory is empty or not */
err = check_empty(dentry, &namelist);
if (err)
goto out;
err = unionfs_rmdir_first(dir, dentry, namelist);
/* create whiteout */
if (!err)
err = create_whiteout(dentry, dbstart(dentry));
else {
int new_err;
if (dbstart(dentry) == 0)
goto out;
/* exit if the error returned was NOT -EROFS */
if (!IS_COPYUP_ERR(err))
goto out;
new_err = create_whiteout(dentry, dbstart(dentry) - 1);
if (new_err != -EEXIST)
err = new_err;
}
out:
/* call d_drop so the system "forgets" about us */
if (!err)
d_drop(dentry);
if (namelist)
free_rdstate(namelist);
unionfs_unlock_dentry(dentry);
return err;
}
static int unionfs_unlink_all(struct inode *dir, struct dentry *dentry)
{
struct dentry *hidden_dentry;
struct dentry *hidden_dir_dentry;
int bstart, bend, bindex;
int err = 0;
int global_err = 0;
print_entry_location();
if ((err = unionfs_partial_lookup(dentry)))
goto out;
bstart = dbstart(dentry);
bend = dbend(dentry);
for (bindex = bend; bindex >= bstart; bindex--) {
hidden_dentry = dtohd_index(dentry, bindex);
if (!hidden_dentry)
continue;
hidden_dir_dentry = lock_parent(hidden_dentry);
/* avoid destroying the hidden inode if the file is in use */
DGET(hidden_dentry);
if (!(err = is_robranch_super(dentry->d_sb, bindex)))
err = vfs_unlink(hidden_dir_dentry->d_inode,
hidden_dentry);
DPUT(hidden_dentry);
fist_copy_attr_times(dir, hidden_dir_dentry->d_inode);
unlock_dir(hidden_dir_dentry);
if (err) {
/* passup the last error we got */
if (!IS_COPYUP_ERR(err))
goto out;
global_err = err;
}
}
/* check if encountered error in the above loop */
if (global_err) {
/* If we failed in the leftmost branch, then err will be set
* and we should move one over to create the whiteout.
* Otherwise, we should try in the leftmost branch. */
if (err) {
if (dbstart(dentry) == 0) {
goto out;
}
err = create_whiteout(dentry, dbstart(dentry) - 1);
} else {
err = create_whiteout(dentry, dbstart(dentry));
}
} else if (dbopaque(dentry) != -1) {
/* There is a hidden lower-priority file with the same name. */
err = create_whiteout(dentry, dbopaque(dentry));
}
out:
/* propagate number of hard-links */
if (dentry->d_inode->i_nlink != 0) {
dentry->d_inode->i_nlink = get_nlinks(dentry->d_inode);
if (!err && global_err)
dentry->d_inode->i_nlink--;
}
/* We don't want to leave negative leftover dentries for revalidate. */
if (!err && (global_err || dbopaque(dentry) != -1))
update_bstart(dentry);
print_exit_status(err);
return err;
}
static int unionfs_rmdir_all(struct inode *dir, struct dentry *dentry,
struct unionfs_dir_state *namelist)
{
struct dentry *hidden_dentry;
struct dentry *hidden_dir_dentry;
int bstart, bend, bindex;
int err = 0;
int global_err = 0;
print_entry_location();
fist_print_dentry("IN unionfs_rmdir_all: ", dentry);
bstart = dbstart(dentry);
bend = dbend(dentry);
for (bindex = bend; bindex >= bstart; bindex--) {
hidden_dentry = dtohd_index(dentry, bindex);
if (!hidden_dentry)
continue;
hidden_dir_dentry = lock_parent(hidden_dentry);
if (S_ISDIR(hidden_dentry->d_inode->i_mode)) {
delete_whiteouts(dentry, bindex, namelist);
if (!(err = is_robranch_super(dentry->d_sb, bindex))) {
err =
vfs_rmdir(hidden_dir_dentry->d_inode,
hidden_dentry);
}
} else {
err = -EISDIR;
}
fist_copy_attr_times(dir, hidden_dir_dentry->d_inode);
unlock_dir(hidden_dir_dentry);
if (err) {
int local_err =
unionfs_refresh_hidden_dentry(dentry, bindex);
if (local_err) {
err = local_err;
goto out;
}
if (!IS_COPYUP_ERR(err) && err != -ENOTEMPTY
&& err != -EISDIR)
goto out;
global_err = err;
}
}
/* check if encountered error in the above loop */
if (global_err) {
/* If we failed in the leftmost branch, then err will be set and we should
* move one over to create the whiteout. Otherwise, we should try in the
* leftmost branch.
*/
if (err) {
if (dbstart(dentry) == 0) {
goto out;
}
err = create_whiteout(dentry, dbstart(dentry) - 1);
} else {
err = create_whiteout(dentry, dbstart(dentry));
}
} else {
err = create_whiteout(dentry, dbstart(dentry));
}
out:
/* propagate number of hard-links */
dentry->d_inode->i_nlink = get_nlinks(dentry->d_inode);
fist_print_dentry("OUT unionfs_rmdir_all: ", dentry);
print_exit_status(err);
return err;
}
static int unionfs_unlink_whiteout(struct inode *dir, struct dentry *dentry)
{
int err = 0;
struct dentry *hidden_old_dentry;
struct dentry *hidden_wh_dentry = NULL;
struct dentry *hidden_old_dir_dentry, *hidden_new_dir_dentry;
char *name = NULL;
struct iattr newattrs;
print_entry_location();
fist_print_dentry("IN unionfs_unlink_whiteout: ", dentry);
/* create whiteout, get the leftmost underlying dentry and rename it */
hidden_old_dentry = dtohd(dentry);
/* lookup .wh.foo first, MUST NOT EXIST */
name = KMALLOC(dentry->d_name.len + sizeof(".wh."), GFP_UNIONFS);
if (!name) {
err = -ENOMEM;
goto out;
}
strcpy(name, ".wh.");
strncat(name, dentry->d_name.name, dentry->d_name.len);
name[4 + dentry->d_name.len] = '\0';
hidden_wh_dentry =
LOOKUP_ONE_LEN(name, hidden_old_dentry->d_parent,
dentry->d_name.len + 4);
if (IS_ERR(hidden_wh_dentry)) {
err = PTR_ERR(hidden_wh_dentry);
goto out;
}
ASSERT(hidden_wh_dentry->d_inode == NULL);
DGET(hidden_old_dentry);
hidden_old_dir_dentry = GET_PARENT(hidden_old_dentry);
hidden_new_dir_dentry = GET_PARENT(hidden_wh_dentry);
double_lock(hidden_old_dir_dentry, hidden_new_dir_dentry);
if (!(err = is_robranch(dentry))) {
if (S_ISREG(hidden_old_dentry->d_inode->i_mode)) {
err = vfs_rename(hidden_old_dir_dentry->d_inode,
hidden_old_dentry,
hidden_new_dir_dentry->d_inode,
hidden_wh_dentry);
} else {
err = vfs_unlink(hidden_old_dir_dentry->d_inode,
hidden_old_dentry);
if (!err)
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
err = vfs_create(hidden_new_dir_dentry->d_inode,
hidden_wh_dentry, 0666, NULL);
#else
err = vfs_create(hidden_new_dir_dentry->d_inode,
hidden_wh_dentry, 0666);
#endif
}
}
double_unlock(hidden_old_dir_dentry, hidden_new_dir_dentry);
DPUT(hidden_old_dentry);
DPUT(hidden_wh_dentry);
if (!err) {
hidden_wh_dentry = LOOKUP_ONE_LEN(name,
hidden_old_dentry->d_parent,
dentry->d_name.len + 4);
if (IS_ERR(hidden_wh_dentry)) {
err = PTR_ERR(hidden_wh_dentry);
goto out;
}
PASSERT(hidden_wh_dentry->d_inode);
down(&hidden_wh_dentry->d_inode->i_sem);
newattrs.ia_valid = ATTR_CTIME;
if (hidden_wh_dentry->d_inode->i_size != 0) {
newattrs.ia_valid |= ATTR_SIZE;
newattrs.ia_size = 0;
}
/* We discard this error, because the entry is whited out
* even if we fail here. */
notify_change(hidden_wh_dentry, &newattrs);
up(&hidden_wh_dentry->d_inode->i_sem);
DPUT(hidden_wh_dentry);
}
if (err) {
if (dbstart(dentry) == 0)
goto out;
/* exit if the error returned was NOT -EROFS */
if (!IS_COPYUP_ERR(err))
goto out;
err = create_whiteout(dentry, dbstart(dentry) - 1);
} else {
fist_copy_attr_all(dir, hidden_new_dir_dentry->d_inode);
}
out:
KFREE(name);
print_exit_status(err);
return err;
}
/*
* Finish off the rename, by either over writing the last destination or
* unlinking the last destination to the left of us
*/
static int __rename_all_clobber(struct inode *old_dir,
struct dentry *old_dentry,
struct inode *new_dir,
struct dentry *new_dentry,
struct rename_info *info)
{
int err = 0;
print_entry_location();
if (dtohd_index(old_dentry, info->new_bstart)) {
/* rename the last source, knowing we're overwriting something */
DPUT(info->wh_old);
info->bwh_old = info->new_bstart;
err =
do_rename(old_dir, old_dentry, new_dir, new_dentry,
info->new_bstart, &info->wh_old);
if (IS_COPYUP_ERR(err)) {
if (info->isdir) {
err = -EXDEV;
goto out;
}
if (info->rename_ok > info->new_bstart) {
if ((info->do_copyup == -1)
|| (info->new_bstart - 1 < info->do_copyup))
info->do_copyup = info->new_bstart - 1;
}
if ((info->do_whiteout == -1)
|| (info->new_bstart - 1 < info->do_whiteout)) {
info->do_whiteout = info->new_bstart - 1;
}
err = 0; // reset error
}
} else if (info->new_bstart < info->old_bstart) {
/* the newly renamed file would get hidden, let's unlink the
* file to the left of it */
struct dentry *unlink_dentry;
struct dentry *unlink_dir_dentry;
unlink_dentry = dtohd_index(new_dentry, info->new_bstart);
unlink_dir_dentry = lock_parent(unlink_dentry);
if (!(err = is_robranch_super(old_dir->i_sb, info->new_bstart)))
err = vfs_unlink(unlink_dir_dentry->d_inode,
unlink_dentry);
fist_copy_attr_times(new_dentry->d_parent->d_inode,
unlink_dir_dentry->d_inode);
new_dentry->d_parent->d_inode->i_nlink =
get_nlinks(new_dentry->d_parent->d_inode);
unlock_dir(unlink_dir_dentry);
if (IS_COPYUP_ERR(err)) {
if (info->isdir) {
err = -EXDEV;
goto out;
}
if ((info->do_copyup == -1)
|| (info->new_bstart - 1 < info->do_copyup))
info->do_copyup = info->new_bstart - 1;
err = 0; // reset error
}
}
out:
print_exit_status(err);
return err;
}
static int unionfs_mknod(struct inode *dir, struct dentry *dentry, int mode,
dev_t dev)
{
int err = 0;
struct dentry *hidden_dentry = NULL, *whiteout_dentry = NULL;
struct dentry *hidden_parent_dentry = NULL;
int bindex = 0, bstart;
char *name = NULL;
int whiteout_unlinked = 0;
print_entry_location();
lock_dentry(dentry);
fist_print_dentry("IN unionfs_mknod", dentry);
bstart = dbstart(dentry);
hidden_dentry = dtohd(dentry);
// check if whiteout exists in this branch, i.e. lookup .wh.foo first
name = alloc_whname(dentry->d_name.name, dentry->d_name.len);
if (IS_ERR(name)) {
err = PTR_ERR(name);
goto out;
}
whiteout_dentry =
LOOKUP_ONE_LEN(name, hidden_dentry->d_parent,
dentry->d_name.len + WHLEN);
if (IS_ERR(whiteout_dentry)) {
err = PTR_ERR(whiteout_dentry);
goto out;
}
if (!whiteout_dentry->d_inode) {
DPUT(whiteout_dentry);
whiteout_dentry = NULL;
} else {
/* found .wh.foo, unlink it */
hidden_parent_dentry = lock_parent(whiteout_dentry);
//found a.wh.foo entry, remove it then do vfs_mkdir
if (!(err = is_robranch_super(dentry->d_sb, bstart)))
err = vfs_unlink(hidden_parent_dentry->d_inode,
whiteout_dentry);
DPUT(whiteout_dentry);
unlock_dir(hidden_parent_dentry);
if (err) {
if (!IS_COPYUP_ERR(err))
goto out;
bstart--;
} else {
whiteout_unlinked = 1;
}
}
for (bindex = bstart; bindex >= 0; bindex--) {
hidden_dentry = dtohd_index(dentry, bindex);
if (!hidden_dentry) {
hidden_dentry = create_parents(dir, dentry, bindex);
if (!hidden_dentry || IS_ERR(hidden_dentry)) {
fist_dprint(8,
"hidden dentry NULL for bindex = %d\n",
bindex);
continue;
}
}
hidden_parent_dentry = lock_parent(hidden_dentry);
if (IS_ERR(hidden_parent_dentry)) {
err = PTR_ERR(hidden_parent_dentry);
goto out;
}
if (!(err = is_robranch_super(dentry->d_sb, bindex))) {
err = vfs_mknod(hidden_parent_dentry->d_inode,
hidden_dentry, mode, dev);
}
/* XXX this could potentially return a negative hidden_dentry! */
if (err || !hidden_dentry->d_inode) {
unlock_dir(hidden_parent_dentry);
/* break out of for, if error was NOT -EROFS */
if (!IS_COPYUP_ERR(err))
break;
} else {
err = unionfs_interpose(dentry, dir->i_sb, 0);
if (!err) {
fist_copy_attr_timesizes(dir,
hidden_parent_dentry->
d_inode);
/* update number of links on parent directory */
dir->i_nlink = get_nlinks(dir);
}
unlock_dir(hidden_parent_dentry);
break;
}
}
out:
if (!dentry->d_inode)
d_drop(dentry);
if (name) {
KFREE(name);
}
fist_print_dentry("OUT unionfs_mknod :", dentry);
unlock_dentry(dentry);
print_exit_status(err);
return err;
}
static int unionfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
{
int err = 0;
struct dentry *lower_dentry = NULL;
struct dentry *lower_parent_dentry = NULL;
struct dentry *parent;
int bindex = 0, bstart;
char *name = NULL;
int valid;
unionfs_read_lock(dentry->d_sb, UNIONFS_SMUTEX_CHILD);
parent = unionfs_lock_parent(dentry, UNIONFS_DMUTEX_PARENT);
unionfs_lock_dentry(dentry, UNIONFS_DMUTEX_CHILD);
valid = __unionfs_d_revalidate(dentry, parent, false, 0);
if (unlikely(!valid)) {
err = -ESTALE; /* same as what real_lookup does */
goto out;
}
bstart = dbstart(dentry);
lower_dentry = unionfs_lower_dentry(dentry);
/* check for a whiteout in new dentry branch, and delete it */
err = check_unlink_whiteout(dentry, lower_dentry, bstart);
if (err > 0) /* whiteout found and removed successfully */
err = 0;
if (err) {
/* exit if the error returned was NOT -EROFS */
if (!IS_COPYUP_ERR(err))
goto out;
bstart--;
}
/* check if copyup's needed, and mkdir */
for (bindex = bstart; bindex >= 0; bindex--) {
int i;
int bend = dbend(dentry);
if (is_robranch_super(dentry->d_sb, bindex))
continue;
lower_dentry = unionfs_lower_dentry_idx(dentry, bindex);
if (!lower_dentry) {
lower_dentry = create_parents(dir, dentry,
dentry->d_name.name,
bindex);
if (!lower_dentry || IS_ERR(lower_dentry)) {
printk(KERN_ERR "unionfs: lower dentry "
" NULL for bindex = %d\n", bindex);
continue;
}
}
lower_parent_dentry = lock_parent(lower_dentry);
if (IS_ERR(lower_parent_dentry)) {
err = PTR_ERR(lower_parent_dentry);
goto out;
}
err = vfs_mkdir(lower_parent_dentry->d_inode, lower_dentry,
mode);
unlock_dir(lower_parent_dentry);
/* did the mkdir succeed? */
if (err)
break;
for (i = bindex + 1; i <= bend; i++) {
/* XXX: use path_put_lowers? */
if (unionfs_lower_dentry_idx(dentry, i)) {
dput(unionfs_lower_dentry_idx(dentry, i));
unionfs_set_lower_dentry_idx(dentry, i, NULL);
}
}
dbend(dentry) = bindex;
/*
* Only INTERPOSE_LOOKUP can return a value other than 0 on
* err.
*/
err = PTR_ERR(unionfs_interpose(dentry, dir->i_sb, 0));
if (!err) {
unionfs_copy_attr_times(dir);
fsstack_copy_inode_size(dir,
lower_parent_dentry->d_inode);
/* update number of links on parent directory */
set_nlink(dir, unionfs_get_nlinks(dir));
}
err = make_dir_opaque(dentry, dbstart(dentry));
if (err) {
printk(KERN_ERR "unionfs: mkdir: error creating "
".wh.__dir_opaque: %d\n", err);
goto out;
}
/* we are done! */
break;
}
out:
if (!dentry->d_inode)
d_drop(dentry);
kfree(name);
if (!err) {
unionfs_copy_attr_times(dentry->d_inode);
unionfs_postcopyup_setmnt(dentry);
}
unionfs_check_inode(dir);
unionfs_check_dentry(dentry);
unionfs_unlock_dentry(dentry);
unionfs_unlock_parent(dentry, parent);
unionfs_read_unlock(dentry->d_sb);
return err;
}
static int unionfs_create(struct inode *parent, struct dentry *dentry,
int mode, struct nameidata *nd)
{
int err = 0;
struct dentry *hidden_dentry = NULL;
struct dentry *whiteout_dentry = NULL;
struct dentry *new_hidden_dentry;
struct dentry *hidden_parent_dentry = NULL;
int bindex = 0, bstart;
char *name = NULL;
print_entry_location();
lock_dentry(dentry);
fist_print_dentry("IN unionfs_create", dentry);
/* We start out in the leftmost branch. */
bstart = dbstart(dentry);
hidden_dentry = dtohd(dentry);
/* check if whiteout exists in this branch, i.e. lookup .wh.foo first */
name = alloc_whname(dentry->d_name.name, dentry->d_name.len);
if (IS_ERR(name)) {
err = PTR_ERR(name);
goto out;
}
whiteout_dentry =
LOOKUP_ONE_LEN(name, hidden_dentry->d_parent,
dentry->d_name.len + WHLEN);
if (IS_ERR(whiteout_dentry)) {
err = PTR_ERR(whiteout_dentry);
whiteout_dentry = NULL;
goto out;
}
if (whiteout_dentry->d_inode) {
/* .wh.foo has been found. */
/* First truncate it and then rename it to foo (hence having
* the same overall effect as a normal create.
*
* XXX: This is not strictly correct. If we have unlinked the
* file and it still has a reference count, then we should
* actually unlink the whiteout so that user's data isn't
* hosed over.
*/
struct dentry *hidden_dir_dentry;
struct iattr newattrs;
down(&whiteout_dentry->d_inode->i_sem);
newattrs.ia_valid = ATTR_CTIME | ATTR_MODE | ATTR_ATIME
| ATTR_MTIME | ATTR_UID | ATTR_GID | ATTR_FORCE
| ATTR_KILL_SUID | ATTR_KILL_SGID;
newattrs.ia_mode = mode & ~current->fs->umask;
newattrs.ia_uid = current->fsuid;
newattrs.ia_gid = current->fsgid;
if (whiteout_dentry->d_inode->i_size != 0) {
newattrs.ia_valid |= ATTR_SIZE;
newattrs.ia_size = 0;
}
err = notify_change(whiteout_dentry, &newattrs);
up(&whiteout_dentry->d_inode->i_sem);
if (err)
printk(KERN_WARNING
"unionfs: %s:%d: notify_change failed: %d, ignoring..\n",
__FILE__, __LINE__, err);
new_hidden_dentry = dtohd(dentry);
DGET(new_hidden_dentry);
hidden_dir_dentry = GET_PARENT(whiteout_dentry);
lock_rename(hidden_dir_dentry, hidden_dir_dentry);
if (!(err = is_robranch_super(dentry->d_sb, bstart))) {
err =
vfs_rename(hidden_dir_dentry->d_inode,
whiteout_dentry,
hidden_dir_dentry->d_inode,
new_hidden_dentry);
}
if (!err) {
fist_copy_attr_timesizes(parent,
new_hidden_dentry->d_parent->
d_inode);
parent->i_nlink = get_nlinks(parent);
}
unlock_rename(hidden_dir_dentry, hidden_dir_dentry);
DPUT(hidden_dir_dentry);
DPUT(new_hidden_dentry);
if (err) {
/* exit if the error returned was NOT -EROFS */
if (!IS_COPYUP_ERR(err))
goto out;
/* We were not able to create the file in this branch,
* so, we try to create it in one branch to left
*/
bstart--;
} else {
/* reset the unionfs dentry to point to the .wh.foo entry. */
/* Discard any old reference. */
DPUT(dtohd(dentry));
/* Trade one reference to another. */
set_dtohd_index(dentry, bstart, whiteout_dentry);
whiteout_dentry = NULL;
err = unionfs_interpose(dentry, parent->i_sb, 0);
goto out;
}
}
for (bindex = bstart; bindex >= 0; bindex--) {
hidden_dentry = dtohd_index(dentry, bindex);
if (!hidden_dentry) {
/* if hidden_dentry is NULL, create the entire
* dentry directory structure in branch 'bindex'.
* hidden_dentry will NOT be null when bindex == bstart
* because lookup passed as a negative unionfs dentry
* pointing to a lone negative underlying dentry */
hidden_dentry = create_parents(parent, dentry, bindex);
if (!hidden_dentry || IS_ERR(hidden_dentry)) {
if (IS_ERR(hidden_dentry))
err = PTR_ERR(hidden_dentry);
continue;
}
}
fist_checkinode(parent, "unionfs_create");
hidden_parent_dentry = lock_parent(hidden_dentry);
if (IS_ERR(hidden_parent_dentry)) {
err = PTR_ERR(hidden_parent_dentry);
goto out;
}
/* We shouldn't create things in a read-only branch. */
if (!(err = is_robranch_super(dentry->d_sb, bindex))) {
//DQ: vfs_create has a different prototype in 2.6
err = vfs_create(hidden_parent_dentry->d_inode,
hidden_dentry, mode, nd);
}
if (err || !hidden_dentry->d_inode) {
unlock_dir(hidden_parent_dentry);
/* break out of for loop if the error wasn't -EROFS */
if (!IS_COPYUP_ERR(err))
break;
} else {
err = unionfs_interpose(dentry, parent->i_sb, 0);
if (!err) {
fist_copy_attr_timesizes(parent,
hidden_parent_dentry->
d_inode);
/* update number of links on parent directory */
parent->i_nlink = get_nlinks(parent);
}
unlock_dir(hidden_parent_dentry);
break;
}
}
out:
DPUT(whiteout_dentry);
KFREE(name);
fist_print_dentry("OUT unionfs_create :", dentry);
unlock_dentry(dentry);
print_exit_status(err);
return err;
}
/*
* The locking rules in u2fs_rename are complex. We could use a simpler
* superblock-level name-space lock for renames and copy-ups.
*/
static int u2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
struct inode *new_dir, struct dentry *new_dentry)
{
int err = 0;
struct dentry *lower_old_dentry = NULL;
struct dentry *lower_new_dentry = NULL;
struct dentry *lower_old_dir_dentry = NULL;
struct dentry *lower_new_dir_dentry = NULL;
struct dentry *trap = NULL;
struct dentry *ret = NULL;
struct path lower_old_path, lower_new_path;
/* creating parent directories if destination is read-only */
if((U2FS_D(old_dentry)->lower_path[LEFT].dentry) == NULL &&
(U2FS_D(old_dentry)->lower_path[LEFT].mnt) == NULL){
err = create_whiteout(old_dentry);
if(err){
err = -EIO;
goto out_copyup;
}
err = copyup_dentry(old_dir, old_dentry,
old_dentry->d_name.name, old_dentry->d_name.len,
NULL, i_size_read(old_dentry->d_inode));
if(err)
goto out_copyup;
}
if((U2FS_D(new_dentry)->lower_path[LEFT].dentry) == NULL &&
(U2FS_D(new_dentry)->lower_path[LEFT].mnt) == NULL){
ret = create_parents(new_dir, new_dentry,
new_dentry->d_name.name);
if (!ret || IS_ERR(ret)) {
err = PTR_ERR(ret);
if (!IS_COPYUP_ERR(err))
printk(KERN_ERR
"u2fs: create_parents for "
"u2fs_rename failed"
"err=%d\n", err);
goto out_copyup;
}
u2fs_postcopyup_setmnt(new_dentry);
u2fs_put_reset_lower_path(new_dentry, RIGHT);
if(err)
goto out_copyup;
}
u2fs_get_lower_path(old_dentry, &lower_old_path, LEFT);
u2fs_get_lower_path(new_dentry, &lower_new_path, LEFT);
lower_old_dentry = lower_old_path.dentry;
lower_new_dentry = lower_new_path.dentry;
lower_old_dir_dentry = dget_parent(lower_old_dentry);
lower_new_dir_dentry = dget_parent(lower_new_dentry);
trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
/* source should not be ancestor of target */
if (trap == lower_old_dentry) {
err = -EINVAL;
goto out;
}
/* target should not be ancestor of source */
if (trap == lower_new_dentry) {
err = -ENOTEMPTY;
goto out;
}
err = mnt_want_write(lower_old_path.mnt);
if (err)
goto out;
err = mnt_want_write(lower_new_path.mnt);
if (err)
goto out_drop_old_write;
err = vfs_rename(lower_old_dir_dentry->d_inode, lower_old_dentry,
lower_new_dir_dentry->d_inode, lower_new_dentry);
if (err)
goto out_err;
fsstack_copy_attr_all(new_dir, lower_new_dir_dentry->d_inode);
fsstack_copy_inode_size(new_dir, lower_new_dir_dentry->d_inode);
if (new_dir != old_dir) {
fsstack_copy_attr_all(old_dir,
lower_old_dir_dentry->d_inode);
fsstack_copy_inode_size(old_dir,
lower_old_dir_dentry->d_inode);
}
out_err:
mnt_drop_write(lower_new_path.mnt);
out_drop_old_write:
mnt_drop_write(lower_old_path.mnt);
out:
unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
dput(lower_old_dir_dentry);
dput(lower_new_dir_dentry);
u2fs_put_lower_path(old_dentry, &lower_old_path);
u2fs_put_lower_path(new_dentry, &lower_new_path);
out_copyup:
return err;
}
static int u2fs_create(struct inode *dir, struct dentry *dentry,
int mode, struct nameidata *nd)
{
int err = 0;
struct dentry *lower_dentry = NULL;
struct dentry *lower_parent_dentry = NULL;
struct dentry *parent= NULL;
struct dentry *ret=NULL;
struct path lower_path, saved_path;
const char *name;
unsigned int namelen;
struct dentry *right_parent_dentry = NULL;
struct dentry *right_lower_dentry = NULL;
/* creating parent directories if destination is read-only */
if((U2FS_D(dentry)->lower_path[LEFT].dentry) == NULL &&
(U2FS_D(dentry)->lower_path[LEFT].mnt) == NULL){
parent = dget_parent(dentry);
right_parent_dentry = U2FS_D(parent)->lower_path[RIGHT].dentry;
ret = create_parents(parent->d_inode, dentry,
dentry->d_name.name);
if (!ret || IS_ERR(ret)) {
err = PTR_ERR(ret);
if (!IS_COPYUP_ERR(err))
printk(KERN_ERR
"u2fs: create_parents for "
"u2fs_create failed"
"err=%d\n", err);
goto out_copyup;
}
u2fs_postcopyup_setmnt(dentry);
u2fs_put_reset_lower_path(dentry, RIGHT);
}
u2fs_get_lower_path(dentry, &lower_path, LEFT);
lower_dentry = lower_path.dentry;
lower_parent_dentry = lock_parent(lower_dentry);
err = mnt_want_write(lower_path.mnt);
if (err)
goto out_unlock;
pathcpy(&saved_path, &nd->path);
pathcpy(&nd->path, &lower_path);
err = vfs_create(lower_parent_dentry->d_inode, lower_dentry, mode, nd);
pathcpy(&nd->path, &saved_path);
if (err)
goto out;
/* looking if the file already exists in right_dir to link inode */
if((U2FS_D(dentry)->lower_path[RIGHT].dentry) != NULL &&
(U2FS_D(dentry)->lower_path[RIGHT].mnt) != NULL){
name = dentry->d_name.name;
namelen = dentry->d_name.len;
right_lower_dentry = lookup_one_len(name, lower_parent_dentry,
namelen);
dentry->d_inode = right_lower_dentry->d_inode;
u2fs_set_lower_inode(dentry->d_inode, lower_dentry->d_inode,
LEFT);
}
else
err = u2fs_interpose(dentry, dir->i_sb, &lower_path, LEFT);
if (err)
goto out;
fsstack_copy_attr_times(dir, u2fs_lower_inode(dir, LEFT));
fsstack_copy_inode_size(dir, lower_parent_dentry->d_inode);
out:
mnt_drop_write(lower_path.mnt);
out_unlock:
unlock_dir(lower_parent_dentry);
u2fs_put_lower_path(dentry, &lower_path);
out_copyup:
if(parent != NULL)
dput(parent);
return err;
}
static int __unionfs_rename(struct inode *old_dir, struct dentry *old_dentry,
struct dentry *old_parent,
struct inode *new_dir, struct dentry *new_dentry,
struct dentry *new_parent,
int bindex)
{
int err = 0;
struct dentry *lower_old_dentry;
struct dentry *lower_new_dentry;
struct dentry *lower_old_dir_dentry;
struct dentry *lower_new_dir_dentry;
struct dentry *trap;
lower_new_dentry = unionfs_lower_dentry_idx(new_dentry, bindex);
lower_old_dentry = unionfs_lower_dentry_idx(old_dentry, bindex);
if (!lower_new_dentry) {
lower_new_dentry =
create_parents(new_parent->d_inode,
new_dentry, new_dentry->d_name.name,
bindex);
if (IS_ERR(lower_new_dentry)) {
err = PTR_ERR(lower_new_dentry);
if (IS_COPYUP_ERR(err))
goto out;
printk(KERN_ERR "unionfs: error creating directory "
"tree for rename, bindex=%d err=%d\n",
bindex, err);
goto out;
}
}
/* check for and remove whiteout, if any */
err = check_unlink_whiteout(new_dentry, lower_new_dentry, bindex);
if (err > 0) /* ignore if whiteout found and successfully removed */
err = 0;
if (err)
goto out;
/* check of old_dentry branch is writable */
err = is_robranch_super(old_dentry->d_sb, bindex);
if (err)
goto out;
dget(lower_old_dentry);
dget(lower_new_dentry);
lower_old_dir_dentry = dget_parent(lower_old_dentry);
lower_new_dir_dentry = dget_parent(lower_new_dentry);
/* see Documentation/filesystems/unionfs/issues.txt */
lockdep_off();
trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
/* source should not be ancenstor of target */
if (trap == lower_old_dentry) {
err = -EINVAL;
goto out_err_unlock;
}
/* target should not be ancenstor of source */
if (trap == lower_new_dentry) {
err = -ENOTEMPTY;
goto out_err_unlock;
}
err = vfs_rename(lower_old_dir_dentry->d_inode, lower_old_dentry,
lower_new_dir_dentry->d_inode, lower_new_dentry);
out_err_unlock:
if (!err) {
/* update parent dir times */
fsstack_copy_attr_times(old_dir, lower_old_dir_dentry->d_inode);
fsstack_copy_attr_times(new_dir, lower_new_dir_dentry->d_inode);
}
unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);
lockdep_on();
dput(lower_old_dir_dentry);
dput(lower_new_dir_dentry);
dput(lower_old_dentry);
dput(lower_new_dentry);
out:
if (!err) {
/* Fixup the new_dentry. */
if (bindex < dbstart(new_dentry))
dbstart(new_dentry) = bindex;
else if (bindex > dbend(new_dentry))
dbend(new_dentry) = bindex;
}
return err;
}
/*
* Main rename code. This is sufficiently complex, that it's documented in
* Documentation/filesystems/unionfs/rename.txt. This routine calls
* __unionfs_rename() above to perform some of the work.
*/
static int do_unionfs_rename(struct inode *old_dir,
struct dentry *old_dentry,
struct dentry *old_parent,
struct inode *new_dir,
struct dentry *new_dentry,
struct dentry *new_parent)
{
int err = 0;
int bindex, bwh_old;
int old_bstart, old_bend;
int new_bstart, new_bend;
int do_copyup = -1;
int local_err = 0;
int eio = 0;
int revert = 0;
old_bstart = dbstart(old_dentry);
bwh_old = old_bstart;
old_bend = dbend(old_dentry);
new_bstart = dbstart(new_dentry);
new_bend = dbend(new_dentry);
/* Rename source to destination. */
err = __unionfs_rename(old_dir, old_dentry, old_parent,
new_dir, new_dentry, new_parent,
old_bstart);
if (err) {
if (!IS_COPYUP_ERR(err))
goto out;
do_copyup = old_bstart - 1;
} else {
revert = 1;
}
/*
* Unlink all instances of destination that exist to the left of
* bstart of source. On error, revert back, goto out.
*/
for (bindex = old_bstart - 1; bindex >= new_bstart; bindex--) {
struct dentry *unlink_dentry;
struct dentry *unlink_dir_dentry;
BUG_ON(bindex < 0);
unlink_dentry = unionfs_lower_dentry_idx(new_dentry, bindex);
if (!unlink_dentry)
continue;
unlink_dir_dentry = lock_parent(unlink_dentry);
err = is_robranch_super(old_dir->i_sb, bindex);
if (!err)
err = vfs_unlink(unlink_dir_dentry->d_inode,
unlink_dentry);
fsstack_copy_attr_times(new_parent->d_inode,
unlink_dir_dentry->d_inode);
/* propagate number of hard-links */
new_parent->d_inode->i_nlink =
unionfs_get_nlinks(new_parent->d_inode);
unlock_dir(unlink_dir_dentry);
if (!err) {
if (bindex != new_bstart) {
dput(unlink_dentry);
unionfs_set_lower_dentry_idx(new_dentry,
bindex, NULL);
}
} else if (IS_COPYUP_ERR(err)) {
do_copyup = bindex - 1;
} else if (revert) {
goto revert;
}
}
if (do_copyup != -1) {
for (bindex = do_copyup; bindex >= 0; bindex--) {
/*
* copyup the file into some left directory, so that
* you can rename it
*/
err = copyup_dentry(old_parent->d_inode,
old_dentry, old_bstart, bindex,
old_dentry->d_name.name,
old_dentry->d_name.len, NULL,
i_size_read(old_dentry->d_inode));
/* if copyup failed, try next branch to the left */
if (err)
continue;
bwh_old = bindex;
err = __unionfs_rename(old_dir, old_dentry, old_parent,
new_dir, new_dentry, new_parent,
bindex);
break;
}
}
/* make it opaque */
if (S_ISDIR(old_dentry->d_inode->i_mode)) {
err = make_dir_opaque(old_dentry, dbstart(old_dentry));
if (err)
goto revert;
}
/*
* Create whiteout for source, only if:
* (1) There is more than one underlying instance of source.
* (2) We did a copy_up
*/
if ((old_bstart != old_bend) || (do_copyup != -1)) {
if (bwh_old < 0) {
printk(KERN_ERR "unionfs: rename error (bwh_old=%d)\n",
bwh_old);
err = -EIO;
goto out;
}
err = create_whiteout(old_dentry, bwh_old);
if (err) {
/* can't fix anything now, so we exit with -EIO */
printk(KERN_ERR "unionfs: can't create a whiteout for "
"%s in rename!\n", old_dentry->d_name.name);
err = -EIO;
}
}
out:
return err;
revert:
/* Do revert here. */
local_err = unionfs_refresh_lower_dentry(new_dentry, new_parent,
old_bstart);
if (local_err) {
printk(KERN_ERR "unionfs: revert failed in rename: "
"the new refresh failed\n");
eio = -EIO;
}
local_err = unionfs_refresh_lower_dentry(old_dentry, old_parent,
old_bstart);
if (local_err) {
printk(KERN_ERR "unionfs: revert failed in rename: "
"the old refresh failed\n");
eio = -EIO;
goto revert_out;
}
if (!unionfs_lower_dentry_idx(new_dentry, bindex) ||
!unionfs_lower_dentry_idx(new_dentry, bindex)->d_inode) {
printk(KERN_ERR "unionfs: revert failed in rename: "
"the object disappeared from under us!\n");
eio = -EIO;
goto revert_out;
}
if (unionfs_lower_dentry_idx(old_dentry, bindex) &&
unionfs_lower_dentry_idx(old_dentry, bindex)->d_inode) {
printk(KERN_ERR "unionfs: revert failed in rename: "
"the object was created underneath us!\n");
eio = -EIO;
goto revert_out;
}
local_err = __unionfs_rename(new_dir, new_dentry, new_parent,
old_dir, old_dentry, old_parent,
old_bstart);
/* If we can't fix it, then we cop-out with -EIO. */
if (local_err) {
printk(KERN_ERR "unionfs: revert failed in rename!\n");
eio = -EIO;
}
local_err = unionfs_refresh_lower_dentry(new_dentry, new_parent,
bindex);
if (local_err)
eio = -EIO;
local_err = unionfs_refresh_lower_dentry(old_dentry, old_parent,
bindex);
if (local_err)
eio = -EIO;
revert_out:
if (eio)
err = eio;
return err;
}
int unionfs_rmdir(struct inode *dir, struct dentry *dentry)
{
int err = 0;
struct unionfs_dir_state *namelist = NULL;
print_entry_location();
lock_dentry(dentry);
fist_print_dentry("IN unionfs_rmdir: ", dentry);
/* check if this unionfs directory is empty or not */
err = check_empty(dentry, &namelist);
if (err) {
#if 0
/* vfs_rmdir(our caller) unhashed the dentry. This will recover
* the Unionfs inode number for the directory itself, but the
* children are already lost. It seems that tmpfs manages its
* way around this by upping the refcount on everything.
*
* Even if we do this, we still lose the inode numbers of the
* children. The best way to fix this is to fix the VFS (or
* use persistent inode maps). */
if (d_unhashed(dentry))
d_rehash(dentry);
#endif
goto out;
}
#ifdef UNIONFS_DELETE_ALL
if (IS_SET(dir->i_sb, DELETE_ALL)) {
/* delete all. */
err = unionfs_rmdir_all(dir, dentry, namelist);
} else { /* Delete the first directory. */
#endif
err = unionfs_rmdir_first(dir, dentry, namelist);
/* create whiteout */
if (!err) {
err = create_whiteout(dentry, dbstart(dentry));
} else {
int new_err;
if (dbstart(dentry) == 0)
goto out;
/* exit if the error returned was NOT -EROFS */
if (!IS_COPYUP_ERR(err))
goto out;
new_err = create_whiteout(dentry, dbstart(dentry) - 1);
if (new_err != -EEXIST)
err = new_err;
}
#ifdef UNIONFS_DELETE_ALL
}
#endif
out:
/* call d_drop so the system "forgets" about us */
if (!err)
d_drop(dentry);
if (namelist)
free_rdstate(namelist);
unlock_dentry(dentry);
print_exit_status(err);
return err;
}
static int unionfs_symlink(struct inode *dir, struct dentry *dentry,
const char *symname)
{
int err = 0;
struct dentry *hidden_dentry = NULL;
struct dentry *whiteout_dentry = NULL;
struct dentry *hidden_dir_dentry = NULL;
umode_t mode;
int bindex = 0, bstart;
char *name = NULL;
print_entry_location();
lock_dentry(dentry);
fist_print_dentry("IN unionfs_symlink", dentry);
/* We start out in the leftmost branch. */
bstart = dbstart(dentry);
hidden_dentry = dtohd(dentry);
/* check if whiteout exists in this branch, i.e. lookup .wh.foo first. If present, delete it */
name = alloc_whname(dentry->d_name.name, dentry->d_name.len);
if (IS_ERR(name)) {
err = PTR_ERR(name);
goto out;
}
whiteout_dentry =
LOOKUP_ONE_LEN(name, hidden_dentry->d_parent,
dentry->d_name.len + WHLEN);
if (IS_ERR(whiteout_dentry)) {
err = PTR_ERR(whiteout_dentry);
goto out;
}
if (!whiteout_dentry->d_inode) {
DPUT(whiteout_dentry);
whiteout_dentry = NULL;
} else {
/* found a .wh.foo entry, unlink it and then call vfs_symlink() */
hidden_dir_dentry = lock_parent(whiteout_dentry);
fist_print_generic_dentry("HDD", hidden_dir_dentry);
fist_print_generic_dentry("WD", whiteout_dentry);
if (!(err = is_robranch_super(dentry->d_sb, bstart))) {
err =
vfs_unlink(hidden_dir_dentry->d_inode,
whiteout_dentry);
}
DPUT(whiteout_dentry);
fist_copy_attr_times(dir, hidden_dir_dentry->d_inode);
/* propagate number of hard-links */
dir->i_nlink = get_nlinks(dir);
unlock_dir(hidden_dir_dentry);
if (err) {
/* exit if the error returned was NOT -EROFS */
if (!IS_COPYUP_ERR(err))
goto out;
/* should now try to create symlink in the another branch */
bstart--;
}
}
/* deleted whiteout if it was present, now do a normal vfs_symlink() with
possible recursive directory creation */
for (bindex = bstart; bindex >= 0; bindex--) {
hidden_dentry = dtohd_index(dentry, bindex);
if (!hidden_dentry) {
/* if hidden_dentry is NULL, create the entire
* dentry directory structure in branch 'bindex'. hidden_dentry will NOT be null when
* bindex == bstart because lookup passed as a negative unionfs dentry pointing to a
* lone negative underlying dentry */
hidden_dentry = create_parents(dir, dentry, bindex);
if (!hidden_dentry || IS_ERR(hidden_dentry)) {
if (IS_ERR(hidden_dentry)) {
err = PTR_ERR(hidden_dentry);
}
fist_dprint(8,
"hidden dentry NULL (or error) for bindex = %d\n",
bindex);
continue;
}
}
hidden_dir_dentry = lock_parent(hidden_dentry);
if (!(err = is_robranch_super(dentry->d_sb, bindex))) {
mode = S_IALLUGO;
err =
vfs_symlink(hidden_dir_dentry->d_inode,
hidden_dentry, symname, mode);
}
unlock_dir(hidden_dir_dentry);
if (err || !hidden_dentry->d_inode) {
/* break out of for loop if error returned was NOT -EROFS */
if (!IS_COPYUP_ERR(err))
break;
} else {
err = unionfs_interpose(dentry, dir->i_sb, 0);
if (!err) {
fist_copy_attr_timesizes(dir,
hidden_dir_dentry->
d_inode);
/* update number of links on parent directory */
dir->i_nlink = get_nlinks(dir);
}
break;
}
}
out:
if (!dentry->d_inode)
d_drop(dentry);
KFREE(name);
fist_print_dentry("OUT unionfs_symlink :", dentry);
unlock_dentry(dentry);
print_exit_status(err);
return err;
}
static int u2fs_link(struct dentry *old_dentry, struct inode *dir,
struct dentry *new_dentry)
{
struct dentry *lower_old_dentry;
struct dentry *lower_new_dentry;
struct dentry *lower_dir_dentry;
u64 file_size_save;
int err=0;
int idx;
struct dentry *ret = NULL;
struct path lower_old_path, lower_new_path;
file_size_save = i_size_read(old_dentry->d_inode);
if((U2FS_D(old_dentry)->lower_path[LEFT].dentry != NULL) &&
(U2FS_D(old_dentry)->lower_path[LEFT].mnt != NULL)){
u2fs_get_lower_path(old_dentry, &lower_old_path, LEFT);
idx = LEFT;
}
else{
u2fs_get_lower_path(old_dentry, &lower_old_path, RIGHT);
idx = RIGHT;
}
/* creating parent directories if destination is read-only */
if((U2FS_D(new_dentry)->lower_path[LEFT].dentry) == NULL &&
(U2FS_D(new_dentry)->lower_path[LEFT].mnt) == NULL){
ret = create_parents(dir, new_dentry,
new_dentry->d_name.name);
if (!ret || IS_ERR(ret)) {
err = PTR_ERR(ret);
if (!IS_COPYUP_ERR(err))
printk(KERN_ERR
"u2fs: create_parents for "
"u2fs_link failed"
"err=%d\n", err);
goto out_copyup;
}
u2fs_postcopyup_setmnt(new_dentry);
u2fs_put_reset_lower_path(new_dentry, RIGHT);
if(err)
goto out_copyup;
}
u2fs_get_lower_path(new_dentry, &lower_new_path, LEFT);
lower_old_dentry = lower_old_path.dentry;
lower_new_dentry = lower_new_path.dentry;
lower_dir_dentry = lock_parent(lower_new_dentry);
err = mnt_want_write(lower_new_path.mnt);
if (err)
goto out_unlock;
err = vfs_link(lower_old_dentry, lower_dir_dentry->d_inode,
lower_new_dentry);
if (err || !lower_new_dentry->d_inode)
goto out;
err = u2fs_interpose(new_dentry, dir->i_sb, &lower_new_path, LEFT);
if (err)
goto out;
fsstack_copy_attr_times(dir, lower_new_dentry->d_inode);
fsstack_copy_inode_size(dir, lower_new_dentry->d_inode);
set_nlink(old_dentry->d_inode,
u2fs_lower_inode(old_dentry->d_inode, idx)->i_nlink);
i_size_write(new_dentry->d_inode, file_size_save);
out:
mnt_drop_write(lower_new_path.mnt);
out_unlock:
unlock_dir(lower_dir_dentry);
u2fs_put_lower_path(new_dentry, &lower_new_path);
out_copyup:
u2fs_put_lower_path(old_dentry, &lower_old_path);
return err;
}
static int unionfs_mkdir(struct inode *parent, struct dentry *dentry, int mode)
{
int err = 0;
struct dentry *hidden_dentry = NULL, *whiteout_dentry = NULL;
struct dentry *hidden_parent_dentry = NULL;
int bindex = 0, bstart;
char *name = NULL;
int whiteout_unlinked = 0;
uid_t saved_uid = current->fsuid;
gid_t saved_gid = current->fsgid;
print_entry_location();
lock_dentry(dentry);
fist_print_dentry("IN unionfs_mkdir", dentry);
bstart = dbstart(dentry);
hidden_dentry = dtohd(dentry);
// check if whiteout exists in this branch, i.e. lookup .wh.foo first
name = alloc_whname(dentry->d_name.name, dentry->d_name.len);
if (IS_ERR(name)) {
err = PTR_ERR(name);
goto out;
}
whiteout_dentry =
LOOKUP_ONE_LEN(name, hidden_dentry->d_parent,
dentry->d_name.len + WHLEN);
if (IS_ERR(whiteout_dentry)) {
err = PTR_ERR(whiteout_dentry);
goto out;
}
if (!whiteout_dentry->d_inode) {
DPUT(whiteout_dentry);
whiteout_dentry = NULL;
} else {
hidden_parent_dentry = lock_parent(whiteout_dentry);
/* Set the uid and gid to trick the fs into allowing us to create
* the file */
current->fsuid = hidden_parent_dentry->d_inode->i_uid;
current->fsgid = hidden_parent_dentry->d_inode->i_gid;
//found a.wh.foo entry, remove it then do vfs_mkdir
if (!(err = is_robranch_super(dentry->d_sb, bstart))) {
err =
vfs_unlink(hidden_parent_dentry->d_inode,
whiteout_dentry);
}
DPUT(whiteout_dentry);
current->fsuid = saved_uid;
current->fsgid = saved_gid;
unlock_dir(hidden_parent_dentry);
if (err) {
/* exit if the error returned was NOT -EROFS */
if (!IS_COPYUP_ERR(err))
goto out;
bstart--;
} else {
whiteout_unlinked = 1;
}
}
for (bindex = bstart; bindex >= 0; bindex--) {
hidden_dentry = dtohd_index(dentry, bindex);
if (!hidden_dentry) {
hidden_dentry = create_parents(parent, dentry, bindex);
if (!hidden_dentry || IS_ERR(hidden_dentry)) {
fist_dprint(8,
"hidden dentry NULL for bindex = %d\n",
bindex);
continue;
}
}
hidden_parent_dentry = lock_parent(hidden_dentry);
if (IS_ERR(hidden_parent_dentry)) {
err = PTR_ERR(hidden_parent_dentry);
goto out;
}
if (!(err = is_robranch_super(dentry->d_sb, bindex))) {
err =
vfs_mkdir(hidden_parent_dentry->d_inode,
hidden_dentry, mode);
}
unlock_dir(hidden_parent_dentry);
/* XXX this could potentially return a negative hidden_dentry! */
if (err || !hidden_dentry->d_inode) {
/* break out of for loop if error returned was NOT -EROFS */
if (!IS_COPYUP_ERR(err))
break;
} else {
int i;
int bend = dbend(dentry);
for (i = bindex + 1; i < bend; i++) {
if (dtohd_index(dentry, i)) {
DPUT(dtohd_index(dentry, i));
set_dtohd_index(dentry, i, NULL);
}
}
bend = bindex;
set_dbend(dentry, bend);
err = unionfs_interpose(dentry, parent->i_sb, 0);
if (!err) {
fist_copy_attr_timesizes(parent,
hidden_parent_dentry->
d_inode);
/* update number of links on parent directory */
parent->i_nlink = get_nlinks(parent);
}
whiteout_dentry = LOOKUP_ONE_LEN(UNIONFS_DIR_OPAQUE,
hidden_dentry,
sizeof
(UNIONFS_DIR_OPAQUE) -
1);
if (IS_ERR(whiteout_dentry)) {
err = PTR_ERR(whiteout_dentry);
goto out;
}
down(&hidden_dentry->d_inode->i_sem);
err = vfs_create(hidden_dentry->d_inode,
whiteout_dentry, 0600, NULL);
up(&hidden_dentry->d_inode->i_sem);
DPUT(whiteout_dentry);
if (err) {
fist_dprint(8,
"mkdir: error creating directory override entry: %d\n",
err);
goto out;
}
break;
}
}
out:
if (!dentry->d_inode)
d_drop(dentry);
KFREE(name);
fist_print_dentry("OUT unionfs_mkdir :", dentry);
unlock_dentry(dentry);
print_exit_status(err);
return err;
}
static int unionfs_link(struct dentry *old_dentry, struct inode *dir,
struct dentry *new_dentry)
{
int err = 0;
struct dentry *lower_old_dentry = NULL;
struct dentry *lower_new_dentry = NULL;
struct dentry *lower_dir_dentry = NULL;
struct dentry *old_parent, *new_parent;
char *name = NULL;
bool valid;
unionfs_read_lock(old_dentry->d_sb, UNIONFS_SMUTEX_CHILD);
old_parent = dget_parent(old_dentry);
new_parent = dget_parent(new_dentry);
unionfs_double_lock_parents(old_parent, new_parent);
unionfs_double_lock_dentry(old_dentry, new_dentry);
valid = __unionfs_d_revalidate(old_dentry, old_parent, false, 0);
if (unlikely(!valid)) {
err = -ESTALE;
goto out;
}
if (new_dentry->d_inode) {
valid = __unionfs_d_revalidate(new_dentry, new_parent, false, 0);
if (unlikely(!valid)) {
err = -ESTALE;
goto out;
}
}
lower_new_dentry = unionfs_lower_dentry(new_dentry);
/* check for a whiteout in new dentry branch, and delete it */
err = check_unlink_whiteout(new_dentry, lower_new_dentry,
dbstart(new_dentry));
if (err > 0) { /* whiteout found and removed successfully */
lower_dir_dentry = dget_parent(lower_new_dentry);
fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
dput(lower_dir_dentry);
set_nlink(dir, unionfs_get_nlinks(dir));
err = 0;
}
if (err)
goto out;
/* check if parent hierachy is needed, then link in same branch */
if (dbstart(old_dentry) != dbstart(new_dentry)) {
lower_new_dentry = create_parents(dir, new_dentry,
new_dentry->d_name.name,
dbstart(old_dentry));
err = PTR_ERR(lower_new_dentry);
if (IS_COPYUP_ERR(err))
goto docopyup;
if (!lower_new_dentry || IS_ERR(lower_new_dentry))
goto out;
}
lower_new_dentry = unionfs_lower_dentry(new_dentry);
lower_old_dentry = unionfs_lower_dentry(old_dentry);
BUG_ON(dbstart(old_dentry) != dbstart(new_dentry));
lower_dir_dentry = lock_parent(lower_new_dentry);
err = is_robranch(old_dentry);
if (!err) {
/* see Documentation/filesystems/unionfs/issues.txt */
lockdep_off();
err = vfs_link(lower_old_dentry, lower_dir_dentry->d_inode,
lower_new_dentry);
lockdep_on();
}
unlock_dir(lower_dir_dentry);
docopyup:
if (IS_COPYUP_ERR(err)) {
int old_bstart = dbstart(old_dentry);
int bindex;
for (bindex = old_bstart - 1; bindex >= 0; bindex--) {
err = copyup_dentry(old_parent->d_inode,
old_dentry, old_bstart,
bindex, old_dentry->d_name.name,
old_dentry->d_name.len, NULL,
i_size_read(old_dentry->d_inode));
if (err)
continue;
lower_new_dentry =
create_parents(dir, new_dentry,
new_dentry->d_name.name,
bindex);
lower_old_dentry = unionfs_lower_dentry(old_dentry);
lower_dir_dentry = lock_parent(lower_new_dentry);
/* see Documentation/filesystems/unionfs/issues.txt */
lockdep_off();
/* do vfs_link */
err = vfs_link(lower_old_dentry,
lower_dir_dentry->d_inode,
lower_new_dentry);
lockdep_on();
unlock_dir(lower_dir_dentry);
goto check_link;
}
goto out;
}
check_link:
if (err || !lower_new_dentry->d_inode)
goto out;
/* Its a hard link, so use the same inode */
new_dentry->d_inode = igrab(old_dentry->d_inode);
d_add(new_dentry, new_dentry->d_inode);
unionfs_copy_attr_all(dir, lower_new_dentry->d_parent->d_inode);
fsstack_copy_inode_size(dir, lower_new_dentry->d_parent->d_inode);
/* propagate number of hard-links */
set_nlink(old_dentry->d_inode,
unionfs_get_nlinks(old_dentry->d_inode));
/* new dentry's ctime may have changed due to hard-link counts */
unionfs_copy_attr_times(new_dentry->d_inode);
out:
if (!new_dentry->d_inode)
d_drop(new_dentry);
kfree(name);
if (!err)
unionfs_postcopyup_setmnt(new_dentry);
unionfs_check_inode(dir);
unionfs_check_dentry(new_dentry);
unionfs_check_dentry(old_dentry);
unionfs_double_unlock_dentry(old_dentry, new_dentry);
unionfs_double_unlock_parents(old_parent, new_parent);
dput(new_parent);
dput(old_parent);
unionfs_read_unlock(old_dentry->d_sb);
return err;
}
static int unionfs_rename_whiteout(struct inode *old_dir,
struct dentry *old_dentry,
struct inode *new_dir,
struct dentry *new_dentry)
{
int err = 0;
int bindex, bwh_old;
int old_bstart, old_bend;
int new_bstart, new_bend;
int do_copyup = -1;
struct dentry *parent_dentry;
int local_err = 0;
int eio = 0;
int revert = 0;
struct dentry *wh_old = NULL;
print_entry_location();
old_bstart = dbstart(old_dentry);
bwh_old = old_bstart;
old_bend = dbend(old_dentry);
parent_dentry = old_dentry->d_parent;
new_bstart = dbstart(new_dentry);
new_bend = dbend(new_dentry);
/* Rename source to destination. */
err = do_rename(old_dir, old_dentry, new_dir, new_dentry, old_bstart,
&wh_old);
if (err) {
if (!IS_COPYUP_ERR(err)) {
goto out;
}
do_copyup = old_bstart - 1;
} else {
revert = 1;
}
/* Unlink all instances of destination that exist to the left of
* bstart of source. On error, revert back, goto out.
*/
for (bindex = old_bstart - 1; bindex >= new_bstart; bindex--) {
struct dentry *unlink_dentry;
struct dentry *unlink_dir_dentry;
unlink_dentry = dtohd_index(new_dentry, bindex);
if (!unlink_dentry) {
continue;
}
unlink_dir_dentry = lock_parent(unlink_dentry);
if (!(err = is_robranch_super(old_dir->i_sb, bindex))) {
err =
vfs_unlink(unlink_dir_dentry->d_inode,
unlink_dentry);
}
fist_copy_attr_times(new_dentry->d_parent->d_inode,
unlink_dir_dentry->d_inode);
/* propagate number of hard-links */
new_dentry->d_parent->d_inode->i_nlink =
get_nlinks(new_dentry->d_parent->d_inode);
unlock_dir(unlink_dir_dentry);
if (!err) {
if (bindex != new_bstart) {
DPUT(unlink_dentry);
set_dtohd_index(new_dentry, bindex, NULL);
}
} else if (IS_COPYUP_ERR(err)) {
do_copyup = bindex - 1;
} else if (revert) {
DPUT(wh_old);
goto revert;
}
}
if (do_copyup != -1) {
for (bindex = do_copyup; bindex >= 0; bindex--) {
/* copyup the file into some left directory, so that you can rename it */
err =
copyup_dentry(old_dentry->d_parent->d_inode,
old_dentry, old_bstart, bindex, NULL,
old_dentry->d_inode->i_size);
if (!err) {
DPUT(wh_old);
bwh_old = bindex;
err =
do_rename(old_dir, old_dentry, new_dir,
new_dentry, bindex, &wh_old);
break;
}
}
}
/* Create whiteout for source, only if:
* (1) There is more than one underlying instance of source.
* (2) We did a copy_up
*/
if ((old_bstart != old_bend) || (do_copyup != -1)) {
struct dentry *hidden_parent;
BUG_ON(!wh_old || IS_ERR(wh_old) || wh_old->d_inode
|| bwh_old < 0);
hidden_parent = lock_parent(wh_old);
local_err = vfs_create(hidden_parent->d_inode, wh_old, S_IRUGO,
NULL);
unlock_dir(hidden_parent);
if (!local_err)
set_dbopaque(old_dentry, bwh_old);
else {
/* We can't fix anything now, so we cop-out and use -EIO. */
printk
("<0>We can't create a whiteout for the source in rename!\n");
err = -EIO;
}
}
out:
DPUT(wh_old);
print_exit_status(err);
return err;
revert:
/* Do revert here. */
local_err = unionfs_refresh_hidden_dentry(new_dentry, old_bstart);
if (local_err) {
printk(KERN_WARNING
"Revert failed in rename: the new refresh failed.\n");
eio = -EIO;
}
local_err = unionfs_refresh_hidden_dentry(old_dentry, old_bstart);
if (local_err) {
printk(KERN_WARNING
"Revert failed in rename: the old refresh failed.\n");
eio = -EIO;
goto revert_out;
}
if (!dtohd_index(new_dentry, bindex)
|| !dtohd_index(new_dentry, bindex)->d_inode) {
printk(KERN_WARNING
"Revert failed in rename: the object disappeared from under us!\n");
eio = -EIO;
goto revert_out;
}
if (dtohd_index(old_dentry, bindex)
&& dtohd_index(old_dentry, bindex)->d_inode) {
printk(KERN_WARNING
"Revert failed in rename: the object was created underneath us!\n");
eio = -EIO;
goto revert_out;
}
local_err =
do_rename(new_dir, new_dentry, old_dir, old_dentry, old_bstart,
NULL);
/* If we can't fix it, then we cop-out with -EIO. */
if (local_err) {
printk(KERN_WARNING "Revert failed in rename!\n");
eio = -EIO;
}
local_err = unionfs_refresh_hidden_dentry(new_dentry, bindex);
if (local_err)
eio = -EIO;
local_err = unionfs_refresh_hidden_dentry(old_dentry, bindex);
if (local_err)
eio = -EIO;
revert_out:
if (eio)
err = eio;
print_exit_status(err);
return err;
}
/*
* Don't grab the superblock read-lock in unionfs_permission, which prevents
* a deadlock with the branch-management "add branch" code (which grabbed
* the write lock). It is safe to not grab the read lock here, because even
* with branch management taking place, there is no chance that
* unionfs_permission, or anything it calls, will use stale branch
* information.
*/
static int unionfs_permission(struct inode *inode, int mask)
{
struct inode *lower_inode = NULL;
int err = 0;
int bindex, bstart, bend;
int is_file;
const int write_mask = (mask & MAY_WRITE) && !(mask & MAY_READ);
struct inode *inode_grabbed;
inode_grabbed = igrab(inode);
is_file = !S_ISDIR(inode->i_mode);
if (!UNIONFS_I(inode)->lower_inodes) {
if (is_file) /* dirs can be unlinked but chdir'ed to */
err = -ESTALE; /* force revalidate */
goto out;
}
bstart = ibstart(inode);
bend = ibend(inode);
if (unlikely(bstart < 0 || bend < 0)) {
/*
* With branch-management, we can get a stale inode here.
* If so, we return ESTALE back to link_path_walk, which
* would discard the dcache entry and re-lookup the
* dentry+inode. This should be equivalent to issuing
* __unionfs_d_revalidate_chain on nd.dentry here.
*/
if (is_file) /* dirs can be unlinked but chdir'ed to */
err = -ESTALE; /* force revalidate */
goto out;
}
for (bindex = bstart; bindex <= bend; bindex++) {
lower_inode = unionfs_lower_inode_idx(inode, bindex);
if (!lower_inode)
continue;
/*
* check the condition for D-F-D underlying files/directories,
* we don't have to check for files, if we are checking for
* directories.
*/
if (!is_file && !S_ISDIR(lower_inode->i_mode))
continue;
/*
* We check basic permissions, but we ignore any conditions
* such as readonly file systems or branches marked as
* readonly, because those conditions should lead to a
* copyup taking place later on. However, if user never had
* access to the file, then no copyup could ever take place.
*/
err = __inode_permission(lower_inode, mask);
if (err && err != -EACCES && err != EPERM && bindex > 0) {
umode_t mode = lower_inode->i_mode;
if ((is_robranch_super(inode->i_sb, bindex) ||
__is_rdonly(lower_inode)) &&
(S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
err = 0;
if (IS_COPYUP_ERR(err))
err = 0;
}
/*
* NFS HACK: NFSv2/3 return EACCES on readonly-exported,
* locally readonly-mounted file systems, instead of EROFS
* like other file systems do. So we have no choice here
* but to intercept this and ignore it for NFS branches
* marked readonly. Specifically, we avoid using NFS's own
* "broken" ->permission method, and rely on
* generic_permission() to do basic checking for us.
*/
if (err && err == -EACCES &&
is_robranch_super(inode->i_sb, bindex) &&
lower_inode->i_sb->s_magic == NFS_SUPER_MAGIC)
err = generic_permission(lower_inode, mask);
/*
* The permissions are an intersection of the overall directory
* permissions, so we fail if one fails.
*/
if (err)
goto out;
/* only the leftmost file matters. */
if (is_file || write_mask) {
if (is_file && write_mask) {
err = get_write_access(lower_inode);
if (!err)
put_write_access(lower_inode);
}
break;
}
}
/* sync times which may have changed (asynchronously) below */
unionfs_copy_attr_times(inode);
out:
unionfs_check_inode(inode);
iput(inode_grabbed);
return err;
}
static int unionfs_link(struct dentry *old_dentry, struct inode *dir,
struct dentry *new_dentry)
{
int err = 0;
struct dentry *hidden_old_dentry = NULL;
struct dentry *hidden_new_dentry = NULL;
struct dentry *hidden_dir_dentry = NULL;
struct dentry *whiteout_dentry;
char *name = NULL;
print_entry_location();
double_lock_dentry(new_dentry, old_dentry);
hidden_new_dentry = dtohd(new_dentry);
/* check if whiteout exists in the branch of new dentry, i.e. lookup
* .wh.foo first. If present, delete it */
name = alloc_whname(new_dentry->d_name.name, new_dentry->d_name.len);
if (IS_ERR(name)) {
err = PTR_ERR(name);
goto out;
}
whiteout_dentry =
LOOKUP_ONE_LEN(name, hidden_new_dentry->d_parent,
new_dentry->d_name.len + WHLEN);
if (IS_ERR(whiteout_dentry)) {
err = PTR_ERR(whiteout_dentry);
goto out;
}
if (!whiteout_dentry->d_inode) {
DPUT(whiteout_dentry);
whiteout_dentry = NULL;
} else {
/* found a .wh.foo entry, unlink it and then call vfs_link() */
hidden_dir_dentry = lock_parent(whiteout_dentry);
if (!
(err =
is_robranch_super(new_dentry->d_sb,
dbstart(new_dentry)))) {
err =
vfs_unlink(hidden_dir_dentry->d_inode,
whiteout_dentry);
}
fist_copy_attr_times(dir, hidden_dir_dentry->d_inode);
dir->i_nlink = get_nlinks(dir);
unlock_dir(hidden_dir_dentry);
hidden_dir_dentry = NULL;
DPUT(whiteout_dentry);
if (err)
goto out;
}
if (dbstart(old_dentry) != dbstart(new_dentry)) {
hidden_new_dentry =
create_parents(dir, new_dentry, dbstart(old_dentry));
err = PTR_ERR(hidden_new_dentry);
if (IS_COPYUP_ERR(err))
goto docopyup;
if (!hidden_new_dentry || IS_ERR(hidden_new_dentry))
goto out;
}
hidden_new_dentry = dtohd(new_dentry);
hidden_old_dentry = dtohd(old_dentry);
BUG_ON(dbstart(old_dentry) != dbstart(new_dentry));
hidden_dir_dentry = lock_parent(hidden_new_dentry);
if (!(err = is_robranch(old_dentry)))
err =
vfs_link(hidden_old_dentry, hidden_dir_dentry->d_inode,
hidden_new_dentry);
unlock_dir(hidden_dir_dentry);
docopyup:
if (IS_COPYUP_ERR(err)) {
int old_bstart = dbstart(old_dentry);
int bindex;
for (bindex = old_bstart - 1; bindex >= 0; bindex--) {
err =
copyup_dentry(old_dentry->d_parent->
d_inode, old_dentry,
old_bstart, bindex, NULL,
old_dentry->d_inode->i_size);
if (!err) {
hidden_new_dentry =
create_parents(dir, new_dentry, bindex);
hidden_old_dentry = dtohd(old_dentry);
hidden_dir_dentry =
lock_parent(hidden_new_dentry);
/* do vfs_link */
err =
vfs_link(hidden_old_dentry,
hidden_dir_dentry->d_inode,
hidden_new_dentry);
unlock_dir(hidden_dir_dentry);
goto check_link;
}
}
goto out;
}
check_link:
if (err || !hidden_new_dentry->d_inode)
goto out;
/* Its a hard link, so use the same inode */
new_dentry->d_inode = IGRAB(old_dentry->d_inode);
d_instantiate(new_dentry, new_dentry->d_inode);
fist_copy_attr_all(dir, hidden_new_dentry->d_parent->d_inode);
/* propagate number of hard-links */
old_dentry->d_inode->i_nlink = get_nlinks(old_dentry->d_inode);
out:
if (!new_dentry->d_inode)
d_drop(new_dentry);
KFREE(name);
unlock_dentry(new_dentry);
unlock_dentry(old_dentry);
print_exit_status(err);
return err;
}