Merge branch 'work.misc' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs

Pull misc vfs cleanups from Al Viro:
 "Assorted cleanups and fixes all over the place"

* 'work.misc' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs:
  coredump: only charge written data against RLIMIT_CORE
  coredump: get rid of coredump_params->written
  ecryptfs_lookup(): try either only encrypted or plaintext name
  ecryptfs: avoid multiple aliases for directories
  bpf: reject invalid names right in ->lookup()
  __d_alloc(): treat NULL name as QSTR("/", 1)
  mtd: switch ubi_open_volume_path() to vfs_stat()
  mtd: switch open_mtd_by_chdev() to use of vfs_stat()

diff --git a/arch/powerpc/platforms/cell/spufs/coredump.c b/arch/powerpc/platforms/cell/spufs/coredump.c
index be6212ddbf06a8a097ac19d361b2f420da35ef6a..84fb984f29c130f89cffbbaaf1aae9b8b1d6c843 100644 (file)
--- a/arch/powerpc/platforms/cell/spufs/coredump.c
+++ b/arch/powerpc/platforms/cell/spufs/coredump.c
@@ -137,6 +137,7 @@ static int spufs_arch_write_note(struct spu_context *ctx, int i,
        char *name;
        char fullname[80], *buf;
        struct elf_note en;
+       size_t skip;
 
        buf = (void *)get_zeroed_page(GFP_KERNEL);
        if (!buf)
@@ -171,8 +172,8 @@ static int spufs_arch_write_note(struct spu_context *ctx, int i,
        if (rc < 0)
                goto out;
 
-       if (!dump_skip(cprm,
-                      roundup(cprm->written - total + sz, 4) - cprm->written))
+       skip = roundup(cprm->file->f_pos - total + sz, 4) - cprm->file->f_pos;
+       if (!dump_skip(cprm, skip))
                goto Eio;
 out:
        free_page((unsigned long)buf);

diff --git a/drivers/mtd/ubi/build.c b/drivers/mtd/ubi/build.c
index 22fd19c0c5d3fa56d0a4b84fa508973d96dcc8ff..a7d1febf667a9da0d14585301ae4dad94d3c3ae2 100644 (file)
--- a/drivers/mtd/ubi/build.c
+++ b/drivers/mtd/ubi/build.c
@@ -1142,22 +1142,19 @@ int ubi_detach_mtd_dev(int ubi_num, int anyway)
  */
 static struct mtd_info * __init open_mtd_by_chdev(const char *mtd_dev)
 {
-       int err, major, minor, mode;
-       struct path path;
+       struct kstat stat;
+       int err, minor;
 
        /* Probably this is an MTD character device node path */
-       err = kern_path(mtd_dev, LOOKUP_FOLLOW, &path);
+       err = vfs_stat(mtd_dev, &stat);
        if (err)
                return ERR_PTR(err);
 
        /* MTD device number is defined by the major / minor numbers */
-       major = imajor(d_backing_inode(path.dentry));
-       minor = iminor(d_backing_inode(path.dentry));
-       mode = d_backing_inode(path.dentry)->i_mode;
-       path_put(&path);
-       if (major != MTD_CHAR_MAJOR || !S_ISCHR(mode))
+       if (MAJOR(stat.rdev) != MTD_CHAR_MAJOR || !S_ISCHR(stat.mode))
                return ERR_PTR(-EINVAL);
 
+       minor = MINOR(stat.rdev);
        if (minor & 1)
                /*
                 * Just do not think the "/dev/mtdrX" devices support is need,

diff --git a/drivers/mtd/ubi/kapi.c b/drivers/mtd/ubi/kapi.c
index e844887732fbd062481cc60a3a34a13dd7c25468..437757c89b9e5933e796a49c752d2da5ded4d3b4 100644 (file)
--- a/drivers/mtd/ubi/kapi.c
+++ b/drivers/mtd/ubi/kapi.c
@@ -301,27 +301,24 @@ EXPORT_SYMBOL_GPL(ubi_open_volume_nm);
  */
 struct ubi_volume_desc *ubi_open_volume_path(const char *pathname, int mode)
 {
-       int error, ubi_num, vol_id, mod;
-       struct inode *inode;
-       struct path path;
+       int error, ubi_num, vol_id;
+       struct kstat stat;
 
        dbg_gen("open volume %s, mode %d", pathname, mode);
 
        if (!pathname || !*pathname)
                return ERR_PTR(-EINVAL);
 
-       error = kern_path(pathname, LOOKUP_FOLLOW, &path);
+       error = vfs_stat(pathname, &stat);
        if (error)
                return ERR_PTR(error);
 
-       inode = d_backing_inode(path.dentry);
-       mod = inode->i_mode;
-       ubi_num = ubi_major2num(imajor(inode));
-       vol_id = iminor(inode) - 1;
-       path_put(&path);
-
-       if (!S_ISCHR(mod))
+       if (!S_ISCHR(stat.mode))
                return ERR_PTR(-EINVAL);
+
+       ubi_num = ubi_major2num(MAJOR(stat.rdev));
+       vol_id = MINOR(stat.rdev) - 1;
+
        if (vol_id >= 0 && ubi_num >= 0)
                return ubi_open_volume(ubi_num, vol_id, mode);
        return ERR_PTR(-ENODEV);

diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index 81381cc0dd177f5f891234a9b065c78a2eec1714..56224ffa94d2c62eed3d3d945158c723d4ddffc5 100644 (file)
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -2273,7 +2273,7 @@ static int elf_core_dump(struct coredump_params *cprm)
                goto end_coredump;
 
        /* Align to page */
-       if (!dump_skip(cprm, dataoff - cprm->written))
+       if (!dump_skip(cprm, dataoff - cprm->file->f_pos))
                goto end_coredump;
 
        for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;

diff --git a/fs/binfmt_elf_fdpic.c b/fs/binfmt_elf_fdpic.c
index 083ea2bc60abd5f7c1ef1e76ad4b304e884c44fa..71ade0e556b7e7cab5b83705228a54099b067749 100644 (file)
--- a/fs/binfmt_elf_fdpic.c
+++ b/fs/binfmt_elf_fdpic.c
@@ -1787,7 +1787,7 @@ static int elf_fdpic_core_dump(struct coredump_params *cprm)
                                goto end_coredump;
        }
 
-       if (!dump_skip(cprm, dataoff - cprm->written))
+       if (!dump_skip(cprm, dataoff - cprm->file->f_pos))
                goto end_coredump;
 
        if (!elf_fdpic_dump_segments(cprm))

diff --git a/fs/coredump.c b/fs/coredump.c
index 47c32c3bfa1d90c10ce6ade45fc7829a39345fcc..492c2db25dc9bd654a3fb6931dc3bdc1162ac42d 100644 (file)
--- a/fs/coredump.c
+++ b/fs/coredump.c
@@ -803,12 +803,9 @@ int dump_skip(struct coredump_params *cprm, size_t nr)
        static char zeroes[PAGE_SIZE];
        struct file *file = cprm->file;
        if (file->f_op->llseek && file->f_op->llseek != no_llseek) {
-               if (cprm->written + nr > cprm->limit)
-                       return 0;
                if (dump_interrupted() ||
                    file->f_op->llseek(file, nr, SEEK_CUR) < 0)
                        return 0;
-               cprm->written += nr;
                return 1;
        } else {
                while (nr > PAGE_SIZE) {
@@ -823,7 +820,7 @@ EXPORT_SYMBOL(dump_skip);
 
 int dump_align(struct coredump_params *cprm, int align)
 {
-       unsigned mod = cprm->written & (align - 1);
+       unsigned mod = cprm->file->f_pos & (align - 1);
        if (align & (align - 1))
                return 0;
        return mod ? dump_skip(cprm, align - mod) : 1;

diff --git a/fs/dcache.c b/fs/dcache.c
index e49ba7d1b9572d4e138c417f77cde4986c57790e..c622872c12c5b754d54f1d9e2cc053ca077b5135 100644 (file)
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -1571,7 +1571,11 @@ struct dentry *__d_alloc(struct super_block *sb, const struct qstr *name)
         * be overwriting an internal NUL character
         */
        dentry->d_iname[DNAME_INLINE_LEN-1] = 0;
-       if (name->len > DNAME_INLINE_LEN-1) {
+       if (unlikely(!name)) {
+               static const struct qstr anon = QSTR_INIT("/", 1);
+               name = &anon;
+               dname = dentry->d_iname;
+       } else if (name->len > DNAME_INLINE_LEN-1) {
                size_t size = offsetof(struct external_name, name[1]);
                struct external_name *p = kmalloc(size + name->len,
                                                  GFP_KERNEL_ACCOUNT);
@@ -1829,9 +1833,7 @@ struct dentry *d_make_root(struct inode *root_inode)
        struct dentry *res = NULL;
 
        if (root_inode) {
-               static const struct qstr name = QSTR_INIT("/", 1);
-
-               res = __d_alloc(root_inode->i_sb, &name);
+               res = __d_alloc(root_inode->i_sb, NULL);
                if (res)
                        d_instantiate(res, root_inode);
                else
@@ -1872,7 +1874,6 @@ EXPORT_SYMBOL(d_find_any_alias);
 
 static struct dentry *__d_obtain_alias(struct inode *inode, int disconnected)
 {
-       static const struct qstr anonstring = QSTR_INIT("/", 1);
        struct dentry *tmp;
        struct dentry *res;
        unsigned add_flags;
@@ -1886,7 +1887,7 @@ static struct dentry *__d_obtain_alias(struct inode *inode, int disconnected)
        if (res)
                goto out_iput;
 
-       tmp = __d_alloc(inode->i_sb, &anonstring);
+       tmp = __d_alloc(inode->i_sb, NULL);
        if (!tmp) {
                res = ERR_PTR(-ENOMEM);
                goto out_iput;

diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index 9b022e90666094ef1702cc2327260a34f475671b..318b04689d769b5da80d6ee39f6ded153a08e725 100644 (file)
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -324,9 +324,8 @@ static int ecryptfs_i_size_read(struct dentry *dentry, struct inode *inode)
 /**
  * ecryptfs_lookup_interpose - Dentry interposition for a lookup
  */
-static int ecryptfs_lookup_interpose(struct dentry *dentry,
-                                    struct dentry *lower_dentry,
-                                    struct inode *dir_inode)
+static struct dentry *ecryptfs_lookup_interpose(struct dentry *dentry,
+                                    struct dentry *lower_dentry)
 {
        struct inode *inode, *lower_inode = d_inode(lower_dentry);
        struct ecryptfs_dentry_info *dentry_info;
@@ -339,11 +338,12 @@ static int ecryptfs_lookup_interpose(struct dentry *dentry,
                       "to allocate ecryptfs_dentry_info struct\n",
                        __func__);
                dput(lower_dentry);
-               return -ENOMEM;
+               return ERR_PTR(-ENOMEM);
        }
 
        lower_mnt = mntget(ecryptfs_dentry_to_lower_mnt(dentry->d_parent));
-       fsstack_copy_attr_atime(dir_inode, d_inode(lower_dentry->d_parent));
+       fsstack_copy_attr_atime(d_inode(dentry->d_parent),
+                               d_inode(lower_dentry->d_parent));
        BUG_ON(!d_count(lower_dentry));
 
        ecryptfs_set_dentry_private(dentry, dentry_info);
@@ -353,27 +353,25 @@ static int ecryptfs_lookup_interpose(struct dentry *dentry,
        if (d_really_is_negative(lower_dentry)) {
                /* We want to add because we couldn't find in lower */
                d_add(dentry, NULL);
-               return 0;
+               return NULL;
        }
-       inode = __ecryptfs_get_inode(lower_inode, dir_inode->i_sb);
+       inode = __ecryptfs_get_inode(lower_inode, dentry->d_sb);
        if (IS_ERR(inode)) {
                printk(KERN_ERR "%s: Error interposing; rc = [%ld]\n",
                       __func__, PTR_ERR(inode));
-               return PTR_ERR(inode);
+               return ERR_CAST(inode);
        }
        if (S_ISREG(inode->i_mode)) {
                rc = ecryptfs_i_size_read(dentry, inode);
                if (rc) {
                        make_bad_inode(inode);
-                       return rc;
+                       return ERR_PTR(rc);
                }
        }
 
        if (inode->i_state & I_NEW)
                unlock_new_inode(inode);
-       d_add(dentry, inode);
-
-       return rc;
+       return d_splice_alias(inode, dentry);
 }
 
 /**
@@ -390,55 +388,42 @@ static struct dentry *ecryptfs_lookup(struct inode *ecryptfs_dir_inode,
                                      unsigned int flags)
 {
        char *encrypted_and_encoded_name = NULL;
-       size_t encrypted_and_encoded_name_size;
-       struct ecryptfs_mount_crypt_stat *mount_crypt_stat = NULL;
+       struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
        struct dentry *lower_dir_dentry, *lower_dentry;
+       const char *name = ecryptfs_dentry->d_name.name;
+       size_t len = ecryptfs_dentry->d_name.len;
+       struct dentry *res;
        int rc = 0;
 
        lower_dir_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry->d_parent);
-       lower_dentry = lookup_one_len_unlocked(ecryptfs_dentry->d_name.name,
-                                     lower_dir_dentry,
-                                     ecryptfs_dentry->d_name.len);
-       if (IS_ERR(lower_dentry)) {
-               rc = PTR_ERR(lower_dentry);
-               ecryptfs_printk(KERN_DEBUG, "%s: lookup_one_len() returned "
-                               "[%d] on lower_dentry = [%pd]\n", __func__, rc,
-                               ecryptfs_dentry);
-               goto out;
-       }
-       if (d_really_is_positive(lower_dentry))
-               goto interpose;
+
        mount_crypt_stat = &ecryptfs_superblock_to_private(
                                ecryptfs_dentry->d_sb)->mount_crypt_stat;
-       if (!(mount_crypt_stat
-           && (mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES)))
-               goto interpose;
-       dput(lower_dentry);
-       rc = ecryptfs_encrypt_and_encode_filename(
-               &encrypted_and_encoded_name, &encrypted_and_encoded_name_size,
-               mount_crypt_stat, ecryptfs_dentry->d_name.name,
-               ecryptfs_dentry->d_name.len);
-       if (rc) {
-               printk(KERN_ERR "%s: Error attempting to encrypt and encode "
-                      "filename; rc = [%d]\n", __func__, rc);
-               goto out;
+       if (mount_crypt_stat
+           && (mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES)) {
+               rc = ecryptfs_encrypt_and_encode_filename(
+                       &encrypted_and_encoded_name, &len,
+                       mount_crypt_stat, name, len);
+               if (rc) {
+                       printk(KERN_ERR "%s: Error attempting to encrypt and encode "
+                              "filename; rc = [%d]\n", __func__, rc);
+                       return ERR_PTR(rc);
+               }
+               name = encrypted_and_encoded_name;
        }
-       lower_dentry = lookup_one_len_unlocked(encrypted_and_encoded_name,
-                                     lower_dir_dentry,
-                                     encrypted_and_encoded_name_size);
+
+       lower_dentry = lookup_one_len_unlocked(name, lower_dir_dentry, len);
        if (IS_ERR(lower_dentry)) {
-               rc = PTR_ERR(lower_dentry);
                ecryptfs_printk(KERN_DEBUG, "%s: lookup_one_len() returned "
-                               "[%d] on lower_dentry = [%s]\n", __func__, rc,
-                               encrypted_and_encoded_name);
-               goto out;
+                               "[%ld] on lower_dentry = [%s]\n", __func__,
+                               PTR_ERR(lower_dentry),
+                               name);
+               res = ERR_CAST(lower_dentry);
+       } else {
+               res = ecryptfs_lookup_interpose(ecryptfs_dentry, lower_dentry);
        }
-interpose:
-       rc = ecryptfs_lookup_interpose(ecryptfs_dentry, lower_dentry,
-                                      ecryptfs_dir_inode);
-out:
        kfree(encrypted_and_encoded_name);
-       return ERR_PTR(rc);
+       return res;
 }
 
 static int ecryptfs_link(struct dentry *old_dentry, struct inode *dir,

diff --git a/kernel/bpf/inode.c b/kernel/bpf/inode.c
index 8f94ca1860cfdcdd9509e40d40c3ad7cbf572e2d..71b75d9c81da0db4786f5ecf03b1fb51cf670af3 100644 (file)
--- a/kernel/bpf/inode.c
+++ b/kernel/bpf/inode.c
@@ -119,18 +119,10 @@ static int bpf_inode_type(const struct inode *inode, enum bpf_type *type)
        return 0;
 }
 
-static bool bpf_dname_reserved(const struct dentry *dentry)
-{
-       return strchr(dentry->d_name.name, '.');
-}
-
 static int bpf_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
        struct inode *inode;
 
-       if (bpf_dname_reserved(dentry))
-               return -EPERM;
-
        inode = bpf_get_inode(dir->i_sb, dir, mode | S_IFDIR);
        if (IS_ERR(inode))
                return PTR_ERR(inode);
@@ -152,9 +144,6 @@ static int bpf_mkobj_ops(struct inode *dir, struct dentry *dentry,
 {
        struct inode *inode;
 
-       if (bpf_dname_reserved(dentry))
-               return -EPERM;
-
        inode = bpf_get_inode(dir->i_sb, dir, mode | S_IFREG);
        if (IS_ERR(inode))
                return PTR_ERR(inode);
@@ -187,31 +176,21 @@ static int bpf_mkobj(struct inode *dir, struct dentry *dentry, umode_t mode,
        }
 }
 
-static int bpf_link(struct dentry *old_dentry, struct inode *dir,
-                   struct dentry *new_dentry)
+static struct dentry *
+bpf_lookup(struct inode *dir, struct dentry *dentry, unsigned flags)
 {
-       if (bpf_dname_reserved(new_dentry))
-               return -EPERM;
-
-       return simple_link(old_dentry, dir, new_dentry);
-}
-
-static int bpf_rename(struct inode *old_dir, struct dentry *old_dentry,
-                     struct inode *new_dir, struct dentry *new_dentry)
-{
-       if (bpf_dname_reserved(new_dentry))
-               return -EPERM;
-
-       return simple_rename(old_dir, old_dentry, new_dir, new_dentry);
+       if (strchr(dentry->d_name.name, '.'))
+               return ERR_PTR(-EPERM);
+       return simple_lookup(dir, dentry, flags);
 }
 
 static const struct inode_operations bpf_dir_iops = {
-       .lookup         = simple_lookup,
+       .lookup         = bpf_lookup,
        .mknod          = bpf_mkobj,
        .mkdir          = bpf_mkdir,
        .rmdir          = simple_rmdir,
-       .rename         = bpf_rename,
-       .link           = bpf_link,
+       .rename         = simple_rename,
+       .link           = simple_link,
        .unlink         = simple_unlink,
 };