static int au_ibusy(struct super_block *sb, struct aufs_ibusy __user *arg)
{
int err;
aufs_bindex_t bstart, bend;
struct aufs_ibusy ibusy;
struct inode *inode, *h_inode;
err = -EPERM;
if (unlikely(!capable(CAP_SYS_ADMIN)))
goto out;
err = copy_from_user(&ibusy, arg, sizeof(ibusy));
if (!err)
err = !access_ok(VERIFY_WRITE, &arg->h_ino, sizeof(arg->h_ino));
if (unlikely(err)) {
err = -EFAULT;
AuTraceErr(err);
goto out;
}
err = -EINVAL;
si_read_lock(sb, AuLock_FLUSH);
if (unlikely(ibusy.bindex < 0 || ibusy.bindex > au_sbend(sb)))
goto out_unlock;
err = 0;
ibusy.h_ino = 0; /* invalid */
inode = ilookup(sb, ibusy.ino);
if (!inode
|| inode->i_ino == AUFS_ROOT_INO
|| is_bad_inode(inode))
goto out_unlock;
ii_read_lock_child(inode);
bstart = au_ibstart(inode);
bend = au_ibend(inode);
if (bstart <= ibusy.bindex && ibusy.bindex <= bend) {
h_inode = au_h_iptr(inode, ibusy.bindex);
if (h_inode && au_test_ibusy(inode, bstart, bend))
ibusy.h_ino = h_inode->i_ino;
}
ii_read_unlock(inode);
iput(inode);
out_unlock:
si_read_unlock(sb);
if (!err) {
err = __put_user(ibusy.h_ino, &arg->h_ino);
if (unlikely(err)) {
err = -EFAULT;
AuTraceErr(err);
}
}
out:
return err;
}
void di_read_unlock(struct dentry *d, int flags)
{
if (d->d_inode) {
if (au_ftest_lock(flags, IW))
ii_write_unlock(d->d_inode);
else if (au_ftest_lock(flags, IR))
ii_read_unlock(d->d_inode);
}
au_rw_read_unlock(&au_di(d)->di_rwsem);
}
static int test_inode_busy(struct super_block *sb, aufs_bindex_t bindex,
unsigned int sigen, const unsigned int verbose)
{
int err;
unsigned long long max, ull;
struct inode *i, **array;
aufs_bindex_t bstart, bend;
array = au_iarray_alloc(sb, &max);
err = PTR_ERR(array);
if (IS_ERR(array))
goto out;
err = 0;
AuDbg("b%d\n", bindex);
for (ull = 0; !err && ull < max; ull++) {
i = array[ull];
if (i->i_ino == AUFS_ROOT_INO)
continue;
/* AuDbgInode(i); */
if (au_iigen(i) == sigen)
ii_read_lock_child(i);
else {
ii_write_lock_child(i);
err = au_refresh_hinode_self(i);
au_iigen_dec(i);
if (!err)
ii_downgrade_lock(i);
else {
ii_write_unlock(i);
break;
}
}
bstart = au_ibstart(i);
bend = au_ibend(i);
if (bstart <= bindex
&& bindex <= bend
&& au_h_iptr(i, bindex)
&& au_test_ibusy(i, bstart, bend)) {
err = -EBUSY;
AuVerbose(verbose, "busy i%lu\n", i->i_ino);
AuDbgInode(i);
}
ii_read_unlock(i);
}
au_iarray_free(array, max);
out:
return err;
}
void di_read_unlock(struct dentry *d, int flags)
{
if (d->d_inode) {
if (au_ftest_lock(flags, IW)) {
au_dbg_verify_dinode(d);
ii_write_unlock(d->d_inode);
} else if (au_ftest_lock(flags, IR)) {
au_dbg_verify_dinode(d);
ii_read_unlock(d->d_inode);
}
}
au_rw_read_unlock(&au_di(d)->di_rwsem);
}
void di_read_unlock(struct dentry *d, int flags)
{
LKTRTrace("%.*s\n", AuDLNPair(d));
SiMustAnyLock(d->d_sb);
if (d->d_inode) {
if (au_ftest_lock(flags, IW))
ii_write_unlock(d->d_inode);
else if (au_ftest_lock(flags, IR))
ii_read_unlock(d->d_inode);
}
au_rw_read_unlock(&au_di(d)->di_rwsem);
au_dbg_locked_di_unreg(d, flags);
}
int au_do_flush(struct file *file, fl_owner_t id,
int (*flush)(struct file *file, fl_owner_t id))
{
int err;
struct dentry *dentry;
struct super_block *sb;
struct inode *inode;
dentry = file->f_dentry;
sb = dentry->d_sb;
inode = dentry->d_inode;
si_noflush_read_lock(sb);
fi_read_lock(file);
ii_read_lock_child(inode);
err = flush(file, id);
au_cpup_attr_timesizes(inode);
ii_read_unlock(inode);
fi_read_unlock(file);
si_read_unlock(sb);
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;
}
static int au_rdu(struct file *file, struct aufs_rdu *rdu)
{
int err;
aufs_bindex_t bend;
struct au_rdu_arg arg;
struct dentry *dentry;
struct inode *inode;
struct file *h_file;
struct au_rdu_cookie *cookie = &rdu->cookie;
err = !access_ok(VERIFY_WRITE, rdu->ent.e, rdu->sz);
if (unlikely(err)) {
err = -EFAULT;
AuTraceErr(err);
goto out;
}
rdu->rent = 0;
rdu->tail = rdu->ent;
rdu->full = 0;
arg.rdu = rdu;
arg.ent = rdu->ent;
arg.end = arg.ent.ul;
arg.end += rdu->sz;
err = -ENOTDIR;
if (unlikely(!file->f_op || !file->f_op->readdir))
goto out;
err = security_file_permission(file, MAY_READ);
AuTraceErr(err);
if (unlikely(err))
goto out;
dentry = file->f_dentry;
inode = dentry->d_inode;
#if 1
mutex_lock(&inode->i_mutex);
#else
err = mutex_lock_killable(&inode->i_mutex);
AuTraceErr(err);
if (unlikely(err))
goto out;
#endif
err = -ENOENT;
if (unlikely(IS_DEADDIR(inode)))
goto out_mtx;
arg.sb = inode->i_sb;
si_read_lock(arg.sb, AuLock_FLUSH);
fi_read_lock(file);
err = -EAGAIN;
if (unlikely(au_ftest_rdu(cookie->flags, CONT)
&& cookie->generation != au_figen(file)))
goto out_unlock;
err = 0;
if (!rdu->blk) {
rdu->blk = au_sbi(arg.sb)->si_rdblk;
if (!rdu->blk)
rdu->blk = au_dir_size(file, /*dentry*/NULL);
}
bend = au_fbstart(file);
if (cookie->bindex < bend)
cookie->bindex = bend;
bend = au_fbend_dir(file);
/* AuDbg("b%d, b%d\n", cookie->bindex, bend); */
for (; !err && cookie->bindex <= bend;
cookie->bindex++, cookie->h_pos = 0) {
h_file = au_hf_dir(file, cookie->bindex);
if (!h_file)
continue;
au_fclr_rdu(cookie->flags, FULL);
err = au_rdu_do(h_file, &arg);
AuTraceErr(err);
if (unlikely(au_ftest_rdu(cookie->flags, FULL) || err))
break;
}
AuDbg("rent %llu\n", rdu->rent);
if (!err && !au_ftest_rdu(cookie->flags, CONT)) {
rdu->shwh = !!au_opt_test(au_sbi(arg.sb)->si_mntflags, SHWH);
au_fset_rdu(cookie->flags, CONT);
cookie->generation = au_figen(file);
}
ii_read_lock_child(inode);
fsstack_copy_attr_atime(inode, au_h_iptr(inode, au_ibstart(inode)));
ii_read_unlock(inode);
out_unlock:
fi_read_unlock(file);
si_read_unlock(arg.sb);
out_mtx:
mutex_unlock(&inode->i_mutex);
out:
AuTraceErr(err);
return err;
}
/*
* prepare the @file for writing.
*/
int au_ready_to_write(struct file *file, loff_t len)
{
int err;
struct dentry *dentry, *parent, *hidden_dentry, *hidden_parent;
struct inode *hidden_inode, *hidden_dir, *inode, *dir;
struct super_block *sb;
aufs_bindex_t bstart, bcpup;
dentry = file->f_dentry;
LKTRTrace("%.*s, len %Ld\n", DLNPair(dentry), len);
FiMustWriteLock(file);
sb = dentry->d_sb;
bstart = fbstart(file);
DEBUG_ON(ftobr(file, bstart) != stobr(sb, bstart));
inode = dentry->d_inode;
ii_read_lock_child(inode);
LKTRTrace("rdonly %d, bstart %d\n", test_ro(sb, bstart, inode), bstart);
err = test_ro(sb, bstart, inode);
ii_read_unlock(inode);
if (!err && (au_h_fptr(file)->f_mode & FMODE_WRITE))
return 0;
/* need to cpup */
parent = dentry->d_parent; // dget_parent()
di_write_lock_child(dentry);
di_write_lock_parent(parent);
bcpup = err = find_rw_parent_br(dentry, bstart);
//bcpup = err = find_rw_br(sb, bstart);
if (unlikely(err < 0))
goto out_unlock;
err = 0;
hidden_parent = au_h_dptr_i(parent, bcpup);
if (!hidden_parent) {
err = cpup_dirs(dentry, bcpup, NULL);
//if (LktrCond) err = -1;
if (unlikely(err))
goto out_unlock;
hidden_parent = au_h_dptr_i(parent, bcpup);
}
hidden_dir = hidden_parent->d_inode;
hidden_dentry = au_h_fptr(file)->f_dentry;
hidden_inode = hidden_dentry->d_inode;
dir = parent->d_inode;
hdir_lock(hidden_dir, dir, bcpup);
hi_lock_child(hidden_inode);
if (d_unhashed(dentry) || d_unhashed(hidden_dentry)
/* || !hidden_inode->i_nlink */) {
if (!au_test_perm(hidden_dir, MAY_EXEC | MAY_WRITE,
need_dlgt(sb)))
err = cpup_wh_file(file, bcpup, len);
else {
struct cpup_wh_file_args args = {
.errp = &err,
.file = file,
.bdst = bcpup,
.len = len
};
au_wkq_wait(call_cpup_wh_file, &args, /*dlgt*/0);
}
//if (LktrCond) err = -1;
TraceErr(err);
} else {
if (!au_h_dptr_i(dentry, bcpup))
int au_do_open(struct inode *inode, struct file *file,
int (*open)(struct file *file, int flags))
{
int err, coo;
struct dentry *dentry;
struct super_block *sb;
aufs_bindex_t bstart;
struct inode *h_dir, *dir;
dentry = file->f_dentry;
LKTRTrace("i%lu, %.*s\n", inode->i_ino, DLNPair(dentry));
sb = dentry->d_sb;
si_read_lock(sb);
coo = 0;
#if 0
switch (au_flag_test_coo(sb)) {
case AuFlag_COO_LEAF:
coo = !S_ISDIR(inode->i_mode);
break;
case AuFlag_COO_ALL:
coo = 1;
break;
}
#endif
err = au_init_finfo(file);
//if (LktrCond) {fi_write_unlock(file); fin_finfo(file); err = -1;}
if (unlikely(err))
goto out;
if (!coo) {
di_read_lock_child(dentry, AUFS_I_RLOCK);
bstart = dbstart(dentry);
} else {
di_write_lock_child(dentry);
bstart = dbstart(dentry);
if (test_ro(sb, bstart, dentry->d_inode)) {
err = do_coo(dentry, bstart);
if (err) {
di_write_unlock(dentry);
goto out_finfo;
}
bstart = dbstart(dentry);
}
di_downgrade_lock(dentry, AUFS_I_RLOCK);
}
// todo: remove this extra locks
dir = dentry->d_parent->d_inode;
if (!IS_ROOT(dentry))
ii_read_lock_parent(dir);
h_dir = au_h_iptr_i(dir, bstart);
hdir_lock(h_dir, dir, bstart);
err = open(file, file->f_flags);
//if (LktrCond) err = -1;
hdir_unlock(h_dir, dir, bstart);
if (!IS_ROOT(dentry))
ii_read_unlock(dir);
di_read_unlock(dentry, AUFS_I_RLOCK);
out_finfo:
fi_write_unlock(file);
if (unlikely(err))
au_fin_finfo(file);
//DbgFile(file);
out:
si_read_unlock(sb);
TraceErr(err);
return err;
}
static int au_ready_to_write_wh(struct file *file, loff_t len,
aufs_bindex_t bcpup, struct au_pin *pin)
{
int err;
struct inode *inode, *h_inode;
struct dentry *h_dentry, *hi_wh;
struct au_cp_generic cpg = {
.dentry = file->f_dentry,
.bdst = bcpup,
.bsrc = -1,
.len = len,
.pin = pin
};
au_update_dbstart(cpg.dentry);
inode = cpg.dentry->d_inode;
h_inode = NULL;
if (au_dbstart(cpg.dentry) <= bcpup
&& au_dbend(cpg.dentry) >= bcpup) {
h_dentry = au_h_dptr(cpg.dentry, bcpup);
if (h_dentry)
h_inode = h_dentry->d_inode;
}
hi_wh = au_hi_wh(inode, bcpup);
if (!hi_wh && !h_inode)
err = au_sio_cpup_wh(&cpg, file);
else
/* already copied-up after unlink */
err = au_reopen_wh(file, bcpup, hi_wh);
if (!err
&& inode->i_nlink > 1
&& au_opt_test(au_mntflags(cpg.dentry->d_sb), PLINK))
au_plink_append(inode, bcpup, au_h_dptr(cpg.dentry, bcpup));
return err;
}
/*
* prepare the @file for writing.
*/
int au_ready_to_write(struct file *file, loff_t len, struct au_pin *pin)
{
int err;
aufs_bindex_t dbstart;
struct dentry *parent, *h_dentry;
struct inode *inode;
struct super_block *sb;
struct file *h_file;
struct au_cp_generic cpg = {
.dentry = file->f_dentry,
.bdst = -1,
.bsrc = -1,
.len = len,
.pin = pin,
.flags = AuCpup_DTIME
};
sb = cpg.dentry->d_sb;
inode = cpg.dentry->d_inode;
AuDebugOn(au_special_file(inode->i_mode));
cpg.bsrc = au_fbstart(file);
err = au_test_ro(sb, cpg.bsrc, inode);
if (!err && (au_hf_top(file)->f_mode & FMODE_WRITE)) {
err = au_pin(pin, cpg.dentry, cpg.bsrc, AuOpt_UDBA_NONE,
/*flags*/0);
goto out;
}
/* need to cpup or reopen */
parent = dget_parent(cpg.dentry);
di_write_lock_parent(parent);
err = AuWbrCopyup(au_sbi(sb), cpg.dentry);
cpg.bdst = err;
if (unlikely(err < 0))
goto out_dgrade;
err = 0;
if (!d_unhashed(cpg.dentry) && !au_h_dptr(parent, cpg.bdst)) {
err = au_cpup_dirs(cpg.dentry, cpg.bdst);
if (unlikely(err))
goto out_dgrade;
}
err = au_pin(pin, cpg.dentry, cpg.bdst, AuOpt_UDBA_NONE,
AuPin_DI_LOCKED | AuPin_MNT_WRITE);
if (unlikely(err))
goto out_dgrade;
h_dentry = au_hf_top(file)->f_dentry;
dbstart = au_dbstart(cpg.dentry);
if (dbstart <= cpg.bdst) {
h_dentry = au_h_dptr(cpg.dentry, cpg.bdst);
AuDebugOn(!h_dentry);
cpg.bsrc = cpg.bdst;
}
if (dbstart <= cpg.bdst /* just reopen */
|| !d_unhashed(cpg.dentry) /* copyup and reopen */
) {
h_file = au_h_open_pre(cpg.dentry, cpg.bsrc, /*force_wr*/0);
if (IS_ERR(h_file))
err = PTR_ERR(h_file);
else {
di_downgrade_lock(parent, AuLock_IR);
if (dbstart > cpg.bdst)
err = au_sio_cpup_simple(&cpg);
if (!err)
err = au_reopen_nondir(file);
au_h_open_post(cpg.dentry, cpg.bsrc, h_file);
}
} else { /* copyup as wh and reopen */
/*
* since writable hfsplus branch is not supported,
* h_open_pre/post() are unnecessary.
*/
err = au_ready_to_write_wh(file, len, cpg.bdst, pin);
di_downgrade_lock(parent, AuLock_IR);
}
if (!err) {
au_pin_set_parent_lflag(pin, /*lflag*/0);
goto out_dput; /* success */
}
au_unpin(pin);
goto out_unlock;
out_dgrade:
di_downgrade_lock(parent, AuLock_IR);
out_unlock:
di_read_unlock(parent, AuLock_IR);
out_dput:
dput(parent);
out:
return err;
}
/* ---------------------------------------------------------------------- */
int au_do_flush(struct file *file, fl_owner_t id,
int (*flush)(struct file *file, fl_owner_t id))
{
int err;
struct super_block *sb;
struct inode *inode;
inode = file_inode(file);
sb = inode->i_sb;
si_noflush_read_lock(sb);
fi_read_lock(file);
ii_read_lock_child(inode);
err = flush(file, id);
au_cpup_attr_timesizes(inode);
ii_read_unlock(inode);
fi_read_unlock(file);
si_read_unlock(sb);
return err;
}