summaryrefslogtreecommitdiff
path: root/fs/aufs
diff options
context:
space:
mode:
Diffstat (limited to 'fs/aufs')
-rw-r--r--fs/aufs/branch.c209
-rw-r--r--fs/aufs/branch.h34
-rw-r--r--fs/aufs/cpup.c44
-rw-r--r--fs/aufs/dbgaufs.c14
-rw-r--r--fs/aufs/debug.c76
-rw-r--r--fs/aufs/dentry.c124
-rw-r--r--fs/aufs/dentry.h26
-rw-r--r--fs/aufs/dinfo.c124
-rw-r--r--fs/aufs/dir.c98
-rw-r--r--fs/aufs/dynop.c8
-rw-r--r--fs/aufs/export.c15
-rw-r--r--fs/aufs/f_op.c12
-rw-r--r--fs/aufs/fhsm.c18
-rw-r--r--fs/aufs/file.c102
-rw-r--r--fs/aufs/file.h8
-rw-r--r--fs/aufs/finfo.c11
-rw-r--r--fs/aufs/hfsnotify.c3
-rw-r--r--fs/aufs/hnotify.c24
-rw-r--r--fs/aufs/i_op.c90
-rw-r--r--fs/aufs/i_op_add.c66
-rw-r--r--fs/aufs/i_op_del.c44
-rw-r--r--fs/aufs/i_op_ren.c92
-rw-r--r--fs/aufs/iinfo.c95
-rw-r--r--fs/aufs/inode.c90
-rw-r--r--fs/aufs/inode.h41
-rw-r--r--fs/aufs/ioctl.c10
-rw-r--r--fs/aufs/module.c44
-rw-r--r--fs/aufs/module.h16
-rw-r--r--fs/aufs/mvdown.c48
-rw-r--r--fs/aufs/opts.c38
-rw-r--r--fs/aufs/plink.c12
-rw-r--r--fs/aufs/posix_acl.c2
-rw-r--r--fs/aufs/rdu.c16
-rw-r--r--fs/aufs/rwsem.h79
-rw-r--r--fs/aufs/sbinfo.c17
-rw-r--r--fs/aufs/super.c34
-rw-r--r--fs/aufs/super.h36
-rw-r--r--fs/aufs/sysfs.c26
-rw-r--r--fs/aufs/vdir.c10
-rw-r--r--fs/aufs/vfsub.c2
-rw-r--r--fs/aufs/wbr_policy.c76
-rw-r--r--fs/aufs/whout.c12
-rw-r--r--fs/aufs/wkq.c11
-rw-r--r--fs/aufs/wkq.h8
-rw-r--r--fs/aufs/xino.c71
45 files changed, 1029 insertions, 1007 deletions
diff --git a/fs/aufs/branch.c b/fs/aufs/branch.c
index 496bdaa99..5259d30d1 100644
--- a/fs/aufs/branch.c
+++ b/fs/aufs/branch.c
@@ -25,7 +25,8 @@ static void au_br_do_free(struct au_branch *br)
fput(br->br_xino.xi_file);
mutex_destroy(&br->br_xino.xi_nondir_mtx);
- AuDebugOn(atomic_read(&br->br_count));
+ AuDebugOn(au_br_count(br));
+ au_br_count_fin(br);
wbr = br->br_wbr;
if (wbr) {
@@ -65,7 +66,7 @@ void au_br_free(struct au_sbinfo *sbinfo)
AuRwMustWriteLock(&sbinfo->si_rwsem);
- bmax = sbinfo->si_bend + 1;
+ bmax = sbinfo->si_bbot + 1;
br = sbinfo->si_branch;
while (bmax--)
au_br_do_free(*br++);
@@ -76,10 +77,10 @@ void au_br_free(struct au_sbinfo *sbinfo)
*/
int au_br_index(struct super_block *sb, aufs_bindex_t br_id)
{
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
- bend = au_sbend(sb);
- for (bindex = 0; bindex <= bend; bindex++)
+ bbot = au_sbbot(sb);
+ for (bindex = 0; bindex <= bbot; bindex++)
if (au_sbr_id(sb, bindex) == br_id)
return bindex;
return -1;
@@ -144,7 +145,7 @@ static struct au_branch *au_br_alloc(struct super_block *sb, int new_nbranch,
err = au_di_realloc(au_di(root), new_nbranch);
if (!err) {
inode = d_inode(root);
- err = au_ii_realloc(au_ii(inode), new_nbranch);
+ err = au_hinode_realloc(au_ii(inode), new_nbranch);
}
if (!err)
return add_branch; /* success */
@@ -186,13 +187,13 @@ out:
static int test_add(struct super_block *sb, struct au_opt_add *add, int remount)
{
int err;
- aufs_bindex_t bend, bindex;
+ aufs_bindex_t bbot, bindex;
struct dentry *root, *h_dentry;
struct inode *inode, *h_inode;
root = sb->s_root;
- bend = au_sbend(sb);
- if (unlikely(bend >= 0
+ bbot = au_sbbot(sb);
+ if (unlikely(bbot >= 0
&& au_find_dbindex(root, add->path.dentry) >= 0)) {
err = 1;
if (!remount) {
@@ -204,13 +205,13 @@ static int test_add(struct super_block *sb, struct au_opt_add *add, int remount)
err = -ENOSPC; /* -E2BIG; */
if (unlikely(AUFS_BRANCH_MAX <= add->bindex
- || AUFS_BRANCH_MAX - 1 <= bend)) {
+ || AUFS_BRANCH_MAX - 1 <= bbot)) {
pr_err("number of branches exceeded %s\n", add->pathname);
goto out;
}
err = -EDOM;
- if (unlikely(add->bindex < 0 || bend + 1 < add->bindex)) {
+ if (unlikely(add->bindex < 0 || bbot + 1 < add->bindex)) {
pr_err("bad index %d\n", add->bindex);
goto out;
}
@@ -244,11 +245,11 @@ static int test_add(struct super_block *sb, struct au_opt_add *add, int remount)
if (unlikely(err))
goto out;
- if (bend < 0)
+ if (bbot < 0)
return 0; /* success */
err = -EINVAL;
- for (bindex = 0; bindex <= bend; bindex++)
+ for (bindex = 0; bindex <= bbot; bindex++)
if (unlikely(test_overlap(sb, add->path.dentry,
au_h_dptr(root, bindex)))) {
pr_err("%s is overlapped\n", add->pathname);
@@ -370,7 +371,7 @@ static int au_br_init(struct au_branch *br, struct super_block *sb,
br->br_perm = add->perm;
br->br_path = add->path; /* set first, path_get() later */
spin_lock_init(&br->br_dykey_lock);
- atomic_set(&br->br_count, 0);
+ au_br_count_init(br);
atomic_set(&br->br_xino_running, 0);
br->br_id = au_new_br_id(sb);
AuDebugOn(br->br_id < 0);
@@ -402,7 +403,7 @@ out:
}
static void au_br_do_add_brp(struct au_sbinfo *sbinfo, aufs_bindex_t bindex,
- struct au_branch *br, aufs_bindex_t bend,
+ struct au_branch *br, aufs_bindex_t bbot,
aufs_bindex_t amount)
{
struct au_branch **brp;
@@ -412,13 +413,13 @@ static void au_br_do_add_brp(struct au_sbinfo *sbinfo, aufs_bindex_t bindex,
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;
+ sbinfo->si_bbot++;
+ if (unlikely(bbot < 0))
+ sbinfo->si_bbot = 0;
}
static void au_br_do_add_hdp(struct au_dinfo *dinfo, aufs_bindex_t bindex,
- aufs_bindex_t bend, aufs_bindex_t amount)
+ aufs_bindex_t bbot, aufs_bindex_t amount)
{
struct au_hdentry *hdp;
@@ -427,25 +428,24 @@ static void au_br_do_add_hdp(struct au_dinfo *dinfo, aufs_bindex_t bindex,
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;
+ dinfo->di_bbot++;
+ if (unlikely(bbot < 0))
+ dinfo->di_btop = 0;
}
static void au_br_do_add_hip(struct au_iinfo *iinfo, aufs_bindex_t bindex,
- aufs_bindex_t bend, aufs_bindex_t amount)
+ aufs_bindex_t bbot, aufs_bindex_t amount)
{
struct au_hinode *hip;
AuRwMustWriteLock(&iinfo->ii_rwsem);
- hip = iinfo->ii_hinode + bindex;
+ hip = au_hinode(iinfo, 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;
+ au_hinode_init(hip);
+ iinfo->ii_bbot++;
+ if (unlikely(bbot < 0))
+ iinfo->ii_btop = 0;
}
static void au_br_do_add(struct super_block *sb, struct au_branch *br,
@@ -453,17 +453,17 @@ static void au_br_do_add(struct super_block *sb, struct au_branch *br,
{
struct dentry *root, *h_dentry;
struct inode *root_inode, *h_inode;
- aufs_bindex_t bend, amount;
+ aufs_bindex_t bbot, amount;
root = sb->s_root;
root_inode = d_inode(root);
- bend = au_sbend(sb);
- amount = bend + 1 - bindex;
+ bbot = au_sbbot(sb);
+ amount = bbot + 1 - bindex;
h_dentry = au_br_dentry(br);
au_sbilist_lock();
- au_br_do_add_brp(au_sbi(sb), bindex, br, bend, amount);
- au_br_do_add_hdp(au_di(root), bindex, bend, amount);
- au_br_do_add_hip(au_ii(root_inode), bindex, bend, amount);
+ au_br_do_add_brp(au_sbi(sb), bindex, br, bbot, amount);
+ au_br_do_add_hdp(au_di(root), bindex, bbot, amount);
+ au_br_do_add_hip(au_ii(root_inode), bindex, bbot, amount);
au_set_h_dptr(root, bindex, dget(h_dentry));
h_inode = d_inode(h_dentry);
au_set_h_iptr(root_inode, bindex, au_igrab(h_inode), /*flags*/0);
@@ -473,7 +473,7 @@ static void au_br_do_add(struct super_block *sb, struct au_branch *br,
int au_br_add(struct super_block *sb, struct au_opt_add *add, int remount)
{
int err;
- aufs_bindex_t bend, add_bindex;
+ aufs_bindex_t bbot, add_bindex;
struct dentry *root, *h_dentry;
struct inode *root_inode;
struct au_branch *add_branch;
@@ -489,8 +489,8 @@ int au_br_add(struct super_block *sb, struct au_opt_add *add, int remount)
goto out; /* success */
}
- bend = au_sbend(sb);
- add_branch = au_br_alloc(sb, bend + 2, add->perm);
+ bbot = au_sbbot(sb);
+ add_branch = au_br_alloc(sb, bbot + 2, add->perm);
err = PTR_ERR(add_branch);
if (IS_ERR(add_branch))
goto out;
@@ -566,7 +566,7 @@ static unsigned long long au_farray_cb(struct super_block *sb, void *a,
static struct file **au_farray_alloc(struct super_block *sb,
unsigned long long *max)
{
- *max = atomic_long_read(&au_sbi(sb)->si_nfiles);
+ *max = au_nfiles(sb);
return au_array_alloc(max, au_farray_cb, sb, /*arg*/NULL);
}
@@ -592,16 +592,16 @@ static void au_farray_free(struct file **a, unsigned long long max)
pr_info(fmt, ##__VA_ARGS__); \
} while (0)
-static int au_test_ibusy(struct inode *inode, aufs_bindex_t bstart,
- aufs_bindex_t bend)
+static int au_test_ibusy(struct inode *inode, aufs_bindex_t btop,
+ aufs_bindex_t bbot)
{
- return (inode && !S_ISDIR(inode->i_mode)) || bstart == bend;
+ return (inode && !S_ISDIR(inode->i_mode)) || btop == bbot;
}
-static int au_test_dbusy(struct dentry *dentry, aufs_bindex_t bstart,
- aufs_bindex_t bend)
+static int au_test_dbusy(struct dentry *dentry, aufs_bindex_t btop,
+ aufs_bindex_t bbot)
{
- return au_test_ibusy(d_inode(dentry), bstart, bend);
+ return au_test_ibusy(d_inode(dentry), btop, bbot);
}
/*
@@ -611,7 +611,7 @@ static int test_dentry_busy(struct dentry *root, aufs_bindex_t bindex,
unsigned int sigen, const unsigned int verbose)
{
int err, i, j, ndentry;
- aufs_bindex_t bstart, bend;
+ aufs_bindex_t btop, bbot;
struct au_dcsub_pages dpages;
struct au_dpage *dpage;
struct dentry *d;
@@ -651,12 +651,12 @@ static int test_dentry_busy(struct dentry *root, aufs_bindex_t bindex,
}
/* AuDbgDentry(d); */
- bstart = au_dbstart(d);
- bend = au_dbend(d);
- if (bstart <= bindex
- && bindex <= bend
+ btop = au_dbtop(d);
+ bbot = au_dbbot(d);
+ if (btop <= bindex
+ && bindex <= bbot
&& au_h_dptr(d, bindex)
- && au_test_dbusy(d, bstart, bend)) {
+ && au_test_dbusy(d, btop, bbot)) {
err = -EBUSY;
AuVerbose(verbose, "busy %pd\n", d);
AuDbgDentry(d);
@@ -677,7 +677,7 @@ static int test_inode_busy(struct super_block *sb, aufs_bindex_t bindex,
int err;
unsigned long long max, ull;
struct inode *i, **array;
- aufs_bindex_t bstart, bend;
+ aufs_bindex_t btop, bbot;
array = au_iarray_alloc(sb, &max);
err = PTR_ERR(array);
@@ -708,12 +708,12 @@ static int test_inode_busy(struct super_block *sb, aufs_bindex_t bindex,
}
}
- bstart = au_ibstart(i);
- bend = au_ibend(i);
- if (bstart <= bindex
- && bindex <= bend
+ btop = au_ibtop(i);
+ bbot = au_ibbot(i);
+ if (btop <= bindex
+ && bindex <= bbot
&& au_h_iptr(i, bindex)
- && au_test_ibusy(i, bstart, bend)) {
+ && au_test_ibusy(i, btop, bbot)) {
err = -EBUSY;
AuVerbose(verbose, "busy i%lu\n", i->i_ino);
AuDbgInode(i);
@@ -749,7 +749,7 @@ static int test_dir_busy(struct file *file, aufs_bindex_t br_id,
{
int err;
unsigned char matched, root;
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
struct au_fidir *fidir;
struct au_hfile *hfile;
@@ -765,8 +765,8 @@ static int test_dir_busy(struct file *file, aufs_bindex_t br_id,
matched = 0;
fidir = au_fi(file)->fi_hdir;
AuDebugOn(!fidir);
- bend = au_fbend_dir(file);
- for (bindex = au_fbstart(file); bindex <= bend; bindex++) {
+ bbot = au_fbbot_dir(file);
+ for (bindex = au_fbtop(file); bindex <= bbot; bindex++) {
hfile = fidir->fd_hfile + bindex;
if (!hfile->hf_file)
continue;
@@ -788,7 +788,7 @@ static int test_file_busy(struct super_block *sb, aufs_bindex_t br_id,
{
int err, idx;
unsigned long long ull, max;
- aufs_bindex_t bstart;
+ aufs_bindex_t btop;
struct file *file, **array;
struct dentry *root;
struct au_hfile *hfile;
@@ -809,7 +809,7 @@ static int test_file_busy(struct super_block *sb, aufs_bindex_t br_id,
/* AuDbg("%pD\n", file); */
fi_read_lock(file);
- bstart = au_fbstart(file);
+ btop = au_fbtop(file);
if (!d_is_dir(file->f_path.dentry)) {
hfile = &au_fi(file)->fi_htop;
if (hfile->hf_br->br_id == br_id)
@@ -832,7 +832,7 @@ static void br_del_file(struct file **to_free, unsigned long long opened,
aufs_bindex_t br_id)
{
unsigned long long ull;
- aufs_bindex_t bindex, bstart, bend, bfound;
+ aufs_bindex_t bindex, btop, bbot, bfound;
struct file *file;
struct au_fidir *fidir;
struct au_hfile *hfile;
@@ -848,9 +848,9 @@ static void br_del_file(struct file **to_free, unsigned long long opened,
fidir = au_fi(file)->fi_hdir;
AuDebugOn(!fidir);
fi_write_lock(file);
- bstart = au_fbstart(file);
- bend = au_fbend_dir(file);
- for (bindex = bstart; bindex <= bend; bindex++) {
+ btop = au_fbtop(file);
+ bbot = au_fbbot_dir(file);
+ for (bindex = btop; bindex <= bbot; bindex++) {
hfile = fidir->fd_hfile + bindex;
if (!hfile->hf_file)
continue;
@@ -862,10 +862,10 @@ static void br_del_file(struct file **to_free, unsigned long long opened,
}
AuDebugOn(bfound < 0);
au_set_h_fptr(file, bfound, NULL);
- if (bfound == bstart) {
- for (bstart++; bstart <= bend; bstart++)
- if (au_hf_dir(file, bstart)) {
- au_set_fbstart(file, bstart);
+ if (bfound == btop) {
+ for (btop++; btop <= bbot; btop++)
+ if (au_hf_dir(file, btop)) {
+ au_set_fbtop(file, btop);
break;
}
}
@@ -875,59 +875,58 @@ static void br_del_file(struct file **to_free, unsigned long long opened,
static void au_br_do_del_brp(struct au_sbinfo *sbinfo,
const aufs_bindex_t bindex,
- const aufs_bindex_t bend)
+ const aufs_bindex_t bbot)
{
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--;
+ if (bindex < bbot)
+ memmove(brp, brp + 1, sizeof(*brp) * (bbot - bindex));
+ sbinfo->si_branch[0 + bbot] = NULL;
+ sbinfo->si_bbot--;
- p = krealloc(sbinfo->si_branch, sizeof(*p) * bend, AuGFP_SBILIST);
+ p = krealloc(sbinfo->si_branch, sizeof(*p) * bbot, AuGFP_SBILIST);
if (p)
sbinfo->si_branch = p;
/* harmless error */
}
static void au_br_do_del_hdp(struct au_dinfo *dinfo, const aufs_bindex_t bindex,
- const aufs_bindex_t bend)
+ const aufs_bindex_t bbot)
{
struct au_hdentry *hdp, *p;
AuRwMustWriteLock(&dinfo->di_rwsem);
hdp = dinfo->di_hdentry;
- if (bindex < bend)
+ if (bindex < bbot)
memmove(hdp + bindex, hdp + bindex + 1,
- sizeof(*hdp) * (bend - bindex));
- hdp[0 + bend].hd_dentry = NULL;
- dinfo->di_bend--;
+ sizeof(*hdp) * (bbot - bindex));
+ hdp[0 + bbot].hd_dentry = NULL;
+ dinfo->di_bbot--;
- p = krealloc(hdp, sizeof(*p) * bend, AuGFP_SBILIST);
+ p = krealloc(hdp, sizeof(*p) * bbot, AuGFP_SBILIST);
if (p)
dinfo->di_hdentry = p;
/* harmless error */
}
static void au_br_do_del_hip(struct au_iinfo *iinfo, const aufs_bindex_t bindex,
- const aufs_bindex_t bend)
+ const aufs_bindex_t bbot)
{
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--;
+ hip = au_hinode(iinfo, bindex);
+ if (bindex < bbot)
+ memmove(hip, hip + 1, sizeof(*hip) * (bbot - bindex));
+ /* au_hinode_init(au_hinode(iinfo, bbot)); */
+ iinfo->ii_bbot--;
- p = krealloc(iinfo->ii_hinode, sizeof(*p) * bend, AuGFP_SBILIST);
+ p = krealloc(iinfo->ii_hinode, sizeof(*p) * bbot, AuGFP_SBILIST);
if (p)
iinfo->ii_hinode = p;
/* harmless error */
@@ -936,7 +935,7 @@ static void au_br_do_del_hip(struct au_iinfo *iinfo, const aufs_bindex_t bindex,
static void au_br_do_del(struct super_block *sb, aufs_bindex_t bindex,
struct au_branch *br)
{
- aufs_bindex_t bend;
+ aufs_bindex_t bbot;
struct au_sbinfo *sbinfo;
struct dentry *root, *h_root;
struct inode *inode, *h_inode;
@@ -947,7 +946,7 @@ static void au_br_do_del(struct super_block *sb, aufs_bindex_t bindex,
root = sb->s_root;
inode = d_inode(root);
sbinfo = au_sbi(sb);
- bend = sbinfo->si_bend;
+ bbot = sbinfo->si_bbot;
h_root = au_h_dptr(root, bindex);
hinode = au_hi(inode, bindex);
@@ -955,9 +954,9 @@ static void au_br_do_del(struct super_block *sb, aufs_bindex_t bindex,
au_hiput(hinode);
au_sbilist_lock();
- au_br_do_del_brp(sbinfo, bindex, bend);
- au_br_do_del_hdp(au_di(root), bindex, bend);
- au_br_do_del_hip(au_ii(inode), bindex, bend);
+ au_br_do_del_brp(sbinfo, bindex, bbot);
+ au_br_do_del_hdp(au_di(root), bindex, bbot);
+ au_br_do_del_hip(au_ii(inode), bindex, bbot);
au_sbilist_unlock();
dput(h_root);
@@ -976,7 +975,7 @@ int au_br_del(struct super_block *sb, struct au_opt_del *del, int remount)
int err, rerr, i;
unsigned long long opened;
unsigned int mnt_flags;
- aufs_bindex_t bindex, bend, br_id;
+ aufs_bindex_t bindex, bbot, br_id;
unsigned char do_wh, verbose;
struct au_branch *br;
struct au_wbr *wbr;
@@ -1000,8 +999,8 @@ int au_br_del(struct super_block *sb, struct au_opt_del *del, int remount)
err = -EBUSY;
mnt_flags = au_mntflags(sb);
verbose = !!au_opt_test(mnt_flags, VERBOSE);
- bend = au_sbend(sb);
- if (unlikely(!bend)) {
+ bbot = au_sbbot(sb);
+ if (unlikely(!bbot)) {
AuVerbose(verbose, "no more branches left\n");
goto out;
}
@@ -1009,7 +1008,7 @@ int au_br_del(struct super_block *sb, struct au_opt_del *del, int remount)
AuDebugOn(!path_equal(&br->br_path, &del->h_path));
br_id = br->br_id;
- opened = atomic_read(&br->br_count);
+ opened = au_br_count(br);
if (unlikely(opened)) {
to_free = au_array_alloc(&opened, empty_cb, sb, NULL);
err = PTR_ERR(to_free);
@@ -1089,7 +1088,7 @@ out:
static int au_ibusy(struct super_block *sb, struct aufs_ibusy __user *arg)
{
int err;
- aufs_bindex_t bstart, bend;
+ aufs_bindex_t btop, bbot;
struct aufs_ibusy ibusy;
struct inode *inode, *h_inode;
@@ -1108,7 +1107,7 @@ static int au_ibusy(struct super_block *sb, struct aufs_ibusy __user *arg)
err = -EINVAL;
si_read_lock(sb, AuLock_FLUSH);
- if (unlikely(ibusy.bindex < 0 || ibusy.bindex > au_sbend(sb)))
+ if (unlikely(ibusy.bindex < 0 || ibusy.bindex > au_sbbot(sb)))
goto out_unlock;
err = 0;
@@ -1120,11 +1119,11 @@ static int au_ibusy(struct super_block *sb, struct aufs_ibusy __user *arg)
goto out_unlock;
ii_read_lock_child(inode);
- bstart = au_ibstart(inode);
- bend = au_ibend(inode);
- if (bstart <= ibusy.bindex && ibusy.bindex <= bend) {
+ btop = au_ibtop(inode);
+ bbot = au_ibbot(inode);
+ if (btop <= ibusy.bindex && ibusy.bindex <= bbot) {
h_inode = au_h_iptr(inode, ibusy.bindex);
- if (h_inode && au_test_ibusy(inode, bstart, bend))
+ if (h_inode && au_test_ibusy(inode, btop, bbot))
ibusy.h_ino = h_inode->i_ino;
}
ii_read_unlock(inode);
diff --git a/fs/aufs/branch.h b/fs/aufs/branch.h
index 4c52ae166..32a4d8f36 100644
--- a/fs/aufs/branch.h
+++ b/fs/aufs/branch.h
@@ -86,7 +86,7 @@ struct au_branch {
struct path br_path;
spinlock_t br_dykey_lock;
struct au_dykey *br_dykey[AuBrDynOp];
- atomic_t br_count;
+ struct percpu_counter br_count;
struct au_wbr *br_wbr;
struct au_br_fhsm *br_fhsm;
@@ -121,6 +121,31 @@ static inline struct super_block *au_br_sb(struct au_branch *br)
return au_br_mnt(br)->mnt_sb;
}
+static inline void au_br_get(struct au_branch *br)
+{
+ percpu_counter_inc(&br->br_count);
+}
+
+static inline void au_br_put(struct au_branch *br)
+{
+ percpu_counter_dec(&br->br_count);
+}
+
+static inline s64 au_br_count(struct au_branch *br)
+{
+ return percpu_counter_sum(&br->br_count);
+}
+
+static inline void au_br_count_init(struct au_branch *br)
+{
+ percpu_counter_init(&br->br_count, 0, GFP_NOFS);
+}
+
+static inline void au_br_count_fin(struct au_branch *br)
+{
+ percpu_counter_destroy(&br->br_count);
+}
+
static inline int au_br_rdonly(struct au_branch *br)
{
return ((au_br_sb(br)->s_flags & MS_RDONLY)
@@ -216,9 +241,14 @@ struct super_block *au_sbr_sb(struct super_block *sb, aufs_bindex_t bindex)
return au_br_sb(au_sbr(sb, bindex));
}
+static inline void au_sbr_get(struct super_block *sb, aufs_bindex_t bindex)
+{
+ au_br_get(au_sbr(sb, bindex));
+}
+
static inline void au_sbr_put(struct super_block *sb, aufs_bindex_t bindex)
{
- atomic_dec(&au_sbr(sb, bindex)->br_count);
+ au_br_put(au_sbr(sb, bindex));
}
static inline int au_sbr_perm(struct super_block *sb, aufs_bindex_t bindex)
diff --git a/fs/aufs/cpup.c b/fs/aufs/cpup.c
index 9ff0963ad..dbf96fd60 100644
--- a/fs/aufs/cpup.c
+++ b/fs/aufs/cpup.c
@@ -27,7 +27,7 @@ void au_cpup_attr_timesizes(struct inode *inode)
{
struct inode *h_inode;
- h_inode = au_h_iptr(inode, au_ibstart(inode));
+ h_inode = au_h_iptr(inode, au_ibtop(inode));
fsstack_copy_attr_times(inode, h_inode);
fsstack_copy_inode_size(inode, h_inode);
}
@@ -36,10 +36,10 @@ void au_cpup_attr_nlink(struct inode *inode, int force)
{
struct inode *h_inode;
struct super_block *sb;
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
sb = inode->i_sb;
- bindex = au_ibstart(inode);
+ bindex = au_ibtop(inode);
h_inode = au_h_iptr(inode, bindex);
if (!force
&& !S_ISDIR(h_inode->i_mode)
@@ -62,8 +62,8 @@ void au_cpup_attr_nlink(struct inode *inode, int force)
* it may includes whplink directory.
*/
if (S_ISDIR(h_inode->i_mode)) {
- bend = au_ibend(inode);
- for (bindex++; bindex <= bend; bindex++) {
+ bbot = au_ibbot(inode);
+ for (bindex++; bindex <= bbot; bindex++) {
h_inode = au_h_iptr(inode, bindex);
if (h_inode)
au_add_nlink(inode, h_inode);
@@ -75,7 +75,7 @@ void au_cpup_attr_changeable(struct inode *inode)
{
struct inode *h_inode;
- h_inode = au_h_iptr(inode, au_ibstart(inode));
+ h_inode = au_h_iptr(inode, au_ibtop(inode));
inode->i_mode = h_inode->i_mode;
inode->i_uid = h_inode->i_uid;
inode->i_gid = h_inode->i_gid;
@@ -97,7 +97,7 @@ void au_cpup_attr_all(struct inode *inode, int force)
{
struct inode *h_inode;
- h_inode = au_h_iptr(inode, au_ibstart(inode));
+ h_inode = au_h_iptr(inode, au_ibtop(inode));
au_cpup_attr_changeable(inode);
if (inode->i_nlink > 0)
au_cpup_attr_nlink(inode, force);
@@ -554,7 +554,7 @@ static int au_do_cpup_dir(struct au_cp_generic *cpg, struct dentry *dst_parent,
* particularry setattr case
*/
dir = d_inode(dst_parent);
- if (au_ibstart(dir) == cpg->bdst)
+ if (au_ibtop(dir) == cpg->bdst)
au_cpup_attr_nlink(dir, /*force*/1);
inode = d_inode(cpg->dentry);
au_cpup_attr_nlink(inode, /*force*/1);
@@ -715,7 +715,7 @@ out:
static int au_cpup_single(struct au_cp_generic *cpg, struct dentry *dst_parent)
{
int err, rerr;
- aufs_bindex_t old_ibstart;
+ aufs_bindex_t old_ibtop;
unsigned char isdir, plink;
struct dentry *h_src, *h_dst, *h_parent;
struct inode *dst_inode, *h_dir, *inode, *delegated, *src_inode;
@@ -803,7 +803,7 @@ static int au_cpup_single(struct au_cp_generic *cpg, struct dentry *dst_parent)
}
isdir = S_ISDIR(inode->i_mode);
- old_ibstart = au_ibstart(inode);
+ old_ibtop = au_ibtop(inode);
err = cpup_entry(cpg, dst_parent, &a->h_src_attr);
if (unlikely(err))
goto out_rev;
@@ -820,7 +820,7 @@ static int au_cpup_single(struct au_cp_generic *cpg, struct dentry *dst_parent)
goto out_rev;
}
- if (cpg->bdst < old_ibstart) {
+ if (cpg->bdst < old_ibtop) {
if (S_ISREG(inode->i_mode)) {
err = au_dy_iaop(inode, cpg->bdst, dst_inode);
if (unlikely(err)) {
@@ -830,9 +830,9 @@ static int au_cpup_single(struct au_cp_generic *cpg, struct dentry *dst_parent)
goto out_rev;
}
}
- au_set_ibstart(inode, cpg->bdst);
+ au_set_ibtop(inode, cpg->bdst);
} else
- au_set_ibend(inode, cpg->bdst);
+ au_set_ibbot(inode, cpg->bdst);
au_set_h_iptr(inode, cpg->bdst, au_igrab(dst_inode),
au_hi_flags(inode, isdir));
@@ -988,7 +988,7 @@ static int au_cpup_simple(struct au_cp_generic *cpg)
/* revert */
au_set_h_dptr(dentry, cpg->bdst, NULL);
- au_set_dbstart(dentry, cpg->bsrc);
+ au_set_dbtop(dentry, cpg->bsrc);
}
return err;
@@ -1050,20 +1050,20 @@ out:
int au_sio_cpup_simple(struct au_cp_generic *cpg)
{
- aufs_bindex_t bsrc, bend;
+ aufs_bindex_t bsrc, bbot;
struct dentry *dentry, *h_dentry;
if (cpg->bsrc < 0) {
dentry = cpg->dentry;
- bend = au_dbend(dentry);
- for (bsrc = cpg->bdst + 1; bsrc <= bend; bsrc++) {
+ bbot = au_dbbot(dentry);
+ for (bsrc = cpg->bdst + 1; bsrc <= bbot; bsrc++) {
h_dentry = au_h_dptr(dentry, bsrc);
if (h_dentry) {
AuDebugOn(d_is_negative(h_dentry));
break;
}
}
- AuDebugOn(bsrc > bend);
+ AuDebugOn(bsrc > bbot);
cpg->bsrc = bsrc;
}
AuDebugOn(cpg->bsrc <= cpg->bdst);
@@ -1095,10 +1095,10 @@ static int au_do_cpup_wh(struct au_cp_generic *cpg, struct dentry *wh_dentry,
AuRwMustWriteLock(&dinfo->di_rwsem);
bsrc_orig = cpg->bsrc;
- cpg->bsrc = dinfo->di_bstart;
+ cpg->bsrc = dinfo->di_btop;
hdp = dinfo->di_hdentry;
h_d_dst = hdp[0 + cpg->bdst].hd_dentry;
- dinfo->di_bstart = cpg->bdst;
+ dinfo->di_btop = cpg->bdst;
hdp[0 + cpg->bdst].hd_dentry = wh_dentry;
h_d_start = NULL;
if (file) {
@@ -1115,7 +1115,7 @@ static int au_do_cpup_wh(struct au_cp_generic *cpg, struct dentry *wh_dentry,
hdp[0 + cpg->bsrc].hd_dentry = h_d_start;
}
hdp[0 + cpg->bdst].hd_dentry = h_d_dst;
- dinfo->di_bstart = cpg->bsrc;
+ dinfo->di_btop = cpg->bsrc;
cpg->bsrc = bsrc_orig;
return err;
@@ -1299,7 +1299,7 @@ int au_cp_dirs(struct dentry *dentry, aufs_bindex_t bdst,
h_dentry = au_h_dptr(d, bdst);
if (!h_dentry || d_is_negative(h_dentry)) {
if (h_dentry)
- au_update_dbstart(d);
+ au_update_dbtop(d);
au_pin_set_dentry(&pin, d);
err = au_do_pin(&pin);
diff --git a/fs/aufs/dbgaufs.c b/fs/aufs/dbgaufs.c
index 0aefb5ed8..21ac77398 100644
--- a/fs/aufs/dbgaufs.c
+++ b/fs/aufs/dbgaufs.c
@@ -225,7 +225,7 @@ static int dbgaufs_xino_open(struct inode *inode, struct file *file)
sbinfo = inode->i_private;
sb = sbinfo->si_sb;
si_noflush_read_lock(sb);
- if (l <= au_sbend(sb)) {
+ if (l <= au_sbbot(sb)) {
xf = au_sbr(sb, (aufs_bindex_t)l)->br_xino.xi_file;
err = dbgaufs_xi_open(xf, file, /*do_fcnt*/1);
} else
@@ -245,15 +245,15 @@ static const struct file_operations dbgaufs_xino_fop = {
void dbgaufs_brs_del(struct super_block *sb, aufs_bindex_t bindex)
{
- aufs_bindex_t bend;
+ aufs_bindex_t bbot;
struct au_branch *br;
struct au_xino_file *xi;
if (!au_sbi(sb)->si_dbgaufs)
return;
- bend = au_sbend(sb);
- for (; bindex <= bend; bindex++) {
+ bbot = au_sbbot(sb);
+ for (; bindex <= bbot; bindex++) {
br = au_sbr(sb, bindex);
xi = &br->br_xino;
debugfs_remove(xi->xi_dbgaufs);
@@ -267,7 +267,7 @@ void dbgaufs_brs_add(struct super_block *sb, aufs_bindex_t bindex)
struct dentry *parent;
struct au_branch *br;
struct au_xino_file *xi;
- aufs_bindex_t bend;
+ aufs_bindex_t bbot;
char name[sizeof(DbgaufsXi_PREFIX) + 5]; /* "xi" bindex NULL */
sbinfo = au_sbi(sb);
@@ -275,8 +275,8 @@ void dbgaufs_brs_add(struct super_block *sb, aufs_bindex_t bindex)
if (!parent)
return;
- bend = au_sbend(sb);
- for (; bindex <= bend; bindex++) {
+ bbot = au_sbbot(sb);
+ for (; bindex <= bbot; bindex++) {
snprintf(name, sizeof(name), DbgaufsXi_PREFIX "%d", bindex);
br = au_sbr(sb, bindex);
xi = &br->br_xino;
diff --git a/fs/aufs/debug.c b/fs/aufs/debug.c
index 4529831a9..14e69cbc8 100644
--- a/fs/aufs/debug.c
+++ b/fs/aufs/debug.c
@@ -128,25 +128,24 @@ static int do_pri_inode(aufs_bindex_t bindex, struct inode *inode, int hn,
void au_dpri_inode(struct inode *inode)
{
struct au_iinfo *iinfo;
+ struct au_hinode *hi;
aufs_bindex_t bindex;
int err, hn;
err = do_pri_inode(-1, inode, -1, NULL);
- if (err || !au_test_aufs(inode->i_sb))
+ if (err || !au_test_aufs(inode->i_sb) || is_bad_inode(inode))
return;
iinfo = au_ii(inode);
- if (!iinfo)
- return;
- dpri("i-1: bstart %d, bend %d, gen %d\n",
- iinfo->ii_bstart, iinfo->ii_bend, au_iigen(inode, NULL));
- if (iinfo->ii_bstart < 0)
+ dpri("i-1: btop %d, bbot %d, gen %d\n",
+ iinfo->ii_btop, iinfo->ii_bbot, au_iigen(inode, NULL));
+ if (iinfo->ii_btop < 0)
return;
hn = 0;
- for (bindex = iinfo->ii_bstart; bindex <= iinfo->ii_bend; bindex++) {
- hn = !!au_hn(iinfo->ii_hinode + bindex);
- do_pri_inode(bindex, iinfo->ii_hinode[0 + bindex].hi_inode, hn,
- iinfo->ii_hinode[0 + bindex].hi_whdentry);
+ for (bindex = iinfo->ii_btop; bindex <= iinfo->ii_bbot; bindex++) {
+ hi = au_hinode(iinfo, bindex);
+ hn = !!au_hn(hi);
+ do_pri_inode(bindex, hi->hi_inode, hn, hi->hi_whdentry);
}
}
@@ -165,6 +164,8 @@ static int do_pri_dentry(aufs_bindex_t bindex, struct dentry *dentry)
struct dentry *wh = NULL;
int hn;
struct au_iinfo *iinfo;
+ struct au_hinode *hi;
+ struct inode *inode;
if (!dentry || IS_ERR(dentry)) {
dpri("d%d: err %ld\n", bindex, PTR_ERR(dentry));
@@ -178,16 +179,18 @@ static int do_pri_dentry(aufs_bindex_t bindex, struct dentry *dentry)
au_dcount(dentry), dentry->d_flags,
d_unhashed(dentry) ? "un" : "");
hn = -1;
+ inode = NULL;
if (bindex >= 0
&& d_is_positive(dentry)
- && au_test_aufs(dentry->d_sb)) {
- iinfo = au_ii(d_inode(dentry));
- if (iinfo) {
- hn = !!au_hn(iinfo->ii_hinode + bindex);
- wh = iinfo->ii_hinode[0 + bindex].hi_whdentry;
- }
+ && au_test_aufs(dentry->d_sb))
+ inode = d_inode(dentry);
+ if (inode && !is_bad_inode(inode)) {
+ iinfo = au_ii(inode);
+ hi = au_hinode(iinfo, bindex);
+ hn = !!au_hn(hi);
+ wh = hi->hi_whdentry;
}
- do_pri_inode(bindex, d_inode(dentry), hn, wh);
+ do_pri_inode(bindex, inode, hn, wh);
return 0;
}
@@ -205,14 +208,14 @@ void au_dpri_dentry(struct dentry *dentry)
dinfo = au_di(dentry);
if (!dinfo)
return;
- dpri("d-1: bstart %d, bend %d, bwh %d, bdiropq %d, gen %d, tmp %d\n",
- dinfo->di_bstart, dinfo->di_bend,
+ dpri("d-1: btop %d, bbot %d, bwh %d, bdiropq %d, gen %d, tmp %d\n",
+ dinfo->di_btop, dinfo->di_bbot,
dinfo->di_bwh, dinfo->di_bdiropq, au_digen(dentry),
dinfo->di_tmpfile);
- if (dinfo->di_bstart < 0)
+ if (dinfo->di_btop < 0)
return;
hdp = dinfo->di_hdentry;
- for (bindex = dinfo->di_bstart; bindex <= dinfo->di_bend; bindex++)
+ for (bindex = dinfo->di_btop; bindex <= dinfo->di_bbot; bindex++)
do_pri_dentry(bindex, hdp[0 + bindex].hd_dentry);
}
@@ -284,10 +287,10 @@ static int do_pri_br(aufs_bindex_t bindex, struct au_branch *br)
if (!sb || IS_ERR(sb))
goto out;
- dpri("s%d: {perm 0x%x, id %d, cnt %d, wbr %p}, "
+ dpri("s%d: {perm 0x%x, id %d, cnt %lld, wbr %p}, "
"%s, dev 0x%02x%02x, flags 0x%lx, cnt %d, active %d, "
"xino %d\n",
- bindex, br->br_perm, br->br_id, atomic_read(&br->br_count),
+ bindex, br->br_perm, br->br_id, au_br_count(br),
br->br_wbr, au_sbtype(sb), MAJOR(sb->s_dev), MINOR(sb->s_dev),
sb->s_flags, sb->s_count,
atomic_read(&sb->s_active), !!br->br_xino.xi_file);
@@ -318,9 +321,9 @@ void au_dpri_sb(struct super_block *sb)
a->mnt.mnt_sb = sb;
a->fake.br_path.mnt = &a->mnt;
- atomic_set(&a->fake.br_count, 0);
- smp_mb(); /* atomic_set */
+ au_br_count_init(&a->fake);
err = do_pri_br(-1, &a->fake);
+ au_br_count_fin(&a->fake);
kfree(a);
dpri("dev 0x%x\n", sb->s_dev);
if (err || !au_test_aufs(sb))
@@ -329,10 +332,11 @@ void au_dpri_sb(struct super_block *sb)
sbinfo = au_sbi(sb);
if (!sbinfo)
return;
- dpri("nw %d, gen %u, kobj %d\n",
- atomic_read(&sbinfo->si_nowait.nw_len), sbinfo->si_generation,
+ dpri("nw %lld, gen %u, kobj %d\n",
+ percpu_counter_sum(&sbinfo->si_nowait.nw_len),
+ sbinfo->si_generation,
atomic_read(&sbinfo->si_kobj.kref.refcount));
- for (bindex = 0; bindex <= sbinfo->si_bend; bindex++)
+ for (bindex = 0; bindex <= sbinfo->si_bbot; bindex++)
do_pri_br(bindex, sbinfo->si_branch[0 + bindex]);
}
@@ -342,21 +346,21 @@ void __au_dbg_verify_dinode(struct dentry *dentry, const char *func, int line)
{
struct inode *h_inode, *inode = d_inode(dentry);
struct dentry *h_dentry;
- aufs_bindex_t bindex, bend, bi;
+ aufs_bindex_t bindex, bbot, bi;
if (!inode /* || au_di(dentry)->di_lsc == AuLsc_DI_TMP */)
return;
- bend = au_dbend(dentry);
- bi = au_ibend(inode);
- if (bi < bend)
- bend = bi;
- bindex = au_dbstart(dentry);
- bi = au_ibstart(inode);
+ bbot = au_dbbot(dentry);
+ bi = au_ibbot(inode);
+ if (bi < bbot)
+ bbot = bi;
+ bindex = au_dbtop(dentry);
+ bi = au_ibtop(inode);
if (bi > bindex)
bindex = bi;
- for (; bindex <= bend; bindex++) {
+ for (; bindex <= bbot; bindex++) {
h_dentry = au_h_dptr(dentry, bindex);
if (!h_dentry)
continue;
diff --git a/fs/aufs/dentry.c b/fs/aufs/dentry.c
index e65fadd05..ce2a13632 100644
--- a/fs/aufs/dentry.c
+++ b/fs/aufs/dentry.c
@@ -52,7 +52,7 @@ au_do_lookup(struct dentry *h_parent, struct dentry *dentry,
goto out;
/* We found a whiteout */
- /* au_set_dbend(dentry, bindex); */
+ /* au_set_dbbot(dentry, bindex); */
au_set_dbwh(dentry, bindex);
if (!allow_neg)
return NULL; /* success */
@@ -77,10 +77,10 @@ real_lookup:
|| (args->type && args->type != (h_inode->i_mode & S_IFMT)))
goto out_neg;
- if (au_dbend(dentry) <= bindex)
- au_set_dbend(dentry, bindex);
- if (au_dbstart(dentry) < 0 || bindex < au_dbstart(dentry))
- au_set_dbstart(dentry, bindex);
+ if (au_dbbot(dentry) <= bindex)
+ au_set_dbbot(dentry, bindex);
+ if (au_dbtop(dentry) < 0 || bindex < au_dbtop(dentry))
+ au_set_dbtop(dentry, bindex);
au_set_h_dptr(dentry, bindex, h_dentry);
if (!d_is_dir(h_dentry)
@@ -119,7 +119,7 @@ static int au_test_shwh(struct super_block *sb, const struct qstr *name)
* otherwise an error.
* can be called at unlinking with @type is zero.
*/
-int au_lkup_dentry(struct dentry *dentry, aufs_bindex_t bstart, mode_t type)
+int au_lkup_dentry(struct dentry *dentry, aufs_bindex_t btop, mode_t type)
{
int npositive, err;
aufs_bindex_t bindex, btail, bdiropq;
@@ -150,7 +150,7 @@ int au_lkup_dentry(struct dentry *dentry, aufs_bindex_t bstart, mode_t type)
npositive = 0;
parent = dget_parent(dentry);
btail = au_dbtaildir(parent);
- for (bindex = bstart; bindex <= btail; bindex++) {
+ for (bindex = btop; bindex <= btail; bindex++) {
struct dentry *h_parent, *h_dentry;
struct inode *h_inode, *h_dir;
@@ -201,11 +201,11 @@ int au_lkup_dentry(struct dentry *dentry, aufs_bindex_t bstart, mode_t type)
if (npositive) {
AuLabel(positive);
- au_update_dbstart(dentry);
+ au_update_dbtop(dentry);
}
err = npositive;
if (unlikely(!au_opt_test(au_mntflags(sb), UDBA_NONE)
- && au_dbstart(dentry) < 0)) {
+ && au_dbtop(dentry) < 0)) {
err = -EIO;
AuIOErr("both of real entry and whiteout found, %pd, err %d\n",
dentry, err);
@@ -267,10 +267,10 @@ int au_lkup_neg(struct dentry *dentry, aufs_bindex_t bindex, int wh)
}
err = 0;
- if (bindex < au_dbstart(dentry))
- au_set_dbstart(dentry, bindex);
- if (au_dbend(dentry) < bindex)
- au_set_dbend(dentry, bindex);
+ if (bindex < au_dbtop(dentry))
+ au_set_dbtop(dentry, bindex);
+ if (au_dbbot(dentry) < bindex)
+ au_set_dbbot(dentry, bindex);
au_set_h_dptr(dentry, bindex, h_dentry);
out:
@@ -382,7 +382,7 @@ int au_h_verify(struct dentry *h_dentry, unsigned int udba, struct inode *h_dir,
static int au_do_refresh_hdentry(struct dentry *dentry, struct dentry *parent)
{
int err;
- aufs_bindex_t new_bindex, bindex, bend, bwh, bdiropq;
+ aufs_bindex_t new_bindex, bindex, bbot, bwh, bdiropq;
struct au_hdentry tmp, *p, *q;
struct au_dinfo *dinfo;
struct super_block *sb;
@@ -391,11 +391,11 @@ static int au_do_refresh_hdentry(struct dentry *dentry, struct dentry *parent)
sb = dentry->d_sb;
dinfo = au_di(dentry);
- bend = dinfo->di_bend;
+ bbot = dinfo->di_bbot;
bwh = dinfo->di_bwh;
bdiropq = dinfo->di_bdiropq;
- p = dinfo->di_hdentry + dinfo->di_bstart;
- for (bindex = dinfo->di_bstart; bindex <= bend; bindex++, p++) {
+ p = dinfo->di_hdentry + dinfo->di_btop;
+ for (bindex = dinfo->di_btop; bindex <= bbot; bindex++, p++) {
if (!p->hd_dentry)
continue;
@@ -425,31 +425,31 @@ static int au_do_refresh_hdentry(struct dentry *dentry, struct dentry *parent)
}
dinfo->di_bwh = -1;
- if (bwh >= 0 && bwh <= au_sbend(sb) && au_sbr_whable(sb, bwh))
+ if (bwh >= 0 && bwh <= au_sbbot(sb) && au_sbr_whable(sb, bwh))
dinfo->di_bwh = bwh;
dinfo->di_bdiropq = -1;
if (bdiropq >= 0
- && bdiropq <= au_sbend(sb)
+ && bdiropq <= au_sbbot(sb)
&& au_sbr_whable(sb, bdiropq))
dinfo->di_bdiropq = bdiropq;
err = -EIO;
- dinfo->di_bstart = -1;
- dinfo->di_bend = -1;
- bend = au_dbend(parent);
+ dinfo->di_btop = -1;
+ dinfo->di_bbot = -1;
+ bbot = au_dbbot(parent);
p = dinfo->di_hdentry;
- for (bindex = 0; bindex <= bend; bindex++, p++)
+ for (bindex = 0; bindex <= bbot; bindex++, p++)
if (p->hd_dentry) {
- dinfo->di_bstart = bindex;
+ dinfo->di_btop = bindex;
break;
}
- if (dinfo->di_bstart >= 0) {
- p = dinfo->di_hdentry + bend;
- for (bindex = bend; bindex >= 0; bindex--, p--)
+ if (dinfo->di_btop >= 0) {
+ p = dinfo->di_hdentry + bbot;
+ for (bindex = bbot; bindex >= 0; bindex--, p--)
if (p->hd_dentry) {
- dinfo->di_bend = bindex;
+ dinfo->di_bbot = bindex;
err = 0;
break;
}
@@ -549,7 +549,7 @@ static int au_refresh_by_dinfo(struct dentry *dentry, struct au_dinfo *dinfo,
struct au_dinfo *tmp)
{
int err;
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
struct {
struct dentry *dentry;
struct inode *inode;
@@ -562,16 +562,16 @@ static int au_refresh_by_dinfo(struct dentry *dentry, struct au_dinfo *dinfo,
struct dentry *h_dentry;
err = 0;
- AuDebugOn(dinfo->di_bstart < 0);
+ AuDebugOn(dinfo->di_btop < 0);
orig_h.mode = 0;
- orig_h.dentry = dinfo->di_hdentry[dinfo->di_bstart].hd_dentry;
+ orig_h.dentry = dinfo->di_hdentry[dinfo->di_btop].hd_dentry;
orig_h.inode = NULL;
if (d_is_positive(orig_h.dentry)) {
orig_h.inode = d_inode(orig_h.dentry);
orig_h.mode = orig_h.inode->i_mode & S_IFMT;
}
- if (tmp->di_bstart >= 0) {
- tmp_h.dentry = tmp->di_hdentry[tmp->di_bstart].hd_dentry;
+ if (tmp->di_btop >= 0) {
+ tmp_h.dentry = tmp->di_hdentry[tmp->di_btop].hd_dentry;
if (d_is_positive(tmp_h.dentry)) {
tmp_h.inode = d_inode(tmp_h.dentry);
tmp_h.mode = tmp_h.inode->i_mode & S_IFMT;
@@ -588,20 +588,20 @@ static int au_refresh_by_dinfo(struct dentry *dentry, struct au_dinfo *dinfo,
goto out;
}
AuDebugOn(inode);
- AuDebugOn(dinfo->di_bstart != dinfo->di_bend);
+ AuDebugOn(dinfo->di_btop != dinfo->di_bbot);
AuDebugOn(dinfo->di_bdiropq != -1);
if (!tmp_h.inode) {
AuDbg("negative --> negative\n");
/* should have only one negative lower */
- if (tmp->di_bstart >= 0
- && tmp->di_bstart < dinfo->di_bstart) {
- AuDebugOn(tmp->di_bstart != tmp->di_bend);
- AuDebugOn(dinfo->di_bstart != dinfo->di_bend);
- au_set_h_dptr(dentry, dinfo->di_bstart, NULL);
+ if (tmp->di_btop >= 0
+ && tmp->di_btop < dinfo->di_btop) {
+ AuDebugOn(tmp->di_btop != tmp->di_bbot);
+ AuDebugOn(dinfo->di_btop != dinfo->di_bbot);
+ au_set_h_dptr(dentry, dinfo->di_btop, NULL);
au_di_cp(dinfo, tmp);
- hd = tmp->di_hdentry + tmp->di_bstart;
- au_set_h_dptr(dentry, tmp->di_bstart,
+ hd = tmp->di_hdentry + tmp->di_btop;
+ au_set_h_dptr(dentry, tmp->di_btop,
dget(hd->hd_dentry));
}
au_dbg_verify_dinode(dentry);
@@ -626,7 +626,7 @@ static int au_refresh_by_dinfo(struct dentry *dentry, struct au_dinfo *dinfo,
AuDbg("positive --> negative\n");
/* or bypassing aufs */
au_hide(dentry);
- if (tmp->di_bwh >= 0 && tmp->di_bwh <= dinfo->di_bstart)
+ if (tmp->di_bwh >= 0 && tmp->di_bwh <= dinfo->di_btop)
dinfo->di_bwh = tmp->di_bwh;
if (inode)
err = au_refresh_hinode_self(inode);
@@ -634,7 +634,7 @@ static int au_refresh_by_dinfo(struct dentry *dentry, struct au_dinfo *dinfo,
} else if (orig_h.mode == tmp_h.mode) {
AuDbg("positive --> positive, same type\n");
if (!S_ISDIR(orig_h.mode)
- && dinfo->di_bstart > tmp->di_bstart) {
+ && dinfo->di_btop > tmp->di_btop) {
/*
* similar to the behaviour of removing and
* creating.
@@ -645,15 +645,15 @@ static int au_refresh_by_dinfo(struct dentry *dentry, struct au_dinfo *dinfo,
au_dbg_verify_dinode(dentry);
} else {
/* fill empty slots */
- if (dinfo->di_bstart > tmp->di_bstart)
- dinfo->di_bstart = tmp->di_bstart;
- if (dinfo->di_bend < tmp->di_bend)
- dinfo->di_bend = tmp->di_bend;
+ if (dinfo->di_btop > tmp->di_btop)
+ dinfo->di_btop = tmp->di_btop;
+ if (dinfo->di_bbot < tmp->di_bbot)
+ dinfo->di_bbot = tmp->di_bbot;
dinfo->di_bwh = tmp->di_bwh;
dinfo->di_bdiropq = tmp->di_bdiropq;
hd = tmp->di_hdentry;
- bend = dinfo->di_bend;
- for (bindex = tmp->di_bstart; bindex <= bend;
+ bbot = dinfo->di_bbot;
+ for (bindex = tmp->di_btop; bindex <= bbot;
bindex++) {
if (au_h_dptr(dentry, bindex))
continue;
@@ -726,7 +726,7 @@ int au_refresh_dentry(struct dentry *dentry, struct dentry *parent)
goto out;
dinfo = au_di(dentry);
- err = au_di_realloc(dinfo, au_sbend(sb) + 1);
+ err = au_di_realloc(dinfo, au_sbbot(sb) + 1);
if (unlikely(err))
goto out;
ebrange = au_dbrange_test(dentry);
@@ -734,7 +734,7 @@ int au_refresh_dentry(struct dentry *dentry, struct dentry *parent)
ebrange = au_do_refresh_hdentry(dentry, parent);
if (d_unhashed(dentry) || ebrange /* || dinfo->di_tmpfile */) {
- AuDebugOn(au_dbstart(dentry) < 0 && au_dbend(dentry) >= 0);
+ AuDebugOn(au_dbtop(dentry) < 0 && au_dbbot(dentry) >= 0);
if (d_really_is_positive(dentry)) {
inode = d_inode(dentry);
err = au_refresh_hinode_self(inode);
@@ -757,7 +757,7 @@ int au_refresh_dentry(struct dentry *dentry, struct dentry *parent)
* if current working dir is removed, it returns an error.
* but the dentry is legal.
*/
- err = au_lkup_dentry(dentry, /*bstart*/0, /*type*/0);
+ err = au_lkup_dentry(dentry, /*btop*/0, /*type*/0);
AuDbgDentry(dentry);
au_di_swap(tmp, dinfo);
if (err == -ENOENT)
@@ -820,7 +820,7 @@ static int h_d_revalidate(struct dentry *dentry, struct inode *inode,
{
int err;
umode_t mode, h_mode;
- aufs_bindex_t bindex, btail, bstart, ibs, ibe;
+ aufs_bindex_t bindex, btail, btop, ibs, ibe;
unsigned char plus, unhashed, is_root, h_plus, h_nfs, tmpfile;
struct inode *h_inode, *h_cached_inode;
struct dentry *h_dentry;
@@ -846,15 +846,15 @@ static int h_d_revalidate(struct dentry *dentry, struct inode *inode,
if (do_udba && inode) {
mode = (inode->i_mode & S_IFMT);
plus = (inode->i_nlink > 0);
- ibs = au_ibstart(inode);
- ibe = au_ibend(inode);
+ ibs = au_ibtop(inode);
+ ibe = au_ibbot(inode);
}
- bstart = au_dbstart(dentry);
- btail = bstart;
+ btop = au_dbtop(dentry);
+ btail = btop;
if (inode && S_ISDIR(inode->i_mode))
btail = au_dbtaildir(dentry);
- for (bindex = bstart; bindex <= btail; bindex++) {
+ for (bindex = btop; bindex <= btail; bindex++) {
h_dentry = au_h_dptr(dentry, bindex);
if (!h_dentry)
continue;
@@ -1069,11 +1069,11 @@ static int aufs_d_revalidate(struct dentry *dentry, unsigned int flags)
do_udba = !au_opt_test(au_mntflags(sb), UDBA_NONE);
if (do_udba && inode) {
- aufs_bindex_t bstart = au_ibstart(inode);
+ aufs_bindex_t btop = au_ibtop(inode);
struct inode *h_inode;
- if (bstart >= 0) {
- h_inode = au_h_iptr(inode, bstart);
+ if (btop >= 0) {
+ h_inode = au_h_iptr(inode, btop);
if (h_inode && au_test_higen(inode, h_inode)) {
AuTraceErr(err);
goto out_inval;
@@ -1082,7 +1082,7 @@ static int aufs_d_revalidate(struct dentry *dentry, unsigned int flags)
}
err = h_d_revalidate(dentry, inode, flags, do_udba);
- if (unlikely(!err && do_udba && au_dbstart(dentry) < 0)) {
+ if (unlikely(!err && do_udba && au_dbtop(dentry) < 0)) {
err = -EIO;
AuDbg("both of real entry and whiteout found, %p, err %d\n",
dentry, err);
diff --git a/fs/aufs/dentry.h b/fs/aufs/dentry.h
index c794adf59..3e48b5cde 100644
--- a/fs/aufs/dentry.h
+++ b/fs/aufs/dentry.h
@@ -23,7 +23,7 @@ struct au_dinfo {
atomic_t di_generation;
struct au_rwsem di_rwsem;
- aufs_bindex_t di_bstart, di_bend, di_bwh, di_bdiropq;
+ aufs_bindex_t di_btop, di_bbot, di_bwh, di_bdiropq;
unsigned char di_tmpfile; /* to allow the different name */
struct au_hdentry *di_hdentry;
} ____cacheline_aligned_in_smp;
@@ -37,7 +37,7 @@ struct dentry *au_sio_lkup_one(struct qstr *name, struct dentry *parent);
int au_h_verify(struct dentry *h_dentry, unsigned int udba, struct inode *h_dir,
struct dentry *h_parent, struct au_branch *br);
-int au_lkup_dentry(struct dentry *dentry, aufs_bindex_t bstart, mode_t type);
+int au_lkup_dentry(struct dentry *dentry, aufs_bindex_t btop, mode_t type);
int au_lkup_neg(struct dentry *dentry, aufs_bindex_t bindex, int wh);
int au_refresh_dentry(struct dentry *dentry, struct dentry *parent);
int au_reval_dpath(struct dentry *dentry, unsigned int sigen);
@@ -73,8 +73,8 @@ int au_digen_test(struct dentry *dentry, unsigned int sigen);
int au_dbrange_test(struct dentry *dentry);
void au_update_digen(struct dentry *dentry);
void au_update_dbrange(struct dentry *dentry, int do_put_zero);
-void au_update_dbstart(struct dentry *dentry);
-void au_update_dbend(struct dentry *dentry);
+void au_update_dbtop(struct dentry *dentry);
+void au_update_dbbot(struct dentry *dentry);
int au_find_dbindex(struct dentry *dentry, struct dentry *h_dentry);
/* ---------------------------------------------------------------------- */
@@ -151,16 +151,16 @@ static inline void au_hdput(struct au_hdentry *hd)
dput(hd->hd_dentry);
}
-static inline aufs_bindex_t au_dbstart(struct dentry *dentry)
+static inline aufs_bindex_t au_dbtop(struct dentry *dentry)
{
DiMustAnyLock(dentry);
- return au_di(dentry)->di_bstart;
+ return au_di(dentry)->di_btop;
}
-static inline aufs_bindex_t au_dbend(struct dentry *dentry)
+static inline aufs_bindex_t au_dbbot(struct dentry *dentry)
{
DiMustAnyLock(dentry);
- return au_di(dentry)->di_bend;
+ return au_di(dentry)->di_bbot;
}
static inline aufs_bindex_t au_dbwh(struct dentry *dentry)
@@ -176,22 +176,22 @@ static inline aufs_bindex_t au_dbdiropq(struct dentry *dentry)
}
/* todo: hard/soft set? */
-static inline void au_set_dbstart(struct dentry *dentry, aufs_bindex_t bindex)
+static inline void au_set_dbtop(struct dentry *dentry, aufs_bindex_t bindex)
{
DiMustWriteLock(dentry);
- au_di(dentry)->di_bstart = bindex;
+ au_di(dentry)->di_btop = bindex;
}
-static inline void au_set_dbend(struct dentry *dentry, aufs_bindex_t bindex)
+static inline void au_set_dbbot(struct dentry *dentry, aufs_bindex_t bindex)
{
DiMustWriteLock(dentry);
- au_di(dentry)->di_bend = bindex;
+ au_di(dentry)->di_bbot = bindex;
}
static inline void au_set_dbwh(struct dentry *dentry, aufs_bindex_t bindex)
{
DiMustWriteLock(dentry);
- /* dbwh can be outside of bstart - bend range */
+ /* dbwh can be outside of btop - bbot range */
au_di(dentry)->di_bwh = bindex;
}
diff --git a/fs/aufs/dinfo.c b/fs/aufs/dinfo.c
index ad6d045c4..b2eb8c2de 100644
--- a/fs/aufs/dinfo.c
+++ b/fs/aufs/dinfo.c
@@ -11,10 +11,8 @@
void au_di_init_once(void *_dinfo)
{
struct au_dinfo *dinfo = _dinfo;
- static struct lock_class_key aufs_di;
au_rw_init(&dinfo->di_rwsem);
- au_rw_class(&dinfo->di_rwsem, &aufs_di);
}
struct au_dinfo *au_di_alloc(struct super_block *sb, unsigned int lsc)
@@ -26,14 +24,14 @@ struct au_dinfo *au_di_alloc(struct super_block *sb, unsigned int lsc)
if (unlikely(!dinfo))
goto out;
- nbr = au_sbend(sb) + 1;
+ nbr = au_sbbot(sb) + 1;
if (nbr <= 0)
nbr = 1;
dinfo->di_hdentry = kcalloc(nbr, sizeof(*dinfo->di_hdentry), GFP_NOFS);
if (dinfo->di_hdentry) {
au_rw_write_lock_nested(&dinfo->di_rwsem, lsc);
- dinfo->di_bstart = -1;
- dinfo->di_bend = -1;
+ dinfo->di_btop = -1;
+ dinfo->di_bbot = -1;
dinfo->di_bwh = -1;
dinfo->di_bdiropq = -1;
dinfo->di_tmpfile = 0;
@@ -52,14 +50,14 @@ out:
void au_di_free(struct au_dinfo *dinfo)
{
struct au_hdentry *p;
- aufs_bindex_t bend, bindex;
+ aufs_bindex_t bbot, bindex;
/* dentry may not be revalidated */
- bindex = dinfo->di_bstart;
+ bindex = dinfo->di_btop;
if (bindex >= 0) {
- bend = dinfo->di_bend;
+ bbot = dinfo->di_bbot;
p = dinfo->di_hdentry + bindex;
- while (bindex++ <= bend)
+ while (bindex++ <= bbot)
au_hdput(p++);
}
kfree(dinfo->di_hdentry);
@@ -82,8 +80,8 @@ void au_di_swap(struct au_dinfo *a, struct au_dinfo *b)
} while (0)
DiSwap(p, hdentry);
- DiSwap(bi, bstart);
- DiSwap(bi, bend);
+ DiSwap(bi, btop);
+ DiSwap(bi, bbot);
DiSwap(bi, bwh);
DiSwap(bi, bdiropq);
/* smp_mb(); */
@@ -96,8 +94,8 @@ 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_btop = src->di_btop;
+ dst->di_bbot = src->di_bbot;
dst->di_bwh = src->di_bwh;
dst->di_bdiropq = src->di_bdiropq;
/* smp_mb(); */
@@ -139,7 +137,7 @@ int au_di_realloc(struct au_dinfo *dinfo, int nbr)
AuRwMustWriteLock(&dinfo->di_rwsem);
err = -ENOMEM;
- sz = sizeof(*hdp) * (dinfo->di_bend + 1);
+ sz = sizeof(*hdp) * (dinfo->di_bbot + 1);
if (!sz)
sz = sizeof(*hdp);
hdp = au_kzrealloc(dinfo->di_hdentry, sz, sizeof(*hdp) * nbr, GFP_NOFS);
@@ -307,7 +305,7 @@ struct dentry *au_h_dptr(struct dentry *dentry, aufs_bindex_t bindex)
DiMustAnyLock(dentry);
- if (au_dbstart(dentry) < 0 || bindex < au_dbstart(dentry))
+ if (au_dbtop(dentry) < 0 || bindex < au_dbtop(dentry))
return NULL;
AuDebugOn(bindex < 0);
d = au_di(dentry)->di_hdentry[0 + bindex].hd_dentry;
@@ -328,8 +326,8 @@ struct dentry *au_h_d_alias(struct dentry *dentry, aufs_bindex_t bindex)
AuDebugOn(d_really_is_negative(dentry));
h_dentry = NULL;
- if (au_dbstart(dentry) <= bindex
- && bindex <= au_dbend(dentry))
+ if (au_dbtop(dentry) <= bindex
+ && bindex <= au_dbbot(dentry))
h_dentry = au_h_dptr(dentry, bindex);
if (h_dentry && !au_d_linkable(h_dentry)) {
dget(h_dentry);
@@ -337,8 +335,8 @@ struct dentry *au_h_d_alias(struct dentry *dentry, aufs_bindex_t bindex)
}
inode = d_inode(dentry);
- AuDebugOn(bindex < au_ibstart(inode));
- AuDebugOn(au_ibend(inode) < bindex);
+ AuDebugOn(bindex < au_ibtop(inode));
+ AuDebugOn(au_ibbot(inode) < bindex);
h_inode = au_h_iptr(inode, bindex);
h_dentry = d_find_alias(h_inode);
if (h_dentry) {
@@ -368,30 +366,30 @@ out:
aufs_bindex_t au_dbtail(struct dentry *dentry)
{
- aufs_bindex_t bend, bwh;
+ aufs_bindex_t bbot, bwh;
- bend = au_dbend(dentry);
- if (0 <= bend) {
+ bbot = au_dbbot(dentry);
+ if (0 <= bbot) {
bwh = au_dbwh(dentry);
if (!bwh)
return bwh;
- if (0 < bwh && bwh < bend)
+ if (0 < bwh && bwh < bbot)
return bwh - 1;
}
- return bend;
+ return bbot;
}
aufs_bindex_t au_dbtaildir(struct dentry *dentry)
{
- aufs_bindex_t bend, bopq;
+ aufs_bindex_t bbot, bopq;
- bend = au_dbtail(dentry);
- if (0 <= bend) {
+ bbot = au_dbtail(dentry);
+ if (0 <= bbot) {
bopq = au_dbdiropq(dentry);
- if (0 <= bopq && bopq < bend)
- bend = bopq;
+ if (0 <= bopq && bopq < bbot)
+ bbot = bopq;
}
- return bend;
+ return bbot;
}
/* ---------------------------------------------------------------------- */
@@ -415,16 +413,16 @@ void au_set_h_dptr(struct dentry *dentry, aufs_bindex_t bindex,
int au_dbrange_test(struct dentry *dentry)
{
int err;
- aufs_bindex_t bstart, bend;
+ aufs_bindex_t btop, bbot;
err = 0;
- bstart = au_dbstart(dentry);
- bend = au_dbend(dentry);
- if (bstart >= 0)
- AuDebugOn(bend < 0 && bstart > bend);
+ btop = au_dbtop(dentry);
+ bbot = au_dbbot(dentry);
+ if (btop >= 0)
+ AuDebugOn(bbot < 0 && btop > bbot);
else {
err = -EIO;
- AuDebugOn(bend >= 0);
+ AuDebugOn(bbot >= 0);
}
return err;
@@ -457,68 +455,68 @@ void au_update_dbrange(struct dentry *dentry, int do_put_zero)
DiMustWriteLock(dentry);
dinfo = au_di(dentry);
- if (!dinfo || dinfo->di_bstart < 0)
+ if (!dinfo || dinfo->di_btop < 0)
return;
hdp = dinfo->di_hdentry;
if (do_put_zero) {
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
- bend = dinfo->di_bend;
- for (bindex = dinfo->di_bstart; bindex <= bend; bindex++) {
+ bbot = dinfo->di_bbot;
+ for (bindex = dinfo->di_btop; bindex <= bbot; bindex++) {
h_d = hdp[0 + bindex].hd_dentry;
if (h_d && d_is_negative(h_d))
au_set_h_dptr(dentry, bindex, NULL);
}
}
- dinfo->di_bstart = -1;
- while (++dinfo->di_bstart <= dinfo->di_bend)
- if (hdp[0 + dinfo->di_bstart].hd_dentry)
+ dinfo->di_btop = -1;
+ while (++dinfo->di_btop <= dinfo->di_bbot)
+ if (hdp[0 + dinfo->di_btop].hd_dentry)
break;
- if (dinfo->di_bstart > dinfo->di_bend) {
- dinfo->di_bstart = -1;
- dinfo->di_bend = -1;
+ if (dinfo->di_btop > dinfo->di_bbot) {
+ dinfo->di_btop = -1;
+ dinfo->di_bbot = -1;
return;
}
- dinfo->di_bend++;
- while (0 <= --dinfo->di_bend)
- if (hdp[0 + dinfo->di_bend].hd_dentry)
+ dinfo->di_bbot++;
+ while (0 <= --dinfo->di_bbot)
+ if (hdp[0 + dinfo->di_bbot].hd_dentry)
break;
- AuDebugOn(dinfo->di_bstart > dinfo->di_bend || dinfo->di_bend < 0);
+ AuDebugOn(dinfo->di_btop > dinfo->di_bbot || dinfo->di_bbot < 0);
}
-void au_update_dbstart(struct dentry *dentry)
+void au_update_dbtop(struct dentry *dentry)
{
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
struct dentry *h_dentry;
- bend = au_dbend(dentry);
- for (bindex = au_dbstart(dentry); bindex <= bend; bindex++) {
+ bbot = au_dbbot(dentry);
+ for (bindex = au_dbtop(dentry); bindex <= bbot; bindex++) {
h_dentry = au_h_dptr(dentry, bindex);
if (!h_dentry)
continue;
if (d_is_positive(h_dentry)) {
- au_set_dbstart(dentry, bindex);
+ au_set_dbtop(dentry, bindex);
return;
}
au_set_h_dptr(dentry, bindex, NULL);
}
}
-void au_update_dbend(struct dentry *dentry)
+void au_update_dbbot(struct dentry *dentry)
{
- aufs_bindex_t bindex, bstart;
+ aufs_bindex_t bindex, btop;
struct dentry *h_dentry;
- bstart = au_dbstart(dentry);
- for (bindex = au_dbend(dentry); bindex >= bstart; bindex--) {
+ btop = au_dbtop(dentry);
+ for (bindex = au_dbbot(dentry); bindex >= btop; bindex--) {
h_dentry = au_h_dptr(dentry, bindex);
if (!h_dentry)
continue;
if (d_is_positive(h_dentry)) {
- au_set_dbend(dentry, bindex);
+ au_set_dbbot(dentry, bindex);
return;
}
au_set_h_dptr(dentry, bindex, NULL);
@@ -527,10 +525,10 @@ void au_update_dbend(struct dentry *dentry)
int au_find_dbindex(struct dentry *dentry, struct dentry *h_dentry)
{
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
- bend = au_dbend(dentry);
- for (bindex = au_dbstart(dentry); bindex <= bend; bindex++)
+ bbot = au_dbbot(dentry);
+ for (bindex = au_dbtop(dentry); bindex <= bbot; bindex++)
if (au_h_dptr(dentry, bindex) == h_dentry)
return bindex;
return -1;
diff --git a/fs/aufs/dir.c b/fs/aufs/dir.c
index 4644de4a9..4dc666eb4 100644
--- a/fs/aufs/dir.c
+++ b/fs/aufs/dir.c
@@ -42,7 +42,7 @@ void au_sub_nlink(struct inode *dir, struct inode *h_dir)
loff_t au_dir_size(struct file *file, struct dentry *dentry)
{
loff_t sz;
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
struct file *h_file;
struct dentry *h_dentry;
@@ -50,9 +50,9 @@ loff_t au_dir_size(struct file *file, struct dentry *dentry)
if (file) {
AuDebugOn(!d_is_dir(file->f_path.dentry));
- bend = au_fbend_dir(file);
- for (bindex = au_fbstart(file);
- bindex <= bend && sz < KMALLOC_MAX_SIZE;
+ bbot = au_fbbot_dir(file);
+ for (bindex = au_fbtop(file);
+ bindex <= bbot && sz < KMALLOC_MAX_SIZE;
bindex++) {
h_file = au_hf_dir(file, bindex);
if (h_file && file_inode(h_file))
@@ -62,9 +62,9 @@ loff_t au_dir_size(struct file *file, struct dentry *dentry)
AuDebugOn(!dentry);
AuDebugOn(!d_is_dir(dentry));
- bend = au_dbtaildir(dentry);
- for (bindex = au_dbstart(dentry);
- bindex <= bend && sz < KMALLOC_MAX_SIZE;
+ bbot = au_dbtaildir(dentry);
+ for (bindex = au_dbtop(dentry);
+ bindex <= bbot && sz < KMALLOC_MAX_SIZE;
bindex++) {
h_dentry = au_h_dptr(dentry, bindex);
if (h_dentry && d_is_positive(h_dentry))
@@ -97,7 +97,7 @@ static void au_do_dir_ts(void *arg)
struct au_branch *br;
struct au_hinode *hdir;
int err;
- aufs_bindex_t bstart, bindex;
+ aufs_bindex_t btop, bindex;
sb = a->dentry->d_sb;
if (d_really_is_negative(a->dentry))
@@ -106,9 +106,9 @@ static void au_do_dir_ts(void *arg)
aufs_read_lock(a->dentry, AuLock_DW); /* noflush */
dir = d_inode(a->dentry);
- bstart = au_ibstart(dir);
+ btop = au_ibtop(dir);
bindex = au_br_index(sb, a->brid);
- if (bindex < bstart)
+ if (bindex < btop)
goto out_unlock;
br = au_sbr(sb, bindex);
@@ -118,17 +118,17 @@ static void au_do_dir_ts(void *arg)
h_path.mnt = au_br_mnt(br);
au_dtime_store(&dt, a->dentry, &h_path);
- br = au_sbr(sb, bstart);
+ br = au_sbr(sb, btop);
if (!au_br_writable(br->br_perm))
goto out_unlock;
- h_path.dentry = au_h_dptr(a->dentry, bstart);
+ h_path.dentry = au_h_dptr(a->dentry, btop);
h_path.mnt = au_br_mnt(br);
err = vfsub_mnt_want_write(h_path.mnt);
if (err)
goto out_unlock;
- hdir = au_hi(dir, bstart);
+ hdir = au_hi(dir, btop);
au_hn_imtx_lock_nested(hdir, AuLsc_I_PARENT);
- h_dir = au_h_iptr(dir, bstart);
+ h_dir = au_h_iptr(dir, btop);
if (h_dir->i_nlink
&& timespec_compare(&h_dir->i_mtime, &dt.dt_mtime) < 0) {
dt.dt_h_path = h_path;
@@ -149,7 +149,7 @@ out:
void au_dir_ts(struct inode *dir, aufs_bindex_t bindex)
{
int perm, wkq_err;
- aufs_bindex_t bstart;
+ aufs_bindex_t btop;
struct au_dir_ts_arg *arg;
struct dentry *dentry;
struct super_block *sb;
@@ -159,13 +159,13 @@ void au_dir_ts(struct inode *dir, aufs_bindex_t bindex)
dentry = d_find_any_alias(dir);
AuDebugOn(!dentry);
sb = dentry->d_sb;
- bstart = au_ibstart(dir);
- if (bstart == bindex) {
+ btop = au_ibtop(dir);
+ if (btop == bindex) {
au_cpup_attr_timesizes(dir);
goto out;
}
- perm = au_sbr_perm(sb, bstart);
+ perm = au_sbr_perm(sb, btop);
if (!au_br_writable(perm))
goto out;
@@ -192,24 +192,24 @@ static int reopen_dir(struct file *file)
{
int err;
unsigned int flags;
- aufs_bindex_t bindex, btail, bstart;
+ aufs_bindex_t bindex, btail, btop;
struct dentry *dentry, *h_dentry;
struct file *h_file;
/* open all lower dirs */
dentry = file->f_path.dentry;
- bstart = au_dbstart(dentry);
- for (bindex = au_fbstart(file); bindex < bstart; bindex++)
+ btop = au_dbtop(dentry);
+ for (bindex = au_fbtop(file); bindex < btop; bindex++)
au_set_h_fptr(file, bindex, NULL);
- au_set_fbstart(file, bstart);
+ au_set_fbtop(file, btop);
btail = au_dbtaildir(dentry);
- for (bindex = au_fbend_dir(file); btail < bindex; bindex--)
+ for (bindex = au_fbbot_dir(file); btail < bindex; bindex--)
au_set_h_fptr(file, bindex, NULL);
- au_set_fbend_dir(file, btail);
+ au_set_fbbot_dir(file, btail);
flags = vfsub_file_flags(file);
- for (bindex = bstart; bindex <= btail; bindex++) {
+ for (bindex = btop; bindex <= btail; bindex++) {
h_dentry = au_h_dptr(dentry, bindex);
if (!h_dentry)
continue;
@@ -246,10 +246,10 @@ static int do_open_dir(struct file *file, int flags, struct file *h_file)
mnt = file->f_path.mnt;
dentry = file->f_path.dentry;
file->f_version = d_inode(dentry)->i_version;
- bindex = au_dbstart(dentry);
- au_set_fbstart(file, bindex);
+ bindex = au_dbtop(dentry);
+ au_set_fbtop(file, bindex);
btail = au_dbtaildir(dentry);
- au_set_fbend_dir(file, btail);
+ au_set_fbbot_dir(file, btail);
for (; !err && bindex <= btail; bindex++) {
h_dentry = au_h_dptr(dentry, bindex);
if (!h_dentry)
@@ -272,10 +272,10 @@ static int do_open_dir(struct file *file, int flags, struct file *h_file)
return 0; /* success */
/* close all */
- for (bindex = au_fbstart(file); bindex <= btail; bindex++)
+ for (bindex = au_fbtop(file); bindex <= btail; bindex++)
au_set_h_fptr(file, bindex, NULL);
- au_set_fbstart(file, -1);
- au_set_fbend_dir(file, -1);
+ au_set_fbtop(file, -1);
+ au_set_fbbot_dir(file, -1);
return err;
}
@@ -310,7 +310,7 @@ static int aufs_release_dir(struct inode *inode __maybe_unused,
struct au_vdir *vdir_cache;
struct au_finfo *finfo;
struct au_fidir *fidir;
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
finfo = au_fi(file);
fidir = finfo->fi_hdir;
@@ -327,8 +327,8 @@ static int aufs_release_dir(struct inode *inode __maybe_unused,
* calls fput() instead of filp_close(),
* since no dnotify or lock for the lower file.
*/
- bend = fidir->fd_bbot;
- for (; bindex <= bend; bindex++)
+ bbot = fidir->fd_bbot;
+ for (; bindex <= bbot; bindex++)
au_set_h_fptr(file, bindex, NULL);
}
kfree(fidir);
@@ -343,12 +343,12 @@ static int aufs_release_dir(struct inode *inode __maybe_unused,
static int au_do_flush_dir(struct file *file, fl_owner_t id)
{
int err;
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
struct file *h_file;
err = 0;
- bend = au_fbend_dir(file);
- for (bindex = au_fbstart(file); !err && bindex <= bend; bindex++) {
+ bbot = au_fbbot_dir(file);
+ for (bindex = au_fbtop(file); !err && bindex <= bbot; bindex++) {
h_file = au_hf_dir(file, bindex);
if (h_file)
err = vfsub_flush(h_file, id);
@@ -366,7 +366,7 @@ static int aufs_flush_dir(struct file *file, fl_owner_t id)
static int au_do_fsync_dir_no_file(struct dentry *dentry, int datasync)
{
int err;
- aufs_bindex_t bend, bindex;
+ aufs_bindex_t bbot, bindex;
struct inode *inode;
struct super_block *sb;
@@ -374,8 +374,8 @@ static int au_do_fsync_dir_no_file(struct dentry *dentry, int datasync)
sb = dentry->d_sb;
inode = d_inode(dentry);
IMustLock(inode);
- bend = au_dbend(dentry);
- for (bindex = au_dbstart(dentry); !err && bindex <= bend; bindex++) {
+ bbot = au_dbbot(dentry);
+ for (bindex = au_dbtop(dentry); !err && bindex <= bbot; bindex++) {
struct path h_path;
if (au_test_ro(sb, bindex, inode))
@@ -394,7 +394,7 @@ static int au_do_fsync_dir_no_file(struct dentry *dentry, int datasync)
static int au_do_fsync_dir(struct file *file, int datasync)
{
int err;
- aufs_bindex_t bend, bindex;
+ aufs_bindex_t bbot, bindex;
struct file *h_file;
struct super_block *sb;
struct inode *inode;
@@ -405,8 +405,8 @@ static int au_do_fsync_dir(struct file *file, int datasync)
inode = file_inode(file);
sb = inode->i_sb;
- bend = au_fbend_dir(file);
- for (bindex = au_fbstart(file); !err && bindex <= bend; bindex++) {
+ bbot = au_fbbot_dir(file);
+ for (bindex = au_fbtop(file); !err && bindex <= bbot; bindex++) {
h_file = au_hf_dir(file, bindex);
if (!h_file || au_test_ro(sb, bindex, inode))
continue;
@@ -478,7 +478,7 @@ static int aufs_iterate(struct file *file, struct dir_context *ctx)
if (unlikely(err))
goto out_unlock;
- h_inode = au_h_iptr(inode, au_ibstart(inode));
+ h_inode = au_h_iptr(inode, au_ibtop(inode));
if (!au_test_nfsd()) {
err = au_vdir_fill_de(file, ctx);
fsstack_copy_attr_atime(inode, h_inode);
@@ -647,7 +647,7 @@ int au_test_empty_lower(struct dentry *dentry)
{
int err;
unsigned int rdhash;
- aufs_bindex_t bindex, bstart, btail;
+ aufs_bindex_t bindex, btop, btail;
struct au_nhash whlist;
struct test_empty_arg arg = {
.ctx = {
@@ -667,20 +667,20 @@ int au_test_empty_lower(struct dentry *dentry)
arg.flags = 0;
arg.whlist = &whlist;
- bstart = au_dbstart(dentry);
+ btop = au_dbtop(dentry);
if (au_opt_test(au_mntflags(dentry->d_sb), SHWH))
au_fset_testempty(arg.flags, SHWH);
test_empty = do_test_empty;
if (au_opt_test(au_mntflags(dentry->d_sb), DIRPERM1))
test_empty = sio_test_empty;
- arg.bindex = bstart;
+ arg.bindex = btop;
err = test_empty(dentry, &arg);
if (unlikely(err))
goto out_whlist;
au_fset_testempty(arg.flags, WHONLY);
btail = au_dbtaildir(dentry);
- for (bindex = bstart + 1; !err && bindex <= btail; bindex++) {
+ for (bindex = btop + 1; !err && bindex <= btail; bindex++) {
struct dentry *h_dentry;
h_dentry = au_h_dptr(dentry, bindex);
@@ -712,7 +712,7 @@ int au_test_empty(struct dentry *dentry, struct au_nhash *whlist)
if (au_opt_test(au_mntflags(dentry->d_sb), SHWH))
au_fset_testempty(arg.flags, SHWH);
btail = au_dbtaildir(dentry);
- for (bindex = au_dbstart(dentry); !err && bindex <= btail; bindex++) {
+ for (bindex = au_dbtop(dentry); !err && bindex <= btail; bindex++) {
struct dentry *h_dentry;
h_dentry = au_h_dptr(dentry, bindex);
diff --git a/fs/aufs/dynop.c b/fs/aufs/dynop.c
index 53a8b55d8..dfb3a718d 100644
--- a/fs/aufs/dynop.c
+++ b/fs/aufs/dynop.c
@@ -308,14 +308,14 @@ out:
int au_dy_irefresh(struct inode *inode)
{
int err;
- aufs_bindex_t bstart;
+ aufs_bindex_t btop;
struct inode *h_inode;
err = 0;
if (S_ISREG(inode->i_mode)) {
- bstart = au_ibstart(inode);
- h_inode = au_h_iptr(inode, bstart);
- err = au_dy_iaop(inode, bstart, h_inode);
+ btop = au_ibtop(inode);
+ h_inode = au_h_iptr(inode, btop);
+ err = au_dy_iaop(inode, btop, h_inode);
}
return err;
}
diff --git a/fs/aufs/export.c b/fs/aufs/export.c
index 69b70f2a1..8755b1ef0 100644
--- a/fs/aufs/export.c
+++ b/fs/aufs/export.c
@@ -500,9 +500,11 @@ struct dentry *decode_by_path(struct super_block *sb, ino_t ino, __u32 *fh,
h_mnt = au_br_mnt(br);
h_sb = h_mnt->mnt_sb;
/* todo: call lower fh_to_dentry()? fh_to_parent()? */
+ lockdep_off();
h_parent = exportfs_decode_fh(h_mnt, (void *)(fh + Fh_tail),
fh_len - Fh_tail, fh[Fh_h_type],
h_acceptable, /*context*/NULL);
+ lockdep_on();
dentry = h_parent;
if (unlikely(!h_parent || IS_ERR(h_parent))) {
AuWarn1("%s decode_fh failed, %ld\n",
@@ -606,7 +608,7 @@ aufs_fh_to_dentry(struct super_block *sb, struct fid *fid, int fh_len,
/* is the parent dir cached? */
br = au_sbr(sb, nsi_lock.bindex);
- atomic_inc(&br->br_count);
+ au_br_get(br);
dentry = decode_by_dir_ino(sb, ino, dir_ino, &nsi_lock);
if (IS_ERR(dentry))
goto out_unlock;
@@ -630,7 +632,7 @@ accept:
dentry = ERR_PTR(-ESTALE);
out_unlock:
if (br)
- atomic_dec(&br->br_count);
+ au_br_put(br);
si_read_unlock(sb);
out:
AuTraceErrPtr(dentry);
@@ -697,7 +699,7 @@ static int aufs_encode_fh(struct inode *inode, __u32 *fh, int *max_len,
err = -EIO;
parent = NULL;
ii_read_lock_child(inode);
- bindex = au_ibstart(inode);
+ bindex = au_ibtop(inode);
if (!dir) {
dentry = d_find_any_alias(inode);
if (unlikely(!dentry))
@@ -772,7 +774,7 @@ static int aufs_commit_metadata(struct inode *inode)
sb = inode->i_sb;
si_read_lock(sb, AuLock_FLUSH | AuLock_NOPLMW);
ii_write_lock_child(inode);
- bindex = au_ibstart(inode);
+ bindex = au_ibtop(inode);
AuDebugOn(bindex < 0);
h_inode = au_h_iptr(inode, bindex);
@@ -808,6 +810,11 @@ void au_export_init(struct super_block *sb)
struct au_sbinfo *sbinfo;
__u32 u;
+ BUILD_BUG_ON_MSG(IS_BUILTIN(CONFIG_AUFS_FS)
+ && IS_MODULE(CONFIG_EXPORTFS),
+ AUFS_NAME ": unsupported configuration "
+ "CONFIG_EXPORTFS=m and CONFIG_AUFS_FS=y");
+
sb->s_export_op = &aufs_export_op;
sbinfo = au_sbi(sb);
sbinfo->si_xigen = NULL;
diff --git a/fs/aufs/f_op.c b/fs/aufs/f_op.c
index ac1304a18..b0b0fff5f 100644
--- a/fs/aufs/f_op.c
+++ b/fs/aufs/f_op.c
@@ -28,7 +28,7 @@ int au_do_open_nondir(struct file *file, int flags, struct file *h_file)
finfo = au_fi(file);
memset(&finfo->fi_htop, 0, sizeof(finfo->fi_htop));
atomic_set(&finfo->fi_mmapped, 0);
- bindex = au_dbstart(dentry);
+ bindex = au_dbtop(dentry);
if (!h_file) {
h_dentry = au_h_dptr(dentry, bindex);
err = vfsub_test_mntns(file->f_path.mnt, h_dentry->d_sb);
@@ -52,7 +52,7 @@ int au_do_open_nondir(struct file *file, int flags, struct file *h_file)
h_inode->i_state |= I_LINKABLE;
spin_unlock(&h_inode->i_lock);
}
- au_set_fbstart(file, bindex);
+ au_set_fbtop(file, bindex);
au_set_h_fptr(file, bindex, h_file);
au_update_figen(file);
/* todo: necessary? */
@@ -154,7 +154,7 @@ static void au_read_post(struct inode *inode, struct file *h_file)
struct au_write_pre {
blkcnt_t blks;
- aufs_bindex_t bstart;
+ aufs_bindex_t btop;
};
/*
@@ -187,7 +187,7 @@ static struct file *au_write_pre(struct file *file, int do_ready,
di_downgrade_lock(dentry, /*flags*/0);
if (wpre)
- wpre->bstart = au_fbstart(file);
+ wpre->btop = au_fbtop(file);
h_file = au_hf_top(file);
get_file(h_file);
if (wpre)
@@ -208,7 +208,7 @@ static void au_write_post(struct inode *inode, struct file *h_file,
struct inode *h_inode;
au_cpup_attr_timesizes(inode);
- AuDebugOn(au_ibstart(inode) != wpre->bstart);
+ AuDebugOn(au_ibtop(inode) != wpre->btop);
h_inode = file_inode(h_file);
inode->i_mode = h_inode->i_mode;
ii_write_unlock(inode);
@@ -216,7 +216,7 @@ static void au_write_post(struct inode *inode, struct file *h_file,
/* AuDbg("blks %llu, %llu\n", (u64)blks, (u64)h_inode->i_blocks); */
if (written > 0)
- au_fhsm_wrote(inode->i_sb, wpre->bstart,
+ au_fhsm_wrote(inode->i_sb, wpre->btop,
/*force*/h_inode->i_blocks > wpre->blks);
}
diff --git a/fs/aufs/fhsm.c b/fs/aufs/fhsm.c
index db079d6ee..e3cb6ed95 100644
--- a/fs/aufs/fhsm.c
+++ b/fs/aufs/fhsm.c
@@ -141,12 +141,12 @@ void au_fhsm_wrote(struct super_block *sb, aufs_bindex_t bindex, int force)
void au_fhsm_wrote_all(struct super_block *sb, int force)
{
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
struct au_branch *br;
/* exclude the bottom */
- bend = au_fhsm_bottom(sb);
- for (bindex = 0; bindex < bend; bindex++) {
+ bbot = au_fhsm_bottom(sb);
+ for (bindex = 0; bindex < bbot; bindex++) {
br = au_sbr(sb, bindex);
if (au_br_fhsm(br->br_perm))
au_fhsm_wrote(sb, bindex, force);
@@ -192,15 +192,15 @@ static ssize_t au_fhsm_do_read(struct super_block *sb,
{
ssize_t err;
int nstbr;
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
struct au_branch *br;
struct au_br_fhsm *bf;
/* except the bottom branch */
err = 0;
nstbr = 0;
- bend = au_fhsm_bottom(sb);
- for (bindex = 0; !err && bindex < bend; bindex++) {
+ bbot = au_fhsm_bottom(sb);
+ for (bindex = 0; !err && bindex < bbot; bindex++) {
br = au_sbr(sb, bindex);
if (!au_br_fhsm(br->br_perm))
continue;
@@ -231,7 +231,7 @@ static ssize_t au_fhsm_read(struct file *file, char __user *buf, size_t count,
{
ssize_t err;
int readable;
- aufs_bindex_t nfhsm, bindex, bend;
+ aufs_bindex_t nfhsm, bindex, bbot;
struct au_sbinfo *sbinfo;
struct au_fhsm *fhsm;
struct au_branch *br;
@@ -262,8 +262,8 @@ need_data:
AuDebugOn(!sb);
/* exclude the bottom branch */
nfhsm = 0;
- bend = au_fhsm_bottom(sb);
- for (bindex = 0; bindex < bend; bindex++) {
+ bbot = au_fhsm_bottom(sb);
+ for (bindex = 0; bindex < bbot; bindex++) {
br = au_sbr(sb, bindex);
if (au_br_fhsm(br->br_perm))
nfhsm++;
diff --git a/fs/aufs/file.c b/fs/aufs/file.c
index 6b8a66b4a..27c5bf825 100644
--- a/fs/aufs/file.c
+++ b/fs/aufs/file.c
@@ -69,7 +69,7 @@ struct file *au_h_open(struct dentry *dentry, aufs_bindex_t bindex, int flags,
}
}
flags &= ~O_CREAT;
- atomic_inc(&br->br_count);
+ au_br_get(br);
h_path.dentry = h_dentry;
h_path.mnt = au_br_mnt(br);
h_file = vfsub_dentry_open(&h_path, flags);
@@ -88,7 +88,7 @@ struct file *au_h_open(struct dentry *dentry, aufs_bindex_t bindex, int flags,
goto out; /* success */
out_br:
- atomic_dec(&br->br_count);
+ au_br_put(br);
out:
return h_file;
}
@@ -122,7 +122,7 @@ static int au_cmoo(struct dentry *dentry)
err = 0;
if (IS_ROOT(dentry))
goto out;
- cpg.bsrc = au_dbstart(dentry);
+ cpg.bsrc = au_dbtop(dentry);
if (!cpg.bsrc)
goto out;
@@ -237,7 +237,7 @@ int au_do_open(struct file *file, struct au_do_open_args *args)
if (!err)
err = args->open(file, vfsub_file_flags(file),
args->h_file);
- if (!err && au_fbstart(file) != au_dbstart(dentry))
+ if (!err && au_fbtop(file) != au_dbtop(dentry))
/*
* cmoo happens after h_file was opened.
* need to refresh file later.
@@ -270,49 +270,49 @@ out:
int au_reopen_nondir(struct file *file)
{
int err;
- aufs_bindex_t bstart;
+ aufs_bindex_t btop;
struct dentry *dentry;
struct file *h_file, *h_file_tmp;
dentry = file->f_path.dentry;
- bstart = au_dbstart(dentry);
+ btop = au_dbtop(dentry);
h_file_tmp = NULL;
- if (au_fbstart(file) == bstart) {
+ if (au_fbtop(file) == btop) {
h_file = au_hf_top(file);
if (file->f_mode == h_file->f_mode)
return 0; /* success */
h_file_tmp = h_file;
get_file(h_file_tmp);
- au_set_h_fptr(file, bstart, NULL);
+ au_set_h_fptr(file, btop, NULL);
}
AuDebugOn(au_fi(file)->fi_hdir);
/*
* it can happen
* file exists on both of rw and ro
- * open --> dbstart and fbstart are both 0
+ * open --> dbtop and fbtop are both 0
* prepend a branch as rw, "rw" become ro
* remove rw/file
* delete the top branch, "rw" becomes rw again
- * --> dbstart is 1, fbstart is still 0
- * write --> fbstart is 0 but dbstart is 1
+ * --> dbtop is 1, fbtop is still 0
+ * write --> fbtop is 0 but dbtop is 1
*/
- /* AuDebugOn(au_fbstart(file) < bstart); */
+ /* AuDebugOn(au_fbtop(file) < btop); */
- h_file = au_h_open(dentry, bstart, vfsub_file_flags(file) & ~O_TRUNC,
+ h_file = au_h_open(dentry, btop, vfsub_file_flags(file) & ~O_TRUNC,
file, /*force_wr*/0);
err = PTR_ERR(h_file);
if (IS_ERR(h_file)) {
if (h_file_tmp) {
- atomic_inc(&au_sbr(dentry->d_sb, bstart)->br_count);
- au_set_h_fptr(file, bstart, h_file_tmp);
+ au_sbr_get(dentry->d_sb, btop);
+ au_set_h_fptr(file, btop, h_file_tmp);
h_file_tmp = NULL;
}
goto out; /* todo: close all? */
}
err = 0;
- au_set_fbstart(file, bstart);
- au_set_h_fptr(file, bstart, h_file);
+ au_set_fbtop(file, btop);
+ au_set_h_fptr(file, btop, h_file);
au_update_figen(file);
/* todo: necessary? */
/* file->f_ra = h_file->f_ra; */
@@ -329,7 +329,7 @@ static int au_reopen_wh(struct file *file, aufs_bindex_t btgt,
struct dentry *hi_wh)
{
int err;
- aufs_bindex_t bstart;
+ aufs_bindex_t btop;
struct au_dinfo *dinfo;
struct dentry *h_dentry;
struct au_hdentry *hdp;
@@ -337,14 +337,14 @@ static int au_reopen_wh(struct file *file, aufs_bindex_t btgt,
dinfo = au_di(file->f_path.dentry);
AuRwMustWriteLock(&dinfo->di_rwsem);
- bstart = dinfo->di_bstart;
- dinfo->di_bstart = btgt;
+ btop = dinfo->di_btop;
+ dinfo->di_btop = btgt;
hdp = dinfo->di_hdentry;
h_dentry = hdp[0 + btgt].hd_dentry;
hdp[0 + btgt].hd_dentry = hi_wh;
err = au_reopen_nondir(file);
hdp[0 + btgt].hd_dentry = h_dentry;
- dinfo->di_bstart = bstart;
+ dinfo->di_btop = btop;
return err;
}
@@ -363,11 +363,11 @@ static int au_ready_to_write_wh(struct file *file, loff_t len,
.pin = pin
};
- au_update_dbstart(cpg.dentry);
+ au_update_dbtop(cpg.dentry);
inode = d_inode(cpg.dentry);
h_inode = NULL;
- if (au_dbstart(cpg.dentry) <= bcpup
- && au_dbend(cpg.dentry) >= bcpup) {
+ if (au_dbtop(cpg.dentry) <= bcpup
+ && au_dbbot(cpg.dentry) >= bcpup) {
h_dentry = au_h_dptr(cpg.dentry, bcpup);
if (h_dentry && d_is_positive(h_dentry))
h_inode = d_inode(h_dentry);
@@ -394,7 +394,7 @@ static int au_ready_to_write_wh(struct file *file, loff_t len,
int au_ready_to_write(struct file *file, loff_t len, struct au_pin *pin)
{
int err;
- aufs_bindex_t dbstart;
+ aufs_bindex_t dbtop;
struct dentry *parent;
struct inode *inode;
struct super_block *sb;
@@ -410,7 +410,7 @@ int au_ready_to_write(struct file *file, loff_t len, struct au_pin *pin)
sb = cpg.dentry->d_sb;
inode = d_inode(cpg.dentry);
- cpg.bsrc = au_fbstart(file);
+ cpg.bsrc = au_fbtop(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,
@@ -438,11 +438,11 @@ int au_ready_to_write(struct file *file, loff_t len, struct au_pin *pin)
if (unlikely(err))
goto out_dgrade;
- dbstart = au_dbstart(cpg.dentry);
- if (dbstart <= cpg.bdst)
+ dbtop = au_dbtop(cpg.dentry);
+ if (dbtop <= cpg.bdst)
cpg.bsrc = cpg.bdst;
- if (dbstart <= cpg.bdst /* just reopen */
+ if (dbtop <= cpg.bdst /* just reopen */
|| !d_unhashed(cpg.dentry) /* copyup and reopen */
) {
h_file = au_h_open_pre(cpg.dentry, cpg.bsrc, /*force_wr*/0);
@@ -450,7 +450,7 @@ int au_ready_to_write(struct file *file, loff_t len, struct au_pin *pin)
err = PTR_ERR(h_file);
else {
di_downgrade_lock(parent, AuLock_IR);
- if (dbstart > cpg.bdst)
+ if (dbtop > cpg.bdst)
err = au_sio_cpup_simple(&cpg);
if (!err)
err = au_reopen_nondir(file);
@@ -531,7 +531,7 @@ static int au_file_refresh_by_inode(struct file *file, int *need_reopen)
finfo = au_fi(file);
sb = cpg.dentry->d_sb;
inode = d_inode(cpg.dentry);
- cpg.bdst = au_ibstart(inode);
+ cpg.bdst = au_ibtop(inode);
if (cpg.bdst == finfo->fi_btop || IS_ROOT(cpg.dentry))
goto out;
@@ -552,7 +552,7 @@ static int au_file_refresh_by_inode(struct file *file, int *need_reopen)
&& au_opt_test(au_mntflags(sb), PLINK)
&& au_plink_test(inode)
&& !d_unhashed(cpg.dentry)
- && cpg.bdst < au_dbstart(cpg.dentry)) {
+ && cpg.bdst < au_dbtop(cpg.dentry)) {
err = au_test_and_cpup_dirs(cpg.dentry, cpg.bdst);
if (unlikely(err))
goto out_unlock;
@@ -580,7 +580,7 @@ out:
static void au_do_refresh_dir(struct file *file)
{
- aufs_bindex_t bindex, bend, new_bindex, brid;
+ aufs_bindex_t bindex, bbot, new_bindex, brid;
struct au_hfile *p, tmp, *q;
struct au_finfo *finfo;
struct super_block *sb;
@@ -594,8 +594,8 @@ static void au_do_refresh_dir(struct file *file)
AuDebugOn(!fidir);
p = fidir->fd_hfile + finfo->fi_btop;
brid = p->hf_br->br_id;
- bend = fidir->fd_bbot;
- for (bindex = finfo->fi_btop; bindex <= bend; bindex++, p++) {
+ bbot = fidir->fd_bbot;
+ for (bindex = finfo->fi_btop; bindex <= bbot; bindex++, p++) {
if (!p->hf_file)
continue;
@@ -620,8 +620,8 @@ static void au_do_refresh_dir(struct file *file)
p = fidir->fd_hfile;
if (!au_test_mmapped(file) && !d_unlinked(file->f_path.dentry)) {
- bend = au_sbend(sb);
- for (finfo->fi_btop = 0; finfo->fi_btop <= bend;
+ bbot = au_sbbot(sb);
+ for (finfo->fi_btop = 0; finfo->fi_btop <= bbot;
finfo->fi_btop++, p++)
if (p->hf_file) {
if (file_inode(p->hf_file))
@@ -629,16 +629,16 @@ static void au_do_refresh_dir(struct file *file)
au_hfput(p, file);
}
} else {
- bend = au_br_index(sb, brid);
- for (finfo->fi_btop = 0; finfo->fi_btop < bend;
+ bbot = au_br_index(sb, brid);
+ for (finfo->fi_btop = 0; finfo->fi_btop < bbot;
finfo->fi_btop++, p++)
if (p->hf_file)
au_hfput(p, file);
- bend = au_sbend(sb);
+ bbot = au_sbbot(sb);
}
- p = fidir->fd_hfile + bend;
- for (fidir->fd_bbot = bend; fidir->fd_bbot >= finfo->fi_btop;
+ p = fidir->fd_hfile + bbot;
+ for (fidir->fd_bbot = bbot; fidir->fd_bbot >= finfo->fi_btop;
fidir->fd_bbot--, p--)
if (p->hf_file) {
if (file_inode(p->hf_file))
@@ -654,7 +654,7 @@ static void au_do_refresh_dir(struct file *file)
static int refresh_file(struct file *file, int (*reopen)(struct file *file))
{
int err, need_reopen;
- aufs_bindex_t bend, bindex;
+ aufs_bindex_t bbot, bindex;
struct dentry *dentry;
struct au_finfo *finfo;
struct au_hfile *hfile;
@@ -667,9 +667,9 @@ static int refresh_file(struct file *file, int (*reopen)(struct file *file))
bindex = au_br_index(dentry->d_sb, hfile->hf_br->br_id);
AuDebugOn(bindex < 0);
if (bindex != finfo->fi_btop)
- au_set_fbstart(file, bindex);
+ au_set_fbtop(file, bindex);
} else {
- err = au_fidir_realloc(finfo, au_sbend(dentry->d_sb) + 1);
+ err = au_fidir_realloc(finfo, au_sbbot(dentry->d_sb) + 1);
if (unlikely(err))
goto out;
au_do_refresh_dir(file);
@@ -688,8 +688,8 @@ static int refresh_file(struct file *file, int (*reopen)(struct file *file))
/* error, close all lower files */
if (finfo->fi_hdir) {
- bend = au_fbend_dir(file);
- for (bindex = au_fbstart(file); bindex <= bend; bindex++)
+ bbot = au_fbbot_dir(file);
+ for (bindex = au_fbtop(file); bindex <= bbot; bindex++)
au_set_h_fptr(file, bindex, NULL);
}
@@ -703,7 +703,7 @@ int au_reval_and_lock_fdi(struct file *file, int (*reopen)(struct file *file),
{
int err;
unsigned int sigen, figen;
- aufs_bindex_t bstart;
+ aufs_bindex_t btop;
unsigned char pseudo_link;
struct dentry *dentry;
struct inode *inode;
@@ -715,9 +715,9 @@ int au_reval_and_lock_fdi(struct file *file, int (*reopen)(struct file *file),
fi_write_lock(file);
figen = au_figen(file);
di_write_lock_child(dentry);
- bstart = au_dbstart(dentry);
- pseudo_link = (bstart != au_ibstart(inode));
- if (sigen == figen && !pseudo_link && au_fbstart(file) == bstart) {
+ btop = au_dbtop(dentry);
+ pseudo_link = (btop != au_ibtop(inode));
+ if (sigen == figen && !pseudo_link && au_fbtop(file) == btop) {
if (!wlock) {
di_downgrade_lock(dentry, AuLock_IR);
fi_downgrade_lock(file);
diff --git a/fs/aufs/file.h b/fs/aufs/file.h
index 27d802487..96ab0a088 100644
--- a/fs/aufs/file.h
+++ b/fs/aufs/file.h
@@ -144,13 +144,13 @@ AuSimpleRwsemFuncs(fi, struct file *f, &au_fi(f)->fi_rwsem);
/* ---------------------------------------------------------------------- */
/* todo: hard/soft set? */
-static inline aufs_bindex_t au_fbstart(struct file *file)
+static inline aufs_bindex_t au_fbtop(struct file *file)
{
FiMustAnyLock(file);
return au_fi(file)->fi_btop;
}
-static inline aufs_bindex_t au_fbend_dir(struct file *file)
+static inline aufs_bindex_t au_fbbot_dir(struct file *file)
{
FiMustAnyLock(file);
AuDebugOn(!au_fi(file)->fi_hdir);
@@ -164,13 +164,13 @@ static inline struct au_vdir *au_fvdir_cache(struct file *file)
return au_fi(file)->fi_hdir->fd_vdir_cache;
}
-static inline void au_set_fbstart(struct file *file, aufs_bindex_t bindex)
+static inline void au_set_fbtop(struct file *file, aufs_bindex_t bindex)
{
FiMustWriteLock(file);
au_fi(file)->fi_btop = bindex;
}
-static inline void au_set_fbend_dir(struct file *file, aufs_bindex_t bindex)
+static inline void au_set_fbbot_dir(struct file *file, aufs_bindex_t bindex)
{
FiMustWriteLock(file);
AuDebugOn(!au_fi(file)->fi_hdir);
diff --git a/fs/aufs/finfo.c b/fs/aufs/finfo.c
index b5eb55dfb..07f6eb32d 100644
--- a/fs/aufs/finfo.c
+++ b/fs/aufs/finfo.c
@@ -15,7 +15,7 @@ void au_hfput(struct au_hfile *hf, struct file *file)
allow_write_access(hf->hf_file);
fput(hf->hf_file);
hf->hf_file = NULL;
- atomic_dec(&hf->hf_br->br_count);
+ au_br_put(hf->hf_br);
hf->hf_br = NULL;
}
@@ -55,7 +55,7 @@ struct au_fidir *au_fidir_alloc(struct super_block *sb)
struct au_fidir *fidir;
int nbr;
- nbr = au_sbend(sb) + 1;
+ nbr = au_sbbot(sb) + 1;
if (nbr < 2)
nbr = 2; /* initial allocate for 2 branches */
fidir = kzalloc(au_fidir_sz(nbr), GFP_NOFS);
@@ -105,10 +105,8 @@ void au_finfo_fin(struct file *file)
void au_fi_init_once(void *_finfo)
{
struct au_finfo *finfo = _finfo;
- static struct lock_class_key aufs_fi;
au_rw_init(&finfo->fi_rwsem);
- au_rw_class(&finfo->fi_rwsem, &aufs_fi);
}
int au_finfo_init(struct file *file, struct au_fidir *fidir)
@@ -125,11 +123,6 @@ int au_finfo_init(struct file *file, struct au_fidir *fidir)
err = 0;
au_nfiles_inc(dentry->d_sb);
- /* verbose coding for lock class name */
- if (!fidir)
- au_rw_class(&finfo->fi_rwsem, au_lc_key + AuLcNonDir_FIINFO);
- else
- au_rw_class(&finfo->fi_rwsem, au_lc_key + AuLcDir_FIINFO);
au_rw_write_lock(&finfo->fi_rwsem);
finfo->fi_btop = -1;
finfo->fi_hdir = fidir;
diff --git a/fs/aufs/hfsnotify.c b/fs/aufs/hfsnotify.c
index c0a1a63a9..07b4ecc53 100644
--- a/fs/aufs/hfsnotify.c
+++ b/fs/aufs/hfsnotify.c
@@ -50,8 +50,6 @@ static int au_hfsn_alloc(struct au_hinode *hinode)
lockdep_off();
err = fsnotify_add_mark(mark, br->br_hfsn->hfsn_group, hinode->hi_inode,
/*mnt*/NULL, /*allow_dups*/1);
- /* even if err */
- fsnotify_put_mark(mark);
lockdep_on();
return err;
@@ -73,6 +71,7 @@ static int au_hfsn_free(struct au_hinode *hinode, struct au_hnotify *hn)
spin_unlock(&mark->lock);
lockdep_off();
fsnotify_destroy_mark(mark, group);
+ fsnotify_put_mark(mark);
fsnotify_put_group(group);
lockdep_on();
diff --git a/fs/aufs/hnotify.c b/fs/aufs/hnotify.c
index 92e432b6a..3016c5e73 100644
--- a/fs/aufs/hnotify.c
+++ b/fs/aufs/hnotify.c
@@ -60,12 +60,12 @@ void au_hn_ctl(struct au_hinode *hinode, int do_set)
void au_hn_reset(struct inode *inode, unsigned int flags)
{
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
struct inode *hi;
struct dentry *iwhdentry;
- bend = au_ibend(inode);
- for (bindex = au_ibstart(inode); bindex <= bend; bindex++) {
+ bbot = au_ibbot(inode);
+ for (bindex = au_ibtop(inode); bindex <= bbot; bindex++) {
hi = au_h_iptr(inode, bindex);
if (!hi)
continue;
@@ -89,7 +89,7 @@ void au_hn_reset(struct inode *inode, unsigned int flags)
static int hn_xino(struct inode *inode, struct inode *h_inode)
{
int err;
- aufs_bindex_t bindex, bend, bfound, bstart;
+ aufs_bindex_t bindex, bbot, bfound, btop;
struct inode *h_i;
err = 0;
@@ -99,15 +99,15 @@ static int hn_xino(struct inode *inode, struct inode *h_inode)
}
bfound = -1;
- bend = au_ibend(inode);
- bstart = au_ibstart(inode);
+ bbot = au_ibbot(inode);
+ btop = au_ibtop(inode);
#if 0 /* reserved for future use */
- if (bindex == bend) {
+ if (bindex == bbot) {
/* keep this ino in rename case */
goto out;
}
#endif
- for (bindex = bstart; bindex <= bend; bindex++)
+ for (bindex = btop; bindex <= bbot; bindex++)
if (au_h_iptr(inode, bindex) == h_inode) {
bfound = bindex;
break;
@@ -115,7 +115,7 @@ static int hn_xino(struct inode *inode, struct inode *h_inode)
if (bfound < 0)
goto out;
- for (bindex = bstart; bindex <= bend; bindex++) {
+ for (bindex = btop; bindex <= bbot; bindex++) {
h_i = au_h_iptr(inode, bindex);
if (!h_i)
continue;
@@ -420,7 +420,7 @@ static void au_hn_bh(void *_args)
{
struct au_hnotify_args *a = _args;
struct super_block *sb;
- aufs_bindex_t bindex, bend, bfound;
+ aufs_bindex_t bindex, bbot, bfound;
unsigned char xino, try_iput;
int err;
struct inode *inode;
@@ -451,8 +451,8 @@ static void au_hn_bh(void *_args)
ii_read_lock_parent(a->dir);
bfound = -1;
- bend = au_ibend(a->dir);
- for (bindex = au_ibstart(a->dir); bindex <= bend; bindex++)
+ bbot = au_ibbot(a->dir);
+ for (bindex = au_ibtop(a->dir); bindex <= bbot; bindex++)
if (au_h_iptr(a->dir, bindex) == a->h_dir) {
bfound = bindex;
break;
diff --git a/fs/aufs/i_op.c b/fs/aufs/i_op.c
index a70d5b050..1572a7d4d 100644
--- a/fs/aufs/i_op.c
+++ b/fs/aufs/i_op.c
@@ -74,7 +74,7 @@ out:
static int aufs_permission(struct inode *inode, int mask)
{
int err;
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
const unsigned char isdir = !!S_ISDIR(inode->i_mode),
write_mask = !!(mask & (MAY_WRITE | MAY_APPEND));
struct inode *h_inode;
@@ -98,14 +98,14 @@ static int aufs_permission(struct inode *inode, int mask)
|| write_mask
|| au_opt_test(au_mntflags(sb), DIRPERM1)) {
err = au_busy_or_stale();
- h_inode = au_h_iptr(inode, au_ibstart(inode));
+ h_inode = au_h_iptr(inode, au_ibtop(inode));
if (unlikely(!h_inode
|| (h_inode->i_mode & S_IFMT)
!= (inode->i_mode & S_IFMT)))
goto out;
err = 0;
- bindex = au_ibstart(inode);
+ bindex = au_ibtop(inode);
br = au_sbr(sb, bindex);
err = h_permission(h_inode, mask, au_br_mnt(br), br->br_perm);
if (write_mask
@@ -124,8 +124,8 @@ static int aufs_permission(struct inode *inode, int mask)
/* non-write to dir */
err = 0;
- bend = au_ibend(inode);
- for (bindex = au_ibstart(inode); !err && bindex <= bend; bindex++) {
+ bbot = au_ibbot(inode);
+ for (bindex = au_ibtop(inode); !err && bindex <= bbot; bindex++) {
h_inode = au_h_iptr(inode, bindex);
if (h_inode) {
err = au_busy_or_stale();
@@ -184,7 +184,7 @@ static struct dentry *aufs_lookup(struct inode *dir, struct dentry *dentry,
if (!err)
err = au_digen_test(parent, au_sigen(sb));
if (!err) {
- npositive = au_lkup_dentry(dentry, au_dbstart(parent),
+ npositive = au_lkup_dentry(dentry, au_dbtop(parent),
/*type*/0);
err = npositive;
}
@@ -226,18 +226,6 @@ static struct dentry *aufs_lookup(struct inode *dir, struct dentry *dentry,
out_unlock:
di_write_unlock(dentry);
- if (inode) {
- /* verbose coding for lock class name */
- if (unlikely(S_ISLNK(inode->i_mode)))
- au_rw_class(&au_di(dentry)->di_rwsem,
- au_lc_key + AuLcSymlink_DIINFO);
- else if (unlikely(S_ISDIR(inode->i_mode)))
- au_rw_class(&au_di(dentry)->di_rwsem,
- au_lc_key + AuLcDir_DIINFO);
- else /* likely */
- au_rw_class(&au_di(dentry)->di_rwsem,
- au_lc_key + AuLcNonDir_DIINFO);
- }
out_si:
si_read_unlock(sb);
out:
@@ -324,7 +312,7 @@ static int aufs_atomic_open(struct inode *dir, struct dentry *dentry,
parent = dentry->d_parent; /* dir is locked */
di_write_lock_parent(parent);
- err = au_lkup_dentry(dentry, /*bstart*/0, /*type*/0);
+ err = au_lkup_dentry(dentry, /*btop*/0, /*type*/0);
if (unlikely(err))
goto out_unlock;
@@ -391,7 +379,7 @@ out:
static int au_wr_dir_cpup(struct dentry *dentry, struct dentry *parent,
const unsigned char add_entry, aufs_bindex_t bcpup,
- aufs_bindex_t bstart)
+ aufs_bindex_t btop)
{
int err;
struct dentry *h_parent;
@@ -404,9 +392,9 @@ static int au_wr_dir_cpup(struct dentry *dentry, struct dentry *parent,
err = 0;
if (!au_h_dptr(parent, bcpup)) {
- if (bstart > bcpup)
+ if (btop > bcpup)
err = au_cpup_dirs(dentry, bcpup);
- else if (bstart < bcpup)
+ else if (btop < bcpup)
err = au_cpdown_dirs(dentry, bcpup);
else
BUG();
@@ -422,7 +410,7 @@ static int au_wr_dir_cpup(struct dentry *dentry, struct dentry *parent,
AuDbg("bcpup %d\n", bcpup);
if (!err) {
if (d_really_is_negative(dentry))
- au_set_h_dptr(dentry, bstart, NULL);
+ au_set_h_dptr(dentry, btop, NULL);
au_update_dbrange(dentry, /*do_put_zero*/0);
}
}
@@ -446,7 +434,7 @@ int au_wr_dir(struct dentry *dentry, struct dentry *src_dentry,
{
int err;
unsigned int flags;
- aufs_bindex_t bcpup, bstart, src_bstart;
+ aufs_bindex_t bcpup, btop, src_btop;
const unsigned char add_entry
= au_ftest_wrdir(args->flags, ADD_ENTRY)
| au_ftest_wrdir(args->flags, TMPFILE);
@@ -457,13 +445,13 @@ int au_wr_dir(struct dentry *dentry, struct dentry *src_dentry,
sb = dentry->d_sb;
sbinfo = au_sbi(sb);
parent = dget_parent(dentry);
- bstart = au_dbstart(dentry);
- bcpup = bstart;
+ btop = au_dbtop(dentry);
+ bcpup = btop;
if (args->force_btgt < 0) {
if (src_dentry) {
- src_bstart = au_dbstart(src_dentry);
- if (src_bstart < bstart)
- bcpup = src_bstart;
+ src_btop = au_dbtop(src_dentry);
+ if (src_btop < btop)
+ bcpup = src_btop;
} else if (add_entry) {
flags = 0;
if (au_ftest_wrdir(args->flags, ISDIR))
@@ -492,18 +480,18 @@ int au_wr_dir(struct dentry *dentry, struct dentry *src_dentry,
AuDebugOn(au_test_ro(sb, bcpup, d_inode(dentry)));
}
- AuDbg("bstart %d, bcpup %d\n", bstart, bcpup);
+ AuDbg("btop %d, bcpup %d\n", btop, bcpup);
err = bcpup;
- if (bcpup == bstart)
+ if (bcpup == btop)
goto out; /* success */
/* copyup the new parent into the branch we process */
- err = au_wr_dir_cpup(dentry, parent, add_entry, bcpup, bstart);
+ err = au_wr_dir_cpup(dentry, parent, add_entry, bcpup, btop);
if (err >= 0) {
if (d_really_is_negative(dentry)) {
- au_set_h_dptr(dentry, bstart, NULL);
- au_set_dbstart(dentry, bcpup);
- au_set_dbend(dentry, bcpup);
+ au_set_h_dptr(dentry, btop, NULL);
+ au_set_dbtop(dentry, bcpup);
+ au_set_dbbot(dentry, bcpup);
}
AuDebugOn(add_entry
&& !au_ftest_wrdir(args->flags, TMPFILE)
@@ -645,7 +633,7 @@ int au_do_pin(struct au_pin *p)
}
p->h_dentry = NULL;
- if (p->bindex <= au_dbend(p->dentry))
+ if (p->bindex <= au_dbbot(p->dentry))
p->h_dentry = au_h_dptr(p->dentry, p->bindex);
p->parent = dget_parent(p->dentry);
@@ -761,7 +749,7 @@ int au_pin_and_icpup(struct dentry *dentry, struct iattr *ia,
{
int err;
loff_t sz;
- aufs_bindex_t bstart, ibstart;
+ aufs_bindex_t btop, ibtop;
struct dentry *hi_wh, *parent;
struct inode *inode;
struct au_wr_dir_args wr_dir_args = {
@@ -772,16 +760,16 @@ int au_pin_and_icpup(struct dentry *dentry, struct iattr *ia,
if (d_is_dir(dentry))
au_fset_wrdir(wr_dir_args.flags, ISDIR);
/* plink or hi_wh() case */
- bstart = au_dbstart(dentry);
+ btop = au_dbtop(dentry);
inode = d_inode(dentry);
- ibstart = au_ibstart(inode);
- if (bstart != ibstart && !au_test_ro(inode->i_sb, ibstart, inode))
- wr_dir_args.force_btgt = ibstart;
+ ibtop = au_ibtop(inode);
+ if (btop != ibtop && !au_test_ro(inode->i_sb, ibtop, inode))
+ wr_dir_args.force_btgt = ibtop;
err = au_wr_dir(dentry, /*src_dentry*/NULL, &wr_dir_args);
if (unlikely(err < 0))
goto out;
a->btgt = err;
- if (err != bstart)
+ if (err != btop)
au_fset_icpup(a->flags, DID_CPUP);
err = 0;
@@ -797,8 +785,8 @@ int au_pin_and_icpup(struct dentry *dentry, struct iattr *ia,
if (unlikely(err))
goto out_parent;
- a->h_path.dentry = au_h_dptr(dentry, bstart);
sz = -1;
+ a->h_path.dentry = au_h_dptr(dentry, btop);
a->h_inode = d_inode(a->h_path.dentry);
if (ia && (ia->ia_valid & ATTR_SIZE)) {
inode_lock_nested(a->h_inode, AuLsc_I_CHILD);
@@ -839,7 +827,7 @@ int au_pin_and_icpup(struct dentry *dentry, struct iattr *ia,
struct au_cp_generic cpg = {
.dentry = dentry,
.bdst = a->btgt,
- .bsrc = bstart,
+ .bsrc = btop,
.len = sz,
.pin = &a->pin,
.flags = AuCpup_DTIME | AuCpup_HOPEN
@@ -976,7 +964,7 @@ out_unlock:
inode_unlock(a->h_inode);
au_unpin(&a->pin);
if (unlikely(err))
- au_update_dbstart(dentry);
+ au_update_dbtop(dentry);
out_dentry:
di_write_unlock(dentry);
if (file) {
@@ -1073,7 +1061,7 @@ ssize_t au_srxattr(struct dentry *dentry, struct au_srxattr *arg)
au_unpin(&a->pin);
if (unlikely(err))
- au_update_dbstart(dentry);
+ au_update_dbtop(dentry);
out_di:
di_write_unlock(dentry);
@@ -1165,7 +1153,7 @@ int au_h_path_getattr(struct dentry *dentry, int force, struct path *h_path)
di_read_lock_child(dentry, AuLock_IR);
inode = d_inode(dentry);
- bindex = au_ibstart(inode);
+ bindex = au_ibtop(inode);
h_path->mnt = au_sbr_mnt(sb, bindex);
h_sb = h_path->mnt->mnt_sb;
if (!force
@@ -1173,7 +1161,7 @@ int au_h_path_getattr(struct dentry *dentry, int force, struct path *h_path)
&& udba_none)
goto out; /* success */
- if (au_dbstart(dentry) == bindex)
+ if (au_dbtop(dentry) == bindex)
h_path->dentry = au_h_dptr(dentry, bindex);
else if (au_opt_test(mnt_flags, PLINK) && au_plink_test(inode)) {
h_path->dentry = au_plink_lkup(inode, bindex);
@@ -1258,14 +1246,14 @@ static const char *aufs_get_link(struct dentry *dentry, struct inode *inode,
err = -EINVAL;
inode = d_inode(dentry);
- bindex = au_ibstart(inode);
+ bindex = au_ibtop(inode);
h_inode = au_h_iptr(inode, bindex);
if (unlikely(!h_inode->i_op->get_link))
goto out_unlock;
err = -EBUSY;
h_dentry = NULL;
- if (au_dbstart(dentry) <= bindex) {
+ if (au_dbtop(dentry) <= bindex) {
h_dentry = au_h_dptr(dentry, bindex);
if (h_dentry)
dget(h_dentry);
@@ -1311,7 +1299,7 @@ static int aufs_update_time(struct inode *inode, struct timespec *ts, int flags)
si_read_lock(sb, AuLock_FLUSH);
ii_write_lock_child(inode);
lockdep_on();
- h_inode = au_h_iptr(inode, au_ibstart(inode));
+ h_inode = au_h_iptr(inode, au_ibtop(inode));
err = vfsub_update_time(h_inode, ts, flags);
lockdep_off();
if (!err)
diff --git a/fs/aufs/i_op_add.c b/fs/aufs/i_op_add.c
index 533b36a2a..8e3fb61e8 100644
--- a/fs/aufs/i_op_add.c
+++ b/fs/aufs/i_op_add.c
@@ -167,7 +167,7 @@ lock_hdir_lkup_wh(struct dentry *dentry, struct au_dtime *dt,
h_parent = au_pinned_h_parent(pin);
if (udba != AuOpt_UDBA_NONE
- && au_dbstart(dentry) == bcpup)
+ && au_dbtop(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))
@@ -229,7 +229,7 @@ static int add_simple(struct inode *dir, struct dentry *dentry,
struct simple_arg *arg)
{
int err, rerr;
- aufs_bindex_t bstart;
+ aufs_bindex_t btop;
unsigned char created;
const unsigned char try_aopen
= (arg->type == Creat && arg->u.c.try_aopen);
@@ -272,10 +272,10 @@ static int add_simple(struct inode *dir, struct dentry *dentry,
if (IS_ERR(wh_dentry))
goto out_parent;
- bstart = au_dbstart(dentry);
+ btop = au_dbtop(dentry);
sb = dentry->d_sb;
- br = au_sbr(sb, bstart);
- a->h_path.dentry = au_h_dptr(dentry, bstart);
+ br = au_sbr(sb, btop);
+ a->h_path.dentry = au_h_dptr(dentry, btop);
a->h_path.mnt = au_br_mnt(br);
h_dir = au_pinned_h_dir(&a->pin);
switch (arg->type) {
@@ -300,7 +300,7 @@ static int add_simple(struct inode *dir, struct dentry *dentry,
}
created = !err;
if (!err)
- err = epilog(dir, bstart, wh_dentry, dentry);
+ err = epilog(dir, btop, wh_dentry, dentry);
/* revert */
if (unlikely(created && err && d_is_positive(a->h_path.dentry))) {
@@ -326,7 +326,7 @@ out_parent:
di_write_unlock(parent);
out_unlock:
if (unlikely(err)) {
- au_update_dbstart(dentry);
+ au_update_dbtop(dentry);
d_drop(dentry);
}
if (!try_aopen)
@@ -423,9 +423,9 @@ int aufs_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode)
if (unlikely(err))
goto out_parent;
- bindex = au_dbstart(parent);
- au_set_dbstart(dentry, bindex);
- au_set_dbend(dentry, bindex);
+ bindex = au_dbtop(parent);
+ au_set_dbtop(dentry, bindex);
+ au_set_dbbot(dentry, bindex);
err = au_wr_dir(dentry, /*src_dentry*/NULL, &wr_dir_args);
bindex = err;
if (unlikely(err < 0))
@@ -455,15 +455,15 @@ int aufs_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode)
if (unlikely(err))
goto out_dentry;
- au_set_dbstart(dentry, bindex);
- au_set_dbend(dentry, bindex);
+ au_set_dbtop(dentry, bindex);
+ au_set_dbbot(dentry, bindex);
au_set_h_dptr(dentry, bindex, dget(h_dentry));
inode = au_new_inode(dentry, /*must_new*/1);
if (IS_ERR(inode)) {
err = PTR_ERR(inode);
au_set_h_dptr(dentry, bindex, NULL);
- au_set_dbstart(dentry, -1);
- au_set_dbend(dentry, -1);
+ au_set_dbtop(dentry, -1);
+ au_set_dbbot(dentry, -1);
} else {
if (!inode->i_nlink)
set_nlink(inode, 1);
@@ -471,7 +471,7 @@ int aufs_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode)
au_di(dentry)->di_tmpfile = 1;
/* update without i_mutex */
- if (au_ibstart(dir) == au_dbstart(dentry))
+ if (au_ibtop(dir) == au_dbtop(dentry))
au_cpup_attr_timesizes(dir);
}
@@ -483,15 +483,7 @@ out_parent:
di_write_unlock(parent);
dput(parent);
di_write_unlock(dentry);
- if (!err)
-#if 0
- /* verbose coding for lock class name */
- au_rw_class(&au_di(dentry)->di_rwsem,
- au_lc_key + AuLcNonDir_DIINFO);
-#else
- ;
-#endif
- else {
+ if (unlikely(err)) {
au_di_fin(dentry);
dentry->d_fsdata = NULL;
}
@@ -550,7 +542,7 @@ static int au_cpup_or_link(struct dentry *src_dentry, struct dentry *dentry,
{
int err;
unsigned char plink;
- aufs_bindex_t bend;
+ aufs_bindex_t bbot;
struct dentry *h_src_dentry;
struct inode *h_inode, *inode, *delegated;
struct super_block *sb;
@@ -560,13 +552,13 @@ static int au_cpup_or_link(struct dentry *src_dentry, struct dentry *dentry,
h_inode = NULL;
sb = src_dentry->d_sb;
inode = d_inode(src_dentry);
- if (au_ibstart(inode) <= a->bdst)
+ if (au_ibtop(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. */
- bend = au_dbend(dentry);
- if (bend < a->bsrc)
- au_set_dbend(dentry, a->bsrc);
+ bbot = au_dbbot(dentry);
+ if (bbot < a->bsrc)
+ au_set_dbbot(dentry, a->bsrc);
au_set_h_dptr(dentry, a->bsrc,
dget(au_h_dptr(src_dentry, a->bsrc)));
dget(a->h_path.dentry);
@@ -601,7 +593,7 @@ static int au_cpup_or_link(struct dentry *src_dentry, struct dentry *dentry,
spin_unlock(&dentry->d_lock);
AuDbg("temporary d_inode...done\n");
au_set_h_dptr(dentry, a->bsrc, NULL);
- au_set_dbend(dentry, bend);
+ au_set_dbbot(dentry, bbot);
} else {
/* the inode of src_dentry already exists on a.bdst branch */
h_src_dentry = d_find_alias(h_inode);
@@ -679,7 +671,7 @@ int aufs_link(struct dentry *src_dentry, struct inode *dir,
goto out_unlock;
a->src_parent = dget_parent(src_dentry);
- wr_dir_args.force_btgt = au_ibstart(inode);
+ wr_dir_args.force_btgt = au_ibtop(inode);
di_write_lock_parent(a->parent);
wr_dir_args.force_btgt = au_wbr(dentry, wr_dir_args.force_btgt);
@@ -691,15 +683,15 @@ int aufs_link(struct dentry *src_dentry, struct inode *dir,
err = 0;
sb = dentry->d_sb;
- a->bdst = au_dbstart(dentry);
+ a->bdst = au_dbtop(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);
+ a->bsrc = au_ibtop(inode);
h_src_dentry = au_h_d_alias(src_dentry, a->bsrc);
if (!h_src_dentry && au_di(src_dentry)->di_tmpfile)
h_src_dentry = dget(au_hi_wh(inode, a->bsrc));
if (!h_src_dentry) {
- a->bsrc = au_dbstart(src_dentry);
+ a->bsrc = au_dbtop(src_dentry);
h_src_dentry = au_h_d_alias(src_dentry, a->bsrc);
AuDebugOn(!h_src_dentry);
} else if (IS_ERR(h_src_dentry)) {
@@ -799,7 +791,7 @@ out_parent:
dput(a->src_parent);
out_unlock:
if (unlikely(err)) {
- au_update_dbstart(dentry);
+ au_update_dbtop(dentry);
d_drop(dentry);
}
aufs_read_and_write_unlock2(dentry, src_dentry);
@@ -851,7 +843,7 @@ int aufs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
goto out_parent;
sb = dentry->d_sb;
- bindex = au_dbstart(dentry);
+ bindex = au_dbtop(dentry);
h_path.dentry = au_h_dptr(dentry, bindex);
h_path.mnt = au_sbr_mnt(sb, bindex);
err = vfsub_mkdir(au_pinned_h_dir(&a->pin), &h_path, mode);
@@ -908,7 +900,7 @@ out_parent:
di_write_unlock(parent);
out_unlock:
if (unlikely(err)) {
- au_update_dbstart(dentry);
+ au_update_dbtop(dentry);
d_drop(dentry);
}
aufs_read_unlock(dentry, AuLock_DW);
diff --git a/fs/aufs/i_op_del.c b/fs/aufs/i_op_del.c
index 68741aadb..bda70b008 100644
--- a/fs/aufs/i_op_del.c
+++ b/fs/aufs/i_op_del.c
@@ -21,25 +21,25 @@
int au_wr_dir_need_wh(struct dentry *dentry, int isdir, aufs_bindex_t *bcpup)
{
int need_wh, err;
- aufs_bindex_t bstart;
+ aufs_bindex_t btop;
struct super_block *sb;
sb = dentry->d_sb;
- bstart = au_dbstart(dentry);
+ btop = au_dbtop(dentry);
if (*bcpup < 0) {
- *bcpup = bstart;
- if (au_test_ro(sb, bstart, d_inode(dentry))) {
+ *bcpup = btop;
+ if (au_test_ro(sb, btop, d_inode(dentry))) {
err = AuWbrCopyup(au_sbi(sb), dentry);
*bcpup = err;
if (unlikely(err < 0))
goto out;
}
} else
- AuDebugOn(bstart < *bcpup
+ AuDebugOn(btop < *bcpup
|| au_test_ro(sb, *bcpup, d_inode(dentry)));
- AuDbg("bcpup %d, bstart %d\n", *bcpup, bstart);
+ AuDbg("bcpup %d, btop %d\n", *bcpup, btop);
- if (*bcpup != bstart) {
+ if (*bcpup != btop) {
err = au_cpup_dirs(dentry, *bcpup);
if (unlikely(err))
goto out;
@@ -54,7 +54,7 @@ int au_wr_dir_need_wh(struct dentry *dentry, int isdir, aufs_bindex_t *bcpup)
au_di_cp(tmp, dinfo);
au_di_swap(tmp, dinfo);
/* returns the number of positive dentries */
- need_wh = au_lkup_dentry(dentry, bstart + 1, /*type*/0);
+ need_wh = au_lkup_dentry(dentry, btop + 1, /*type*/0);
au_di_swap(tmp, dinfo);
au_rw_write_unlock(&tmp->di_rwsem);
au_di_free(tmp);
@@ -165,7 +165,7 @@ lock_hdir_create_wh(struct dentry *dentry, int isdir, aufs_bindex_t *rbcpup,
h_path.dentry = au_pinned_h_parent(pin);
if (udba != AuOpt_UDBA_NONE
- && au_dbstart(dentry) == bcpup) {
+ && au_dbtop(dentry) == bcpup) {
err = au_may_del(dentry, bcpup, h_path.dentry, isdir);
wh_dentry = ERR_PTR(err);
if (unlikely(err))
@@ -287,7 +287,7 @@ static int do_revert(int err, struct inode *dir, aufs_bindex_t bindex,
int aufs_unlink(struct inode *dir, struct dentry *dentry)
{
int err;
- aufs_bindex_t bwh, bindex, bstart;
+ aufs_bindex_t bwh, bindex, btop;
struct inode *inode, *h_dir, *delegated;
struct dentry *parent, *wh_dentry;
/* to reuduce stack size */
@@ -316,7 +316,7 @@ int aufs_unlink(struct inode *dir, struct dentry *dentry)
if (unlikely(d_is_dir(dentry)))
goto out_unlock; /* possible? */
- bstart = au_dbstart(dentry);
+ btop = au_dbtop(dentry);
bwh = au_dbwh(dentry);
bindex = -1;
parent = dentry->d_parent; /* dir inode is locked */
@@ -327,10 +327,10 @@ int aufs_unlink(struct inode *dir, struct dentry *dentry)
if (IS_ERR(wh_dentry))
goto out_parent;
- a->h_path.mnt = au_sbr_mnt(dentry->d_sb, bstart);
- a->h_path.dentry = au_h_dptr(dentry, bstart);
+ a->h_path.mnt = au_sbr_mnt(dentry->d_sb, btop);
+ a->h_path.dentry = au_h_dptr(dentry, btop);
dget(a->h_path.dentry);
- if (bindex == bstart) {
+ if (bindex == btop) {
h_dir = au_pinned_h_dir(&a->pin);
delegated = NULL;
err = vfsub_unlink(h_dir, &a->h_path, &delegated, /*force*/0);
@@ -351,7 +351,7 @@ int aufs_unlink(struct inode *dir, struct dentry *dentry)
epilog(dir, dentry, bindex);
/* update target timestamps */
- if (bindex == bstart) {
+ if (bindex == btop) {
vfsub_update_h_iattr(&a->h_path, /*did*/NULL);
/*ignore*/
inode->i_ctime = d_inode(a->h_path.dentry)->i_ctime;
@@ -388,7 +388,7 @@ out:
int aufs_rmdir(struct inode *dir, struct dentry *dentry)
{
int err, rmdir_later;
- aufs_bindex_t bwh, bindex, bstart;
+ aufs_bindex_t bwh, bindex, btop;
struct inode *inode;
struct dentry *parent, *wh_dentry, *h_dentry;
struct au_whtmp_rmdir *args;
@@ -428,7 +428,7 @@ int aufs_rmdir(struct inode *dir, struct dentry *dentry)
if (unlikely(err))
goto out_parent;
- bstart = au_dbstart(dentry);
+ btop = au_dbtop(dentry);
bwh = au_dbwh(dentry);
bindex = -1;
wh_dentry = lock_hdir_create_wh(dentry, /*isdir*/1, &bindex, &a->dt,
@@ -437,18 +437,18 @@ int aufs_rmdir(struct inode *dir, struct dentry *dentry)
if (IS_ERR(wh_dentry))
goto out_parent;
- h_dentry = au_h_dptr(dentry, bstart);
+ h_dentry = au_h_dptr(dentry, btop);
dget(h_dentry);
rmdir_later = 0;
- if (bindex == bstart) {
- err = renwh_and_rmdir(dentry, bstart, &args->whlist, dir);
+ if (bindex == btop) {
+ err = renwh_and_rmdir(dentry, btop, &args->whlist, dir);
if (err > 0) {
rmdir_later = err;
err = 0;
}
} else {
/* stop monitoring */
- au_hn_free(au_hi(inode, bstart));
+ au_hn_free(au_hi(inode, btop));
/* dir inode is locked */
IMustLock(d_inode(wh_dentry->d_parent));
@@ -461,7 +461,7 @@ int aufs_rmdir(struct inode *dir, struct dentry *dentry)
epilog(dir, dentry, bindex);
if (rmdir_later) {
- au_whtmp_kick_rmdir(dir, bstart, h_dentry, args);
+ au_whtmp_kick_rmdir(dir, btop, h_dentry, args);
args = NULL;
}
diff --git a/fs/aufs/i_op_ren.c b/fs/aufs/i_op_ren.c
index de4e03bf0..fdc299221 100644
--- a/fs/aufs/i_op_ren.c
+++ b/fs/aufs/i_op_ren.c
@@ -32,7 +32,7 @@ struct au_ren_args {
struct inode *dir, *inode;
struct au_hinode *hdir;
struct au_dtime dt[AuParentChild];
- aufs_bindex_t bstart;
+ aufs_bindex_t btop;
} sd[AuSrcDst];
#define src_dentry sd[AuSRC].dentry
@@ -45,7 +45,7 @@ struct au_ren_args {
#define src_hdir sd[AuSRC].hdir
#define src_h_dir sd[AuSRC].hdir->hi_inode
#define src_dt sd[AuSRC].dt
-#define src_bstart sd[AuSRC].bstart
+#define src_btop sd[AuSRC].btop
#define dst_dentry sd[AuDST].dentry
#define dst_dir sd[AuDST].dir
@@ -57,7 +57,7 @@ struct au_ren_args {
#define dst_hdir sd[AuDST].hdir
#define dst_h_dir sd[AuDST].hdir->hi_inode
#define dst_dt sd[AuDST].dt
-#define dst_bstart sd[AuDST].bstart
+#define dst_btop sd[AuDST].btop
struct dentry *h_trap;
struct au_branch *br;
@@ -189,12 +189,12 @@ static int au_ren_or_cpup(struct au_ren_args *a)
struct inode *delegated;
d = a->src_dentry;
- if (au_dbstart(d) == a->btgt) {
+ if (au_dbtop(d) == a->btgt) {
a->h_path.dentry = a->dst_h_dentry;
if (au_ftest_ren(a->flags, DIROPQ)
&& au_dbdiropq(d) == a->btgt)
au_fclr_ren(a->flags, DIROPQ);
- AuDebugOn(au_dbstart(d) != a->btgt);
+ AuDebugOn(au_dbtop(d) != a->btgt);
delegated = NULL;
err = vfsub_rename(a->src_h_dir, au_h_dptr(d, a->btgt),
a->dst_h_dir, &a->h_path, &delegated);
@@ -313,7 +313,7 @@ static int do_rename(struct au_ren_args *a)
a->dst_h_dentry = au_h_dptr(d, a->btgt);
}
- BUG_ON(d_is_positive(a->dst_h_dentry) && a->src_bstart != a->btgt);
+ BUG_ON(d_is_positive(a->dst_h_dentry) && a->src_btop != a->btgt);
/* rename by vfs_rename or cpup */
d = a->dst_dentry;
@@ -321,7 +321,7 @@ static int do_rename(struct au_ren_args *a)
&& (a->dst_wh_dentry
|| au_dbdiropq(d) == a->btgt
/* hide the lower to keep xino */
- || a->btgt < au_dbend(d)
+ || a->btgt < au_dbbot(d)
|| au_opt_test(au_mntflags(d->d_sb), ALWAYS_DIROPQ)))
au_fset_ren(a->flags, DIROPQ);
err = au_ren_or_cpup(a);
@@ -337,7 +337,7 @@ static int do_rename(struct au_ren_args *a)
}
/* update target timestamps */
- AuDebugOn(au_dbstart(a->src_dentry) != a->btgt);
+ AuDebugOn(au_dbtop(a->src_dentry) != a->btgt);
a->h_path.dentry = au_h_dptr(a->src_dentry, a->btgt);
vfsub_update_h_iattr(&a->h_path, /*did*/NULL); /*ignore*/
a->src_inode->i_ctime = d_inode(a->h_path.dentry)->i_ctime;
@@ -410,10 +410,10 @@ static int may_rename_srcdir(struct dentry *dentry, aufs_bindex_t btgt)
{
int err;
unsigned int rdhash;
- aufs_bindex_t bstart;
+ aufs_bindex_t btop;
- bstart = au_dbstart(dentry);
- if (bstart != btgt) {
+ btop = au_dbtop(dentry);
+ if (btop != btgt) {
struct au_nhash whlist;
SiMustAnyLock(dentry->d_sb);
@@ -429,7 +429,7 @@ static int may_rename_srcdir(struct dentry *dentry, aufs_bindex_t btgt)
goto out;
}
- if (bstart == au_dbtaildir(dentry))
+ if (btop == au_dbtaildir(dentry))
return 0; /* success */
err = au_test_empty_lower(dentry);
@@ -462,16 +462,16 @@ static int au_ren_may_dir(struct au_ren_args *a)
if (unlikely(err))
goto out;
- au_set_dbstart(d, a->dst_bstart);
+ au_set_dbtop(d, a->dst_btop);
err = may_rename_dstdir(d, &a->whlist);
- au_set_dbstart(d, a->btgt);
+ au_set_dbtop(d, a->btgt);
}
- a->dst_h_dentry = au_h_dptr(d, au_dbstart(d));
+ a->dst_h_dentry = au_h_dptr(d, au_dbtop(d));
if (unlikely(err))
goto out;
d = a->src_dentry;
- a->src_h_dentry = au_h_dptr(d, au_dbstart(d));
+ a->src_h_dentry = au_h_dptr(d, au_dbtop(d));
if (au_ftest_ren(a->flags, ISDIR)) {
err = may_rename_srcdir(d, a->btgt);
if (unlikely(err)) {
@@ -494,7 +494,7 @@ static int au_may_ren(struct au_ren_args *a)
int err, isdir;
struct inode *h_inode;
- if (a->src_bstart == a->btgt) {
+ if (a->src_btop == a->btgt) {
err = au_may_del(a->src_dentry, a->btgt, a->src_h_parent,
au_ftest_ren(a->flags, ISDIR));
if (unlikely(err))
@@ -505,7 +505,7 @@ static int au_may_ren(struct au_ren_args *a)
}
err = 0;
- if (a->dst_bstart != a->btgt)
+ if (a->dst_btop != a->btgt)
goto out;
err = -ENOTEMPTY;
@@ -588,11 +588,11 @@ static int au_ren_lock(struct au_ren_args *a)
if (unlikely(a->src_hdir->hi_inode != d_inode(a->src_h_parent)
|| a->dst_hdir->hi_inode != d_inode(a->dst_h_parent)))
err = au_busy_or_stale();
- if (!err && au_dbstart(a->src_dentry) == a->btgt)
+ if (!err && au_dbtop(a->src_dentry) == a->btgt)
err = au_h_verify(a->src_h_dentry, udba,
d_inode(a->src_h_parent), a->src_h_parent,
a->br);
- if (!err && au_dbstart(a->dst_dentry) == a->btgt)
+ if (!err && au_dbtop(a->dst_dentry) == a->btgt)
err = au_h_verify(a->dst_h_dentry, udba,
d_inode(a->dst_h_parent), a->dst_h_parent,
a->br);
@@ -634,7 +634,7 @@ static void au_ren_refresh_dir(struct au_ren_args *a)
static void au_ren_refresh(struct au_ren_args *a)
{
- aufs_bindex_t bend, bindex;
+ aufs_bindex_t bbot, bindex;
struct dentry *d, *h_d;
struct inode *i, *h_i;
struct super_block *sb;
@@ -655,32 +655,32 @@ static void au_ren_refresh(struct au_ren_args *a)
}
au_update_dbrange(d, /*do_put_zero*/1);
} else {
- bend = a->btgt;
- for (bindex = au_dbstart(d); bindex < bend; bindex++)
+ bbot = a->btgt;
+ for (bindex = au_dbtop(d); bindex < bbot; bindex++)
au_set_h_dptr(d, bindex, NULL);
- bend = au_dbend(d);
- for (bindex = a->btgt + 1; bindex <= bend; bindex++)
+ bbot = au_dbbot(d);
+ for (bindex = a->btgt + 1; bindex <= bbot; bindex++)
au_set_h_dptr(d, bindex, NULL);
au_update_dbrange(d, /*do_put_zero*/0);
}
d = a->src_dentry;
au_set_dbwh(d, -1);
- bend = au_dbend(d);
- for (bindex = a->btgt + 1; bindex <= bend; bindex++) {
+ bbot = au_dbbot(d);
+ for (bindex = a->btgt + 1; bindex <= bbot; bindex++) {
h_d = au_h_dptr(d, bindex);
if (h_d)
au_set_h_dptr(d, bindex, NULL);
}
- au_set_dbend(d, a->btgt);
+ au_set_dbbot(d, a->btgt);
sb = d->d_sb;
i = a->src_inode;
if (au_opt_test(au_mntflags(sb), PLINK) && au_plink_test(i))
return; /* success */
- bend = au_ibend(i);
- for (bindex = a->btgt + 1; bindex <= bend; bindex++) {
+ bbot = au_ibbot(i);
+ for (bindex = a->btgt + 1; bindex <= bbot; bindex++) {
h_i = au_h_iptr(i, bindex);
if (h_i) {
au_xino_write(sb, bindex, h_i->i_ino, /*ino*/0);
@@ -688,7 +688,7 @@ static void au_ren_refresh(struct au_ren_args *a)
au_set_h_iptr(i, bindex, NULL, 0);
}
}
- au_set_ibend(i, a->btgt);
+ au_set_ibbot(i, a->btgt);
}
/* ---------------------------------------------------------------------- */
@@ -715,7 +715,7 @@ int au_wbr(struct dentry *dentry, aufs_bindex_t btgt)
return btgt;
}
-/* sets src_bstart, dst_bstart and btgt */
+/* sets src_btop, dst_btop and btgt */
static int au_ren_wbr(struct au_ren_args *a)
{
int err;
@@ -724,13 +724,13 @@ static int au_ren_wbr(struct au_ren_args *a)
.flags = AuWrDir_ADD_ENTRY
};
- a->src_bstart = au_dbstart(a->src_dentry);
- a->dst_bstart = au_dbstart(a->dst_dentry);
+ a->src_btop = au_dbtop(a->src_dentry);
+ a->dst_btop = au_dbtop(a->dst_dentry);
if (au_ftest_ren(a->flags, ISDIR))
au_fset_wrdir(wr_dir_args.flags, ISDIR);
- wr_dir_args.force_btgt = a->src_bstart;
- if (a->dst_inode && a->dst_bstart < a->src_bstart)
- wr_dir_args.force_btgt = a->dst_bstart;
+ wr_dir_args.force_btgt = a->src_btop;
+ if (a->dst_inode && a->dst_btop < a->src_btop)
+ wr_dir_args.force_btgt = a->dst_btop;
wr_dir_args.force_btgt = au_wbr(a->dst_dentry, wr_dir_args.force_btgt);
err = au_wr_dir(a->dst_dentry, a->src_dentry, &wr_dir_args);
a->btgt = err;
@@ -880,7 +880,7 @@ int aufs_rename(struct inode *_src_dir, struct dentry *_src_dentry,
goto out_children;
/* prepare the writable parent dir on the same branch */
- if (a->dst_bstart == a->btgt) {
+ if (a->dst_btop == a->btgt) {
au_fset_ren(a->flags, WHDST);
} else {
err = au_cpup_dirs(a->dst_dentry, a->btgt);
@@ -911,7 +911,7 @@ int aufs_rename(struct inode *_src_dir, struct dentry *_src_dentry,
au_fset_ren(a->flags, WHSRC);
/* cpup src */
- if (a->src_bstart != a->btgt) {
+ if (a->src_btop != a->btgt) {
struct au_pin pin;
err = au_pin(&pin, a->src_dentry, a->btgt,
@@ -921,18 +921,18 @@ int aufs_rename(struct inode *_src_dir, struct dentry *_src_dentry,
struct au_cp_generic cpg = {
.dentry = a->src_dentry,
.bdst = a->btgt,
- .bsrc = a->src_bstart,
+ .bsrc = a->src_btop,
.len = -1,
.pin = &pin,
.flags = AuCpup_DTIME | AuCpup_HOPEN
};
- AuDebugOn(au_dbstart(a->src_dentry) != a->src_bstart);
+ AuDebugOn(au_dbtop(a->src_dentry) != a->src_btop);
err = au_sio_cpup_simple(&cpg);
au_unpin(&pin);
}
if (unlikely(err))
goto out_children;
- a->src_bstart = a->btgt;
+ a->src_btop = a->btgt;
a->src_h_dentry = au_h_dptr(a->src_dentry, a->btgt);
au_fset_ren(a->flags, WHSRC);
}
@@ -972,16 +972,16 @@ out_hdir:
au_ren_unlock(a);
out_children:
au_nhash_wh_free(&a->whlist);
- if (err && a->dst_inode && a->dst_bstart != a->btgt) {
- AuDbg("bstart %d, btgt %d\n", a->dst_bstart, a->btgt);
+ if (err && a->dst_inode && a->dst_btop != a->btgt) {
+ AuDbg("btop %d, btgt %d\n", a->dst_btop, a->btgt);
au_set_h_dptr(a->dst_dentry, a->btgt, NULL);
- au_set_dbstart(a->dst_dentry, a->dst_bstart);
+ au_set_dbtop(a->dst_dentry, a->dst_btop);
}
out_parent:
if (!err)
d_move(a->src_dentry, a->dst_dentry);
else {
- au_update_dbstart(a->dst_dentry);
+ au_update_dbtop(a->dst_dentry);
if (!a->dst_inode)
d_drop(a->dst_dentry);
}
diff --git a/fs/aufs/iinfo.c b/fs/aufs/iinfo.c
index 67ef672a0..3a10d8f13 100644
--- a/fs/aufs/iinfo.c
+++ b/fs/aufs/iinfo.c
@@ -11,10 +11,12 @@
struct inode *au_h_iptr(struct inode *inode, aufs_bindex_t bindex)
{
struct inode *h_inode;
+ struct au_hinode *hinode;
IiMustAnyLock(inode);
- h_inode = au_ii(inode)->ii_hinode[0 + bindex].hi_inode;
+ hinode = au_hinode(au_ii(inode), bindex);
+ h_inode = hinode->hi_inode;
AuDebugOn(h_inode && atomic_read(&h_inode->i_count) <= 0);
return h_inode;
}
@@ -49,7 +51,7 @@ void au_set_h_iptr(struct inode *inode, aufs_bindex_t bindex,
IiMustWriteLock(inode);
- hinode = iinfo->ii_hinode + bindex;
+ hinode = au_hinode(iinfo, bindex);
hi = hinode->hi_inode;
AuDebugOn(h_inode && atomic_read(&h_inode->i_count) <= 0);
@@ -64,7 +66,7 @@ void au_set_h_iptr(struct inode *inode, aufs_bindex_t bindex,
AuDebugOn(inode->i_mode
&& (h_inode->i_mode & S_IFMT)
!= (inode->i_mode & S_IFMT));
- if (bindex == iinfo->ii_bstart)
+ if (bindex == iinfo->ii_btop)
au_cpup_igen(inode, h_inode);
br = au_sbr(sb, bindex);
hinode->hi_id = br->br_id;
@@ -91,7 +93,7 @@ void au_set_hi_wh(struct inode *inode, aufs_bindex_t bindex,
IiMustWriteLock(inode);
- hinode = au_ii(inode)->ii_hinode + bindex;
+ hinode = au_hinode(au_ii(inode), bindex);
AuDebugOn(hinode->hi_whdentry);
hinode->hi_whdentry = h_wh;
}
@@ -118,20 +120,18 @@ void au_update_iigen(struct inode *inode, int half)
void au_update_ibrange(struct inode *inode, int do_put_zero)
{
struct au_iinfo *iinfo;
- aufs_bindex_t bindex, bend;
-
- iinfo = au_ii(inode);
- if (!iinfo)
- return;
+ aufs_bindex_t bindex, bbot;
+ AuDebugOn(is_bad_inode(inode));
IiMustWriteLock(inode);
- if (do_put_zero && iinfo->ii_bstart >= 0) {
- for (bindex = iinfo->ii_bstart; bindex <= iinfo->ii_bend;
+ iinfo = au_ii(inode);
+ if (do_put_zero && iinfo->ii_btop >= 0) {
+ for (bindex = iinfo->ii_btop; bindex <= iinfo->ii_bbot;
bindex++) {
struct inode *h_i;
- h_i = iinfo->ii_hinode[0 + bindex].hi_inode;
+ h_i = au_hinode(iinfo, bindex)->hi_inode;
if (h_i
&& !h_i->i_nlink
&& !(h_i->i_state & I_LINKABLE))
@@ -139,21 +139,21 @@ void au_update_ibrange(struct inode *inode, int do_put_zero)
}
}
- iinfo->ii_bstart = -1;
- iinfo->ii_bend = -1;
- bend = au_sbend(inode->i_sb);
- for (bindex = 0; bindex <= bend; bindex++)
- if (iinfo->ii_hinode[0 + bindex].hi_inode) {
- iinfo->ii_bstart = bindex;
+ iinfo->ii_btop = -1;
+ iinfo->ii_bbot = -1;
+ bbot = au_sbbot(inode->i_sb);
+ for (bindex = 0; bindex <= bbot; bindex++)
+ if (au_hinode(iinfo, bindex)->hi_inode) {
+ iinfo->ii_btop = bindex;
break;
}
- if (iinfo->ii_bstart >= 0)
- for (bindex = bend; bindex >= iinfo->ii_bstart; bindex--)
- if (iinfo->ii_hinode[0 + bindex].hi_inode) {
- iinfo->ii_bend = bindex;
+ if (iinfo->ii_btop >= 0)
+ for (bindex = bbot; bindex >= iinfo->ii_btop; bindex--)
+ if (au_hinode(iinfo, bindex)->hi_inode) {
+ iinfo->ii_bbot = bindex;
break;
}
- AuDebugOn(iinfo->ii_bstart > iinfo->ii_bend);
+ AuDebugOn(iinfo->ii_btop > iinfo->ii_bbot);
}
/* ---------------------------------------------------------------------- */
@@ -162,14 +162,20 @@ void au_icntnr_init_once(void *_c)
{
struct au_icntnr *c = _c;
struct au_iinfo *iinfo = &c->iinfo;
- static struct lock_class_key aufs_ii;
spin_lock_init(&iinfo->ii_generation.ig_spin);
au_rw_init(&iinfo->ii_rwsem);
- au_rw_class(&iinfo->ii_rwsem, &aufs_ii);
inode_init_once(&c->vfs_inode);
}
+void au_hinode_init(struct au_hinode *hinode)
+{
+ hinode->hi_inode = NULL;
+ hinode->hi_id = -1;
+ au_hn_init(hinode);
+ hinode->hi_whdentry = NULL;
+}
+
int au_iinfo_init(struct inode *inode)
{
struct au_iinfo *iinfo;
@@ -178,37 +184,37 @@ int au_iinfo_init(struct inode *inode)
sb = inode->i_sb;
iinfo = &(container_of(inode, struct au_icntnr, vfs_inode)->iinfo);
- nbr = au_sbend(sb) + 1;
+ nbr = au_sbbot(sb) + 1;
if (unlikely(nbr <= 0))
nbr = 1;
- iinfo->ii_hinode = kcalloc(nbr, sizeof(*iinfo->ii_hinode), GFP_NOFS);
+ iinfo->ii_hinode = kmalloc_array(nbr, sizeof(*iinfo->ii_hinode),
+ GFP_NOFS);
if (iinfo->ii_hinode) {
au_ninodes_inc(sb);
for (i = 0; i < nbr; i++)
- iinfo->ii_hinode[i].hi_id = -1;
+ au_hinode_init(iinfo->ii_hinode + i);
iinfo->ii_generation.ig_generation = au_sigen(sb);
- iinfo->ii_bstart = -1;
- iinfo->ii_bend = -1;
+ iinfo->ii_btop = -1;
+ iinfo->ii_bbot = -1;
iinfo->ii_vdir = NULL;
return 0;
}
return -ENOMEM;
}
-int au_ii_realloc(struct au_iinfo *iinfo, int nbr)
+int au_hinode_realloc(struct au_iinfo *iinfo, int nbr)
{
- int err, sz;
+ int err, i;
struct au_hinode *hip;
AuRwMustWriteLock(&iinfo->ii_rwsem);
err = -ENOMEM;
- sz = sizeof(*hip) * (iinfo->ii_bend + 1);
- if (!sz)
- sz = sizeof(*hip);
- hip = au_kzrealloc(iinfo->ii_hinode, sz, sizeof(*hip) * nbr, GFP_NOFS);
+ hip = krealloc(iinfo->ii_hinode, sizeof(*hip) * nbr, GFP_NOFS);
if (hip) {
+ for (i = iinfo->ii_bbot + 1; i < nbr; i++)
+ au_hinode_init(hip + i);
iinfo->ii_hinode = hip;
err = 0;
}
@@ -221,13 +227,10 @@ void au_iinfo_fin(struct inode *inode)
struct au_iinfo *iinfo;
struct au_hinode *hi;
struct super_block *sb;
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
const unsigned char unlinked = !inode->i_nlink;
- iinfo = au_ii(inode);
- /* bad_inode case */
- if (!iinfo)
- return;
+ AuDebugOn(is_bad_inode(inode));
sb = inode->i_sb;
au_ninodes_dec(sb);
@@ -245,20 +248,20 @@ void au_iinfo_fin(struct inode *inode)
lockdep_on();
}
+ iinfo = au_ii(inode);
if (iinfo->ii_vdir)
au_vdir_free(iinfo->ii_vdir);
- bindex = iinfo->ii_bstart;
+ bindex = iinfo->ii_btop;
if (bindex >= 0) {
- hi = iinfo->ii_hinode + bindex;
- bend = iinfo->ii_bend;
- while (bindex++ <= bend) {
+ hi = au_hinode(iinfo, bindex);
+ bbot = iinfo->ii_bbot;
+ while (bindex++ <= bbot) {
if (hi->hi_inode)
au_hiput(hi);
hi++;
}
}
kfree(iinfo->ii_hinode);
- iinfo->ii_hinode = NULL;
AuRwDestroy(&iinfo->ii_rwsem);
}
diff --git a/fs/aufs/inode.c b/fs/aufs/inode.c
index 5a87727ba..d599b4c80 100644
--- a/fs/aufs/inode.c
+++ b/fs/aufs/inode.c
@@ -34,19 +34,20 @@ static int au_ii_refresh(struct inode *inode, int *update)
struct au_iinfo *iinfo;
struct au_hinode *p, *q, tmp;
+ AuDebugOn(is_bad_inode(inode));
IiMustWriteLock(inode);
*update = 0;
sb = inode->i_sb;
type = inode->i_mode & S_IFMT;
iinfo = au_ii(inode);
- err = au_ii_realloc(iinfo, au_sbend(sb) + 1);
+ err = au_hinode_realloc(iinfo, au_sbbot(sb) + 1);
if (unlikely(err))
goto out;
- AuDebugOn(iinfo->ii_bstart < 0);
- p = iinfo->ii_hinode + iinfo->ii_bstart;
- for (bindex = iinfo->ii_bstart; bindex <= iinfo->ii_bend;
+ AuDebugOn(iinfo->ii_btop < 0);
+ p = au_hinode(iinfo, iinfo->ii_btop);
+ for (bindex = iinfo->ii_btop; bindex <= iinfo->ii_bbot;
bindex++, p++) {
if (!p->hi_inode)
continue;
@@ -63,12 +64,12 @@ static int au_ii_refresh(struct inode *inode, int *update)
continue;
}
- if (new_bindex < iinfo->ii_bstart)
- iinfo->ii_bstart = new_bindex;
- if (iinfo->ii_bend < new_bindex)
- iinfo->ii_bend = new_bindex;
+ if (new_bindex < iinfo->ii_btop)
+ iinfo->ii_btop = new_bindex;
+ if (iinfo->ii_bbot < new_bindex)
+ iinfo->ii_bbot = new_bindex;
/* swap two lower inode, and loop again */
- q = iinfo->ii_hinode + new_bindex;
+ q = au_hinode(iinfo, new_bindex);
tmp = *q;
*q = *p;
*p = tmp;
@@ -130,7 +131,7 @@ int au_refresh_hinode(struct inode *inode, struct dentry *dentry)
int err, e, update;
unsigned int flags;
umode_t mode;
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
unsigned char isdir;
struct au_hinode *p;
struct au_iinfo *iinfo;
@@ -141,12 +142,12 @@ int au_refresh_hinode(struct inode *inode, struct dentry *dentry)
update = 0;
iinfo = au_ii(inode);
- p = iinfo->ii_hinode + iinfo->ii_bstart;
+ p = au_hinode(iinfo, iinfo->ii_btop);
mode = (inode->i_mode & S_IFMT);
isdir = S_ISDIR(mode);
flags = au_hi_flags(inode, isdir);
- bend = au_dbend(dentry);
- for (bindex = au_dbstart(dentry); bindex <= bend; bindex++) {
+ bbot = au_dbbot(dentry);
+ for (bindex = au_dbtop(dentry); bindex <= bbot; bindex++) {
struct inode *h_i, *h_inode;
struct dentry *h_d;
@@ -156,7 +157,7 @@ int au_refresh_hinode(struct inode *inode, struct dentry *dentry)
h_inode = d_inode(h_d);
AuDebugOn(mode != (h_inode->i_mode & S_IFMT));
- if (iinfo->ii_bstart <= bindex && bindex <= iinfo->ii_bend) {
+ if (iinfo->ii_btop <= bindex && bindex <= iinfo->ii_bbot) {
h_i = au_h_iptr(inode, bindex);
if (h_i) {
if (h_i == h_inode)
@@ -165,10 +166,10 @@ int au_refresh_hinode(struct inode *inode, struct dentry *dentry)
break;
}
}
- if (bindex < iinfo->ii_bstart)
- iinfo->ii_bstart = bindex;
- if (iinfo->ii_bend < bindex)
- iinfo->ii_bend = bindex;
+ if (bindex < iinfo->ii_btop)
+ iinfo->ii_btop = bindex;
+ if (iinfo->ii_bbot < bindex)
+ iinfo->ii_bbot = bindex;
au_set_h_iptr(inode, bindex, au_igrab(h_inode), flags);
update = 1;
}
@@ -189,7 +190,7 @@ static int set_inode(struct inode *inode, struct dentry *dentry)
int err;
unsigned int flags;
umode_t mode;
- aufs_bindex_t bindex, bstart, btail;
+ aufs_bindex_t bindex, btop, btail;
unsigned char isdir;
struct dentry *h_dentry;
struct inode *h_inode;
@@ -201,8 +202,8 @@ static int set_inode(struct inode *inode, struct dentry *dentry)
err = 0;
isdir = 0;
iop = au_sbi(inode->i_sb)->si_iop_array;
- bstart = au_dbstart(dentry);
- h_dentry = au_h_dptr(dentry, bstart);
+ btop = au_dbtop(dentry);
+ h_dentry = au_h_dptr(dentry, btop);
h_inode = d_inode(h_dentry);
mode = h_inode->i_mode;
switch (mode & S_IFMT) {
@@ -210,7 +211,7 @@ static int set_inode(struct inode *inode, struct dentry *dentry)
btail = au_dbtail(dentry);
inode->i_op = iop + AuIop_OTHER;
inode->i_fop = &aufs_file_fop;
- err = au_dy_iaop(inode, bstart, h_inode);
+ err = au_dy_iaop(inode, btop, h_inode);
if (unlikely(err))
goto out;
break;
@@ -246,9 +247,9 @@ static int set_inode(struct inode *inode, struct dentry *dentry)
&& !memcmp(dentry->d_name.name, AUFS_WH_PFX, AUFS_WH_PFX_LEN))
au_fclr_hi(flags, HNOTIFY);
iinfo = au_ii(inode);
- iinfo->ii_bstart = bstart;
- iinfo->ii_bend = btail;
- for (bindex = bstart; bindex <= btail; bindex++) {
+ iinfo->ii_btop = btop;
+ iinfo->ii_bbot = btail;
+ for (bindex = btop; bindex <= btail; bindex++) {
h_dentry = au_h_dptr(dentry, bindex);
if (h_dentry)
au_set_h_iptr(inode, bindex,
@@ -274,7 +275,7 @@ static int reval_inode(struct inode *inode, struct dentry *dentry)
{
int err;
unsigned int gen, igflags;
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
struct inode *h_inode, *h_dinode;
struct dentry *h_dentry;
@@ -289,10 +290,10 @@ static int reval_inode(struct inode *inode, struct dentry *dentry)
err = 1;
ii_write_lock_new_child(inode);
- h_dentry = au_h_dptr(dentry, au_dbstart(dentry));
+ h_dentry = au_h_dptr(dentry, au_dbtop(dentry));
h_dinode = d_inode(h_dentry);
- bend = au_ibend(inode);
- for (bindex = au_ibstart(inode); bindex <= bend; bindex++) {
+ bbot = au_ibbot(inode);
+ for (bindex = au_ibtop(inode); bindex <= bbot; bindex++) {
h_inode = au_h_iptr(inode, bindex);
if (!h_inode || h_inode != h_dinode)
continue;
@@ -358,11 +359,11 @@ struct inode *au_new_inode(struct dentry *dentry, int must_new)
struct mutex *mtx;
ino_t h_ino, ino;
int err;
- aufs_bindex_t bstart;
+ aufs_bindex_t btop;
sb = dentry->d_sb;
- bstart = au_dbstart(dentry);
- h_dentry = au_h_dptr(dentry, bstart);
+ btop = au_dbtop(dentry);
+ h_dentry = au_h_dptr(dentry, btop);
h_inode = d_inode(h_dentry);
h_ino = h_inode->i_ino;
@@ -372,12 +373,12 @@ struct inode *au_new_inode(struct dentry *dentry, int must_new)
*/
mtx = NULL;
if (!d_is_dir(h_dentry))
- mtx = &au_sbr(sb, bstart)->br_xino.xi_nondir_mtx;
+ mtx = &au_sbr(sb, btop)->br_xino.xi_nondir_mtx;
new_ino:
if (mtx)
mutex_lock(mtx);
- err = au_xino_read(sb, bstart, h_ino, &ino);
+ err = au_xino_read(sb, btop, h_ino, &ino);
inode = ERR_PTR(err);
if (unlikely(err))
goto out;
@@ -398,17 +399,6 @@ new_ino:
AuDbg("%lx, new %d\n", inode->i_state, !!(inode->i_state & I_NEW));
if (inode->i_state & I_NEW) {
- /* verbose coding for lock class name */
- if (unlikely(d_is_symlink(h_dentry)))
- au_rw_class(&au_ii(inode)->ii_rwsem,
- au_lc_key + AuLcSymlink_IIINFO);
- else if (unlikely(d_is_dir(h_dentry)))
- au_rw_class(&au_ii(inode)->ii_rwsem,
- au_lc_key + AuLcDir_IIINFO);
- else /* likely */
- au_rw_class(&au_ii(inode)->ii_rwsem,
- au_lc_key + AuLcNonDir_IIINFO);
-
ii_write_lock_new_child(inode);
err = set_inode(inode, dentry);
if (!err) {
@@ -424,7 +414,7 @@ new_ino:
atomic_inc(&inode->i_count);
iget_failed(inode);
ii_write_unlock(inode);
- au_xino_write(sb, bstart, h_ino, /*ino*/0);
+ au_xino_write(sb, btop, h_ino, /*ino*/0);
/* ignore this error */
goto out_iput;
} else if (!must_new && !IS_DEADDIR(inode) && inode->i_nlink) {
@@ -450,10 +440,10 @@ new_ino:
if (unlikely(au_test_fs_unique_ino(h_inode)))
AuWarn1("Warning: Un-notified UDBA or repeatedly renamed dir,"
" b%d, %s, %pd, hi%lu, i%lu.\n",
- bstart, au_sbtype(h_dentry->d_sb), dentry,
+ btop, au_sbtype(h_dentry->d_sb), dentry,
(unsigned long)h_ino, (unsigned long)ino);
ino = 0;
- err = au_xino_write(sb, bstart, h_ino, /*ino*/0);
+ err = au_xino_write(sb, btop, h_ino, /*ino*/0);
if (!err) {
iput(inode);
if (mtx)
@@ -483,8 +473,8 @@ int au_test_ro(struct super_block *sb, aufs_bindex_t bindex,
/* pseudo-link after flushed may happen out of bounds */
if (!err
&& inode
- && au_ibstart(inode) <= bindex
- && bindex <= au_ibend(inode)) {
+ && au_ibtop(inode) <= bindex
+ && bindex <= au_ibbot(inode)) {
/*
* permission check is unnecessary since vfsub routine
* will be called later
diff --git a/fs/aufs/inode.h b/fs/aufs/inode.h
index e694be498..0d654e83a 100644
--- a/fs/aufs/inode.h
+++ b/fs/aufs/inode.h
@@ -56,7 +56,7 @@ struct au_iinfo {
struct super_block *ii_hsb1; /* no get/put */
struct au_rwsem ii_rwsem;
- aufs_bindex_t ii_bstart, ii_bend;
+ aufs_bindex_t ii_btop, ii_bbot;
__u32 ii_higen;
struct au_hinode *ii_hinode;
struct au_vdir *ii_vdir;
@@ -106,12 +106,8 @@ void au_pin_hdir_release(struct au_pin *p);
static inline struct au_iinfo *au_ii(struct inode *inode)
{
- struct au_iinfo *iinfo;
-
- iinfo = &(container_of(inode, struct au_icntnr, vfs_inode)->iinfo);
- if (iinfo->ii_hinode)
- return iinfo;
- return NULL; /* debugging bad_inode case */
+ BUG_ON(is_bad_inode(inode));
+ return &(container_of(inode, struct au_icntnr, vfs_inode)->iinfo);
}
/* ---------------------------------------------------------------------- */
@@ -254,9 +250,10 @@ void au_update_iigen(struct inode *inode, int half);
void au_update_ibrange(struct inode *inode, int do_put_zero);
void au_icntnr_init_once(void *_c);
+void au_hinode_init(struct au_hinode *hinode);
int au_iinfo_init(struct inode *inode);
void au_iinfo_fin(struct inode *inode);
-int au_ii_realloc(struct au_iinfo *iinfo, int nbr);
+int au_hinode_realloc(struct au_iinfo *iinfo, int nbr);
#ifdef CONFIG_PROC_FS
/* plink.c */
@@ -464,23 +461,29 @@ static inline int au_iigen_test(struct inode *inode, unsigned int sigen)
/* ---------------------------------------------------------------------- */
+static inline struct au_hinode *au_hinode(struct au_iinfo *iinfo,
+ aufs_bindex_t bindex)
+{
+ return iinfo->ii_hinode + bindex;
+}
+
static inline aufs_bindex_t au_ii_br_id(struct inode *inode,
aufs_bindex_t bindex)
{
IiMustAnyLock(inode);
- return au_ii(inode)->ii_hinode[0 + bindex].hi_id;
+ return au_hinode(au_ii(inode), bindex)->hi_id;
}
-static inline aufs_bindex_t au_ibstart(struct inode *inode)
+static inline aufs_bindex_t au_ibtop(struct inode *inode)
{
IiMustAnyLock(inode);
- return au_ii(inode)->ii_bstart;
+ return au_ii(inode)->ii_btop;
}
-static inline aufs_bindex_t au_ibend(struct inode *inode)
+static inline aufs_bindex_t au_ibbot(struct inode *inode)
{
IiMustAnyLock(inode);
- return au_ii(inode)->ii_bend;
+ return au_ii(inode)->ii_bbot;
}
static inline struct au_vdir *au_ivdir(struct inode *inode)
@@ -492,19 +495,19 @@ static inline struct au_vdir *au_ivdir(struct inode *inode)
static inline struct dentry *au_hi_wh(struct inode *inode, aufs_bindex_t bindex)
{
IiMustAnyLock(inode);
- return au_ii(inode)->ii_hinode[0 + bindex].hi_whdentry;
+ return au_hinode(au_ii(inode), bindex)->hi_whdentry;
}
-static inline void au_set_ibstart(struct inode *inode, aufs_bindex_t bindex)
+static inline void au_set_ibtop(struct inode *inode, aufs_bindex_t bindex)
{
IiMustWriteLock(inode);
- au_ii(inode)->ii_bstart = bindex;
+ au_ii(inode)->ii_btop = bindex;
}
-static inline void au_set_ibend(struct inode *inode, aufs_bindex_t bindex)
+static inline void au_set_ibbot(struct inode *inode, aufs_bindex_t bindex)
{
IiMustWriteLock(inode);
- au_ii(inode)->ii_bend = bindex;
+ au_ii(inode)->ii_bbot = bindex;
}
static inline void au_set_ivdir(struct inode *inode, struct au_vdir *vdir)
@@ -516,7 +519,7 @@ static inline void au_set_ivdir(struct inode *inode, struct au_vdir *vdir)
static inline struct au_hinode *au_hi(struct inode *inode, aufs_bindex_t bindex)
{
IiMustAnyLock(inode);
- return au_ii(inode)->ii_hinode + bindex;
+ return au_hinode(au_ii(inode), bindex);
}
/* ---------------------------------------------------------------------- */
diff --git a/fs/aufs/ioctl.c b/fs/aufs/ioctl.c
index 6528fb911..2ebfdc4c1 100644
--- a/fs/aufs/ioctl.c
+++ b/fs/aufs/ioctl.c
@@ -17,7 +17,7 @@
static int au_wbr_fd(struct path *path, struct aufs_wbr_fd __user *arg)
{
int err, fd;
- aufs_bindex_t wbi, bindex, bend;
+ aufs_bindex_t wbi, bindex, bbot;
struct file *h_file;
struct super_block *sb;
struct dentry *root;
@@ -57,10 +57,10 @@ static int au_wbr_fd(struct path *path, struct aufs_wbr_fd __user *arg)
sb = path->dentry->d_sb;
root = sb->s_root;
aufs_read_lock(root, AuLock_IR);
- bend = au_sbend(sb);
+ bbot = au_sbbot(sb);
if (wbrfd.brid >= 0) {
wbi = au_br_index(sb, wbrfd.brid);
- if (unlikely(wbi < 0 || wbi > bend))
+ if (unlikely(wbi < 0 || wbi > bbot))
goto out_unlock;
}
@@ -72,7 +72,7 @@ static int au_wbr_fd(struct path *path, struct aufs_wbr_fd __user *arg)
bindex = wbi + 1;
wbi = -1;
- for (; bindex <= bend; bindex++) {
+ for (; bindex <= bbot; bindex++) {
br = au_sbr(sb, bindex);
if (au_br_writable(br->br_perm)) {
wbi = bindex;
@@ -92,7 +92,7 @@ out_unlock:
if (IS_ERR(h_file))
goto out_fd;
- atomic_dec(&br->br_count); /* cf. au_h_open() */
+ au_br_put(br); /* cf. au_h_open() */
fd_install(fd, h_file);
err = fd;
goto out; /* success */
diff --git a/fs/aufs/module.c b/fs/aufs/module.c
index 317fde014..88f8f4123 100644
--- a/fs/aufs/module.c
+++ b/fs/aufs/module.c
@@ -26,7 +26,28 @@ void *au_kzrealloc(void *p, unsigned int nused, unsigned int new_sz, gfp_t gfp)
/*
* aufs caches
*/
-struct kmem_cache *au_cachep[AuCache_Last];
+struct kmem_cache *au_cachep[AuCache_Last] = {
+ [0] = NULL
+};
+
+static void au_cache_fin(void)
+{
+ int i;
+
+ /*
+ * Make sure all delayed rcu free inodes are flushed before we
+ * destroy cache.
+ */
+ rcu_barrier();
+
+ /* excluding AuCache_HNOTIFY */
+ BUILD_BUG_ON(AuCache_HNOTIFY + 1 != AuCache_Last);
+ for (i = 0; i < AuCache_HNOTIFY; i++) {
+ kmem_cache_destroy(au_cachep[i]);
+ au_cachep[i] = NULL;
+ }
+}
+
static int __init au_cache_init(void)
{
au_cachep[AuCache_DINFO] = AuCacheCtor(au_dinfo, au_di_init_once);
@@ -44,27 +65,10 @@ static int __init au_cache_init(void)
if (au_cachep[AuCache_DEHSTR])
return 0;
+ au_cache_fin();
return -ENOMEM;
}
-static void au_cache_fin(void)
-{
- int i;
-
- /*
- * Make sure all delayed rcu free inodes are flushed before we
- * destroy cache.
- */
- rcu_barrier();
-
- /* excluding AuCache_HNOTIFY */
- BUILD_BUG_ON(AuCache_HNOTIFY + 1 != AuCache_Last);
- for (i = 0; i < AuCache_HNOTIFY; i++) {
- kmem_cache_destroy(au_cachep[i]);
- au_cachep[i] = NULL;
- }
-}
-
/* ---------------------------------------------------------------------- */
int au_dir_roflags;
@@ -77,8 +81,6 @@ int au_dir_roflags;
struct au_sphlhead au_sbilist;
#endif
-struct lock_class_key au_lc_key[AuLcKey_Last];
-
/*
* functions for module interface.
*/
diff --git a/fs/aufs/module.h b/fs/aufs/module.h
index bb8644730..1383e3da9 100644
--- a/fs/aufs/module.h
+++ b/fs/aufs/module.h
@@ -24,22 +24,6 @@ extern bool au_userns;
extern int au_dir_roflags;
-enum {
- AuLcNonDir_FIINFO,
- AuLcNonDir_DIINFO,
- AuLcNonDir_IIINFO,
-
- AuLcDir_FIINFO,
- AuLcDir_DIINFO,
- AuLcDir_IIINFO,
-
- AuLcSymlink_DIINFO,
- AuLcSymlink_IIINFO,
-
- AuLcKey_Last
-};
-extern struct lock_class_key au_lc_key[AuLcKey_Last];
-
void *au_kzrealloc(void *p, unsigned int nused, unsigned int new_sz, gfp_t gfp);
int au_seq_path(struct seq_file *seq, struct path *path);
diff --git a/fs/aufs/mvdown.c b/fs/aufs/mvdown.c
index d8415422b..334f25c13 100644
--- a/fs/aufs/mvdown.c
+++ b/fs/aufs/mvdown.c
@@ -53,27 +53,27 @@ struct au_mvd_args {
static int find_lower_writable(struct au_mvd_args *a)
{
struct super_block *sb;
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
struct au_branch *br;
sb = a->sb;
bindex = a->mvd_bsrc;
- bend = au_sbend(sb);
+ bbot = au_sbbot(sb);
if (a->mvdown.flags & AUFS_MVDOWN_FHSM_LOWER)
- for (bindex++; bindex <= bend; bindex++) {
+ for (bindex++; bindex <= bbot; bindex++) {
br = au_sbr(sb, bindex);
if (au_br_fhsm(br->br_perm)
&& (!(au_br_sb(br)->s_flags & MS_RDONLY)))
return bindex;
}
else if (!(a->mvdown.flags & AUFS_MVDOWN_ROLOWER))
- for (bindex++; bindex <= bend; bindex++) {
+ for (bindex++; bindex <= bbot; bindex++) {
br = au_sbr(sb, bindex);
if (!au_br_rdonly(br))
return bindex;
}
else
- for (bindex++; bindex <= bend; bindex++) {
+ for (bindex++; bindex <= bbot; bindex++) {
br = au_sbr(sb, bindex);
if (!(au_br_sb(br)->s_flags & MS_RDONLY)) {
if (au_br_rdonly(br))
@@ -96,7 +96,7 @@ static int au_do_mkdir(const unsigned char dmsg, struct au_mvd_args *a)
a->mvd_hdir_dst = au_hi(a->dir, a->mvd_bdst);
a->mvd_h_src_parent = au_h_dptr(a->parent, a->mvd_bsrc);
a->mvd_h_dst_parent = NULL;
- if (au_dbend(a->parent) >= a->mvd_bdst)
+ if (au_dbbot(a->parent) >= a->mvd_bdst)
a->mvd_h_dst_parent = au_h_dptr(a->parent, a->mvd_bdst);
if (!a->mvd_h_dst_parent) {
err = au_cpdown_dirs(a->dentry, a->mvd_bdst);
@@ -350,20 +350,20 @@ static int au_do_mvdown(const unsigned char dmsg, struct au_mvd_args *a)
/* maintain internal array */
if (!(a->mvdown.flags & AUFS_MVDOWN_KUPPER)) {
au_set_h_dptr(a->dentry, a->mvd_bsrc, NULL);
- au_set_dbstart(a->dentry, a->mvd_bdst);
+ au_set_dbtop(a->dentry, a->mvd_bdst);
au_set_h_iptr(a->inode, a->mvd_bsrc, NULL, /*flags*/0);
- au_set_ibstart(a->inode, a->mvd_bdst);
+ au_set_ibtop(a->inode, a->mvd_bdst);
} else {
/* hide the lower */
au_set_h_dptr(a->dentry, a->mvd_bdst, NULL);
- au_set_dbend(a->dentry, a->mvd_bsrc);
+ au_set_dbbot(a->dentry, a->mvd_bsrc);
au_set_h_iptr(a->inode, a->mvd_bdst, NULL, /*flags*/0);
- au_set_ibend(a->inode, a->mvd_bsrc);
+ au_set_ibbot(a->inode, a->mvd_bsrc);
}
- if (au_dbend(a->dentry) < a->mvd_bdst)
- au_set_dbend(a->dentry, a->mvd_bdst);
- if (au_ibend(a->inode) < a->mvd_bdst)
- au_set_ibend(a->inode, a->mvd_bdst);
+ if (au_dbbot(a->dentry) < a->mvd_bdst)
+ au_set_dbbot(a->dentry, a->mvd_bdst);
+ if (au_ibbot(a->inode) < a->mvd_bdst)
+ au_set_ibbot(a->inode, a->mvd_bdst);
out_unlock:
au_do_unlock(dmsg, a);
@@ -381,7 +381,7 @@ static int au_mvd_args_busy(const unsigned char dmsg, struct au_mvd_args *a)
err = 0;
plinked = !!au_opt_test(au_mntflags(a->sb), PLINK);
- if (au_dbstart(a->dentry) == a->mvd_bsrc
+ if (au_dbtop(a->dentry) == a->mvd_bsrc
&& au_dcount(a->dentry) == 1
&& atomic_read(&a->inode->i_count) == 1
/* && a->mvd_h_src_inode->i_nlink == 1 */
@@ -392,7 +392,7 @@ static int au_mvd_args_busy(const unsigned char dmsg, struct au_mvd_args *a)
err = -EBUSY;
AU_MVD_PR(dmsg,
"b%d, d{b%d, c%d?}, i{c%d?, l%u}, hi{l%u}, p{%d, %d}\n",
- a->mvd_bsrc, au_dbstart(a->dentry), au_dcount(a->dentry),
+ a->mvd_bsrc, au_dbtop(a->dentry), au_dcount(a->dentry),
atomic_read(&a->inode->i_count), a->inode->i_nlink,
a->mvd_h_src_inode->i_nlink,
plinked, plinked ? au_plink_test(a->inode) : 0);
@@ -455,7 +455,7 @@ static int au_mvd_args_intermediate(const unsigned char dmsg,
if (!err)
a->bwh = au_dbwh(a->dentry);
else if (err > 0)
- a->bfound = au_dbstart(a->dentry);
+ a->bfound = au_dbtop(a->dentry);
au_di_swap(tmp, dinfo);
au_rw_write_unlock(&tmp->di_rwsem);
@@ -542,22 +542,22 @@ static int au_mvd_args(const unsigned char dmsg, struct au_mvd_args *a)
err = -EINVAL;
if (!(a->mvdown.flags & AUFS_MVDOWN_BRID_UPPER))
- a->mvd_bsrc = au_ibstart(a->inode);
+ a->mvd_bsrc = au_ibtop(a->inode);
else {
a->mvd_bsrc = au_br_index(a->sb, a->mvd_src_brid);
if (unlikely(a->mvd_bsrc < 0
- || (a->mvd_bsrc < au_dbstart(a->dentry)
- || au_dbend(a->dentry) < a->mvd_bsrc
+ || (a->mvd_bsrc < au_dbtop(a->dentry)
+ || au_dbbot(a->dentry) < a->mvd_bsrc
|| !au_h_dptr(a->dentry, a->mvd_bsrc))
- || (a->mvd_bsrc < au_ibstart(a->inode)
- || au_ibend(a->inode) < a->mvd_bsrc
+ || (a->mvd_bsrc < au_ibtop(a->inode)
+ || au_ibbot(a->inode) < a->mvd_bsrc
|| !au_h_iptr(a->inode, a->mvd_bsrc)))) {
a->mvd_errno = EAU_MVDOWN_NOUPPER;
AU_MVD_PR(dmsg, "no upper\n");
goto out;
}
}
- if (unlikely(a->mvd_bsrc == au_sbend(a->sb))) {
+ if (unlikely(a->mvd_bsrc == au_sbbot(a->sb))) {
a->mvd_errno = EAU_MVDOWN_BOTTOM;
AU_MVD_PR(dmsg, "on the bottom\n");
goto out;
@@ -587,7 +587,7 @@ static int au_mvd_args(const unsigned char dmsg, struct au_mvd_args *a)
} else {
a->mvd_bdst = au_br_index(a->sb, a->mvd_dst_brid);
if (unlikely(a->mvd_bdst < 0
- || au_sbend(a->sb) < a->mvd_bdst)) {
+ || au_sbbot(a->sb) < a->mvd_bdst)) {
a->mvd_errno = EAU_MVDOWN_NOLOWERBR;
AU_MVD_PR(dmsg, "no lower brid\n");
goto out;
diff --git a/fs/aufs/opts.c b/fs/aufs/opts.c
index fc90b657a..23a146d17 100644
--- a/fs/aufs/opts.c
+++ b/fs/aufs/opts.c
@@ -824,7 +824,7 @@ static int au_opts_parse_idel(struct super_block *sb, aufs_bindex_t bindex,
err = -EINVAL;
root = sb->s_root;
aufs_read_lock(root, AuLock_FLUSH);
- if (bindex < 0 || au_sbend(sb) < bindex) {
+ if (bindex < 0 || au_sbbot(sb) < bindex) {
pr_err("out of bounds, %d\n", bindex);
goto out;
}
@@ -880,7 +880,7 @@ static int au_opts_parse_imod(struct super_block *sb, aufs_bindex_t bindex,
err = -EINVAL;
root = sb->s_root;
aufs_read_lock(root, AuLock_FLUSH);
- if (bindex < 0 || au_sbend(sb) < bindex) {
+ if (bindex < 0 || au_sbbot(sb) < bindex) {
pr_err("out of bounds, %d\n", bindex);
goto out;
}
@@ -929,7 +929,7 @@ au_opts_parse_xino_itrunc_path(struct super_block *sb,
substring_t args[])
{
int err;
- aufs_bindex_t bend, bindex;
+ aufs_bindex_t bbot, bindex;
struct path path;
struct dentry *root;
@@ -942,8 +942,8 @@ au_opts_parse_xino_itrunc_path(struct super_block *sb,
xino_itrunc->bindex = -1;
root = sb->s_root;
aufs_read_lock(root, AuLock_FLUSH);
- bend = au_sbend(sb);
- for (bindex = 0; bindex <= bend; bindex++) {
+ bbot = au_sbbot(sb);
+ for (bindex = 0; bindex <= bbot; bindex++) {
if (au_h_dptr(root, bindex) == path.dentry) {
xino_itrunc->bindex = bindex;
break;
@@ -1087,7 +1087,7 @@ int au_opts_parse(struct super_block *sb, char *str, struct au_opts *opts)
}
u.xino_itrunc->bindex = n;
aufs_read_lock(root, AuLock_FLUSH);
- if (n < 0 || au_sbend(sb) < n) {
+ if (n < 0 || au_sbbot(sb) < n) {
pr_err("out of bounds, %d\n", n);
aufs_read_unlock(root, !AuLock_IR);
break;
@@ -1465,7 +1465,7 @@ static int au_opt_br(struct super_block *sb, struct au_opt *opt,
err = 0;
switch (opt->type) {
case Opt_append:
- opt->add.bindex = au_sbend(sb) + 1;
+ opt->add.bindex = au_sbbot(sb) + 1;
if (opt->add.bindex < 0)
opt->add.bindex = 0;
goto add;
@@ -1513,7 +1513,7 @@ static int au_opt_xino(struct super_block *sb, struct au_opt *opt,
struct au_opts *opts)
{
int err;
- aufs_bindex_t bend, bindex;
+ aufs_bindex_t bbot, bindex;
struct dentry *root, *parent, *h_root;
err = 0;
@@ -1530,8 +1530,8 @@ static int au_opt_xino(struct super_block *sb, struct au_opt *opt,
/* safe d_parent access */
parent = opt->xino.file->f_path.dentry->d_parent;
root = sb->s_root;
- bend = au_sbend(sb);
- for (bindex = 0; bindex <= bend; bindex++) {
+ bbot = au_sbbot(sb);
+ for (bindex = 0; bindex <= bbot; bindex++) {
h_root = au_h_dptr(root, bindex);
if (h_root == parent) {
au_xino_brid_set(sb, au_sbr_id(sb, bindex));
@@ -1554,7 +1554,7 @@ int au_opts_verify(struct super_block *sb, unsigned long sb_flags,
unsigned int pending)
{
int err, fhsm;
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
unsigned char do_plink, skip, do_free, can_no_dreval;
struct au_branch *br;
struct au_wbr *wbr;
@@ -1590,8 +1590,8 @@ int au_opts_verify(struct super_block *sb, unsigned long sb_flags,
do_plink = !!au_opt_test(sbinfo->si_mntflags, PLINK);
can_no_dreval = !!au_opt_test((sbinfo->si_mntflags | pending),
UDBA_NONE);
- bend = au_sbend(sb);
- for (bindex = 0; !err && bindex <= bend; bindex++) {
+ bbot = au_sbbot(sb);
+ for (bindex = 0; !err && bindex <= bbot; bindex++) {
skip = 0;
h_dir = au_h_iptr(dir, bindex);
br = au_sbr(sb, bindex);
@@ -1677,7 +1677,7 @@ int au_opts_verify(struct super_block *sb, unsigned long sb_flags,
if (fhsm >= 2) {
au_fset_si(sbinfo, FHSM);
- for (bindex = bend; bindex >= 0; bindex--) {
+ for (bindex = bbot; bindex >= 0; bindex--) {
br = au_sbr(sb, bindex);
if (au_br_fhsm(br->br_perm)) {
au_fhsm_set_bottom(sb, bindex);
@@ -1696,7 +1696,7 @@ int au_opts_mount(struct super_block *sb, struct au_opts *opts)
{
int err;
unsigned int tmp;
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
struct au_opt *opt;
struct au_opt_xino *opt_xino, xino;
struct au_sbinfo *sbinfo;
@@ -1729,8 +1729,8 @@ int au_opts_mount(struct super_block *sb, struct au_opts *opts)
else if (unlikely(err < 0))
goto out;
- bend = au_sbend(sb);
- if (unlikely(bend < 0)) {
+ bbot = au_sbbot(sb);
+ if (unlikely(bbot < 0)) {
err = -EINVAL;
pr_err("no branches\n");
goto out;
@@ -1765,8 +1765,8 @@ int au_opts_mount(struct super_block *sb, struct au_opts *opts)
tmp &= AuOptMask_UDBA;
sbinfo->si_mntflags &= ~AuOptMask_UDBA;
sbinfo->si_mntflags |= tmp;
- bend = au_sbend(sb);
- for (bindex = 0; bindex <= bend; bindex++) {
+ bbot = au_sbbot(sb);
+ for (bindex = 0; bindex <= bbot; bindex++) {
br = au_sbr(sb, bindex);
err = au_hnotify_reset_br(tmp, br, br->br_perm);
if (unlikely(err))
diff --git a/fs/aufs/plink.c b/fs/aufs/plink.c
index b6d63269c..c42734dd4 100644
--- a/fs/aufs/plink.c
+++ b/fs/aufs/plink.c
@@ -429,13 +429,13 @@ void au_plink_clean(struct super_block *sb, int verbose)
static int au_plink_do_half_refresh(struct inode *inode, aufs_bindex_t br_id)
{
int do_put;
- aufs_bindex_t bstart, bend, bindex;
+ aufs_bindex_t btop, bbot, bindex;
do_put = 0;
- bstart = au_ibstart(inode);
- bend = au_ibend(inode);
- if (bstart >= 0) {
- for (bindex = bstart; bindex <= bend; bindex++) {
+ btop = au_ibtop(inode);
+ bbot = au_ibbot(inode);
+ if (btop >= 0) {
+ for (bindex = btop; bindex <= bbot; bindex++) {
if (!au_h_iptr(inode, bindex)
|| au_ii_br_id(inode, bindex) != br_id)
continue;
@@ -444,7 +444,7 @@ static int au_plink_do_half_refresh(struct inode *inode, aufs_bindex_t br_id)
break;
}
if (do_put)
- for (bindex = bstart; bindex <= bend; bindex++)
+ for (bindex = btop; bindex <= bbot; bindex++)
if (au_h_iptr(inode, bindex)) {
do_put = 0;
break;
diff --git a/fs/aufs/posix_acl.c b/fs/aufs/posix_acl.c
index d6eeebdec..0ddd46997 100644
--- a/fs/aufs/posix_acl.c
+++ b/fs/aufs/posix_acl.c
@@ -24,7 +24,7 @@ struct posix_acl *aufs_get_acl(struct inode *inode, int type)
if (!(sb->s_flags & MS_POSIXACL))
goto out;
- bindex = au_ibstart(inode);
+ bindex = au_ibtop(inode);
h_inode = au_h_iptr(inode, bindex);
if (unlikely(!h_inode
|| ((h_inode->i_mode & S_IFMT)
diff --git a/fs/aufs/rdu.c b/fs/aufs/rdu.c
index ec0844673..7180f18e6 100644
--- a/fs/aufs/rdu.c
+++ b/fs/aufs/rdu.c
@@ -109,7 +109,7 @@ out:
static int au_rdu(struct file *file, struct aufs_rdu *rdu)
{
int err;
- aufs_bindex_t bend;
+ aufs_bindex_t bbot;
struct au_rdu_arg arg = {
.ctx = {
.actor = au_rdu_fill
@@ -176,12 +176,12 @@ static int au_rdu(struct file *file, struct aufs_rdu *rdu)
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;
+ bbot = au_fbtop(file);
+ if (cookie->bindex < bbot)
+ cookie->bindex = bbot;
+ bbot = au_fbbot_dir(file);
+ /* AuDbg("b%d, b%d\n", cookie->bindex, bbot); */
+ for (; !err && cookie->bindex <= bbot;
cookie->bindex++, cookie->h_pos = 0) {
h_file = au_hf_dir(file, cookie->bindex);
if (!h_file)
@@ -202,7 +202,7 @@ static int au_rdu(struct file *file, struct aufs_rdu *rdu)
}
ii_read_lock_child(inode);
- fsstack_copy_attr_atime(inode, au_h_iptr(inode, au_ibstart(inode)));
+ fsstack_copy_attr_atime(inode, au_h_iptr(inode, au_ibtop(inode)));
ii_read_unlock(inode);
out_unlock:
diff --git a/fs/aufs/rwsem.h b/fs/aufs/rwsem.h
index ef50c2ccb..6c0d5a902 100644
--- a/fs/aufs/rwsem.h
+++ b/fs/aufs/rwsem.h
@@ -21,6 +21,15 @@ struct au_rwsem {
#endif
};
+#ifdef CONFIG_LOCKDEP
+#define au_lockdep_set_name(rw) \
+ lockdep_set_class_and_name(&(rw)->rwsem, \
+ /*original key*/(rw)->rwsem.dep_map.key, \
+ /*name*/#rw)
+#else
+#define au_lockdep_set_name(rw) do {} while (0)
+#endif
+
#ifdef CONFIG_AUFS_DEBUG
#define AuDbgCntInit(rw) do { \
atomic_set(&(rw)->rcnt, 0); \
@@ -28,11 +37,15 @@ struct au_rwsem {
smp_mb(); /* atomic set */ \
} while (0)
-#define AuDbgRcntInc(rw) atomic_inc(&(rw)->rcnt)
-#define AuDbgRcntDec(rw) WARN_ON(atomic_dec_return(&(rw)->rcnt) < 0)
-#define AuDbgWcntInc(rw) atomic_inc(&(rw)->wcnt)
-#define AuDbgWcntDec(rw) WARN_ON(atomic_dec_return(&(rw)->wcnt) < 0)
+#define AuDbgCnt(rw, cnt) atomic_read(&(rw)->cnt)
+#define AuDbgCntInc(rw, cnt) atomic_inc(&(rw)->cnt)
+#define AuDbgCntDec(rw, cnt) WARN_ON(atomic_dec_return(&(rw)->cnt) < 0)
+#define AuDbgRcntInc(rw) AuDbgCntInc(rw, rcnt)
+#define AuDbgRcntDec(rw) AuDbgCntDec(rw, rcnt)
+#define AuDbgWcntInc(rw) AuDbgCntInc(rw, wcnt)
+#define AuDbgWcntDec(rw) AuDbgCntDec(rw, wcnt)
#else
+#define AuDbgCnt(rw, cnt) 0
#define AuDbgCntInit(rw) do {} while (0)
#define AuDbgRcntInc(rw) do {} while (0)
#define AuDbgRcntDec(rw) do {} while (0)
@@ -41,37 +54,32 @@ struct au_rwsem {
#endif /* CONFIG_AUFS_DEBUG */
/* to debug easier, do not make them inlined functions */
-#define AuRwMustNoWaiters(rw) AuDebugOn(!list_empty(&(rw)->rwsem.wait_list))
+#define AuRwMustNoWaiters(rw) AuDebugOn(rwsem_is_contended(&(rw)->rwsem))
/* rwsem_is_locked() is unusable */
-#define AuRwMustReadLock(rw) AuDebugOn(atomic_read(&(rw)->rcnt) <= 0)
-#define AuRwMustWriteLock(rw) AuDebugOn(atomic_read(&(rw)->wcnt) <= 0)
-#define AuRwMustAnyLock(rw) AuDebugOn(atomic_read(&(rw)->rcnt) <= 0 \
- && atomic_read(&(rw)->wcnt) <= 0)
-#define AuRwDestroy(rw) AuDebugOn(atomic_read(&(rw)->rcnt) \
- || atomic_read(&(rw)->wcnt))
-
-#define au_rw_class(rw, key) lockdep_set_class(&(rw)->rwsem, key)
-
-static inline void au_rw_init(struct au_rwsem *rw)
-{
- AuDbgCntInit(rw);
- init_rwsem(&rw->rwsem);
-}
-
-static inline void au_rw_init_wlock(struct au_rwsem *rw)
-{
- au_rw_init(rw);
- down_write(&rw->rwsem);
- AuDbgWcntInc(rw);
-}
-
-static inline void au_rw_init_wlock_nested(struct au_rwsem *rw,
- unsigned int lsc)
-{
- au_rw_init(rw);
- down_write_nested(&rw->rwsem, lsc);
- AuDbgWcntInc(rw);
-}
+#define AuRwMustReadLock(rw) AuDebugOn(AuDbgCnt(rw, rcnt) <= 0)
+#define AuRwMustWriteLock(rw) AuDebugOn(AuDbgCnt(rw, wcnt) <= 0)
+#define AuRwMustAnyLock(rw) AuDebugOn(AuDbgCnt(rw, rcnt) <= 0 \
+ && AuDbgCnt(rw, wcnt) <= 0)
+#define AuRwDestroy(rw) AuDebugOn(AuDbgCnt(rw, rcnt) \
+ || AuDbgCnt(rw, wcnt))
+
+#define au_rw_init(rw) do { \
+ AuDbgCntInit(rw); \
+ init_rwsem(&(rw)->rwsem); \
+ au_lockdep_set_name(rw); \
+ } while (0)
+
+#define au_rw_init_wlock(rw) do { \
+ au_rw_init(rw); \
+ down_write(&(rw)->rwsem); \
+ AuDbgWcntInc(rw); \
+ } while (0)
+
+#define au_rw_init_wlock_nested(rw, lsc) do { \
+ au_rw_init(rw); \
+ down_write_nested(&(rw)->rwsem, lsc); \
+ AuDbgWcntInc(rw); \
+ } while (0)
static inline void au_rw_read_lock(struct au_rwsem *rw)
{
@@ -141,10 +149,9 @@ static inline int au_rw_write_trylock(struct au_rwsem *rw)
return ret;
}
-#undef AuDbgCntInit
+#undef AuDbgCntDec
#undef AuDbgRcntInc
#undef AuDbgRcntDec
-#undef AuDbgWcntInc
#undef AuDbgWcntDec
#define AuSimpleLockRwsemFuncs(prefix, param, rwsem) \
diff --git a/fs/aufs/sbinfo.c b/fs/aufs/sbinfo.c
index a9d782e43..aa970593a 100644
--- a/fs/aufs/sbinfo.c
+++ b/fs/aufs/sbinfo.c
@@ -20,7 +20,12 @@ void au_si_free(struct kobject *kobj)
sbinfo = container_of(kobj, struct au_sbinfo, si_kobj);
for (i = 0; i < AuPlink_NHASH; i++)
AuDebugOn(!hlist_empty(&sbinfo->si_plink[i].head));
- AuDebugOn(atomic_read(&sbinfo->si_nowait.nw_len));
+ au_nwt_fin(&sbinfo->si_nowait);
+
+ AuDebugOn(percpu_counter_sum(&sbinfo->si_ninodes));
+ percpu_counter_destroy(&sbinfo->si_ninodes);
+ AuDebugOn(percpu_counter_sum(&sbinfo->si_nfiles));
+ percpu_counter_destroy(&sbinfo->si_nfiles);
au_rw_write_lock(&sbinfo->si_rwsem);
au_br_free(sbinfo);
@@ -40,7 +45,6 @@ int au_si_alloc(struct super_block *sb)
{
int err, i;
struct au_sbinfo *sbinfo;
- static struct lock_class_key aufs_si;
err = -ENOMEM;
sbinfo = kzalloc(sizeof(*sbinfo), GFP_NOFS);
@@ -58,13 +62,12 @@ int au_si_alloc(struct super_block *sb)
au_nwt_init(&sbinfo->si_nowait);
au_rw_init_wlock(&sbinfo->si_rwsem);
- au_rw_class(&sbinfo->si_rwsem, &aufs_si);
mutex_init(&sbinfo->au_si_pid.pid_mtx);
- atomic_long_set(&sbinfo->si_ninodes, 0);
- atomic_long_set(&sbinfo->si_nfiles, 0);
+ percpu_counter_init(&sbinfo->si_ninodes, 0, GFP_NOFS);
+ percpu_counter_init(&sbinfo->si_nfiles, 0, GFP_NOFS);
- sbinfo->si_bend = -1;
+ sbinfo->si_bbot = -1;
sbinfo->si_last_br_id = AUFS_BRANCH_MAX / 2;
sbinfo->si_wbr_copyup = AuWbrCopyup_Def;
@@ -122,7 +125,7 @@ int au_sbr_realloc(struct au_sbinfo *sbinfo, int nbr)
AuRwMustWriteLock(&sbinfo->si_rwsem);
err = -ENOMEM;
- sz = sizeof(*brp) * (sbinfo->si_bend + 1);
+ sz = sizeof(*brp) * (sbinfo->si_bbot + 1);
if (unlikely(!sz))
sz = sizeof(*brp);
brp = au_kzrealloc(sbinfo->si_branch, sz, sizeof(*brp) * nbr, GFP_NOFS);
diff --git a/fs/aufs/super.c b/fs/aufs/super.c
index 7928a5031..18190aa5f 100644
--- a/fs/aufs/super.c
+++ b/fs/aufs/super.c
@@ -23,7 +23,6 @@ static struct inode *aufs_alloc_inode(struct super_block *sb __maybe_unused)
if (c) {
au_icntnr_init(c);
c->vfs_inode.i_version = 1; /* sigen(sb); */
- c->iinfo.ii_hinode = NULL;
return &c->vfs_inode;
}
return NULL;
@@ -39,7 +38,8 @@ static void aufs_destroy_inode_cb(struct rcu_head *head)
static void aufs_destroy_inode(struct inode *inode)
{
- au_iinfo_fin(inode);
+ if (!is_bad_inode(inode))
+ au_iinfo_fin(inode);
call_rcu(&inode->i_rcu, aufs_destroy_inode_cb);
}
@@ -77,16 +77,16 @@ out:
static int au_show_brs(struct seq_file *seq, struct super_block *sb)
{
int err;
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
struct path path;
struct au_hdentry *hdp;
struct au_branch *br;
au_br_perm_str_t perm;
err = 0;
- bend = au_sbend(sb);
+ bbot = au_sbbot(sb);
hdp = au_di(sb->s_root)->di_hdentry;
- for (bindex = 0; !err && bindex <= bend; bindex++) {
+ for (bindex = 0; !err && bindex <= bbot; bindex++) {
br = au_sbr(sb, bindex);
path.mnt = au_br_mnt(br);
path.dentry = hdp[bindex].hd_dentry;
@@ -94,7 +94,7 @@ static int au_show_brs(struct seq_file *seq, struct super_block *sb)
if (!err) {
au_optstr_br_perm(&perm, br->br_perm);
seq_printf(seq, "=%s", perm.a);
- if (bindex != bend)
+ if (bindex != bbot)
seq_putc(seq, ':');
}
}
@@ -318,7 +318,7 @@ static int au_statfs_sum(struct super_block *sb, struct kstatfs *buf)
int err;
long bsize, factor;
u64 blocks, bfree, bavail, files, ffree;
- aufs_bindex_t bend, bindex, i;
+ aufs_bindex_t bbot, bindex, i;
unsigned char shared;
struct path h_path;
struct super_block *h_sb;
@@ -330,8 +330,8 @@ static int au_statfs_sum(struct super_block *sb, struct kstatfs *buf)
blocks = 0;
bfree = 0;
bavail = 0;
- bend = au_sbend(sb);
- for (bindex = 0; bindex <= bend; bindex++) {
+ bbot = au_sbbot(sb);
+ for (bindex = 0; bindex <= bbot; bindex++) {
h_path.mnt = au_sbr_mnt(sb, bindex);
h_sb = h_path.mnt->mnt_sb;
shared = 0;
@@ -414,14 +414,14 @@ static int aufs_statfs(struct dentry *dentry, struct kstatfs *buf)
static int aufs_sync_fs(struct super_block *sb, int wait)
{
int err, e;
- aufs_bindex_t bend, bindex;
+ aufs_bindex_t bbot, bindex;
struct au_branch *br;
struct super_block *h_sb;
err = 0;
si_noflush_read_lock(sb);
- bend = au_sbend(sb);
- for (bindex = 0; bindex <= bend; bindex++) {
+ bbot = au_sbbot(sb);
+ for (bindex = 0; bindex <= bbot; bindex++) {
br = au_sbr(sb, bindex);
if (!au_br_writable(br->br_perm))
continue;
@@ -504,7 +504,7 @@ static unsigned long long au_iarray_cb(struct super_block *sb, void *a,
spin_lock(&sb->s_inode_list_lock);
list_for_each_entry(inode, head, i_sb_list) {
if (!is_bad_inode(inode)
- && au_ii(inode)->ii_bstart >= 0) {
+ && au_ii(inode)->ii_btop >= 0) {
spin_lock(&inode->i_lock);
if (atomic_read(&inode->i_count)) {
au_igrab(inode);
@@ -522,7 +522,7 @@ static unsigned long long au_iarray_cb(struct super_block *sb, void *a,
struct inode **au_iarray_alloc(struct super_block *sb, unsigned long long *max)
{
- *max = atomic_long_read(&au_sbi(sb)->si_ninodes);
+ *max = au_ninodes(sb);
return au_array_alloc(max, au_iarray_cb, sb, &sb->s_inodes);
}
@@ -681,7 +681,7 @@ static void au_remount_refresh(struct super_block *sb, unsigned int do_idop)
{
int err, e;
unsigned int udba;
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
struct dentry *root;
struct inode *inode;
struct au_branch *br;
@@ -697,8 +697,8 @@ static void au_remount_refresh(struct super_block *sb, unsigned int do_idop)
IiMustNoWaiters(inode);
udba = au_opt_udba(sb);
- bend = au_sbend(sb);
- for (bindex = 0; bindex <= bend; bindex++) {
+ bbot = au_sbbot(sb);
+ for (bindex = 0; bindex <= bbot; bindex++) {
br = au_sbr(sb, bindex);
err = au_hnotify_reset_br(udba, br, br->br_perm);
if (unlikely(err))
diff --git a/fs/aufs/super.h b/fs/aufs/super.h
index 23d03a067..b8ca14994 100644
--- a/fs/aufs/super.h
+++ b/fs/aufs/super.h
@@ -91,7 +91,7 @@ struct au_sbinfo {
* dirty approach to protect sb->sb_inodes and ->s_files (gone) from
* remount.
*/
- atomic_long_t si_ninodes, si_nfiles;
+ struct percpu_counter si_ninodes, si_nfiles;
/* branch management */
unsigned int si_generation;
@@ -99,7 +99,7 @@ struct au_sbinfo {
/* see AuSi_ flags */
unsigned char au_si_status;
- aufs_bindex_t si_bend;
+ aufs_bindex_t si_bbot;
/* dirty trick to keep br_id plus */
unsigned int si_last_br_id :
@@ -285,7 +285,7 @@ extern struct au_wbr_copyup_operations au_wbr_copyup_ops[];
extern struct au_wbr_create_operations au_wbr_create_ops[];
int au_cpdown_dirs(struct dentry *dentry, aufs_bindex_t bdst);
int au_wbr_nonopq(struct dentry *dentry, aufs_bindex_t bindex);
-int au_wbr_do_copyup_bu(struct dentry *dentry, aufs_bindex_t bstart);
+int au_wbr_do_copyup_bu(struct dentry *dentry, aufs_bindex_t btop);
/* mvdown.c */
int au_mvdown(struct dentry *dentry, struct aufs_mvdown __user *arg);
@@ -548,10 +548,10 @@ static inline void si_downgrade_lock(struct super_block *sb)
/* ---------------------------------------------------------------------- */
-static inline aufs_bindex_t au_sbend(struct super_block *sb)
+static inline aufs_bindex_t au_sbbot(struct super_block *sb)
{
SiMustAnyLock(sb);
- return au_sbi(sb)->si_bend;
+ return au_sbi(sb)->si_bbot;
}
static inline unsigned int au_mntflags(struct super_block *sb)
@@ -566,26 +566,40 @@ static inline unsigned int au_sigen(struct super_block *sb)
return au_sbi(sb)->si_generation;
}
+static inline unsigned long long au_ninodes(struct super_block *sb)
+{
+ s64 n = percpu_counter_sum(&au_sbi(sb)->si_ninodes);
+
+ BUG_ON(n < 0);
+ return n;
+}
+
static inline void au_ninodes_inc(struct super_block *sb)
{
- atomic_long_inc(&au_sbi(sb)->si_ninodes);
+ percpu_counter_inc(&au_sbi(sb)->si_ninodes);
}
static inline void au_ninodes_dec(struct super_block *sb)
{
- AuDebugOn(!atomic_long_read(&au_sbi(sb)->si_ninodes));
- atomic_long_dec(&au_sbi(sb)->si_ninodes);
+ percpu_counter_dec(&au_sbi(sb)->si_ninodes);
+}
+
+static inline unsigned long long au_nfiles(struct super_block *sb)
+{
+ s64 n = percpu_counter_sum(&au_sbi(sb)->si_nfiles);
+
+ BUG_ON(n < 0);
+ return n;
}
static inline void au_nfiles_inc(struct super_block *sb)
{
- atomic_long_inc(&au_sbi(sb)->si_nfiles);
+ percpu_counter_inc(&au_sbi(sb)->si_nfiles);
}
static inline void au_nfiles_dec(struct super_block *sb)
{
- AuDebugOn(!atomic_long_read(&au_sbi(sb)->si_nfiles));
- atomic_long_dec(&au_sbi(sb)->si_nfiles);
+ percpu_counter_dec(&au_sbi(sb)->si_nfiles);
}
static inline struct au_branch *au_sbr(struct super_block *sb,
diff --git a/fs/aufs/sysfs.c b/fs/aufs/sysfs.c
index ed42f53d0..0efb77a4e 100644
--- a/fs/aufs/sysfs.c
+++ b/fs/aufs/sysfs.c
@@ -106,7 +106,7 @@ ssize_t sysaufs_si_show(struct kobject *kobj, struct attribute *attr,
ssize_t err;
int idx;
long l;
- aufs_bindex_t bend;
+ aufs_bindex_t bbot;
struct au_sbinfo *sbinfo;
struct super_block *sb;
struct seq_file *seq;
@@ -159,8 +159,8 @@ ssize_t sysaufs_si_show(struct kobject *kobj, struct attribute *attr,
err = kstrtol(name, 10, &l);
if (!err) {
- bend = au_sbend(sb);
- if (l <= bend)
+ bbot = au_sbbot(sb);
+ if (l <= bbot)
err = sysaufs_si_br(seq, sb, (aufs_bindex_t)l, idx);
else
err = -ENOENT;
@@ -186,15 +186,15 @@ static int au_brinfo(struct super_block *sb, union aufs_brinfo __user *arg)
{
int err;
int16_t brid;
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
size_t sz;
char *buf;
struct seq_file *seq;
struct au_branch *br;
si_read_lock(sb, AuLock_FLUSH);
- bend = au_sbend(sb);
- err = bend + 1;
+ bbot = au_sbbot(sb);
+ err = bbot + 1;
if (!arg)
goto out;
@@ -209,7 +209,7 @@ static int au_brinfo(struct super_block *sb, union aufs_brinfo __user *arg)
goto out_buf;
sz = sizeof(*arg) - offsetof(union aufs_brinfo, path);
- for (bindex = 0; bindex <= bend; bindex++, arg++) {
+ for (bindex = 0; bindex <= bbot; bindex++, arg++) {
err = !access_ok(VERIFY_WRITE, arg, sizeof(*arg));
if (unlikely(err))
break;
@@ -288,7 +288,7 @@ void sysaufs_brs_del(struct super_block *sb, aufs_bindex_t bindex)
struct kobject *kobj;
struct au_brsysfs *br_sysfs;
int i;
- aufs_bindex_t bend;
+ aufs_bindex_t bbot;
dbgaufs_brs_del(sb, bindex);
@@ -296,8 +296,8 @@ void sysaufs_brs_del(struct super_block *sb, aufs_bindex_t bindex)
return;
kobj = &au_sbi(sb)->si_kobj;
- bend = au_sbend(sb);
- for (; bindex <= bend; bindex++) {
+ bbot = au_sbbot(sb);
+ for (; bindex <= bbot; bindex++) {
br = au_sbr(sb, bindex);
br_sysfs = br->br_sysfs;
for (i = 0; i < ARRAY_SIZE(br->br_sysfs); i++) {
@@ -310,7 +310,7 @@ void sysaufs_brs_del(struct super_block *sb, aufs_bindex_t bindex)
void sysaufs_brs_add(struct super_block *sb, aufs_bindex_t bindex)
{
int err, i;
- aufs_bindex_t bend;
+ aufs_bindex_t bbot;
struct kobject *kobj;
struct au_branch *br;
struct au_brsysfs *br_sysfs;
@@ -321,8 +321,8 @@ void sysaufs_brs_add(struct super_block *sb, aufs_bindex_t bindex)
return;
kobj = &au_sbi(sb)->si_kobj;
- bend = au_sbend(sb);
- for (; bindex <= bend; bindex++) {
+ bbot = au_sbbot(sb);
+ for (; bindex <= bbot; bindex++) {
br = au_sbr(sb, bindex);
br_sysfs = br->br_sysfs;
snprintf(br_sysfs[AuBrSysfs_BR].name, sizeof(br_sysfs->name),
diff --git a/fs/aufs/vdir.c b/fs/aufs/vdir.c
index f64cc2b7a..feddcc204 100644
--- a/fs/aufs/vdir.c
+++ b/fs/aufs/vdir.c
@@ -538,7 +538,7 @@ static int au_do_read_vdir(struct fillvdir_arg *arg)
int err;
unsigned int rdhash;
loff_t offset;
- aufs_bindex_t bend, bindex, bstart;
+ aufs_bindex_t bbot, bindex, btop;
unsigned char shwh;
struct file *hf, *file;
struct super_block *sb;
@@ -564,9 +564,9 @@ static int au_do_read_vdir(struct fillvdir_arg *arg)
shwh = 1;
au_fset_fillvdir(arg->flags, SHWH);
}
- bstart = au_fbstart(file);
- bend = au_fbend_dir(file);
- for (bindex = bstart; !err && bindex <= bend; bindex++) {
+ btop = au_fbtop(file);
+ bbot = au_fbbot_dir(file);
+ for (bindex = btop; !err && bindex <= bbot; bindex++) {
hf = au_hf_dir(file, bindex);
if (!hf)
continue;
@@ -579,7 +579,7 @@ static int au_do_read_vdir(struct fillvdir_arg *arg)
arg->bindex = bindex;
au_fclr_fillvdir(arg->flags, WHABLE);
if (shwh
- || (bindex != bend
+ || (bindex != bbot
&& au_br_whable(au_sbr_perm(sb, bindex))))
au_fset_fillvdir(arg->flags, WHABLE);
do {
diff --git a/fs/aufs/vfsub.c b/fs/aufs/vfsub.c
index 29e0bbc32..2e54bad6a 100644
--- a/fs/aufs/vfsub.c
+++ b/fs/aufs/vfsub.c
@@ -125,7 +125,7 @@ int vfsub_atomic_open(struct inode *dir, struct dentry *dentry,
goto out;
}
- atomic_inc(&br->br_count);
+ au_br_get(br);
fsnotify_open(file);
out:
diff --git a/fs/aufs/wbr_policy.c b/fs/aufs/wbr_policy.c
index 994316302..91a010a11 100644
--- a/fs/aufs/wbr_policy.c
+++ b/fs/aufs/wbr_policy.c
@@ -94,13 +94,13 @@ static int au_cpdown_dir(struct dentry *dentry, aufs_bindex_t bdst,
struct dentry *h_parent, void *arg)
{
int err, rerr;
- aufs_bindex_t bopq, bstart;
+ aufs_bindex_t bopq, btop;
struct path h_path;
struct dentry *parent;
struct inode *h_dir, *h_inode, *inode, *dir;
unsigned int *flags = arg;
- bstart = au_dbstart(dentry);
+ btop = au_dbtop(dentry);
/* dentry is di-locked */
parent = dget_parent(dentry);
dir = d_inode(parent);
@@ -136,7 +136,7 @@ static int au_cpdown_dir(struct dentry *dentry, aufs_bindex_t bdst,
}
}
- err = au_cpdown_attr(&h_path, au_h_dptr(dentry, bstart));
+ err = au_cpdown_attr(&h_path, au_h_dptr(dentry, btop));
inode_unlock(h_inode);
if (unlikely(err))
goto out_opq;
@@ -148,8 +148,8 @@ static int au_cpdown_dir(struct dentry *dentry, aufs_bindex_t bdst,
}
inode = d_inode(dentry);
- if (au_ibend(inode) < bdst)
- au_set_ibend(inode, bdst);
+ if (au_ibbot(inode) < bdst)
+ au_set_ibbot(inode, bdst);
au_set_h_iptr(inode, bdst, au_igrab(h_inode),
au_hi_flags(inode, /*isdir*/1));
au_fhsm_wrote(dentry->d_sb, bdst, /*force*/0);
@@ -179,8 +179,8 @@ out_dir:
}
out_put:
au_set_h_dptr(dentry, bdst, NULL);
- if (au_dbend(dentry) == bdst)
- au_update_dbend(dentry);
+ if (au_dbbot(dentry) == bdst)
+ au_update_dbbot(dentry);
out:
dput(parent);
return err;
@@ -252,19 +252,19 @@ static int au_wbr_create_tdp(struct dentry *dentry,
unsigned int flags __maybe_unused)
{
int err;
- aufs_bindex_t bstart, bindex;
+ aufs_bindex_t btop, bindex;
struct super_block *sb;
struct dentry *parent, *h_parent;
sb = dentry->d_sb;
- bstart = au_dbstart(dentry);
- err = bstart;
- if (!au_br_rdonly(au_sbr(sb, bstart)))
+ btop = au_dbtop(dentry);
+ err = btop;
+ if (!au_br_rdonly(au_sbr(sb, btop)))
goto out;
err = -EROFS;
parent = dget_parent(dentry);
- for (bindex = au_dbstart(parent); bindex < bstart; bindex++) {
+ for (bindex = au_dbtop(parent); bindex < btop; bindex++) {
h_parent = au_h_dptr(parent, bindex);
if (!h_parent || d_is_negative(h_parent))
continue;
@@ -278,7 +278,7 @@ static int au_wbr_create_tdp(struct dentry *dentry,
/* bottom up here */
if (unlikely(err < 0)) {
- err = au_wbr_bu(sb, bstart - 1);
+ err = au_wbr_bu(sb, btop - 1);
if (err >= 0)
err = au_wbr_nonopq(dentry, err);
}
@@ -330,7 +330,7 @@ static int au_wbr_create_init_rr(struct super_block *sb)
{
int err;
- err = au_wbr_bu(sb, au_sbend(sb));
+ err = au_wbr_bu(sb, au_sbbot(sb));
atomic_set(&au_sbi(sb)->si_wbr_rr_next, -err); /* less important */
/* smp_mb(); */
@@ -342,7 +342,7 @@ static int au_wbr_create_rr(struct dentry *dentry, unsigned int flags)
{
int err, nbr;
unsigned int u;
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
struct super_block *sb;
atomic_t *next;
@@ -352,9 +352,9 @@ static int au_wbr_create_rr(struct dentry *dentry, unsigned int flags)
sb = dentry->d_sb;
next = &au_sbi(sb)->si_wbr_rr_next;
- bend = au_sbend(sb);
- nbr = bend + 1;
- for (bindex = 0; bindex <= bend; bindex++) {
+ bbot = au_sbbot(sb);
+ nbr = bbot + 1;
+ for (bindex = 0; bindex <= bbot; bindex++) {
if (!au_ftest_wbr(flags, DIR)) {
err = atomic_dec_return(next) + 1;
/* modulo for 0 is meaningless */
@@ -388,7 +388,7 @@ static void au_mfs(struct dentry *dentry, struct dentry *parent)
struct au_branch *br;
struct au_wbr_mfs *mfs;
struct dentry *h_parent;
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
int err;
unsigned long long b, bavail;
struct path h_path;
@@ -409,13 +409,13 @@ static void au_mfs(struct dentry *dentry, struct dentry *parent)
mfs->mfsrr_bytes = 0;
if (!parent) {
bindex = 0;
- bend = au_sbend(sb);
+ bbot = au_sbbot(sb);
} else {
- bindex = au_dbstart(parent);
- bend = au_dbtaildir(parent);
+ bindex = au_dbtop(parent);
+ bbot = au_dbtaildir(parent);
}
- for (; bindex <= bend; bindex++) {
+ for (; bindex <= bbot; bindex++) {
if (parent) {
h_parent = au_h_dptr(parent, bindex);
if (!h_parent || d_is_negative(h_parent))
@@ -540,7 +540,7 @@ static int au_wbr_create_pmfs(struct dentry *dentry, unsigned int flags)
{
int err, e2;
unsigned long long b;
- aufs_bindex_t bindex, bstart, bend;
+ aufs_bindex_t bindex, btop, bbot;
struct super_block *sb;
struct dentry *parent, *h_parent;
struct au_branch *br;
@@ -549,9 +549,9 @@ static int au_wbr_create_pmfs(struct dentry *dentry, unsigned int flags)
if (unlikely(err < 0))
goto out;
parent = dget_parent(dentry);
- bstart = au_dbstart(parent);
- bend = au_dbtaildir(parent);
- if (bstart == bend)
+ btop = au_dbtop(parent);
+ bbot = au_dbtaildir(parent);
+ if (btop == bbot)
goto out_parent; /* success */
e2 = au_wbr_create_mfs(dentry, flags);
@@ -564,7 +564,7 @@ static int au_wbr_create_pmfs(struct dentry *dentry, unsigned int flags)
b = br->br_wbr->wbr_bytes;
AuDbg("b%d, %llu\n", err, b);
- for (bindex = bstart; bindex <= bend; bindex++) {
+ for (bindex = btop; bindex <= bbot; bindex++) {
h_parent = au_h_dptr(parent, bindex);
if (!h_parent || d_is_negative(h_parent))
continue;
@@ -635,15 +635,15 @@ static int au_wbr_copyup_tdp(struct dentry *dentry)
static int au_wbr_copyup_bup(struct dentry *dentry)
{
int err;
- aufs_bindex_t bindex, bstart;
+ aufs_bindex_t bindex, btop;
struct dentry *parent, *h_parent;
struct super_block *sb;
err = -EROFS;
sb = dentry->d_sb;
parent = dget_parent(dentry);
- bstart = au_dbstart(parent);
- for (bindex = au_dbstart(dentry); bindex >= bstart; bindex--) {
+ btop = au_dbtop(parent);
+ for (bindex = au_dbtop(dentry); bindex >= btop; bindex--) {
h_parent = au_h_dptr(parent, bindex);
if (!h_parent || d_is_negative(h_parent))
continue;
@@ -657,20 +657,20 @@ static int au_wbr_copyup_bup(struct dentry *dentry)
/* bottom up here */
if (unlikely(err < 0))
- err = au_wbr_bu(sb, bstart - 1);
+ err = au_wbr_bu(sb, btop - 1);
AuDbg("b%d\n", err);
return err;
}
/* bottom up */
-int au_wbr_do_copyup_bu(struct dentry *dentry, aufs_bindex_t bstart)
+int au_wbr_do_copyup_bu(struct dentry *dentry, aufs_bindex_t btop)
{
int err;
- err = au_wbr_bu(dentry->d_sb, bstart);
+ err = au_wbr_bu(dentry->d_sb, btop);
AuDbg("b%d\n", err);
- if (err > bstart)
+ if (err > btop)
err = au_wbr_nonopq(dentry, err);
AuDbg("b%d\n", err);
@@ -680,10 +680,10 @@ int au_wbr_do_copyup_bu(struct dentry *dentry, aufs_bindex_t bstart)
static int au_wbr_copyup_bu(struct dentry *dentry)
{
int err;
- aufs_bindex_t bstart;
+ aufs_bindex_t btop;
- bstart = au_dbstart(dentry);
- err = au_wbr_do_copyup_bu(dentry, bstart);
+ btop = au_dbtop(dentry);
+ err = au_wbr_do_copyup_bu(dentry, btop);
return err;
}
diff --git a/fs/aufs/whout.c b/fs/aufs/whout.c
index fdda85eef..78f97ed60 100644
--- a/fs/aufs/whout.c
+++ b/fs/aufs/whout.c
@@ -585,7 +585,7 @@ static void reinit_br_wh(void *arg)
out:
if (wbr)
atomic_dec(&wbr->wbr_wh_running);
- atomic_dec(&a->br->br_count);
+ au_br_put(a->br);
si_write_unlock(a->sb);
au_nwt_done(&au_sbi(a->sb)->si_nowait);
kfree(arg);
@@ -611,11 +611,11 @@ static void kick_reinit_br_wh(struct super_block *sb, struct au_branch *br)
*/
arg->sb = sb;
arg->br = br;
- atomic_inc(&br->br_count);
+ au_br_get(br);
wkq_err = au_wkq_nowait(reinit_br_wh, arg, sb, /*flags*/0);
if (unlikely(wkq_err)) {
atomic_dec(&br->br_wbr->wbr_wh_running);
- atomic_dec(&br->br_count);
+ au_br_put(br);
kfree(arg);
}
do_dec = 0;
@@ -904,7 +904,7 @@ out:
void au_whtmp_rmdir_free(struct au_whtmp_rmdir *whtmp)
{
if (whtmp->br)
- atomic_dec(&whtmp->br->br_count);
+ au_br_put(whtmp->br);
dput(whtmp->wh_dentry);
iput(whtmp->dir);
au_nhash_wh_free(&whtmp->whlist);
@@ -963,7 +963,7 @@ int au_whtmp_rmdir(struct inode *dir, aufs_bindex_t bindex,
}
if (!err) {
- if (au_ibstart(dir) == bindex) {
+ if (au_ibtop(dir) == bindex) {
/* todo: dir->i_mutex is necessary */
au_cpup_attr_timesizes(dir);
if (h_nlink)
@@ -1037,7 +1037,7 @@ void au_whtmp_kick_rmdir(struct inode *dir, aufs_bindex_t bindex,
sb = dir->i_sb;
args->dir = au_igrab(dir);
args->br = au_sbr(sb, bindex);
- atomic_inc(&args->br->br_count);
+ au_br_get(args->br);
args->wh_dentry = dget(wh_dentry);
wkq_err = au_wkq_nowait(call_rmdir_whtmp, args, sb, /*flags*/0);
if (unlikely(wkq_err)) {
diff --git a/fs/aufs/wkq.c b/fs/aufs/wkq.c
index 0f1500e93..65c0137a5 100644
--- a/fs/aufs/wkq.c
+++ b/fs/aufs/wkq.c
@@ -145,7 +145,7 @@ int au_wkq_nowait(au_wkq_func_t func, void *args, struct super_block *sb,
int err;
struct au_wkinfo *wkinfo;
- atomic_inc(&au_sbi(sb)->si_nowait.nw_len);
+ percpu_counter_inc(&au_sbi(sb)->si_nowait.nw_len);
/*
* wkq_func() must free this wkinfo.
@@ -175,11 +175,16 @@ int au_wkq_nowait(au_wkq_func_t func, void *args, struct super_block *sb,
void au_nwt_init(struct au_nowait_tasks *nwt)
{
- atomic_set(&nwt->nw_len, 0);
- /* smp_mb(); */ /* atomic_set */
+ percpu_counter_init(&nwt->nw_len, 0, GFP_NOFS);
init_waitqueue_head(&nwt->nw_wq);
}
+void au_nwt_fin(struct au_nowait_tasks *nwt)
+{
+ AuDebugOn(percpu_counter_sum(&nwt->nw_len));
+ percpu_counter_destroy(&nwt->nw_len);
+}
+
void au_wkq_fin(void)
{
destroy_workqueue(au_wkq);
diff --git a/fs/aufs/wkq.h b/fs/aufs/wkq.h
index f6c9b9902..752b9c52d 100644
--- a/fs/aufs/wkq.h
+++ b/fs/aufs/wkq.h
@@ -20,7 +20,7 @@ struct super_block;
* in the next operation, wait for the 'nowait' tasks in system-wide workqueue
*/
struct au_nowait_tasks {
- atomic_t nw_len;
+ struct percpu_counter nw_len;
wait_queue_head_t nw_wq;
};
@@ -47,6 +47,7 @@ int au_wkq_do_wait(unsigned int flags, au_wkq_func_t func, void *args);
int au_wkq_nowait(au_wkq_func_t func, void *args, struct super_block *sb,
unsigned int flags);
void au_nwt_init(struct au_nowait_tasks *nwt);
+void au_nwt_fin(struct au_nowait_tasks *nwt);
int __init au_wkq_init(void);
void au_wkq_fin(void);
@@ -64,13 +65,14 @@ static inline int au_wkq_wait(au_wkq_func_t func, void *args)
static inline void au_nwt_done(struct au_nowait_tasks *nwt)
{
- if (atomic_dec_and_test(&nwt->nw_len))
+ percpu_counter_dec(&nwt->nw_len);
+ if (!percpu_counter_sum(&nwt->nw_len))
wake_up_all(&nwt->nw_wq);
}
static inline int au_nwt_flush(struct au_nowait_tasks *nwt)
{
- wait_event(nwt->nw_wq, !atomic_read(&nwt->nw_len));
+ wait_event(nwt->nw_wq, !percpu_counter_sum(&nwt->nw_len));
return 0;
}
diff --git a/fs/aufs/xino.c b/fs/aufs/xino.c
index 2773caedc..c0eb51f3c 100644
--- a/fs/aufs/xino.c
+++ b/fs/aufs/xino.c
@@ -259,7 +259,7 @@ int au_xino_trunc(struct super_block *sb, aufs_bindex_t bindex)
int err;
unsigned long jiffy;
blkcnt_t blocks;
- aufs_bindex_t bi, bend;
+ aufs_bindex_t bi, bbot;
struct kstatfs *st;
struct au_branch *br;
struct file *new_xino, *file;
@@ -272,8 +272,8 @@ int au_xino_trunc(struct super_block *sb, aufs_bindex_t bindex)
goto out;
err = -EINVAL;
- bend = au_sbend(sb);
- if (unlikely(bindex < 0 || bend < bindex))
+ bbot = au_sbbot(sb);
+ if (unlikely(bindex < 0 || bbot < bindex))
goto out_st;
br = au_sbr(sb, bindex);
file = br->br_xino.xi_file;
@@ -302,7 +302,7 @@ int au_xino_trunc(struct super_block *sb, aufs_bindex_t bindex)
br->br_xino.xi_file = new_xino;
h_sb = au_br_sb(br);
- for (bi = 0; bi <= bend; bi++) {
+ for (bi = 0; bi <= bbot; bi++) {
if (unlikely(bi == bindex))
continue;
br = au_sbr(sb, bi);
@@ -357,7 +357,7 @@ static void xino_do_trunc(void *_args)
if (unlikely(err))
pr_warn("err b%d, (%d)\n", bindex, err);
atomic_dec(&br->br_xino_running);
- atomic_dec(&br->br_count);
+ au_br_put(br);
si_write_unlock(sb);
au_nwt_done(&au_sbi(sb)->si_nowait);
kfree(args);
@@ -405,7 +405,7 @@ static void xino_try_trunc(struct super_block *sb, struct au_branch *br)
goto out_args;
}
- atomic_inc(&br->br_count);
+ au_br_get(br);
args->sb = sb;
args->br = br;
wkq_err = au_wkq_nowait(xino_do_trunc, args, sb, /*flags*/0);
@@ -413,7 +413,7 @@ static void xino_try_trunc(struct super_block *sb, struct au_branch *br)
return; /* success */
pr_err("wkq %d\n", wkq_err);
- atomic_dec(&br->br_count);
+ au_br_put(br);
out_args:
kfree(args);
@@ -576,7 +576,7 @@ void au_xino_delete_inode(struct inode *inode, const int unlinked)
{
int err;
unsigned int mnt_flags;
- aufs_bindex_t bindex, bend, bi;
+ aufs_bindex_t bindex, bbot, bi;
unsigned char try_trunc;
struct au_iinfo *iinfo;
struct super_block *sb;
@@ -585,6 +585,8 @@ void au_xino_delete_inode(struct inode *inode, const int unlinked)
struct au_branch *br;
vfs_writef_t xwrite;
+ AuDebugOn(is_bad_inode(inode));
+
sb = inode->i_sb;
mnt_flags = au_mntflags(sb);
if (!au_opt_test(mnt_flags, XINO)
@@ -597,18 +599,15 @@ void au_xino_delete_inode(struct inode *inode, const int unlinked)
}
iinfo = au_ii(inode);
- if (!iinfo)
- return;
-
- bindex = iinfo->ii_bstart;
+ bindex = iinfo->ii_btop;
if (bindex < 0)
return;
xwrite = au_sbi(sb)->si_xwrite;
try_trunc = !!au_opt_test(mnt_flags, TRUNC_XINO);
- hi = iinfo->ii_hinode + bindex;
- bend = iinfo->ii_bend;
- for (; bindex <= bend; bindex++, hi++) {
+ hi = au_hinode(iinfo, bindex);
+ bbot = iinfo->ii_bbot;
+ for (; bindex <= bbot; bindex++, hi++) {
h_inode = hi->hi_inode;
if (!h_inode
|| (!unlinked && h_inode->i_nlink))
@@ -797,10 +796,10 @@ out:
/*
* find another branch who is on the same filesystem of the specified
- * branch{@btgt}. search until @bend.
+ * branch{@btgt}. search until @bbot.
*/
static int is_sb_shared(struct super_block *sb, aufs_bindex_t btgt,
- aufs_bindex_t bend)
+ aufs_bindex_t bbot)
{
aufs_bindex_t bindex;
struct super_block *tgt_sb = au_sbr_sb(sb, btgt);
@@ -808,7 +807,7 @@ static int is_sb_shared(struct super_block *sb, aufs_bindex_t btgt,
for (bindex = 0; bindex < btgt; bindex++)
if (unlikely(tgt_sb == au_sbr_sb(sb, bindex)))
return bindex;
- for (bindex++; bindex <= bend; bindex++)
+ for (bindex++; bindex <= bbot; bindex++)
if (unlikely(tgt_sb == au_sbr_sb(sb, bindex)))
return bindex;
return -1;
@@ -827,16 +826,16 @@ int au_xino_br(struct super_block *sb, struct au_branch *br, ino_t h_ino,
{
int err;
ino_t ino;
- aufs_bindex_t bend, bindex;
+ aufs_bindex_t bbot, bindex;
struct au_branch *shared_br, *b;
struct file *file;
struct super_block *tgt_sb;
shared_br = NULL;
- bend = au_sbend(sb);
+ bbot = au_sbbot(sb);
if (do_test) {
tgt_sb = au_br_sb(br);
- for (bindex = 0; bindex <= bend; bindex++) {
+ for (bindex = 0; bindex <= bbot; bindex++) {
b = au_sbr(sb, bindex);
if (tgt_sb == au_br_sb(b)) {
shared_br = b;
@@ -924,7 +923,7 @@ out:
static int xib_restore(struct super_block *sb)
{
int err;
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
void *page;
err = -ENOMEM;
@@ -933,8 +932,8 @@ static int xib_restore(struct super_block *sb)
goto out;
err = 0;
- bend = au_sbend(sb);
- for (bindex = 0; !err && bindex <= bend; bindex++)
+ bbot = au_sbbot(sb);
+ for (bindex = 0; !err && bindex <= bbot; bindex++)
if (!bindex || is_sb_shared(sb, bindex, bindex - 1) < 0)
err = do_xib_restore
(sb, au_sbr(sb, bindex)->br_xino.xi_file, page);
@@ -1076,11 +1075,11 @@ out:
/* xino for each branch */
static void xino_clear_br(struct super_block *sb)
{
- aufs_bindex_t bindex, bend;
+ aufs_bindex_t bindex, bbot;
struct au_branch *br;
- bend = au_sbend(sb);
- for (bindex = 0; bindex <= bend; bindex++) {
+ bbot = au_sbbot(sb);
+ for (bindex = 0; bindex <= bbot; bindex++) {
br = au_sbr(sb, bindex);
if (!br || !br->br_xino.xi_file)
continue;
@@ -1094,7 +1093,7 @@ static int au_xino_set_br(struct super_block *sb, struct file *base)
{
int err;
ino_t ino;
- aufs_bindex_t bindex, bend, bshared;
+ aufs_bindex_t bindex, bbot, bshared;
struct {
struct file *old, *new;
} *fpair, *p;
@@ -1105,15 +1104,15 @@ static int au_xino_set_br(struct super_block *sb, struct file *base)
SiMustWriteLock(sb);
err = -ENOMEM;
- bend = au_sbend(sb);
- fpair = kcalloc(bend + 1, sizeof(*fpair), GFP_NOFS);
+ bbot = au_sbbot(sb);
+ fpair = kcalloc(bbot + 1, sizeof(*fpair), GFP_NOFS);
if (unlikely(!fpair))
goto out;
inode = d_inode(sb->s_root);
ino = AUFS_ROOT_INO;
writef = au_sbi(sb)->si_xwrite;
- for (bindex = 0, p = fpair; bindex <= bend; bindex++, p++) {
+ for (bindex = 0, p = fpair; bindex <= bbot; bindex++, p++) {
br = au_sbr(sb, bindex);
bshared = is_sb_shared(sb, bindex, bindex - 1);
if (bshared >= 0) {
@@ -1139,7 +1138,7 @@ static int au_xino_set_br(struct super_block *sb, struct file *base)
goto out_pair;
}
- for (bindex = 0, p = fpair; bindex <= bend; bindex++, p++) {
+ for (bindex = 0, p = fpair; bindex <= bbot; bindex++, p++) {
br = au_sbr(sb, bindex);
if (br->br_xino.xi_file)
fput(br->br_xino.xi_file);
@@ -1148,7 +1147,7 @@ static int au_xino_set_br(struct super_block *sb, struct file *base)
}
out_pair:
- for (bindex = 0, p = fpair; bindex <= bend; bindex++, p++)
+ for (bindex = 0, p = fpair; bindex <= bbot; bindex++, p++)
if (p->new)
fput(p->new);
else
@@ -1234,12 +1233,12 @@ struct file *au_xino_def(struct super_block *sb)
struct au_branch *br;
struct super_block *h_sb;
struct path path;
- aufs_bindex_t bend, bindex, bwr;
+ aufs_bindex_t bbot, bindex, bwr;
br = NULL;
- bend = au_sbend(sb);
+ bbot = au_sbbot(sb);
bwr = -1;
- for (bindex = 0; bindex <= bend; bindex++) {
+ for (bindex = 0; bindex <= bbot; bindex++) {
br = au_sbr(sb, bindex);
if (au_br_writable(br->br_perm)
&& !au_test_fs_bad_xino(au_br_sb(br))) {