void au_di_cp(struct au_dinfo *dst, struct au_dinfo *src)
{
AuRwMustWriteLock(&dst->di_rwsem);
AuRwMustWriteLock(&src->di_rwsem);
dst->di_bstart = src->di_bstart;
dst->di_bend = src->di_bend;
dst->di_bwh = src->di_bwh;
dst->di_bdiropq = src->di_bdiropq;
/* smp_mb(); */
}
/*
* frees all branches
*/
void au_br_free(struct au_sbinfo *sbinfo)
{
aufs_bindex_t bmax;
struct au_branch **br;
AuRwMustWriteLock(&sbinfo->si_rwsem);
bmax = sbinfo->si_bend + 1;
br = sbinfo->si_branch;
while (bmax--)
au_br_do_free(*br++);
}
static void au_br_do_add_hdp(struct au_dinfo *dinfo, aufs_bindex_t bindex,
aufs_bindex_t bend, aufs_bindex_t amount)
{
struct au_hdentry *hdp;
AuRwMustWriteLock(&dinfo->di_rwsem);
hdp = dinfo->di_hdentry + bindex;
memmove(hdp + 1, hdp, sizeof(*hdp) * amount);
au_h_dentry_init(hdp);
dinfo->di_bend++;
if (unlikely(bend < 0))
dinfo->di_bstart = 0;
}
void au_di_swap(struct au_dinfo *a, struct au_dinfo *b)
{
struct au_hdentry *p;
aufs_bindex_t bi;
AuRwMustWriteLock(&a->di_rwsem);
AuRwMustWriteLock(&b->di_rwsem);
#define DiSwap(v, name) \
do { \
v = a->di_##name; \
a->di_##name = b->di_##name; \
b->di_##name = v; \
} while (0)
DiSwap(p, hdentry);
DiSwap(bi, bstart);
DiSwap(bi, bend);
DiSwap(bi, bwh);
DiSwap(bi, bdiropq);
/* smp_mb(); */
#undef DiSwap
}
static void au_br_do_add_hip(struct au_iinfo *iinfo, aufs_bindex_t bindex,
aufs_bindex_t bend, aufs_bindex_t amount)
{
struct au_hinode *hip;
AuRwMustWriteLock(&iinfo->ii_rwsem);
hip = iinfo->ii_hinode + bindex;
memmove(hip + 1, hip, sizeof(*hip) * amount);
hip->hi_inode = NULL;
au_hn_init(hip);
iinfo->ii_bend++;
if (unlikely(bend < 0))
iinfo->ii_bstart = 0;
}
static void au_br_do_add_brp(struct au_sbinfo *sbinfo, aufs_bindex_t bindex,
struct au_branch *br, aufs_bindex_t bend,
aufs_bindex_t amount)
{
struct au_branch **brp;
AuRwMustWriteLock(&sbinfo->si_rwsem);
brp = sbinfo->si_branch + bindex;
memmove(brp + 1, brp, sizeof(*brp) * amount);
*brp = br;
sbinfo->si_bend++;
if (unlikely(bend < 0))
sbinfo->si_bend = 0;
}
int au_di_realloc(struct au_dinfo *dinfo, int nbr)
{
int err, sz;
struct au_hdentry *hdp;
AuRwMustWriteLock(&dinfo->di_rwsem);
err = -ENOMEM;
sz = sizeof(*hdp) * (dinfo->di_bend + 1);
if (!sz)
sz = sizeof(*hdp);
hdp = au_kzrealloc(dinfo->di_hdentry, sz, sizeof(*hdp) * nbr, GFP_NOFS);
if (hdp) {
dinfo->di_hdentry = hdp;
err = 0;
}
return err;
}
int au_sbr_realloc(struct au_sbinfo *sbinfo, int nbr)
{
int err, sz;
struct au_branch **brp;
AuRwMustWriteLock(&sbinfo->si_rwsem);
err = -ENOMEM;
sz = sizeof(*brp) * (sbinfo->si_bend + 1);
if (unlikely(!sz))
sz = sizeof(*brp);
brp = au_kzrealloc(sbinfo->si_branch, sz, sizeof(*brp) * nbr, GFP_NOFS);
if (brp) {
sbinfo->si_branch = brp;
err = 0;
}
return err;
}
static void au_br_do_del_hip(struct au_iinfo *iinfo, const aufs_bindex_t bindex,
const aufs_bindex_t bend)
{
struct au_hinode *hip, *p;
AuRwMustWriteLock(&iinfo->ii_rwsem);
hip = iinfo->ii_hinode + bindex;
if (bindex < bend)
memmove(hip, hip + 1, sizeof(*hip) * (bend - bindex));
iinfo->ii_hinode[0 + bend].hi_inode = NULL;
au_hn_init(iinfo->ii_hinode + bend);
iinfo->ii_bend--;
p = krealloc(iinfo->ii_hinode, sizeof(*p) * bend, AuGFP_SBILIST);
if (p)
iinfo->ii_hinode = p;
/* harmless error */
}
static void au_br_do_del_hdp(struct au_dinfo *dinfo, const aufs_bindex_t bindex,
const aufs_bindex_t bend)
{
struct au_hdentry *hdp, *p;
AuRwMustWriteLock(&dinfo->di_rwsem);
hdp = dinfo->di_hdentry;
if (bindex < bend)
memmove(hdp + bindex, hdp + bindex + 1,
sizeof(*hdp) * (bend - bindex));
hdp[0 + bend].hd_dentry = NULL;
dinfo->di_bend--;
p = krealloc(hdp, sizeof(*p) * bend, AuGFP_SBILIST);
if (p)
dinfo->di_hdentry = p;
/* harmless error */
}
static void au_br_do_del_brp(struct au_sbinfo *sbinfo,
const aufs_bindex_t bindex,
const aufs_bindex_t bend)
{
struct au_branch **brp, **p;
AuRwMustWriteLock(&sbinfo->si_rwsem);
brp = sbinfo->si_branch + bindex;
if (bindex < bend)
memmove(brp, brp + 1, sizeof(*brp) * (bend - bindex));
sbinfo->si_branch[0 + bend] = NULL;
sbinfo->si_bend--;
p = krealloc(sbinfo->si_branch, sizeof(*p) * bend, AuGFP_SBILIST);
if (p)
sbinfo->si_branch = p;
/* harmless error */
}
int au_fidir_realloc(struct au_finfo *finfo, int nbr)
{
int err;
struct au_fidir *fidir, *p;
AuRwMustWriteLock(&finfo->fi_rwsem);
fidir = finfo->fi_hdir;
AuDebugOn(!fidir);
err = -ENOMEM;
p = au_kzrealloc(fidir, au_fidir_sz(fidir->fd_nent), au_fidir_sz(nbr),
GFP_NOFS);
if (p) {
p->fd_nent = nbr;
finfo->fi_hdir = p;
err = 0;
}
return err;
}
static int au_reopen_wh(struct file *file, aufs_bindex_t btgt,
struct dentry *hi_wh)
{
int err;
aufs_bindex_t bstart;
struct au_dinfo *dinfo;
struct dentry *h_dentry;
dinfo = au_di(file->f_dentry);
AuRwMustWriteLock(&dinfo->di_rwsem);
bstart = dinfo->di_bstart;
dinfo->di_bstart = btgt;
h_dentry = dinfo->di_hdentry[0 + btgt].hd_dentry;
dinfo->di_hdentry[0 + btgt].hd_dentry = hi_wh;
err = au_reopen_nondir(file);
dinfo->di_hdentry[0 + btgt].hd_dentry = h_dentry;
dinfo->di_bstart = bstart;
return err;
}
static void au_do_refresh_hdentry(struct au_hdentry *p, struct au_dinfo *dinfo,
struct dentry *parent)
{
struct dentry *h_d, *h_dp;
struct au_hdentry tmp, *q;
struct super_block *sb;
aufs_bindex_t new_bindex, bindex, bend, bwh, bdiropq;
AuRwMustWriteLock(&dinfo->di_rwsem);
bend = dinfo->di_bend;
bwh = dinfo->di_bwh;
bdiropq = dinfo->di_bdiropq;
for (bindex = dinfo->di_bstart; bindex <= bend; bindex++, p++) {
h_d = p->hd_dentry;
if (!h_d)
continue;
h_dp = dget_parent(h_d);
if (h_dp == au_h_dptr(parent, bindex)) {
dput(h_dp);
continue;
}
new_bindex = au_find_dbindex(parent, h_dp);
dput(h_dp);
if (dinfo->di_bwh == bindex)
bwh = new_bindex;
if (dinfo->di_bdiropq == bindex)
bdiropq = new_bindex;
if (new_bindex < 0) {
au_hdput(p);
p->hd_dentry = NULL;
continue;
}
/* swap two lower dentries, and loop again */
q = dinfo->di_hdentry + new_bindex;
tmp = *q;
*q = *p;
*p = tmp;
if (tmp.hd_dentry) {
bindex--;
p--;
}
}
sb = parent->d_sb;
dinfo->di_bwh = -1;
if (bwh >= 0 && bwh <= au_sbend(sb) && au_sbr_whable(sb, bwh))
dinfo->di_bwh = bwh;
dinfo->di_bdiropq = -1;
if (bdiropq >= 0
&& bdiropq <= au_sbend(sb)
&& au_sbr_whable(sb, bdiropq))
dinfo->di_bdiropq = bdiropq;
bend = au_dbend(parent);
p = dinfo->di_hdentry;
for (bindex = 0; bindex <= bend; bindex++, p++)
if (p->hd_dentry) {
dinfo->di_bstart = bindex;
break;
}
p = dinfo->di_hdentry + bend;
for (bindex = bend; bindex >= 0; bindex--, p--)
if (p->hd_dentry) {
dinfo->di_bend = bindex;
break;
}
}
