/*
* initial procedure of adding a new entry.
* prepare writable branch and the parent dir, lock it,
* and lookup whiteout for the new entry.
*/
static struct dentry*
lock_hdir_lkup_wh(struct dentry *dentry, struct au_dtime *dt,
struct dentry *src_dentry, struct au_pin *pin,
struct au_wr_dir_args *wr_dir_args)
{
struct dentry *wh_dentry, *h_parent;
struct super_block *sb;
struct au_branch *br;
int err;
unsigned int udba;
aufs_bindex_t bcpup;
AuDbg("%.*s\n", AuDLNPair(dentry));
err = au_wr_dir(dentry, src_dentry, wr_dir_args);
bcpup = err;
wh_dentry = ERR_PTR(err);
if (unlikely(err < 0))
goto out;
sb = dentry->d_sb;
udba = au_opt_udba(sb);
err = au_pin(pin, dentry, bcpup, udba,
AuPin_DI_LOCKED | AuPin_MNT_WRITE);
wh_dentry = ERR_PTR(err);
if (unlikely(err))
goto out;
h_parent = au_pinned_h_parent(pin);
if (udba != AuOpt_UDBA_NONE
&& au_dbstart(dentry) == bcpup)
err = au_may_add(dentry, bcpup, h_parent,
au_ftest_wrdir(wr_dir_args->flags, ISDIR));
else if (unlikely(dentry->d_name.len > AUFS_MAX_NAMELEN))
err = -ENAMETOOLONG;
wh_dentry = ERR_PTR(err);
if (unlikely(err))
goto out_unpin;
br = au_sbr(sb, bcpup);
if (dt) {
struct path tmp = {
.dentry = h_parent,
.mnt = au_br_mnt(br)
};
au_dtime_store(dt, au_pinned_parent(pin), &tmp);
}
wh_dentry = NULL;
if (bcpup != au_dbwh(dentry))
goto out; /* success */
wh_dentry = au_wh_lkup(h_parent, &dentry->d_name, br);
out_unpin:
if (IS_ERR(wh_dentry))
au_unpin(pin);
out:
return wh_dentry;
}
/*
* decide the branch where we operate for @dentry. the branch index will be set
* @rbcpup. after diciding it, 'pin' it and store the timestamps of the parent
* dir for reverting.
* when a new whiteout is necessary, create it.
*/
static struct dentry*
lock_hdir_create_wh(struct dentry *dentry, int isdir, aufs_bindex_t *rbcpup,
struct au_dtime *dt, struct au_pin *pin)
{
struct dentry *wh_dentry;
struct super_block *sb;
struct path h_path;
int err, need_wh;
unsigned int udba;
aufs_bindex_t bcpup;
need_wh = au_wr_dir_need_wh(dentry, isdir, rbcpup);
wh_dentry = ERR_PTR(need_wh);
if (unlikely(need_wh < 0))
goto out;
sb = dentry->d_sb;
udba = au_opt_udba(sb);
bcpup = *rbcpup;
err = au_pin(pin, dentry, bcpup, udba,
AuPin_DI_LOCKED | AuPin_MNT_WRITE);
wh_dentry = ERR_PTR(err);
if (unlikely(err))
goto out;
h_path.dentry = au_pinned_h_parent(pin);
if (udba != AuOpt_UDBA_NONE
&& au_dbstart(dentry) == bcpup) {
err = au_may_del(dentry, bcpup, h_path.dentry, isdir);
wh_dentry = ERR_PTR(err);
if (unlikely(err))
goto out_unpin;
}
h_path.mnt = au_sbr_mnt(sb, bcpup);
au_dtime_store(dt, au_pinned_parent(pin), &h_path);
wh_dentry = NULL;
if (!need_wh)
goto out; /* success, no need to create whiteout */
wh_dentry = au_wh_create(dentry, bcpup, h_path.dentry);
if (IS_ERR(wh_dentry))
goto out_unpin;
/* returns with the parent is locked and wh_dentry is dget-ed */
goto out; /* success */
out_unpin:
au_unpin(pin);
out:
return wh_dentry;
}
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;
}
/* lock them all */
static int au_do_lock(const unsigned char dmsg, struct au_mvd_args *a)
{
int err;
struct dentry *h_trap;
a->mvd_h_src_sb = au_sbr_sb(a->sb, a->mvd_bsrc);
a->mvd_h_dst_sb = au_sbr_sb(a->sb, a->mvd_bdst);
if (a->mvd_h_src_sb != a->mvd_h_dst_sb) {
a->rename_lock = 0;
err = au_pin(&a->pin, a->dentry, a->mvd_bdst,
au_opt_udba(a->sb),
AuPin_MNT_WRITE | AuPin_DI_LOCKED);
if (!err) {
a->mvd_h_src_dir = a->mvd_h_src_parent->d_inode;
mutex_lock_nested(&a->mvd_h_src_dir->i_mutex,
AuLsc_I_PARENT3);
} else
AU_MVD_PR(dmsg, "pin failed\n");
goto out;
}
err = 0;
a->rename_lock = 1;
h_trap = vfsub_lock_rename(a->mvd_h_src_parent, a->mvd_hdir_src,
a->mvd_h_dst_parent, a->mvd_hdir_dst);
if (h_trap) {
err = (h_trap != a->mvd_h_src_parent);
if (err)
err = (h_trap != a->mvd_h_dst_parent);
}
BUG_ON(err); /* it should never happen */
out:
AuTraceErr(err);
return err;
}
/* lock them all */
static int au_do_lock(const unsigned char dmsg, struct au_mvd_args *a)
{
int err;
struct dentry *h_trap;
a->mvd_h_src_sb = au_sbr_sb(a->sb, a->mvd_bsrc);
a->mvd_h_dst_sb = au_sbr_sb(a->sb, a->mvd_bdst);
err = au_pin(&a->mvd_pin_dst, a->dentry, a->mvd_bdst,
au_opt_udba(a->sb),
AuPin_MNT_WRITE | AuPin_DI_LOCKED);
AuTraceErr(err);
if (unlikely(err)) {
AU_MVD_PR(dmsg, "pin_dst failed\n");
goto out;
}
if (a->mvd_h_src_sb != a->mvd_h_dst_sb) {
a->rename_lock = 0;
au_pin_init(&a->mvd_pin_src, a->dentry, a->mvd_bsrc,
AuLsc_DI_PARENT, AuLsc_I_PARENT3,
au_opt_udba(a->sb),
AuPin_MNT_WRITE | AuPin_DI_LOCKED);
err = au_do_pin(&a->mvd_pin_src);
AuTraceErr(err);
a->mvd_h_src_dir = d_inode(a->mvd_h_src_parent);
if (unlikely(err)) {
AU_MVD_PR(dmsg, "pin_src failed\n");
goto out_dst;
}
goto out; /* success */
}
a->rename_lock = 1;
au_pin_hdir_unlock(&a->mvd_pin_dst);
err = au_pin(&a->mvd_pin_src, a->dentry, a->mvd_bsrc,
au_opt_udba(a->sb),
AuPin_MNT_WRITE | AuPin_DI_LOCKED);
AuTraceErr(err);
a->mvd_h_src_dir = d_inode(a->mvd_h_src_parent);
if (unlikely(err)) {
AU_MVD_PR(dmsg, "pin_src failed\n");
au_pin_hdir_lock(&a->mvd_pin_dst);
goto out_dst;
}
au_pin_hdir_unlock(&a->mvd_pin_src);
h_trap = vfsub_lock_rename(a->mvd_h_src_parent, a->mvd_hdir_src,
a->mvd_h_dst_parent, a->mvd_hdir_dst);
if (h_trap) {
err = (h_trap != a->mvd_h_src_parent);
if (err)
err = (h_trap != a->mvd_h_dst_parent);
}
BUG_ON(err); /* it should never happen */
if (unlikely(a->mvd_h_src_dir != au_pinned_h_dir(&a->mvd_pin_src))) {
err = -EBUSY;
AuTraceErr(err);
vfsub_unlock_rename(a->mvd_h_src_parent, a->mvd_hdir_src,
a->mvd_h_dst_parent, a->mvd_hdir_dst);
au_pin_hdir_lock(&a->mvd_pin_src);
au_unpin(&a->mvd_pin_src);
au_pin_hdir_lock(&a->mvd_pin_dst);
goto out_dst;
}
goto out; /* success */
out_dst:
au_unpin(&a->mvd_pin_dst);
out:
AuTraceErr(err);
return err;
}
int aufs_link(struct dentry *src_dentry, struct inode *dir,
struct dentry *dentry)
{
int err, rerr;
struct au_dtime dt;
struct au_link_args *a;
struct dentry *wh_dentry, *h_src_dentry;
struct inode *inode;
struct super_block *sb;
struct au_wr_dir_args wr_dir_args = {
/* .force_btgt = -1, */
.flags = AuWrDir_ADD_ENTRY
};
IMustLock(dir);
inode = src_dentry->d_inode;
IMustLock(inode);
err = -ENOMEM;
a = kzalloc(sizeof(*a), GFP_NOFS);
if (unlikely(!a))
goto out;
a->parent = dentry->d_parent; /* dir inode is locked */
err = aufs_read_and_write_lock2(dentry, src_dentry,
AuLock_NOPLM | AuLock_GEN);
if (unlikely(err))
goto out_kfree;
err = au_d_hashed_positive(src_dentry);
if (unlikely(err))
goto out_unlock;
err = au_d_may_add(dentry);
if (unlikely(err))
goto out_unlock;
a->src_parent = dget_parent(src_dentry);
wr_dir_args.force_btgt = au_ibstart(inode);
di_write_lock_parent(a->parent);
wr_dir_args.force_btgt = au_wbr(dentry, wr_dir_args.force_btgt);
wh_dentry = lock_hdir_lkup_wh(dentry, &dt, src_dentry, &a->pin,
&wr_dir_args);
err = PTR_ERR(wh_dentry);
if (IS_ERR(wh_dentry))
goto out_parent;
err = 0;
sb = dentry->d_sb;
a->bdst = au_dbstart(dentry);
a->h_path.dentry = au_h_dptr(dentry, a->bdst);
a->h_path.mnt = au_sbr_mnt(sb, a->bdst);
a->bsrc = au_ibstart(inode);
h_src_dentry = au_h_d_alias(src_dentry, a->bsrc);
if (!h_src_dentry) {
a->bsrc = au_dbstart(src_dentry);
h_src_dentry = au_h_d_alias(src_dentry, a->bsrc);
AuDebugOn(!h_src_dentry);
} else if (IS_ERR(h_src_dentry))
goto out_parent;
if (au_opt_test(au_mntflags(sb), PLINK)) {
if (a->bdst < a->bsrc
/* && h_src_dentry->d_sb != a->h_path.dentry->d_sb */)
err = au_cpup_or_link(src_dentry, a);
else
err = vfsub_link(h_src_dentry, au_pinned_h_dir(&a->pin),
&a->h_path);
dput(h_src_dentry);
} else {
/*
* copyup src_dentry to the branch we process,
* and then link(2) to it.
*/
dput(h_src_dentry);
if (a->bdst < a->bsrc
/* && h_src_dentry->d_sb != a->h_path.dentry->d_sb */) {
au_unpin(&a->pin);
di_write_unlock(a->parent);
err = au_cpup_before_link(src_dentry, a);
di_write_lock_parent(a->parent);
if (!err)
err = au_pin(&a->pin, dentry, a->bdst,
au_opt_udba(sb),
AuPin_DI_LOCKED | AuPin_MNT_WRITE);
if (unlikely(err))
goto out_wh;
}
if (!err) {
h_src_dentry = au_h_dptr(src_dentry, a->bdst);
err = -ENOENT;
if (h_src_dentry && h_src_dentry->d_inode)
err = vfsub_link(h_src_dentry,
au_pinned_h_dir(&a->pin),
&a->h_path);
}
}
if (unlikely(err))
goto out_unpin;
if (wh_dentry) {
a->h_path.dentry = wh_dentry;
err = au_wh_unlink_dentry(au_pinned_h_dir(&a->pin), &a->h_path,
dentry);
if (unlikely(err))
goto out_revert;
}
dir->i_version++;
if (au_ibstart(dir) == au_dbstart(dentry))
au_cpup_attr_timesizes(dir);
inc_nlink(inode);
inode->i_ctime = dir->i_ctime;
d_instantiate(dentry, au_igrab(inode));
if (d_unhashed(a->h_path.dentry))
/* some filesystem calls d_drop() */
d_drop(dentry);
goto out_unpin; /* success */
out_revert:
rerr = vfsub_unlink(au_pinned_h_dir(&a->pin), &a->h_path, /*force*/0);
if (unlikely(rerr)) {
AuIOErr("%.*s reverting failed(%d, %d)\n",
AuDLNPair(dentry), err, rerr);
err = -EIO;
}
au_dtime_revert(&dt);
out_unpin:
au_unpin(&a->pin);
out_wh:
dput(wh_dentry);
out_parent:
di_write_unlock(a->parent);
dput(a->src_parent);
out_unlock:
if (unlikely(err)) {
au_update_dbstart(dentry);
d_drop(dentry);
}
aufs_read_and_write_unlock2(dentry, src_dentry);
out_kfree:
kfree(a);
out:
return err;
}
/*
* initial procedure of adding a new entry.
* prepare writable branch and the parent dir, lock it,
* and lookup whiteout for the new entry.
*/
static struct dentry*
lock_hdir_lkup_wh(struct dentry *dentry, struct au_dtime *dt,
struct dentry *src_dentry, struct au_pin *pin,
struct au_wr_dir_args *wr_dir_args)
{
struct dentry *wh_dentry, *h_parent;
struct super_block *sb;
struct au_branch *br;
int err;
unsigned int udba;
aufs_bindex_t bcpup;
AuDbg("%.*s\n", AuDLNPair(dentry));
err = au_wr_dir(dentry, src_dentry, wr_dir_args);
bcpup = err;
wh_dentry = ERR_PTR(err);
if (unlikely(err < 0))
goto out;
sb = dentry->d_sb;
udba = au_opt_udba(sb);
err = au_pin(pin, dentry, bcpup, udba,
AuPin_DI_LOCKED | AuPin_MNT_WRITE);
wh_dentry = ERR_PTR(err);
if (unlikely(err))
goto out;
h_parent = au_pinned_h_parent(pin);
if (udba != AuOpt_UDBA_NONE
&& au_dbstart(dentry) == bcpup)
err = au_may_add(dentry, bcpup, h_parent,
au_ftest_wrdir(wr_dir_args->flags, ISDIR));
else if (unlikely(dentry->d_name.len > AUFS_MAX_NAMELEN))
err = -ENAMETOOLONG;
wh_dentry = ERR_PTR(err);
if (unlikely(err))
goto out_unpin;
br = au_sbr(sb, bcpup);
if (dt) {
struct path tmp = {
.dentry = h_parent,
.mnt = br->br_mnt
};
au_dtime_store(dt, au_pinned_parent(pin), &tmp);
}
wh_dentry = NULL;
if (bcpup != au_dbwh(dentry))
goto out; /* success */
wh_dentry = au_wh_lkup(h_parent, &dentry->d_name, br);
out_unpin:
if (IS_ERR(wh_dentry))
au_unpin(pin);
out:
return wh_dentry;
}
/* ---------------------------------------------------------------------- */
enum { Mknod, Symlink, Creat };
struct simple_arg {
int type;
union {
struct {
int mode;
struct nameidata *nd;
} c;
struct {
const char *symname;
} s;
struct {
int mode;
dev_t dev;
} m;
} u;
};
static int add_simple(struct inode *dir, struct dentry *dentry,
struct simple_arg *arg)
{
int err;
aufs_bindex_t bstart;
unsigned char created;
struct au_dtime dt;
struct au_pin pin;
struct path h_path;
struct dentry *wh_dentry, *parent;
struct inode *h_dir;
struct au_wr_dir_args wr_dir_args = {
.force_btgt = -1,
.flags = AuWrDir_ADD_ENTRY
};
AuDbg("%.*s\n", AuDLNPair(dentry));
IMustLock(dir);
parent = dentry->d_parent; /* dir inode is locked */
err = aufs_read_lock(dentry, AuLock_DW | AuLock_GEN);
if (unlikely(err))
goto out;
err = au_d_may_add(dentry);
if (unlikely(err))
goto out_unlock;
di_write_lock_parent(parent);
wh_dentry = lock_hdir_lkup_wh(dentry, &dt, /*src_dentry*/NULL, &pin,
&wr_dir_args);
err = PTR_ERR(wh_dentry);
if (IS_ERR(wh_dentry))
goto out_parent;
bstart = au_dbstart(dentry);
h_path.dentry = au_h_dptr(dentry, bstart);
h_path.mnt = au_sbr_mnt(dentry->d_sb, bstart);
h_dir = au_pinned_h_dir(&pin);
switch (arg->type) {
case Creat:
err = vfsub_create(h_dir, &h_path, arg->u.c.mode);
break;
case Symlink:
err = vfsub_symlink(h_dir, &h_path, arg->u.s.symname);
break;
case Mknod:
err = vfsub_mknod(h_dir, &h_path, arg->u.m.mode, arg->u.m.dev);
break;
default:
BUG();
}
created = !err;
if (!err)
err = epilog(dir, bstart, wh_dentry, dentry);
/* revert */
if (unlikely(created && err && h_path.dentry->d_inode)) {
int rerr;
rerr = vfsub_unlink(h_dir, &h_path, /*force*/0);
if (rerr) {
AuIOErr("%.*s revert failure(%d, %d)\n",
AuDLNPair(dentry), err, rerr);
err = -EIO;
}
au_dtime_revert(&dt);
}
au_unpin(&pin);
dput(wh_dentry);
out_parent:
di_write_unlock(parent);
out_unlock:
if (unlikely(err)) {
au_update_dbstart(dentry);
d_drop(dentry);
}
aufs_read_unlock(dentry, AuLock_DW);
out:
return err;
}
int aufs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
{
struct simple_arg arg = {
.type = Mknod,
.u.m = {
.mode = mode,
.dev = dev
}
};
return add_simple(dir, dentry, &arg);
}
int aufs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
{
struct simple_arg arg = {
.type = Symlink,
.u.s.symname = symname
};
return add_simple(dir, dentry, &arg);
}
int aufs_create(struct inode *dir, struct dentry *dentry, int mode,
struct nameidata *nd)
{
struct simple_arg arg = {
.type = Creat,
.u.c = {
.mode = mode,
.nd = nd
}
};
return add_simple(dir, dentry, &arg);
}
/* ---------------------------------------------------------------------- */
struct au_link_args {
aufs_bindex_t bdst, bsrc;
struct au_pin pin;
struct path h_path;
struct dentry *src_parent, *parent;
};
static int au_cpup_before_link(struct dentry *src_dentry,
struct au_link_args *a)
{
int err;
struct dentry *h_src_dentry;
struct mutex *h_mtx;
struct file *h_file;
di_read_lock_parent(a->src_parent, AuLock_IR);
err = au_test_and_cpup_dirs(src_dentry, a->bdst);
if (unlikely(err))
goto out;
h_src_dentry = au_h_dptr(src_dentry, a->bsrc);
h_mtx = &h_src_dentry->d_inode->i_mutex;
err = au_pin(&a->pin, src_dentry, a->bdst,
au_opt_udba(src_dentry->d_sb),
AuPin_DI_LOCKED | AuPin_MNT_WRITE);
if (unlikely(err))
goto out;
mutex_lock_nested(h_mtx, AuLsc_I_CHILD);
h_file = au_h_open_pre(src_dentry, a->bsrc);
if (IS_ERR(h_file)) {
err = PTR_ERR(h_file);
h_file = NULL;
} else
err = au_sio_cpup_simple(src_dentry, a->bdst, a->bsrc,
AuCpup_DTIME /* | AuCpup_KEEPLINO */);
mutex_unlock(h_mtx);
au_h_open_post(src_dentry, a->bsrc, h_file);
au_unpin(&a->pin);
out:
di_read_unlock(a->src_parent, AuLock_IR);
return err;
}
static int au_cpup_or_link(struct dentry *src_dentry, struct au_link_args *a)
{
int err;
unsigned char plink;
struct inode *h_inode, *inode;
struct dentry *h_src_dentry;
struct super_block *sb;
struct file *h_file;
plink = 0;
h_inode = NULL;
sb = src_dentry->d_sb;
inode = src_dentry->d_inode;
if (au_ibstart(inode) <= a->bdst)
h_inode = au_h_iptr(inode, a->bdst);
if (!h_inode || !h_inode->i_nlink) {
/* copyup src_dentry as the name of dentry. */
au_set_dbstart(src_dentry, a->bdst);
au_set_h_dptr(src_dentry, a->bdst, dget(a->h_path.dentry));
h_inode = au_h_dptr(src_dentry, a->bsrc)->d_inode;
mutex_lock_nested(&h_inode->i_mutex, AuLsc_I_CHILD);
h_file = au_h_open_pre(src_dentry, a->bsrc);
if (IS_ERR(h_file)) {
err = PTR_ERR(h_file);
h_file = NULL;
} else
err = au_sio_cpup_single(src_dentry, a->bdst, a->bsrc,
-1, AuCpup_KEEPLINO,
a->parent);
mutex_unlock(&h_inode->i_mutex);
au_h_open_post(src_dentry, a->bsrc, h_file);
au_set_h_dptr(src_dentry, a->bdst, NULL);
au_set_dbstart(src_dentry, a->bsrc);
} else {
/* the inode of src_dentry already exists on a.bdst branch */
h_src_dentry = d_find_alias(h_inode);
if (!h_src_dentry && au_plink_test(inode)) {
plink = 1;
h_src_dentry = au_plink_lkup(inode, a->bdst);
err = PTR_ERR(h_src_dentry);
if (IS_ERR(h_src_dentry))
goto out;
if (unlikely(!h_src_dentry->d_inode)) {
dput(h_src_dentry);
h_src_dentry = NULL;
}
}
if (h_src_dentry) {
err = vfsub_link(h_src_dentry, au_pinned_h_dir(&a->pin),
&a->h_path);
dput(h_src_dentry);
} else {
AuIOErr("no dentry found for hi%lu on b%d\n",
h_inode->i_ino, a->bdst);
err = -EIO;
}
}
if (!err && !plink)
au_plink_append(inode, a->bdst, a->h_path.dentry);
out:
AuTraceErr(err);
return err;
}
static int au_cmoo(struct dentry *dentry)
{
int err, cmoo;
unsigned int udba;
struct path h_path;
struct au_pin pin;
struct au_cp_generic cpg = {
.dentry = dentry,
.bdst = -1,
.bsrc = -1,
.len = -1,
.pin = &pin,
.flags = AuCpup_DTIME | AuCpup_HOPEN
};
struct inode *inode, *delegated;
struct super_block *sb;
struct au_sbinfo *sbinfo;
struct au_fhsm *fhsm;
pid_t pid;
struct au_branch *br;
struct dentry *parent;
struct au_hinode *hdir;
DiMustWriteLock(dentry);
inode = dentry->d_inode;
IiMustWriteLock(inode);
err = 0;
if (IS_ROOT(dentry))
goto out;
cpg.bsrc = au_dbstart(dentry);
if (!cpg.bsrc)
goto out;
sb = dentry->d_sb;
sbinfo = au_sbi(sb);
fhsm = &sbinfo->si_fhsm;
pid = au_fhsm_pid(fhsm);
if (pid
&& (current->pid == pid
|| current->real_parent->pid == pid))
goto out;
br = au_sbr(sb, cpg.bsrc);
cmoo = au_br_cmoo(br->br_perm);
if (!cmoo)
goto out;
if (!S_ISREG(inode->i_mode))
cmoo &= AuBrAttr_COO_ALL;
if (!cmoo)
goto out;
parent = dget_parent(dentry);
di_write_lock_parent(parent);
err = au_wbr_do_copyup_bu(dentry, cpg.bsrc - 1);
cpg.bdst = err;
if (unlikely(err < 0)) {
err = 0; /* there is no upper writable branch */
goto out_dgrade;
}
AuDbg("bsrc %d, bdst %d\n", cpg.bsrc, cpg.bdst);
/* do not respect the coo attrib for the target branch */
err = au_cpup_dirs(dentry, cpg.bdst);
if (unlikely(err))
goto out_dgrade;
di_downgrade_lock(parent, AuLock_IR);
udba = au_opt_udba(sb);
err = au_pin(&pin, dentry, cpg.bdst, udba,
AuPin_DI_LOCKED | AuPin_MNT_WRITE);
if (unlikely(err))
goto out_parent;
err = au_sio_cpup_simple(&cpg);
au_unpin(&pin);
if (unlikely(err))
goto out_parent;
if (!(cmoo & AuBrWAttr_MOO))
goto out_parent; /* success */
err = au_pin(&pin, dentry, cpg.bsrc, udba,
AuPin_DI_LOCKED | AuPin_MNT_WRITE);
if (unlikely(err))
goto out_parent;
h_path.mnt = au_br_mnt(br);
h_path.dentry = au_h_dptr(dentry, cpg.bsrc);
hdir = au_hi(parent->d_inode, cpg.bsrc);
delegated = NULL;
err = vfsub_unlink(hdir->hi_inode, &h_path, &delegated, /*force*/1);
au_unpin(&pin);
/* todo: keep h_dentry or not? */
if (unlikely(err == -EWOULDBLOCK)) {
pr_warn("cannot retry for NFSv4 delegation"
" for an internal unlink\n");
iput(delegated);
}
if (unlikely(err)) {
pr_err("unlink %pd after coo failed (%d), ignored\n",
dentry, err);
err = 0;
}
goto out_parent; /* success */
out_dgrade:
di_downgrade_lock(parent, AuLock_IR);
out_parent:
di_read_unlock(parent, AuLock_IR);
dput(parent);
out:
AuTraceErr(err);
return err;
}
int au_do_open(struct file *file, int (*open)(struct file *file, int flags),
struct au_fidir *fidir)
{
int err;
struct dentry *dentry;
struct au_finfo *finfo;
err = au_finfo_init(file, fidir);
if (unlikely(err))
goto out;
dentry = file->f_path.dentry;
di_write_lock_child(dentry);
err = au_cmoo(dentry);
di_downgrade_lock(dentry, AuLock_IR);
if (!err)
err = open(file, vfsub_file_flags(file));
di_read_unlock(dentry, AuLock_IR);
finfo = au_fi(file);
if (!err) {
finfo->fi_file = file;
au_sphl_add(&finfo->fi_hlist,
&au_sbi(file->f_path.dentry->d_sb)->si_files);
}
fi_write_unlock(file);
if (unlikely(err)) {
finfo->fi_hdir = NULL;
au_finfo_fin(file);
}
out:
return err;
}
