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

5 files changed, 45 insertions, 62 deletions

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,