[PATCH 10/25] Unionfs: add un/likely conditionals on copyup ops

From: Erez Zadok
Date: Tue Sep 25 2007 - 23:34:54 EST

Signed-off-by: Erez Zadok <ezk@xxxxxxxxxxxxx>
---
fs/unionfs/copyup.c | 102 +++++++++++++++++++++++++-------------------------
1 files changed, 51 insertions(+), 51 deletions(-)

diff --git a/fs/unionfs/copyup.c b/fs/unionfs/copyup.c
index 23ac4c8..e3c5f15 100644
--- a/fs/unionfs/copyup.c
+++ b/fs/unionfs/copyup.c
@@ -36,14 +36,14 @@ static int copyup_xattrs(struct dentry *old_lower_dentry,

/* query the actual size of the xattr list */
list_size = vfs_listxattr(old_lower_dentry, NULL, 0);
- if (list_size <= 0) {
+ if (unlikely(list_size <= 0)) {
err = list_size;
goto out;
}

/* allocate space for the actual list */
name_list = unionfs_xattr_alloc(list_size + 1, XATTR_LIST_MAX);
- if (!name_list || IS_ERR(name_list)) {
+ if (unlikely(!name_list || IS_ERR(name_list))) {
err = PTR_ERR(name_list);
goto out;
}
@@ -52,14 +52,14 @@ static int copyup_xattrs(struct dentry *old_lower_dentry,

/* now get the actual xattr list of the source file */
list_size = vfs_listxattr(old_lower_dentry, name_list, list_size);
- if (list_size <= 0) {
+ if (unlikely(list_size <= 0)) {
err = list_size;
goto out;
}

/* allocate space to hold each xattr's value */
attr_value = unionfs_xattr_alloc(XATTR_SIZE_MAX, XATTR_SIZE_MAX);
- if (!attr_value || IS_ERR(attr_value)) {
+ if (unlikely(!attr_value || IS_ERR(attr_value))) {
err = PTR_ERR(name_list);
goto out;
}
@@ -73,11 +73,11 @@ static int copyup_xattrs(struct dentry *old_lower_dentry,
size = vfs_getxattr(old_lower_dentry, name_list,
attr_value, XATTR_SIZE_MAX);
mutex_unlock(&old_lower_dentry->d_inode->i_mutex);
- if (size < 0) {
+ if (unlikely(size < 0)) {
err = size;
goto out;
}
- if (size > XATTR_SIZE_MAX) {
+ if (unlikely(size > XATTR_SIZE_MAX)) {
err = -E2BIG;
goto out;
}
@@ -91,13 +91,13 @@ static int copyup_xattrs(struct dentry *old_lower_dentry,
* temporarily get FOWNER privileges.
* XXX: move entire copyup code to SIOQ.
*/
- if (err == -EPERM && !capable(CAP_FOWNER)) {
+ if (unlikely(err == -EPERM && !capable(CAP_FOWNER))) {
cap_raise(current->cap_effective, CAP_FOWNER);
err = vfs_setxattr(new_lower_dentry, name_list,
attr_value, size, 0);
cap_lower(current->cap_effective, CAP_FOWNER);
}
- if (err < 0)
+ if (unlikely(err < 0))
goto out;
name_list += strlen(name_list) + 1;
}
@@ -105,7 +105,7 @@ out:
unionfs_xattr_kfree(name_list_buf);
unionfs_xattr_kfree(attr_value);
/* Ignore if xattr isn't supported */
- if (err == -ENOTSUPP || err == -EOPNOTSUPP)
+ if (unlikely(err == -ENOTSUPP || err == -EOPNOTSUPP))
err = 0;
return err;
}
@@ -136,15 +136,15 @@ static int copyup_permissions(struct super_block *sb,
ATTR_ATIME_SET | ATTR_MTIME_SET | ATTR_FORCE |
ATTR_GID | ATTR_UID;
err = notify_change(new_lower_dentry, &newattrs);
- if (err)
+ if (unlikely(err))
goto out;

/* now try to change the mode and ignore EOPNOTSUPP on symlinks */
newattrs.ia_mode = i->i_mode;
newattrs.ia_valid = ATTR_MODE | ATTR_FORCE;
err = notify_change(new_lower_dentry, &newattrs);
- if (err == -EOPNOTSUPP &&
- S_ISLNK(new_lower_dentry->d_inode->i_mode)) {
+ if (unlikely(err == -EOPNOTSUPP &&
+ S_ISLNK(new_lower_dentry->d_inode->i_mode))) {
printk(KERN_WARNING
"unionfs: changing \"%s\" symlink mode unsupported\n",
new_lower_dentry->d_name.name);
@@ -178,7 +178,7 @@ static int __copyup_ndentry(struct dentry *old_lower_dentry,

run_sioq(__unionfs_mkdir, &args);
err = args.err;
- } else if (S_ISLNK(old_mode)) {
+ } else if (unlikely(S_ISLNK(old_mode))) {
args.symlink.parent = new_lower_parent_dentry->d_inode;
args.symlink.dentry = new_lower_dentry;
args.symlink.symbuf = symbuf;
@@ -186,8 +186,8 @@ static int __copyup_ndentry(struct dentry *old_lower_dentry,

run_sioq(__unionfs_symlink, &args);
err = args.err;
- } else if (S_ISBLK(old_mode) || S_ISCHR(old_mode) ||
- S_ISFIFO(old_mode) || S_ISSOCK(old_mode)) {
+ } else if (unlikely(S_ISBLK(old_mode) || S_ISCHR(old_mode) ||
+ S_ISFIFO(old_mode) || S_ISSOCK(old_mode))) {
args.mknod.parent = new_lower_parent_dentry->d_inode;
args.mknod.dentry = new_lower_dentry;
args.mknod.mode = old_mode;
@@ -198,7 +198,7 @@ static int __copyup_ndentry(struct dentry *old_lower_dentry,
} else if (S_ISREG(old_mode)) {
struct nameidata nd;
err = init_lower_nd(&nd, LOOKUP_CREATE);
- if (err < 0)
+ if (unlikely(err < 0))
goto out;
args.create.nd = &nd;
args.create.parent = new_lower_parent_dentry->d_inode;
@@ -240,12 +240,12 @@ static int __copyup_reg_data(struct dentry *dentry,
input_file = dentry_open(old_lower_dentry,
unionfs_lower_mnt_idx(dentry, old_bindex),
O_RDONLY | O_LARGEFILE);
- if (IS_ERR(input_file)) {
+ if (unlikely(IS_ERR(input_file))) {
dput(old_lower_dentry);
err = PTR_ERR(input_file);
goto out;
}
- if (!input_file->f_op || !input_file->f_op->read) {
+ if (unlikely(!input_file->f_op || !input_file->f_op->read)) {
err = -EINVAL;
goto out_close_in;
}
@@ -256,18 +256,18 @@ static int __copyup_reg_data(struct dentry *dentry,
branchget(sb, new_bindex);
output_file = dentry_open(new_lower_dentry, output_mnt,
O_RDWR | O_LARGEFILE);
- if (IS_ERR(output_file)) {
+ if (unlikely(IS_ERR(output_file))) {
err = PTR_ERR(output_file);
goto out_close_in2;
}
- if (!output_file->f_op || !output_file->f_op->write) {
+ if (unlikely(!output_file->f_op || !output_file->f_op->write)) {
err = -EINVAL;
goto out_close_out;
}

/* allocating a buffer */
buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
- if (!buf) {
+ if (unlikely(!buf)) {
err = -ENOMEM;
goto out_close_out;
}
@@ -302,7 +302,7 @@ static int __copyup_reg_data(struct dentry *dentry,
(char __user *)buf,
read_bytes,
&output_file->f_pos);
- if ((write_bytes < 0) || (write_bytes < read_bytes)) {
+ if (unlikely((write_bytes < 0) || (write_bytes < read_bytes))) {
err = write_bytes;
break;
}
@@ -312,11 +312,11 @@ static int __copyup_reg_data(struct dentry *dentry,

kfree(buf);

- if (!err)
+ if (likely(!err))
err = output_file->f_op->fsync(output_file,
new_lower_dentry, 0);

- if (err)
+ if (unlikely(err))
goto out_close_out;

if (copyup_file) {
@@ -399,7 +399,7 @@ int copyup_dentry(struct inode *dir, struct dentry *dentry, int bstart,

/* Create the directory structure above this dentry. */
new_lower_dentry = create_parents(dir, dentry, name, new_bindex);
- if (IS_ERR(new_lower_dentry)) {
+ if (unlikely(IS_ERR(new_lower_dentry))) {
err = PTR_ERR(new_lower_dentry);
goto out;
}
@@ -409,10 +409,10 @@ int copyup_dentry(struct inode *dir, struct dentry *dentry, int bstart,
dget(old_lower_dentry);

/* For symlinks, we must read the link before we lock the directory. */
- if (S_ISLNK(old_lower_dentry->d_inode->i_mode)) {
+ if (unlikely(S_ISLNK(old_lower_dentry->d_inode->i_mode))) {

symbuf = kmalloc(PATH_MAX, GFP_KERNEL);
- if (!symbuf) {
+ if (unlikely(!symbuf)) {
__clear(dentry, old_lower_dentry,
old_bstart, old_bend,
new_lower_dentry, new_bindex);
@@ -427,7 +427,7 @@ int copyup_dentry(struct inode *dir, struct dentry *dentry, int bstart,
(char __user *)symbuf,
PATH_MAX);
set_fs(oldfs);
- if (err < 0) {
+ if (unlikely(err < 0)) {
__clear(dentry, old_lower_dentry,
old_bstart, old_bend,
new_lower_dentry, new_bindex);
@@ -443,7 +443,7 @@ int copyup_dentry(struct inode *dir, struct dentry *dentry, int bstart,
err = __copyup_ndentry(old_lower_dentry, new_lower_dentry,
new_lower_parent_dentry, symbuf);

- if (err) {
+ if (unlikely(err)) {
__clear(dentry, old_lower_dentry,
old_bstart, old_bend,
new_lower_dentry, new_bindex);
@@ -455,22 +455,22 @@ int copyup_dentry(struct inode *dir, struct dentry *dentry, int bstart,
err = __copyup_reg_data(dentry, new_lower_dentry, new_bindex,
old_lower_dentry, old_bindex,
copyup_file, len);
- if (err)
+ if (unlikely(err))
goto out_unlink;

/* Set permissions. */
- if ((err = copyup_permissions(sb, old_lower_dentry,
- new_lower_dentry)))
+ if (unlikely((err = copyup_permissions(sb, old_lower_dentry,
+ new_lower_dentry))))
goto out_unlink;

#ifdef CONFIG_UNION_FS_XATTR
/* Selinux uses extended attributes for permissions. */
- if ((err = copyup_xattrs(old_lower_dentry, new_lower_dentry)))
+ if (unlikely((err = copyup_xattrs(old_lower_dentry, new_lower_dentry))))
goto out_unlink;
#endif /* CONFIG_UNION_FS_XATTR */

/* do not allow files getting deleted to be re-interposed */
- if (!d_deleted(dentry))
+ if (likely(!d_deleted(dentry)))
unionfs_reinterpose(dentry);

goto out_unlock;
@@ -513,11 +513,11 @@ out_free:
dput(old_lower_dentry);
kfree(symbuf);

- if (err)
+ if (unlikely(err))
goto out;
if (!S_ISDIR(dentry->d_inode->i_mode)) {
unionfs_postcopyup_release(dentry);
- if (!unionfs_lower_inode(dentry->d_inode)) {
+ if (unlikely(!unionfs_lower_inode(dentry->d_inode))) {
/*
* If we got here, then we copied up to an
* unlinked-open file, whose name is .unionfsXXXXX.
@@ -551,7 +551,7 @@ int copyup_named_file(struct inode *dir, struct file *file, char *name,

err = copyup_dentry(dir, file->f_path.dentry, bstart, new_bindex,
name, strlen(name), &output_file, len);
- if (!err) {
+ if (likely(!err)) {
fbstart(file) = new_bindex;
unionfs_set_lower_file_idx(file, new_bindex, output_file);
}
@@ -573,7 +573,7 @@ int copyup_file(struct inode *dir, struct file *file, int bstart,
err = copyup_dentry(dir, dentry, bstart, new_bindex,
dentry->d_name.name, dentry->d_name.len,
&output_file, len);
- if (!err) {
+ if (likely(!err)) {
fbstart(file) = new_bindex;
unionfs_set_lower_file_idx(file, new_bindex, output_file);
}
@@ -600,7 +600,7 @@ static void __cleanup_dentry(struct dentry *dentry, int bindex,
* dentries except bindex
*/
for (i = loop_start; i <= loop_end; i++) {
- if (!unionfs_lower_dentry_idx(dentry, i))
+ if (unlikely(!unionfs_lower_dentry_idx(dentry, i)))
continue;

if (i == bindex) {
@@ -623,9 +623,9 @@ static void __cleanup_dentry(struct dentry *dentry, int bindex,
}
}

- if (new_bstart < 0)
+ if (unlikely(new_bstart < 0))
new_bstart = bindex;
- if (new_bend < 0)
+ if (unlikely(new_bend < 0))
new_bend = bindex;
set_dbstart(dentry, new_bstart);
set_dbend(dentry, new_bend);
@@ -679,7 +679,7 @@ struct dentry *create_parents(struct inode *dir, struct dentry *dentry,

verify_locked(dentry);

- if ((err = is_robranch_super(dir->i_sb, bindex))) {
+ if (unlikely((err = is_robranch_super(dir->i_sb, bindex)))) {
lower_dentry = ERR_PTR(err);
goto out;
}
@@ -692,7 +692,7 @@ struct dentry *create_parents(struct inode *dir, struct dentry *dentry,
/* There is no sense allocating any less than the minimum. */
nr_dentry = 1;
path = kmalloc(nr_dentry * sizeof(struct dentry *), GFP_KERNEL);
- if (!path)
+ if (unlikely(!path))
goto out;

/* assume the negative dentry of unionfs as the parent dentry */
@@ -719,13 +719,13 @@ struct dentry *create_parents(struct inode *dir, struct dentry *dentry,
unionfs_lower_dentry_idx(parent_dentry, bindex);

/* grow path table */
- if (count == nr_dentry) {
+ if (unlikely(count == nr_dentry)) {
void *p;

nr_dentry *= 2;
p = krealloc(path, nr_dentry * sizeof(struct dentry *),
GFP_KERNEL);
- if (!p) {
+ if (unlikely(!p)) {
lower_dentry = ERR_PTR(-ENOMEM);
goto out;
}
@@ -757,7 +757,7 @@ begin:
/* lookup child in the underlying file system */
lower_dentry = lookup_one_len(childname, lower_parent_dentry,
childnamelen);
- if (IS_ERR(lower_dentry))
+ if (unlikely(IS_ERR(lower_dentry)))
goto out;
} else {
/*
@@ -766,7 +766,7 @@ begin:
*/
lower_dentry = lookup_one_len(name, lower_parent_dentry,
strlen(name));
- if (IS_ERR(lower_dentry))
+ if (unlikely(IS_ERR(lower_dentry)))
goto out;

/* Replace the current dentry (if any) with the new one */
@@ -797,11 +797,11 @@ begin:
run_sioq(__unionfs_mkdir, &args);
err = args.err;

- if (!err)
+ if (likely(!err))
err = copyup_permissions(dir->i_sb, child_dentry,
lower_dentry);
unlock_dir(lower_parent_dentry);
- if (err) {
+ if (unlikely(err)) {
struct inode *inode = lower_dentry->d_inode;
/*
* If we get here, it means that we created a new
@@ -836,7 +836,7 @@ begin:
goto begin;
out:
/* cleanup any leftover locks from the do/while loop above */
- if (IS_ERR(lower_dentry))
+ if (unlikely(IS_ERR(lower_dentry)))
while (count)
unionfs_unlock_dentry(path[count--]);
kfree(path);
@@ -852,7 +852,7 @@ void unionfs_postcopyup_setmnt(struct dentry *dentry)
struct dentry *parent, *hasone;
int bindex = dbstart(dentry);

- if (unionfs_lower_mnt_idx(dentry, bindex))
+ if (unlikely(unionfs_lower_mnt_idx(dentry, bindex)))
return;
hasone = dentry->d_parent;
/* this loop should stop at root dentry */
--
1.5.2.2

-
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/