[PATCH 12/25] Unionfs: add un/likely conditionals on dentry ops

Erez Zadok
2007-09-26T03:33:25Z

fs/unionfs/dentry.c | 68 ++++++++++++++++++++++++++------------------------
1 files changed, 35 insertions(+), 33 deletions(-)

diff --git a/fs/unionfs/dentry.c b/fs/unionfs/dentry.c
index 52bcb18..3f3a18d 100644
--- a/fs/unionfs/dentry.c
+++ b/fs/unionfs/dentry.c
@@ -45,7 +45,7 @@ static bool __unionfs_d_revalidate_one(struct dentry *dentry,
verify_locked(dentry);

/* if the dentry is unhashed, do NOT revalidate */
- if (d_deleted(dentry)) {
+ if (unlikely(d_deleted(dentry))) {
dprintk(KERN_DEBUG "unionfs: unhashed dentry being "
"revalidated: %*s\n",
dentry->d_name.len, dentry->d_name.name);
@@ -53,7 +53,7 @@ static bool __unionfs_d_revalidate_one(struct dentry *dentry,
}

BUG_ON(dbstart(dentry) == -1);
- if (dentry->d_inode)
+ if (likely(dentry->d_inode))
positive = 1;
dgen = atomic_read(&UNIONFS_D(dentry)->generation);
sbgen = atomic_read(&UNIONFS_SB(dentry->d_sb)->generation);
@@ -62,7 +62,7 @@ static bool __unionfs_d_revalidate_one(struct dentry *dentry,
* revalidation to be done, because this file does not exist within
* the namespace, and Unionfs operates on the namespace, not data.
*/
- if (sbgen != dgen) {
+ if (unlikely(sbgen != dgen)) {
struct dentry *result;
int pdgen;

@@ -76,7 +76,7 @@ static bool __unionfs_d_revalidate_one(struct dentry *dentry,
/* Free the pointers for our inodes and this dentry. */
bstart = dbstart(dentry);
bend = dbend(dentry);
- if (bstart >= 0) {
+ if (likely(bstart >= 0)) {
struct dentry *lower_dentry;
for (bindex = bstart; bindex <= bend; bindex++) {
lower_dentry =
@@ -89,7 +89,7 @@ static bool __unionfs_d_revalidate_one(struct dentry *dentry,
set_dbend(dentry, -1);

interpose_flag = INTERPOSE_REVAL_NEG;
- if (positive) {
+ if (likely(positive)) {
interpose_flag = INTERPOSE_REVAL;
/*
* During BRM, the VFS could already hold a lock on
@@ -97,14 +97,14 @@ static bool __unionfs_d_revalidate_one(struct dentry *dentry,
* (deadlock), but if you lock it in this function,
* then release it here too.
*/
- if (!mutex_is_locked(&dentry->d_inode->i_mutex)) {
+ if (unlikely(!mutex_is_locked(&dentry->d_inode->i_mutex))) {
mutex_lock(&dentry->d_inode->i_mutex);
locked = 1;
}

bstart = ibstart(dentry->d_inode);
bend = ibend(dentry->d_inode);
- if (bstart >= 0) {
+ if (likely(bstart >= 0)) {
struct inode *lower_inode;
for (bindex = bstart; bindex <= bend;
bindex++) {
@@ -119,14 +119,14 @@ static bool __unionfs_d_revalidate_one(struct dentry *dentry,
UNIONFS_I(dentry->d_inode)->lower_inodes = NULL;
ibstart(dentry->d_inode) = -1;
ibend(dentry->d_inode) = -1;
- if (locked)
+ if (unlikely(locked))
mutex_unlock(&dentry->d_inode->i_mutex);
}

result = unionfs_lookup_backend(dentry, &lowernd,
interpose_flag);
- if (result) {
- if (IS_ERR(result)) {
+ if (likely(result)) {
+ if (unlikely(IS_ERR(result))) {
valid = false;
goto out;
}
@@ -138,7 +138,7 @@ static bool __unionfs_d_revalidate_one(struct dentry *dentry,
dentry = result;
}

- if (positive && UNIONFS_I(dentry->d_inode)->stale) {
+ if (unlikely(positive && UNIONFS_I(dentry->d_inode)->stale)) {
make_bad_inode(dentry->d_inode);
d_drop(dentry);
valid = false;
@@ -153,8 +153,8 @@ static bool __unionfs_d_revalidate_one(struct dentry *dentry,
BUG_ON(bstart == -1);
for (bindex = bstart; bindex <= bend; bindex++) {
lower_dentry = unionfs_lower_dentry_idx(dentry, bindex);
- if (!lower_dentry || !lower_dentry->d_op
- || !lower_dentry->d_op->d_revalidate)
+ if (unlikely(!lower_dentry || !lower_dentry->d_op
+ || !lower_dentry->d_op->d_revalidate))
continue;
/*
* Don't pass nameidata to lower file system, because we
@@ -164,14 +164,15 @@ static bool __unionfs_d_revalidate_one(struct dentry *dentry,
* invariants). We will open lower files as and when needed
* later on.
*/
- if (!lower_dentry->d_op->d_revalidate(lower_dentry, NULL))
+ if (unlikely(!lower_dentry->d_op->d_revalidate(lower_dentry,
+ NULL)))
valid = false;
}

- if (!dentry->d_inode)
+ if (unlikely(!dentry->d_inode))
valid = false;

- if (valid) {
+ if (likely(valid)) {
/*
* If we get here, and we copy the meta-data from the lower
* inode to our inode, then it is vital that we have already
@@ -200,32 +201,32 @@ bool is_newer_lower(const struct dentry *dentry)
struct inode *lower_inode;

/* ignore if we're called on semi-initialized dentries/inodes */
- if (!dentry || !UNIONFS_D(dentry))
+ if (likely(!dentry || !UNIONFS_D(dentry)))
return false;
inode = dentry->d_inode;
- if (!inode || !UNIONFS_I(inode) ||
- ibstart(inode) < 0 || ibend(inode) < 0)
+ if (unlikely(!inode || !UNIONFS_I(inode) ||
+ ibstart(inode) < 0 || ibend(inode) < 0))
return false;

for (bindex = ibstart(inode); bindex <= ibend(inode); bindex++) {
lower_inode = unionfs_lower_inode_idx(inode, bindex);
- if (!lower_inode)
+ if (unlikely(!lower_inode))
continue;
/*
* We may want to apply other tests to determine if the
* lower inode's data has changed, but checking for changed
* ctime and mtime on the lower inode should be enough.
*/
- if (timespec_compare(&inode->i_mtime,
- &lower_inode->i_mtime) < 0) {
+ if (unlikely(timespec_compare(&inode->i_mtime,
+ &lower_inode->i_mtime) < 0)) {
printk("unionfs: new lower inode mtime "
"(bindex=%d, name=%s)\n", bindex,
dentry->d_name.name);
show_dinode_times(dentry);
return true; /* mtime changed! */
}
- if (timespec_compare(&inode->i_ctime,
- &lower_inode->i_ctime) < 0) {
+ if (unlikely(timespec_compare(&inode->i_ctime,
+ &lower_inode->i_ctime) < 0)) {
printk("unionfs: new lower inode ctime "
"(bindex=%d, name=%s)\n", bindex,
dentry->d_name.name);
@@ -293,7 +294,7 @@ bool __unionfs_d_revalidate_chain(struct dentry *dentry, struct nameidata *nd,
dtmp = dentry->d_parent;
dgen = atomic_read(&UNIONFS_D(dtmp)->generation);
/* XXX: should we check if is_newer_lower all the way up? */
- if (is_newer_lower(dtmp)) {
+ if (unlikely(is_newer_lower(dtmp))) {
/*
* Special case: the root dentry's generation number must
* always be valid, but its lower inode times don't have to
@@ -327,7 +328,7 @@ bool __unionfs_d_revalidate_chain(struct dentry *dentry, struct nameidata *nd,
* and short lived, so locality will be better.
*/
chain = kzalloc(chain_len * sizeof(struct dentry *), GFP_KERNEL);
- if (!chain) {
+ if (unlikely(!chain)) {
printk("unionfs: no more memory in %s\n", __FUNCTION__);
goto out;
}
@@ -364,7 +365,7 @@ bool __unionfs_d_revalidate_chain(struct dentry *dentry, struct nameidata *nd,
}
unionfs_unlock_dentry(chain[i]);

- if (!valid)
+ if (unlikely(!valid))
goto out_free;
}

@@ -373,7 +374,7 @@ out_this:
/* finally, lock this dentry and revalidate it */
verify_locked(dentry);
dgen = atomic_read(&UNIONFS_D(dentry)->generation);
- if (is_newer_lower(dentry)) {
+ if (unlikely(is_newer_lower(dentry))) {
/* root dentry special case as aforementioned */
if (IS_ROOT(dentry))
unionfs_copy_attr_times(dentry->d_inode);
@@ -399,7 +400,7 @@ out_this:
* which __unionfs_d_revalidate_one has incremented. Note: the "if"
* test below does not depend on whether chain_len was 0 or greater.
*/
- if (valid && sbgen != dgen)
+ if (unlikely(valid && sbgen != dgen))
for (bindex = dbstart(dentry);
bindex <= dbend(dentry);
bindex++)
@@ -425,7 +426,7 @@ static int unionfs_d_revalidate(struct dentry *dentry, struct nameidata *nd)
unionfs_lock_dentry(dentry);
err = __unionfs_d_revalidate_chain(dentry, nd, false);
unionfs_unlock_dentry(dentry);
- if (err > 0) { /* true==1: dentry is valid */
+ if (likely(err > 0)) { /* true==1: dentry is valid */
unionfs_check_dentry(dentry);
unionfs_check_nd(nd);
}
@@ -447,11 +448,11 @@ static void unionfs_d_release(struct dentry *dentry)

unionfs_check_dentry(dentry);
/* this could be a negative dentry, so check first */
- if (!UNIONFS_D(dentry)) {
+ if (unlikely(!UNIONFS_D(dentry))) {
printk(KERN_DEBUG "unionfs: dentry without private data: %.*s\n",
dentry->d_name.len, dentry->d_name.name);
goto out;
- } else if (dbstart(dentry) < 0) {
+ } else if (unlikely(dbstart(dentry) < 0)) {
/* this is due to a failed lookup */
printk(KERN_DEBUG "unionfs: dentry without lower "
"dentries: %.*s\n",
@@ -466,7 +467,8 @@ static void unionfs_d_release(struct dentry *dentry)
dput(unionfs_lower_dentry_idx(dentry, bindex));
unionfs_set_lower_dentry_idx(dentry, bindex, NULL);
/* NULL lower mnt is ok if this is a negative dentry */
- if (!dentry->d_inode && !unionfs_lower_mnt_idx(dentry,bindex))
+ if (unlikely(!dentry->d_inode &&
+ !unionfs_lower_mnt_idx(dentry,bindex)))
continue;
unionfs_mntput(dentry, bindex);
unionfs_set_lower_mnt_idx(dentry, bindex, NULL);
--
1.5.2.2