static int au_ren_lock(struct au_ren_args *a)
{
int err;
unsigned int udba;
err = 0;
a->src_h_parent = au_h_dptr(a->src_parent, a->btgt);
a->src_hdir = au_hi(a->src_dir, a->btgt);
a->dst_h_parent = au_h_dptr(a->dst_parent, a->btgt);
a->dst_hdir = au_hi(a->dst_dir, a->btgt);
a->h_trap = vfsub_lock_rename(a->src_h_parent, a->src_hdir,
a->dst_h_parent, a->dst_hdir);
udba = au_opt_udba(a->src_dentry->d_sb);
if (unlikely(a->src_hdir->hi_inode != a->src_h_parent->d_inode
|| a->dst_hdir->hi_inode != a->dst_h_parent->d_inode))
err = au_busy_or_stale();
if (!err && au_dbstart(a->src_dentry) == a->btgt)
err = au_h_verify(a->src_h_dentry, udba,
a->src_h_parent->d_inode, a->src_h_parent,
a->br);
if (!err && au_dbstart(a->dst_dentry) == a->btgt)
err = au_h_verify(a->dst_h_dentry, udba,
a->dst_h_parent->d_inode, a->dst_h_parent,
a->br);
if (!err) {
err = mnt_want_write(a->br->br_mnt);
if (unlikely(err))
goto out_unlock;
au_fset_ren(a->flags, MNT_WRITE);
goto out; /* success */
}
err = au_busy_or_stale();
out_unlock:
au_ren_unlock(a);
out:
return err;
}
static int au_h_verify_dentry(struct dentry *h_dentry, struct dentry *h_parent,
struct au_branch *br)
{
int err;
struct au_iattr ia;
struct inode *h_inode;
struct dentry *h_d;
struct super_block *h_sb;
err = 0;
memset(&ia, -1, sizeof(ia));
h_sb = h_dentry->d_sb;
h_inode = NULL;
if (d_is_positive(h_dentry)) {
h_inode = d_inode(h_dentry);
au_iattr_save(&ia, h_inode);
} else if (au_test_nfs(h_sb) || au_test_fuse(h_sb))
/* nfs d_revalidate may return 0 for negative dentry */
/* fuse d_revalidate always return 0 for negative dentry */
goto out;
/* main purpose is namei.c:cached_lookup() and d_revalidate */
h_d = vfsub_lkup_one(&h_dentry->d_name, h_parent);
err = PTR_ERR(h_d);
if (IS_ERR(h_d))
goto out;
err = 0;
if (unlikely(h_d != h_dentry
|| d_inode(h_d) != h_inode
|| (h_inode && au_iattr_test(&ia, h_inode))))
err = au_busy_or_stale();
dput(h_d);
out:
AuTraceErr(err);
return err;
}
static int aufs_permission(struct inode *inode, int mask)
{
int err;
aufs_bindex_t bindex, bend;
const unsigned char isdir = !!S_ISDIR(inode->i_mode),
write_mask = !!(mask & (MAY_WRITE | MAY_APPEND));
struct inode *h_inode;
struct super_block *sb;
struct au_branch *br;
/* todo: support rcu-walk? */
if (mask & MAY_NOT_BLOCK)
return -ECHILD;
sb = inode->i_sb;
si_read_lock(sb, AuLock_FLUSH);
ii_read_lock_child(inode);
#if 0
err = au_iigen_test(inode, au_sigen(sb));
if (unlikely(err))
goto out;
#endif
if (!isdir || write_mask) {
err = au_busy_or_stale();
h_inode = au_h_iptr(inode, au_ibstart(inode));
if (unlikely(!h_inode
|| (h_inode->i_mode & S_IFMT)
!= (inode->i_mode & S_IFMT)))
goto out;
err = 0;
bindex = au_ibstart(inode);
br = au_sbr(sb, bindex);
err = h_permission(h_inode, mask, br->br_mnt, br->br_perm);
if (write_mask
&& !err
&& !special_file(h_inode->i_mode)) {
/* test whether the upper writable branch exists */
err = -EROFS;
for (; bindex >= 0; bindex--)
if (!au_br_rdonly(au_sbr(sb, bindex))) {
err = 0;
break;
}
}
goto out;
}
/* non-write to dir */
err = 0;
bend = au_ibend(inode);
for (bindex = au_ibstart(inode); !err && bindex <= bend; bindex++) {
h_inode = au_h_iptr(inode, bindex);
if (h_inode) {
err = au_busy_or_stale();
if (unlikely(!S_ISDIR(h_inode->i_mode)))
break;
br = au_sbr(sb, bindex);
err = h_permission(h_inode, mask, br->br_mnt,
br->br_perm);
}
}
out:
ii_read_unlock(inode);
si_read_unlock(sb);
return err;
}
int au_do_pin(struct au_pin *p)
{
int err;
struct super_block *sb;
struct dentry *h_dentry, *h_parent;
struct au_branch *br;
struct inode *h_dir;
err = 0;
sb = p->dentry->d_sb;
br = au_sbr(sb, p->bindex);
if (IS_ROOT(p->dentry)) {
if (au_ftest_pin(p->flags, MNT_WRITE)) {
p->h_mnt = br->br_mnt;
err = mnt_want_write(p->h_mnt);
if (unlikely(err)) {
au_fclr_pin(p->flags, MNT_WRITE);
goto out_err;
}
}
goto out;
}
h_dentry = NULL;
if (p->bindex <= au_dbend(p->dentry))
h_dentry = au_h_dptr(p->dentry, p->bindex);
p->parent = dget_parent(p->dentry);
if (!au_ftest_pin(p->flags, DI_LOCKED))
di_read_lock(p->parent, AuLock_IR, p->lsc_di);
h_dir = NULL;
h_parent = au_h_dptr(p->parent, p->bindex);
p->hdir = au_hi(p->parent->d_inode, p->bindex);
if (p->hdir)
h_dir = p->hdir->hi_inode;
/*
* udba case, or
* if DI_LOCKED is not set, then p->parent may be different
* and h_parent can be NULL.
*/
if (unlikely(!p->hdir || !h_dir || !h_parent)) {
err = -EBUSY;
if (!au_ftest_pin(p->flags, DI_LOCKED))
di_read_unlock(p->parent, AuLock_IR);
dput(p->parent);
p->parent = NULL;
goto out_err;
}
au_igrab(h_dir);
au_hn_imtx_lock_nested(p->hdir, p->lsc_hi);
if (unlikely(p->hdir->hi_inode != h_parent->d_inode)) {
err = -EBUSY;
goto out_unpin;
}
if (h_dentry) {
err = au_h_verify(h_dentry, p->udba, h_dir, h_parent, br);
if (unlikely(err)) {
au_fclr_pin(p->flags, MNT_WRITE);
goto out_unpin;
}
}
if (au_ftest_pin(p->flags, MNT_WRITE)) {
p->h_mnt = br->br_mnt;
err = mnt_want_write(p->h_mnt);
if (unlikely(err)) {
au_fclr_pin(p->flags, MNT_WRITE);
goto out_unpin;
}
}
goto out; /* success */
out_unpin:
au_unpin(p);
out_err:
pr_err("err %d\n", err);
err = au_busy_or_stale();
out:
return err;
}