Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit a53dc75a authored by Jaegeuk Kim's avatar Jaegeuk Kim
Browse files

fscrypt: updates on 4.15-rc4 



Cherry-picked from origin/upstream-f2fs-stable-linux-4.14.y:

9d468a2b Revert "locking/atomics: COCCINELLE/treewide: Convert trivial ACCESS_ONCE() patterns to READ_ONCE()/WRITE_ONCE()"
13b237d1 fscrypt: move to generic async completion
a2985b1c crypto: introduce crypto wait for async op
4bb665c7 locking/atomics: COCCINELLE/treewide: Convert trivial ACCESS_ONCE() patterns to READ_ONCE()/WRITE_ONCE()
249c9041 fscrypt: new helper function - fscrypt_prepare_setattr()
91d09c05 fscrypt: new helper function - fscrypt_prepare_lookup()
9a24d618 fscrypt: new helper function - fscrypt_prepare_rename()
4bd6179f fscrypt: new helper function - fscrypt_prepare_link()
b811faac fscrypt: new helper function - fscrypt_file_open()
e9f57e37 fscrypt: new helper function - fscrypt_require_key()
b31ee2e1 fscrypt: remove unneeded empty fscrypt_operations structs
82cbed4c fscrypt: remove ->is_encrypted()
2edb5df1 fscrypt: switch from ->is_encrypted() to IS_ENCRYPTED()
cde1fbb0 fs, fscrypt: add an S_ENCRYPTED inode flag
8ec05db2 fscrypt: clean up include file mess

Change-Id: I8980613b8d5ffedf72ef2c91e1ae2eebb521ae19
Signed-off-by: default avatarJaegeuk Kim <jaegeuk@google.com>
parent 45e631ea

crypto/api.c

+13 −0
Original line number Diff line number Diff line
@@ -24,6 +24,7 @@ 
#include <linux/sched/signal.h>

#include <linux/slab.h>

#include <linux/string.h>

#include <linux/completion.h>

#include "internal.h"



LIST_HEAD(crypto_alg_list);
@@ -595,5 +596,17 @@ int crypto_has_alg(const char *name, u32 type, u32 mask) 
}

EXPORT_SYMBOL_GPL(crypto_has_alg);



void crypto_req_done(struct crypto_async_request *req, int err)

{

	struct crypto_wait *wait = req->data;



	if (err == -EINPROGRESS)

		return;



	wait->err = err;

	complete(&wait->completion);

}

EXPORT_SYMBOL_GPL(crypto_req_done);



MODULE_DESCRIPTION("Cryptographic core API");

MODULE_LICENSE("GPL");

fs/crypto/Makefile

+1 −1
Original line number Diff line number Diff line 
obj-$(CONFIG_FS_ENCRYPTION)	+= fscrypto.o



fscrypto-y := crypto.o fname.o policy.o keyinfo.o

fscrypto-y := crypto.o fname.o hooks.o keyinfo.o policy.o

fscrypto-$(CONFIG_BLOCK) += bio.o

fs/crypto/crypto.c

+5 −25
Original line number Diff line number Diff line
@@ -126,21 +126,6 @@ struct fscrypt_ctx *fscrypt_get_ctx(const struct inode *inode, gfp_t gfp_flags) 
}

EXPORT_SYMBOL(fscrypt_get_ctx);



/**

 * page_crypt_complete() - completion callback for page crypto

 * @req: The asynchronous cipher request context

 * @res: The result of the cipher operation

 */

static void page_crypt_complete(struct crypto_async_request *req, int res)

{

	struct fscrypt_completion_result *ecr = req->data;



	if (res == -EINPROGRESS)

		return;

	ecr->res = res;

	complete(&ecr->completion);

}



int fscrypt_do_page_crypto(const struct inode *inode, fscrypt_direction_t rw,

			   u64 lblk_num, struct page *src_page,

			   struct page *dest_page, unsigned int len,
@@ -151,7 +136,7 @@ int fscrypt_do_page_crypto(const struct inode *inode, fscrypt_direction_t rw, 
		u8 padding[FS_IV_SIZE - sizeof(__le64)];

	} iv;

	struct skcipher_request *req = NULL;

	DECLARE_FS_COMPLETION_RESULT(ecr);

	DECLARE_CRYPTO_WAIT(wait);

	struct scatterlist dst, src;

	struct fscrypt_info *ci = inode->i_crypt_info;

	struct crypto_skcipher *tfm = ci->ci_ctfm;
@@ -179,7 +164,7 @@ int fscrypt_do_page_crypto(const struct inode *inode, fscrypt_direction_t rw, 


	skcipher_request_set_callback(

		req, CRYPTO_TFM_REQ_MAY_BACKLOG | CRYPTO_TFM_REQ_MAY_SLEEP,

		page_crypt_complete, &ecr);

		crypto_req_done, &wait);



	sg_init_table(&dst, 1);

	sg_set_page(&dst, dest_page, len, offs);
@@ -187,14 +172,9 @@ int fscrypt_do_page_crypto(const struct inode *inode, fscrypt_direction_t rw, 
	sg_set_page(&src, src_page, len, offs);

	skcipher_request_set_crypt(req, &src, &dst, len, &iv);

	if (rw == FS_DECRYPT)

		res = crypto_skcipher_decrypt(req);

		res = crypto_wait_req(crypto_skcipher_decrypt(req), &wait);

	else

		res = crypto_skcipher_encrypt(req);

	if (res == -EINPROGRESS || res == -EBUSY) {

		BUG_ON(req->base.data != &ecr);

		wait_for_completion(&ecr.completion);

		res = ecr.res;

	}

		res = crypto_wait_req(crypto_skcipher_encrypt(req), &wait);

	skcipher_request_free(req);

	if (res) {

		printk_ratelimited(KERN_ERR
@@ -340,7 +320,7 @@ static int fscrypt_d_revalidate(struct dentry *dentry, unsigned int flags) 
		return -ECHILD;



	dir = dget_parent(dentry);

	if (!d_inode(dir)->i_sb->s_cop->is_encrypted(d_inode(dir))) {

	if (!IS_ENCRYPTED(d_inode(dir))) {

		dput(dir);

		return 0;

	}

fs/crypto/fname.c

+7 −32
Original line number Diff line number Diff line
@@ -15,21 +15,6 @@ 
#include <linux/ratelimit.h>

#include "fscrypt_private.h"



/**

 * fname_crypt_complete() - completion callback for filename crypto

 * @req: The asynchronous cipher request context

 * @res: The result of the cipher operation

 */

static void fname_crypt_complete(struct crypto_async_request *req, int res)

{

	struct fscrypt_completion_result *ecr = req->data;



	if (res == -EINPROGRESS)

		return;

	ecr->res = res;

	complete(&ecr->completion);

}



/**

 * fname_encrypt() - encrypt a filename

 *
@@ -41,7 +26,7 @@ static int fname_encrypt(struct inode *inode, 
			const struct qstr *iname, struct fscrypt_str *oname)

{

	struct skcipher_request *req = NULL;

	DECLARE_FS_COMPLETION_RESULT(ecr);

	DECLARE_CRYPTO_WAIT(wait);

	struct fscrypt_info *ci = inode->i_crypt_info;

	struct crypto_skcipher *tfm = ci->ci_ctfm;

	int res = 0;
@@ -77,17 +62,12 @@ static int fname_encrypt(struct inode *inode, 
	}

	skcipher_request_set_callback(req,

			CRYPTO_TFM_REQ_MAY_BACKLOG | CRYPTO_TFM_REQ_MAY_SLEEP,

			fname_crypt_complete, &ecr);

			crypto_req_done, &wait);

	sg_init_one(&sg, oname->name, cryptlen);

	skcipher_request_set_crypt(req, &sg, &sg, cryptlen, iv);



	/* Do the encryption */

	res = crypto_skcipher_encrypt(req);

	if (res == -EINPROGRESS || res == -EBUSY) {

		/* Request is being completed asynchronously; wait for it */

		wait_for_completion(&ecr.completion);

		res = ecr.res;

	}

	res = crypto_wait_req(crypto_skcipher_encrypt(req), &wait);

	skcipher_request_free(req);

	if (res < 0) {

		printk_ratelimited(KERN_ERR
@@ -111,7 +91,7 @@ static int fname_decrypt(struct inode *inode, 
				struct fscrypt_str *oname)

{

	struct skcipher_request *req = NULL;

	DECLARE_FS_COMPLETION_RESULT(ecr);

	DECLARE_CRYPTO_WAIT(wait);

	struct scatterlist src_sg, dst_sg;

	struct fscrypt_info *ci = inode->i_crypt_info;

	struct crypto_skcipher *tfm = ci->ci_ctfm;
@@ -132,7 +112,7 @@ static int fname_decrypt(struct inode *inode, 
	}

	skcipher_request_set_callback(req,

		CRYPTO_TFM_REQ_MAY_BACKLOG | CRYPTO_TFM_REQ_MAY_SLEEP,

		fname_crypt_complete, &ecr);

		crypto_req_done, &wait);



	/* Initialize IV */

	memset(iv, 0, FS_CRYPTO_BLOCK_SIZE);
@@ -141,11 +121,7 @@ static int fname_decrypt(struct inode *inode, 
	sg_init_one(&src_sg, iname->name, iname->len);

	sg_init_one(&dst_sg, oname->name, oname->len);

	skcipher_request_set_crypt(req, &src_sg, &dst_sg, iname->len, iv);

	res = crypto_skcipher_decrypt(req);

	if (res == -EINPROGRESS || res == -EBUSY) {

		wait_for_completion(&ecr.completion);

		res = ecr.res;

	}

	res = crypto_wait_req(crypto_skcipher_decrypt(req), &wait);

	skcipher_request_free(req);

	if (res < 0) {

		printk_ratelimited(KERN_ERR
@@ -383,8 +359,7 @@ int fscrypt_setup_filename(struct inode *dir, const struct qstr *iname, 
	memset(fname, 0, sizeof(struct fscrypt_name));

	fname->usr_fname = iname;



	if (!dir->i_sb->s_cop->is_encrypted(dir) ||

				fscrypt_is_dot_dotdot(iname)) {

	if (!IS_ENCRYPTED(dir) || fscrypt_is_dot_dotdot(iname)) {

		fname->disk_name.name = (unsigned char *)iname->name;

		fname->disk_name.len = iname->len;

		return 0;

fs/crypto/fscrypt_private.h

+2 −11
Original line number Diff line number Diff line
@@ -12,7 +12,8 @@ 
#ifndef _FSCRYPT_PRIVATE_H

#define _FSCRYPT_PRIVATE_H



#include <linux/fscrypt_supp.h>

#define __FS_HAS_ENCRYPTION 1

#include <linux/fscrypt.h>

#include <crypto/hash.h>



/* Encryption parameters */
@@ -70,16 +71,6 @@ typedef enum { 
#define FS_CTX_REQUIRES_FREE_ENCRYPT_FL		0x00000001

#define FS_CTX_HAS_BOUNCE_BUFFER_FL		0x00000002



struct fscrypt_completion_result {

	struct completion completion;

	int res;

};



#define DECLARE_FS_COMPLETION_RESULT(ecr) \

	struct fscrypt_completion_result ecr = { \

		COMPLETION_INITIALIZER_ONSTACK((ecr).completion), 0 }





/* crypto.c */

extern int fscrypt_initialize(unsigned int cop_flags);

extern struct workqueue_struct *fscrypt_read_workqueue;