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()

9 files changed, 69 insertions, 112 deletions

diff --git a/arch/powerpc/platforms/cell/spufs/coredump.c b/arch/powerpc/platforms/cell/spufs/coredump.c
index be6212ddbf06..84fb984f29c1 100644
--- 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 22fd19c0c5d3..a7d1febf667a 100644
--- 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 e844887732fb..437757c89b9e 100644
--- 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 81381cc0dd17..56224ffa94d2 100644
--- 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 083ea2bc60ab..71ade0e556b7 100644
--- 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 47c32c3bfa1d..492c2db25dc9 100644
--- 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 e49ba7d1b957..c622872c12c5 100644
--- 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 9b022e906660..318b04689d76 100644
--- 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 8f94ca1860cf..71b75d9c81da 100644
--- 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,
 };