long link_by_fd(int file_fd, int newdfd, const char __user * newname)
{
int error;
int fput_needed;
struct file *filep;
struct nameidata nd;
struct dentry *new_dentry;
filep = fget_light(file_fd, &fput_needed);
if(!filep)
return -EBADF;
error = __user_walk_fd(newdfd, newname, LOOKUP_PARENT, &nd);
if(error)
goto file_out;
error = -EXDEV;
if(filep->f_vfsmnt != nd.mnt)
goto out_release;
new_dentry = lookup_create(&nd, 0);
error = PTR_ERR(new_dentry);
if(!IS_ERR(new_dentry))
{
error = vfs_link(filep->f_dentry, nd.dentry->d_inode, new_dentry);
dput(new_dentry);
}
mutex_unlock(&nd.dentry->d_inode->i_mutex);
out_release:
path_release(&nd);
file_out:
fput_light(filep, fput_needed);
return error;
}
static int ecryptfs_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 rc;
file_size_save = i_size_read(old_dentry->d_inode);
lower_old_dentry = ecryptfs_dentry_to_lower(old_dentry);
lower_new_dentry = ecryptfs_dentry_to_lower(new_dentry);
dget(lower_old_dentry);
dget(lower_new_dentry);
lower_dir_dentry = lock_parent(lower_new_dentry);
rc = vfs_link(lower_old_dentry, lower_dir_dentry->d_inode,
lower_new_dentry);
if (rc || !lower_new_dentry->d_inode)
goto out_lock;
rc = ecryptfs_interpose(lower_new_dentry, new_dentry, dir->i_sb);
if (rc)
goto out_lock;
fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);
fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);
set_nlink(old_dentry->d_inode,
ecryptfs_inode_to_lower(old_dentry->d_inode)->i_nlink);
i_size_write(new_dentry->d_inode, file_size_save);
out_lock:
unlock_dir(lower_dir_dentry);
dput(lower_new_dentry);
dput(lower_old_dentry);
return rc;
}
//int vfs_link(char *oldpath, char *newpath);
uint32_t sys_link(uint32_t param[4], uint32_t param_size[4])
{
char *oldpath;
char *newpath;
int status;
if ((param_size[0] > CONFIG_FILE_MAX_NAME_LENGTH) || (param_size[1] > CONFIG_FILE_MAX_NAME_LENGTH)) {
syscall_errno = EFAULT;
return (uint32_t) -1;
}
oldpath = heapmm_alloc(param_size[0]);
if (!copy_user_to_kern((void *)param[0], oldpath, param_size[0])) {
syscall_errno = EFAULT;
heapmm_free(oldpath, param_size[0]);
return (uint32_t) -1;
}
newpath = heapmm_alloc(param_size[1]);
if (!copy_user_to_kern((void *)param[1], newpath, param_size[1])) {
syscall_errno = EFAULT;
heapmm_free(oldpath, param_size[0]);
heapmm_free(newpath, param_size[1]);
return (uint32_t) -1;
}
status = vfs_link(oldpath, newpath);
if (status != 0) {
syscall_errno = status;
status = -1;
}
heapmm_free(oldpath, param_size[0]);
heapmm_free(newpath, param_size[1]);
return (uint32_t) status;
}
int do_link (struct inode *inode, struct inode *dir, const char *name,
int len)
{
#if USE_DENTRY_F
struct dentry *ref_dent;
struct dentry *new_dent;
#endif
int ret;
DOWN(&(dir->i_sem));
#if POST_20_KERNEL_F
/* Get a dentry for the link source. */
ref_dent = ovlfs_inode2dentry(inode);
if ( ref_dent == NULL )
{
ret = -ENOENT;
}
else
{
/* Create a temporary negative dentry for the target. */
ret = ovlfs_inode_get_child_dentry(dir, name, len, &new_dent,
OVLFS_DENT_GET_NEGATIVE);
if ( ret != 0 )
dput(ref_dent);
}
if ( ret == 0 )
{
/* Use the vfs_link function to do the dirty work. */
ret = vfs_link(ref_dent, dir, new_dent);
dput(ref_dent);
dput(new_dent);
}
#else
IMARK(inode);
IMARK(dir);
ret = dir->i_op->link(inode, dir, name, len);
#endif
UP(&(dir->i_sem));
return ret;
}
static int wrapfs_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;
struct path lower_old_path, lower_new_path;
if(wrapfs_get_debug(dir->i_sb) & DEBUG_INODE)
DEBUG_MESG("Enter");
file_size_save = i_size_read(old_dentry->d_inode);
wrapfs_get_lower_path(old_dentry, &lower_old_path);
wrapfs_get_lower_path(new_dentry, &lower_new_path);
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 = wrapfs_interpose(new_dentry, dir->i_sb, &lower_new_path);
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,
wrapfs_lower_inode(old_dentry->d_inode)->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);
wrapfs_put_lower_path(old_dentry, &lower_old_path);
wrapfs_put_lower_path(new_dentry, &lower_new_path);
if(wrapfs_get_debug(dir->i_sb) & DEBUG_INODE)
DEBUG_RETURN("Exit", err);
return err;
}
/* sysfile_link - link file */
int
sysfile_link(const char *__path1, const char *__path2) {
int ret;
char *old_path, *new_path;
if ((ret = copy_path(&old_path, __path1)) != 0) {
return ret;
}
if ((ret = copy_path(&new_path, __path2)) != 0) {
kfree(old_path);
return ret;
}
ret = vfs_link(old_path, new_path);
kfree(old_path), kfree(new_path);
return ret;
}
static int sdcardfs_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;
struct path lower_old_path, lower_new_path;
OVERRIDE_CRED(SDCARDFS_SB(dir->i_sb));
file_size_save = i_size_read(old_dentry->d_inode);
sdcardfs_get_lower_path(old_dentry, &lower_old_path);
sdcardfs_get_lower_path(new_dentry, &lower_new_path);
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 = sdcardfs_interpose(new_dentry, dir->i_sb, &lower_new_path);
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,
sdcardfs_lower_inode(old_dentry->d_inode)->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);
sdcardfs_put_lower_path(old_dentry, &lower_old_path);
sdcardfs_put_lower_path(new_dentry, &lower_new_path);
REVERT_CRED();
return err;
}
int vfsub_link(struct dentry *src_dentry, struct inode *dir, struct path *path,
struct inode **delegated_inode)
{
int err;
struct dentry *d;
IMustLock(dir);
err = au_test_nlink(d_inode(src_dentry));
if (unlikely(err))
return err;
/* we don't call may_linkat() */
d = path->dentry;
path->dentry = d->d_parent;
err = security_path_link(src_dentry, path, d);
path->dentry = d;
if (unlikely(err))
goto out;
lockdep_off();
err = vfs_link(src_dentry, dir, path->dentry, delegated_inode);
lockdep_on();
if (!err) {
struct path tmp = *path;
int did;
/* fuse has different memory inode for the same inumber */
vfsub_update_h_iattr(&tmp, &did);
if (did) {
tmp.dentry = path->dentry->d_parent;
vfsub_update_h_iattr(&tmp, /*did*/NULL);
tmp.dentry = src_dentry;
vfsub_update_h_iattr(&tmp, /*did*/NULL);
}
/*ignore*/
}
out:
return err;
}
static int diaryfs_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;
struct path lower_old_path, lower_new_path;
file_size_save = i_size_read(old_dentry->d_inode);
diaryfs_get_lower_path(old_dentry, &lower_old_path);
diaryfs_get_lower_path(new_dentry, &lower_new_path);
lower_old_dentry = lower_old_path.dentry;
lower_new_dentry = lower_new_path.dentry;
lower_dir_dentry = lock_parent(lower_new_dentry);
err = vfs_link(lower_old_dentry, lower_dir_dentry->d_inode,
lower_new_dentry, NULL);
if (err || !lower_new_dentry->d_inode)
goto out;
err = diaryfs_interpose(new_dentry, dir->i_sb, &lower_new_path);
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,
( diaryfs_lower_inode(old_dentry->d_inode))->i_nlink);
i_size_write(new_dentry->d_inode, file_size_save);
out:
unlock_dir(lower_dir_dentry);
diaryfs_put_lower_path(old_dentry, &lower_old_path);
diaryfs_put_lower_path(new_dentry, &lower_new_path);
return err;
}
static int ccfs_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 rc;
// TODO: Update cached link
file_size_save = i_size_read(old_dentry->d_inode);
lower_old_dentry = ccfs_get_nested_dentry(old_dentry);
lower_new_dentry = ccfs_get_nested_dentry(new_dentry);
dget(lower_old_dentry);
dget(lower_new_dentry);
mdbg(INFO3,"Link w/ lower_dentry->d_name.name = [%s] Link = [%s]", lower_old_dentry->d_name.name, lower_new_dentry->d_name.name);
lower_dir_dentry = lock_parent(lower_new_dentry);
rc = vfs_link(lower_old_dentry, lower_dir_dentry->d_inode,
lower_new_dentry);
if (rc || !lower_new_dentry->d_inode)
goto out_lock;
rc = ccfs_interpose(lower_new_dentry, new_dentry, dir->i_sb, 0);
if (rc)
goto out_lock;
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, ccfs_get_nested_inode(old_dentry->d_inode)->i_nlink); //Fix for kernel 3.7.1 use function set_nlink by Jiri Rakosnik
i_size_write(new_dentry->d_inode, file_size_save);
out_lock:
unlock_dir(lower_dir_dentry);
dput(lower_new_dentry);
dput(lower_old_dentry);
d_drop(lower_old_dentry);
d_drop(new_dentry);
d_drop(old_dentry);
return rc;
}
int do_vfsub_link(struct dentry *src_dentry, struct inode *dir,
struct dentry *dentry)
{
int err;
LKTRTrace("%.*s, i%lu, %.*s\n",
AuDLNPair(src_dentry), dir->i_ino, AuDLNPair(dentry));
IMustLock(dir);
lockdep_off();
err = vfs_link(src_dentry, dir, dentry);
lockdep_on();
if (!err) {
LKTRTrace("src_i %p, dst_i %p\n",
src_dentry->d_inode, dentry->d_inode);
/* fuse has different memory inode for the same inumber */
au_update_fuse_h_inode(NULL, src_dentry); /*ignore*/
/* dir inode is locked */
au_update_fuse_h_inode(NULL, dentry->d_parent); /*ignore*/
au_update_fuse_h_inode(NULL, dentry); /*ignore*/
}
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 amfs_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;
struct path lower_old_path, lower_new_path;
char *value = NULL;
if (old_dentry->d_inode->i_ino ==
AMFS_SB(old_dentry->d_sb)->inode_no) {
err = -EPERM;
goto out_err;
}
/************XATTR************/
value = kzalloc(5, __GFP_WAIT);
if (value == NULL) {
err = -ENOMEM;
goto out_err;
}
if (amfs_getxattr(old_dentry, AMFS_XATTR_NAME, value, 5) > 0) {
if (!strncmp(value, AMFS_BADFILE, 3)) {
err = -EPERM;
goto freevalue;
}
} else if (amfs_getxattr(old_dentry, AMFS_XATTR_NAME, value, 5)
!= -ENODATA){
err = amfs_getxattr(old_dentry, AMFS_XATTR_NAME, value, 5);
goto freevalue;
}
/************XATTR***********/
file_size_save = i_size_read(old_dentry->d_inode);
amfs_get_lower_path(old_dentry, &lower_old_path);
amfs_get_lower_path(new_dentry, &lower_new_path);
lower_old_dentry = lower_old_path.dentry;
lower_new_dentry = lower_new_path.dentry;
lower_dir_dentry = lock_parent(lower_new_dentry);
err = vfs_link(lower_old_dentry, lower_dir_dentry->d_inode,
lower_new_dentry, NULL);
if (err || !lower_new_dentry->d_inode)
goto out;
err = amfs_interpose(new_dentry, dir->i_sb, &lower_new_path);
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,
amfs_lower_inode(old_dentry->d_inode)->i_nlink);
i_size_write(new_dentry->d_inode, file_size_save);
out:
unlock_dir(lower_dir_dentry);
amfs_put_lower_path(old_dentry, &lower_old_path);
amfs_put_lower_path(new_dentry, &lower_new_path);
freevalue:
kfree(value);
out_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_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;
}