/*
* returns the number of found lower positive dentries,
* otherwise an error.
*/
int au_refresh_hdentry(struct dentry *dentry, mode_t type)
{
int npositive, err;
unsigned int sigen;
aufs_bindex_t bstart;
struct au_dinfo *dinfo;
struct super_block *sb;
struct dentry *parent;
DiMustWriteLock(dentry);
sb = dentry->d_sb;
AuDebugOn(IS_ROOT(dentry));
sigen = au_sigen(sb);
parent = dget_parent(dentry);
AuDebugOn(au_digen(parent) != sigen
|| au_iigen(parent->d_inode) != sigen);
dinfo = au_di(dentry);
err = au_di_realloc(dinfo, au_sbend(sb) + 1);
npositive = err;
if (unlikely(err))
goto out;
au_do_refresh_hdentry(dinfo->di_hdentry + dinfo->di_bstart, dinfo,
parent);
npositive = 0;
bstart = au_dbstart(parent);
if (type != S_IFDIR && dinfo->di_bstart == bstart)
goto out_dgen; /* success */
npositive = au_lkup_dentry(dentry, bstart, type, /*nd*/NULL);
if (npositive < 0)
goto out;
if (dinfo->di_bwh >= 0 && dinfo->di_bwh <= dinfo->di_bstart)
d_drop(dentry);
out_dgen:
au_update_digen(dentry);
out:
dput(parent);
AuTraceErr(npositive);
return npositive;
}
/*
* returns a newly allocated branch. @new_nbranch is a number of branches
* after adding a branch.
*/
static struct au_branch *au_br_alloc(struct super_block *sb, int new_nbranch,
int perm)
{
struct au_branch *add_branch;
struct dentry *root;
int err;
err = -ENOMEM;
root = sb->s_root;
add_branch = kmalloc(sizeof(*add_branch), GFP_NOFS);
if (unlikely(!add_branch))
goto out;
err = au_hnotify_init_br(add_branch, perm);
if (unlikely(err))
goto out_br;
add_branch->br_wbr = NULL;
if (au_br_writable(perm)) {
/* may be freed separately at changing the branch permission */
add_branch->br_wbr = kmalloc(sizeof(*add_branch->br_wbr),
GFP_NOFS);
if (unlikely(!add_branch->br_wbr))
goto out_hnotify;
}
err = au_sbr_realloc(au_sbi(sb), new_nbranch);
if (!err)
err = au_di_realloc(au_di(root), new_nbranch);
if (!err)
err = au_ii_realloc(au_ii(root->d_inode), new_nbranch);
if (!err)
return add_branch; /* success */
kfree(add_branch->br_wbr);
out_hnotify:
au_hnotify_fin_br(add_branch);
out_br:
kfree(add_branch);
out:
return ERR_PTR(err);
}
int au_refresh_dentry(struct dentry *dentry, struct dentry *parent)
{
int err, ebrange;
unsigned int sigen;
struct au_dinfo *dinfo, *tmp;
struct super_block *sb;
struct inode *inode;
DiMustWriteLock(dentry);
AuDebugOn(IS_ROOT(dentry));
AuDebugOn(!parent->d_inode);
sb = dentry->d_sb;
inode = dentry->d_inode;
sigen = au_sigen(sb);
err = au_digen_test(parent, sigen);
if (unlikely(err))
goto out;
dinfo = au_di(dentry);
err = au_di_realloc(dinfo, au_sbend(sb) + 1);
if (unlikely(err))
goto out;
ebrange = au_dbrange_test(dentry);
if (!ebrange)
ebrange = au_do_refresh_hdentry(dentry, parent);
if (d_unhashed(dentry) || ebrange) {
AuDebugOn(au_dbstart(dentry) < 0 && au_dbend(dentry) >= 0);
if (inode)
err = au_refresh_hinode_self(inode);
au_dbg_verify_dinode(dentry);
if (!err)
goto out_dgen; /* success */
goto out;
}
/* temporary dinfo */
AuDbgDentry(dentry);
err = -ENOMEM;
tmp = au_di_alloc(sb, AuLsc_DI_TMP);
if (unlikely(!tmp))
goto out;
au_di_swap(tmp, dinfo);
/* returns the number of positive dentries */
/*
* if current working dir is removed, it returns an error.
* but the dentry is legal.
*/
err = au_lkup_dentry(dentry, /*bstart*/0, /*type*/0, /*nd*/NULL);
AuDbgDentry(dentry);
au_di_swap(tmp, dinfo);
if (err == -ENOENT)
err = 0;
if (err >= 0) {
/* compare/refresh by dinfo */
AuDbgDentry(dentry);
err = au_refresh_by_dinfo(dentry, dinfo, tmp);
au_dbg_verify_dinode(dentry);
AuTraceErr(err);
}
au_rw_write_unlock(&tmp->di_rwsem);
au_di_free(tmp);
if (unlikely(err))
goto out;
out_dgen:
au_update_digen(dentry);
out:
if (unlikely(err && !(dentry->d_flags & DCACHE_NFSFS_RENAMED))) {
AuIOErr("failed refreshing %.*s, %d\n",
AuDLNPair(dentry), err);
AuDbgDentry(dentry);
}
AuTraceErr(err);
return err;
}
