lkml.org 
[lkml]   [2007]   [Sep]   [25]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 10/25] Unionfs: add un/likely conditionals on copyup ops
    Date
    Signed-off-by: Erez Zadok <ezk@cs.sunysb.edu>
    ---
    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@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

    \
     
     \ /
      Last update: 2007-09-26 05:39    [W:0.039 / U:30.232 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site