static int au_dpages_append(struct au_dcsub_pages *dpages,
struct dentry *dentry, gfp_t gfp)
{
int err, sz;
struct au_dpage *dpage;
void *p;
//TraceEnter();
dpage = dpages->dpages + dpages->ndpage - 1;
AuDebugOn(!dpage);
sz = PAGE_SIZE / sizeof(dentry);
if (unlikely(dpage->ndentry >= sz)) {
LKTRLabel(new dpage);
err = -ENOMEM;
sz = dpages->ndpage * sizeof(*dpages->dpages);
p = au_kzrealloc(dpages->dpages, sz,
sz + sizeof(*dpages->dpages), gfp);
if (unlikely(!p))
goto out;
dpage = dpages->dpages + dpages->ndpage;
p = (void*)__get_free_page(gfp);
if (unlikely(!p))
goto out;
dpage->ndentry = 0;
dpage->dentries = p;
dpages->ndpage++;
}
dpage->dentries[dpage->ndentry++] = dget(dentry);
return 0; /* success */
out:
//TraceErr(err);
return err;
}
int aufs_rmdir(struct inode *dir, struct dentry *dentry)
{
int err, rmdir_later;
struct inode *inode, *hidden_dir;
struct dentry *parent, *wh_dentry, *hidden_dentry, *hidden_parent;
struct dtime dt;
aufs_bindex_t bwh, bindex, bstart;
struct rmdir_whtmp_arg *arg;
struct aufs_nhash *whlist;
LKTRTrace("i%lu, %.*s\n", dir->i_ino, DLNPair(dentry));
IMustLock(dir);
inode = dentry->d_inode;
if (unlikely(!inode))
return -ENOENT; // possible?
IMustLock(inode);
whlist = nhash_new(GFP_KERNEL);
err = PTR_ERR(whlist);
if (IS_ERR(whlist))
goto out;
err = -ENOMEM;
arg = kmalloc(sizeof(*arg), GFP_KERNEL);
//arg = NULL;
if (unlikely(!arg))
goto out_whlist;
aufs_read_lock(dentry, AUFS_D_WLOCK);
parent = dentry->d_parent;
di_write_lock_parent(parent);
err = test_empty(dentry, whlist);
//err = -1;
if (unlikely(err))
goto out_arg;
bstart = dbstart(dentry);
bwh = dbwh(dentry);
bindex = -1;
wh_dentry = lock_hdir_create_wh(dentry, /*isdir*/ 1, &bindex, &dt);
//wh_dentry = ERR_PTR(-1);
err = PTR_ERR(wh_dentry);
if (IS_ERR(wh_dentry))
goto out_arg;
hidden_dentry = au_h_dptr(dentry);
dget(hidden_dentry);
hidden_parent = hidden_dentry->d_parent;
hidden_dir = hidden_parent->d_inode;
rmdir_later = 0;
if (bindex == bstart) {
IMustLock(hidden_dir);
err = renwh_and_rmdir(dentry, bstart, whlist, dir);
//err = -1;
if (err > 0) {
rmdir_later = err;
err = 0;
}
} else {
DEBUG_ON(!wh_dentry);
hidden_parent = wh_dentry->d_parent;
DEBUG_ON(hidden_parent != au_h_dptr_i(parent, bindex));
hidden_dir = hidden_parent->d_inode;
IMustLock(hidden_dir);
err = 0;
}
if (!err) {
au_reset_hinotify(inode, /*flags*/0);
inode->i_nlink = 0;
set_dbdiropq(dentry, -1);
epilog(dir, dentry, bindex);
if (rmdir_later) {
kick_rmdir_whtmp(hidden_dentry, whlist, bstart, dir,
inode, arg);
arg = NULL;
}
goto out_unlock; /* success */
}
/* revert */
LKTRLabel(revert);
if (wh_dentry) {
int rerr;
rerr = do_revert(err, wh_dentry, dentry, bwh, &dt,
need_dlgt(dir->i_sb));
if (rerr)
err = rerr;
}
out_unlock:
hdir_unlock(hidden_dir, dir, bindex);
dput(wh_dentry);
dput(hidden_dentry);
out_arg:
di_write_unlock(parent);
aufs_read_unlock(dentry, AUFS_D_WLOCK);
kfree(arg);
out_whlist:
nhash_del(whlist);
out:
TraceErr(err);
return err;
}
static struct dentry *
aufs_decode_fh(struct super_block *sb, __u32 *fh, int fh_len, int fh_type,
int (*acceptable)(void *context, struct dentry *de),
void *context)
{
struct dentry *dentry;
ino_t ino, dir_ino;
aufs_bindex_t bindex;
struct au_nfsd_si_lock nsi_lock = {
.sigen = fh[Fh_sigen],
.br_id = fh[Fh_br_id],
.force_lock = 0
};
LKTRTrace("%d, fh{br_id %u, sigen %u, i%u, diri%u, g%u}\n",
fh_type, fh[Fh_br_id], fh[Fh_sigen], fh[Fh_ino],
fh[Fh_dir_ino], fh[Fh_igen]);
AuDebugOn(fh_len < Fh_tail);
dentry = ERR_PTR(-ESTALE);
/* branch id may be wrapped around */
bindex = si_nfsd_read_lock(sb, &nsi_lock);
if (unlikely(bindex < 0))
goto out;
nsi_lock.force_lock = 1;
/* is this inode still cached? */
ino = decode_ino(fh + Fh_ino);
AuDebugOn(ino == AUFS_ROOT_INO);
dir_ino = decode_ino(fh + Fh_dir_ino);
dentry = decode_by_ino(sb, ino, dir_ino);
if (IS_ERR(dentry))
goto out_unlock;
if (dentry)
goto accept;
/* is the parent dir cached? */
dentry = decode_by_dir_ino(sb, ino, dir_ino, &nsi_lock);
if (IS_ERR(dentry))
goto out_unlock;
if (dentry)
goto accept;
/* lookup path */
dentry = decode_by_path(sb, bindex, ino, fh, fh_len, &nsi_lock);
if (IS_ERR(dentry))
goto out_unlock;
if (unlikely(!dentry))
goto out_unlock;
accept:
LKTRLabel(accept);
if (dentry->d_inode->i_generation == fh[Fh_igen]
&& acceptable(context, dentry))
goto out_unlock; /* success */
LKTRLabel(stale);
dput(dentry);
dentry = ERR_PTR(-ESTALE);
out_unlock:
LKTRLabel(out_unlock);
si_read_unlock(sb);
out:
LKTRLabel(out);
if (0 && IS_ERR(dentry))
dentry = ERR_PTR(-ESTALE);
AuTraceErrPtr(dentry);
return dentry;
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24)
static struct dentry *
aufs_fh_to_dentry(struct super_block *sb, struct fid *fid, int fh_len,
int fh_type)
{
return aufs_decode_fh(sb, fid->raw, fh_len, fh_type, h_acceptable,
/*context*/NULL);
}
#endif /* KERNEL_VERSION */
/* ---------------------------------------------------------------------- */
static int aufs_encode_fh(struct dentry *dentry, __u32 *fh, int *max_len,
int connectable)
{
int err;
aufs_bindex_t bindex, bend;
struct super_block *sb, *h_sb;
struct inode *inode;
struct dentry *parent, *h_parent;
struct au_branch *br;
LKTRTrace("%.*s, max %d, conn %d\n",
AuDLNPair(dentry), *max_len, connectable);
AuDebugOn(au_test_anon(dentry));
parent = NULL;
err = -ENOSPC;
if (unlikely(*max_len <= Fh_tail)) {
AuWarn1("NFSv2 client (max_len %d)?\n", *max_len);
goto out;
}
err = 0; //FILEID_ROOT;
if (IS_ROOT(dentry)) {
AuDebugOn(dentry->d_inode->i_ino != AUFS_ROOT_INO);
goto out;
}
err = -EIO;
h_parent = NULL;
sb = dentry->d_sb;
aufs_read_lock(dentry, AuLock_FLUSH | AuLock_IR);
parent = dget_parent(dentry);
di_read_lock_parent(parent, !AuLock_IR);
inode = dentry->d_inode;
AuDebugOn(!inode);
#ifdef CONFIG_AUFS_DEBUG
{
unsigned int mnt_flags = au_mntflags(sb);
if (unlikely(!au_opt_test_xino(mnt_flags)))
AuWarn1("NFS-exporting requires xino\n");
if (unlikely(0 && !au_opt_test(mnt_flags, UDBA_INOTIFY)))
AuWarn1("udba=inotify is recommended "
"for NFS-exporting\n");
}
#endif
bend = au_dbtaildir(parent);
for (bindex = au_dbstart(parent); bindex <= bend; bindex++) {
h_parent = au_h_dptr(parent, bindex);
if (h_parent) {
dget(h_parent);
break;
}
}
if (unlikely(!h_parent))
goto out_unlock;
LKTRTrace("b%d\n", bindex);
err = -EPERM;
br = au_sbr(sb, bindex);
h_sb = br->br_mnt->mnt_sb;
if (unlikely(!h_sb->s_export_op)) {
AuErr1("%s branch is not exportable\n", au_sbtype(h_sb));
goto out_dput;
}
fh[Fh_br_id] = br->br_id;
fh[Fh_sigen] = au_sigen(sb);
encode_ino(fh + Fh_ino, inode->i_ino);
encode_ino(fh + Fh_dir_ino, parent->d_inode->i_ino);
fh[Fh_igen] = inode->i_generation;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24)
/* it should be set at exporting time */
if (unlikely(!h_sb->s_export_op->find_exported_dentry)) {
AuWarn("set default find_exported_dentry for %s\n",
au_sbtype(h_sb));
h_sb->s_export_op->find_exported_dentry = find_exported_dentry;
}
#endif
*max_len -= Fh_tail;
fh[Fh_h_type] = au_call_encode_fh(h_parent, fh + Fh_tail, max_len,
/*connectable or subtreecheck*/0);
err = fh[Fh_h_type];
*max_len += Fh_tail;
/* todo: macros? */
if (err != 255)
err = 99;
else
AuWarn1("%s encode_fh failed\n", au_sbtype(h_sb));
out_dput:
dput(h_parent);
out_unlock:
di_read_unlock(parent, !AuLock_IR);
dput(parent);
aufs_read_unlock(dentry, AuLock_IR);
out:
AuTraceErr(err);
if (unlikely(err < 0))
err = 255;
return err;
}
