Merge tag 'for-linus-4.6-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs

Pull f2fs/fscrypto fixes from Jaegeuk Kim:
 "In addition to f2fs/fscrypto fixes, I've added one patch which
  prevents RCU mode lookup in d_revalidate, as Al mentioned.

  These patches fix f2fs and fscrypto based on -rc3 bug fixes in ext4
  crypto, which have not yet been fully propagated as follows.

   - use of dget_parent and file_dentry to avoid crashes
   - disallow RCU-mode lookup in d_invalidate
   - disallow -ENOMEM in the core data encryption path"

* tag 'for-linus-4.6-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs:
  ext4/fscrypto: avoid RCU lookup in d_revalidate
  fscrypto: don't let data integrity writebacks fail with ENOMEM
  f2fs: use dget_parent and file_dentry in f2fs_file_open
  fscrypto: use dget_parent() in fscrypt_d_revalidate()

5 files changed, 61 insertions, 29 deletions

diff --git a/fs/crypto/crypto.c b/fs/crypto/crypto.c
index 7f5804537d30..2fc8c43ce531 100644
--- a/fs/crypto/crypto.c
+++ b/fs/crypto/crypto.c
@@ -26,6 +26,7 @@
 #include <linux/ratelimit.h>
 #include <linux/bio.h>
 #include <linux/dcache.h>
+#include <linux/namei.h>
 #include <linux/fscrypto.h>
 #include <linux/ecryptfs.h>
 
@@ -81,13 +82,14 @@ EXPORT_SYMBOL(fscrypt_release_ctx);
 /**
  * fscrypt_get_ctx() - Gets an encryption context
  * @inode:       The inode for which we are doing the crypto
+ * @gfp_flags:   The gfp flag for memory allocation
  *
  * Allocates and initializes an encryption context.
  *
  * Return: An allocated and initialized encryption context on success; error
  * value or NULL otherwise.
  */
-struct fscrypt_ctx *fscrypt_get_ctx(struct inode *inode)
+struct fscrypt_ctx *fscrypt_get_ctx(struct inode *inode, gfp_t gfp_flags)
 {
         struct fscrypt_ctx *ctx = NULL;
         struct fscrypt_info *ci = inode->i_crypt_info;
@@ -113,7 +115,7 @@ struct fscrypt_ctx *fscrypt_get_ctx(struct inode *inode)
                 list_del(&ctx->free_list);
         spin_unlock_irqrestore(&fscrypt_ctx_lock, flags);
         if (!ctx) {
-                ctx = kmem_cache_zalloc(fscrypt_ctx_cachep, GFP_NOFS);
+                ctx = kmem_cache_zalloc(fscrypt_ctx_cachep, gfp_flags);
                 if (!ctx)
                         return ERR_PTR(-ENOMEM);
                 ctx->flags |= FS_CTX_REQUIRES_FREE_ENCRYPT_FL;
@@ -147,7 +149,8 @@ typedef enum {
 
 static int do_page_crypto(struct inode *inode,
                         fscrypt_direction_t rw, pgoff_t index,
-                        struct page *src_page, struct page *dest_page)
+                        struct page *src_page, struct page *dest_page,
+                        gfp_t gfp_flags)
 {
         u8 xts_tweak[FS_XTS_TWEAK_SIZE];
         struct skcipher_request *req = NULL;
@@ -157,7 +160,7 @@ static int do_page_crypto(struct inode *inode,
         struct crypto_skcipher *tfm = ci->ci_ctfm;
         int res = 0;
 
-        req = skcipher_request_alloc(tfm, GFP_NOFS);
+        req = skcipher_request_alloc(tfm, gfp_flags);
         if (!req) {
                 printk_ratelimited(KERN_ERR
                                 "%s: crypto_request_alloc() failed\n",
@@ -199,10 +202,9 @@ static int do_page_crypto(struct inode *inode,
         return 0;
 }
 
-static struct page *alloc_bounce_page(struct fscrypt_ctx *ctx)
+static struct page *alloc_bounce_page(struct fscrypt_ctx *ctx, gfp_t gfp_flags)
 {
-        ctx->w.bounce_page = mempool_alloc(fscrypt_bounce_page_pool,
-                                                        GFP_NOWAIT);
+        ctx->w.bounce_page = mempool_alloc(fscrypt_bounce_page_pool, gfp_flags);
         if (ctx->w.bounce_page == NULL)
                 return ERR_PTR(-ENOMEM);
         ctx->flags |= FS_WRITE_PATH_FL;
@@ -213,6 +215,7 @@ static struct page *alloc_bounce_page(struct fscrypt_ctx *ctx)
  * fscypt_encrypt_page() - Encrypts a page
  * @inode:          The inode for which the encryption should take place
  * @plaintext_page: The page to encrypt. Must be locked.
+ * @gfp_flags:      The gfp flag for memory allocation
  *
  * Allocates a ciphertext page and encrypts plaintext_page into it using the ctx
  * encryption context.
@@ -225,7 +228,7 @@ static struct page *alloc_bounce_page(struct fscrypt_ctx *ctx)
  * error value or NULL.
  */
 struct page *fscrypt_encrypt_page(struct inode *inode,
-                                struct page *plaintext_page)
+                                struct page *plaintext_page, gfp_t gfp_flags)
 {
         struct fscrypt_ctx *ctx;
         struct page *ciphertext_page = NULL;
@@ -233,18 +236,19 @@ struct page *fscrypt_encrypt_page(struct inode *inode,
 
         BUG_ON(!PageLocked(plaintext_page));
 
-        ctx = fscrypt_get_ctx(inode);
+        ctx = fscrypt_get_ctx(inode, gfp_flags);
         if (IS_ERR(ctx))
                 return (struct page *)ctx;
 
         /* The encryption operation will require a bounce page. */
-        ciphertext_page = alloc_bounce_page(ctx);
+        ciphertext_page = alloc_bounce_page(ctx, gfp_flags);
         if (IS_ERR(ciphertext_page))
                 goto errout;
 
         ctx->w.control_page = plaintext_page;
         err = do_page_crypto(inode, FS_ENCRYPT, plaintext_page->index,
-                                        plaintext_page, ciphertext_page);
+                                        plaintext_page, ciphertext_page,
+                                        gfp_flags);
         if (err) {
                 ciphertext_page = ERR_PTR(err);
                 goto errout;
@@ -275,7 +279,7 @@ int fscrypt_decrypt_page(struct page *page)
         BUG_ON(!PageLocked(page));
 
         return do_page_crypto(page->mapping->host,
-                        FS_DECRYPT, page->index, page, page);
+                        FS_DECRYPT, page->index, page, page, GFP_NOFS);
 }
 EXPORT_SYMBOL(fscrypt_decrypt_page);
 
@@ -289,11 +293,11 @@ int fscrypt_zeroout_range(struct inode *inode, pgoff_t lblk,
 
         BUG_ON(inode->i_sb->s_blocksize != PAGE_SIZE);
 
-        ctx = fscrypt_get_ctx(inode);
+        ctx = fscrypt_get_ctx(inode, GFP_NOFS);
         if (IS_ERR(ctx))
                 return PTR_ERR(ctx);
 
-        ciphertext_page = alloc_bounce_page(ctx);
+        ciphertext_page = alloc_bounce_page(ctx, GFP_NOWAIT);
         if (IS_ERR(ciphertext_page)) {
                 err = PTR_ERR(ciphertext_page);
                 goto errout;
@@ -301,11 +305,12 @@ int fscrypt_zeroout_range(struct inode *inode, pgoff_t lblk,
 
         while (len--) {
                 err = do_page_crypto(inode, FS_ENCRYPT, lblk,
-                                                ZERO_PAGE(0), ciphertext_page);
+                                        ZERO_PAGE(0), ciphertext_page,
+                                        GFP_NOFS);
                 if (err)
                         goto errout;
 
-                bio = bio_alloc(GFP_KERNEL, 1);
+                bio = bio_alloc(GFP_NOWAIT, 1);
                 if (!bio) {
                         err = -ENOMEM;
                         goto errout;
@@ -345,13 +350,20 @@ EXPORT_SYMBOL(fscrypt_zeroout_range);
  */
 static int fscrypt_d_revalidate(struct dentry *dentry, unsigned int flags)
 {
-        struct inode *dir = d_inode(dentry->d_parent);
-        struct fscrypt_info *ci = dir->i_crypt_info;
+        struct dentry *dir;
+        struct fscrypt_info *ci;
         int dir_has_key, cached_with_key;
 
-        if (!dir->i_sb->s_cop->is_encrypted(dir))
+        if (flags & LOOKUP_RCU)
+                return -ECHILD;
+
+        dir = dget_parent(dentry);
+        if (!d_inode(dir)->i_sb->s_cop->is_encrypted(d_inode(dir))) {
+                dput(dir);
                 return 0;
+        }
 
+        ci = d_inode(dir)->i_crypt_info;
         if (ci && ci->ci_keyring_key &&
             (ci->ci_keyring_key->flags & ((1 << KEY_FLAG_INVALIDATED) |
                                           (1 << KEY_FLAG_REVOKED) |
@@ -363,6 +375,7 @@ static int fscrypt_d_revalidate(struct dentry *dentry, unsigned int flags)
         cached_with_key = dentry->d_flags & DCACHE_ENCRYPTED_WITH_KEY;
         spin_unlock(&dentry->d_lock);
         dir_has_key = (ci != NULL);
+        dput(dir);
 
         /*
          * If the dentry was cached without the key, and it is a
diff --git a/fs/ext4/crypto.c b/fs/ext4/crypto.c
index db9ae6e18154..6a6c27373b54 100644
--- a/fs/ext4/crypto.c
+++ b/fs/ext4/crypto.c
@@ -32,6 +32,7 @@
 #include <linux/random.h>
 #include <linux/scatterlist.h>
 #include <linux/spinlock_types.h>
+#include <linux/namei.h>
 
 #include "ext4_extents.h"
 #include "xattr.h"
@@ -482,6 +483,9 @@ static int ext4_d_revalidate(struct dentry *dentry, unsigned int flags)
         struct ext4_crypt_info *ci;
         int dir_has_key, cached_with_key;
 
+        if (flags & LOOKUP_RCU)
+                return -ECHILD;
+
         dir = dget_parent(dentry);
         if (!ext4_encrypted_inode(d_inode(dir))) {
                 dput(dir);
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 53fec0872e60..5dafb9cef12e 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -992,7 +992,7 @@ submit_and_realloc:
                         if (f2fs_encrypted_inode(inode) &&
                                         S_ISREG(inode->i_mode)) {
 
-                                ctx = fscrypt_get_ctx(inode);
+                                ctx = fscrypt_get_ctx(inode, GFP_NOFS);
                                 if (IS_ERR(ctx))
                                         goto set_error_page;
 
@@ -1092,14 +1092,24 @@ int do_write_data_page(struct f2fs_io_info *fio)
         }
 
         if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode)) {
+                gfp_t gfp_flags = GFP_NOFS;
 
                 /* wait for GCed encrypted page writeback */
                 f2fs_wait_on_encrypted_page_writeback(F2FS_I_SB(inode),
                                                         fio->old_blkaddr);
-
-                fio->encrypted_page = fscrypt_encrypt_page(inode, fio->page);
+retry_encrypt:
+                fio->encrypted_page = fscrypt_encrypt_page(inode, fio->page,
+                                                                gfp_flags);
                 if (IS_ERR(fio->encrypted_page)) {
                         err = PTR_ERR(fio->encrypted_page);
+                        if (err == -ENOMEM) {
+                                /* flush pending ios and wait for a while */
+                                f2fs_flush_merged_bios(F2FS_I_SB(inode));
+                                congestion_wait(BLK_RW_ASYNC, HZ/50);
+                                gfp_flags |= __GFP_NOFAIL;
+                                err = 0;
+                                goto retry_encrypt;
+                        }
                         goto out_writepage;
                 }
         }
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 443e07705c2a..90d1157a09f9 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -441,7 +441,7 @@ static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
 static int f2fs_file_open(struct inode *inode, struct file *filp)
 {
         int ret = generic_file_open(inode, filp);
-        struct inode *dir = filp->f_path.dentry->d_parent->d_inode;
+        struct dentry *dir;
 
         if (!ret && f2fs_encrypted_inode(inode)) {
                 ret = fscrypt_get_encryption_info(inode);
@@ -450,9 +450,13 @@ static int f2fs_file_open(struct inode *inode, struct file *filp)
                 if (!fscrypt_has_encryption_key(inode))
                         return -ENOKEY;
         }
-        if (f2fs_encrypted_inode(dir) &&
-                        !fscrypt_has_permitted_context(dir, inode))
+        dir = dget_parent(file_dentry(filp));
+        if (f2fs_encrypted_inode(d_inode(dir)) &&
+                        !fscrypt_has_permitted_context(d_inode(dir), inode)) {
+                dput(dir);
                 return -EPERM;
+        }
+        dput(dir);
         return ret;
 }
 
diff --git a/include/linux/fscrypto.h b/include/linux/fscrypto.h
index cd91f75de49b..6027f6bbb061 100644
--- a/include/linux/fscrypto.h
+++ b/include/linux/fscrypto.h
@@ -263,9 +263,9 @@ static inline void fscrypt_set_d_op(struct dentry *dentry)
 extern struct kmem_cache *fscrypt_info_cachep;
 int fscrypt_initialize(void);
 
-extern struct fscrypt_ctx *fscrypt_get_ctx(struct inode *);
+extern struct fscrypt_ctx *fscrypt_get_ctx(struct inode *, gfp_t);
 extern void fscrypt_release_ctx(struct fscrypt_ctx *);
-extern struct page *fscrypt_encrypt_page(struct inode *, struct page *);
+extern struct page *fscrypt_encrypt_page(struct inode *, struct page *, gfp_t);
 extern int fscrypt_decrypt_page(struct page *);
 extern void fscrypt_decrypt_bio_pages(struct fscrypt_ctx *, struct bio *);
 extern void fscrypt_pullback_bio_page(struct page **, bool);
@@ -299,7 +299,8 @@ extern int fscrypt_fname_usr_to_disk(struct inode *, const struct qstr *,
 #endif
 
 /* crypto.c */
-static inline struct fscrypt_ctx *fscrypt_notsupp_get_ctx(struct inode *i)
+static inline struct fscrypt_ctx *fscrypt_notsupp_get_ctx(struct inode *i,
+                                                        gfp_t f)
 {
         return ERR_PTR(-EOPNOTSUPP);
 }
@@ -310,7 +311,7 @@ static inline void fscrypt_notsupp_release_ctx(struct fscrypt_ctx *c)
 }
 
 static inline struct page *fscrypt_notsupp_encrypt_page(struct inode *i,
-                                                struct page *p)
+                                                struct page *p, gfp_t f)
 {
         return ERR_PTR(-EOPNOTSUPP);
 }