f2fs/fscrypt: updates to v4.17-rc1 (d9197657) · Commits · e / devices / android_kernel_fairphone_FP3

Documentation/ABI/testing/sysfs-fs-f2fs

+11 −0

Original line number	Diff line number	Diff line
		@@ -192,3 +192,14 @@ Date: November 2017
		Contact: "Sheng Yong" <shengyong1@huawei.com>
		Description:
		Controls readahead inode block in readdir.

		What: /sys/fs/f2fs/<disk>/extension_list
		Date: Feburary 2018
		Contact: "Chao Yu" <yuchao0@huawei.com>
		Description:
		Used to control configure extension list:
		- Query: cat /sys/fs/f2fs/<disk>/extension_list
		- Add: echo '[h/c]extension' > /sys/fs/f2fs/<disk>/extension_list
		- Del: echo '[h/c]!extension' > /sys/fs/f2fs/<disk>/extension_list
		- [h] means add/del hot file extension
		- [c] means add/del cold file extension

Documentation/filesystems/f2fs.txt

+17 −0

Original line number	Diff line number	Diff line
		@@ -171,6 +171,23 @@ offgrpjquota Turn off group journelled quota.
		offprjjquota Turn off project journelled quota.
		quota Enable plain user disk quota accounting.
		noquota Disable all plain disk quota option.
		whint_mode=%s Control which write hints are passed down to block
		layer. This supports "off", "user-based", and
		"fs-based". In "off" mode (default), f2fs does not pass
		down hints. In "user-based" mode, f2fs tries to pass
		down hints given by users. And in "fs-based" mode, f2fs
		passes down hints with its policy.
		alloc_mode=%s Adjust block allocation policy, which supports "reuse"
		and "default".
		fsync_mode=%s Control the policy of fsync. Currently supports "posix"
		and "strict". In "posix" mode, which is default, fsync
		will follow POSIX semantics and does a light operation
		to improve the filesystem performance. In "strict" mode,
		fsync will be heavy and behaves in line with xfs, ext4
		and btrfs, where xfstest generic/342 will pass, but the
		performance will regress.
		test_dummy_encryption Enable dummy encryption, which provides a fake fscrypt
		context. The fake fscrypt context is used by xfstests.

		================================================================================
		DEBUGFS ENTRIES

fs/crypto/crypto.c

+1 −0

Original line number	Diff line number	Diff line
		@@ -27,6 +27,7 @@
		#include <linux/dcache.h>
		#include <linux/namei.h>
		#include <crypto/aes.h>
		#include <crypto/skcipher.h>
		#include "fscrypt_private.h"

		static unsigned int num_prealloc_crypto_pages = 32;

fs/crypto/fname.c

+61 −79

Original line number	Diff line number	Diff line
		@@ -12,42 +12,46 @@

		#include <linux/scatterlist.h>
		#include <linux/ratelimit.h>
		#include <crypto/skcipher.h>
		#include "fscrypt_private.h"

		static inline bool fscrypt_is_dot_dotdot(const struct qstr *str)
		{
		if (str->len == 1 && str->name[0] == '.')
		return true;

		if (str->len == 2 && str->name[0] == '.' && str->name[1] == '.')
		return true;

		return false;
		}

		/**
		* fname_encrypt() - encrypt a filename
		*
		* The caller must have allocated sufficient memory for the @oname string.
		* The output buffer must be at least as large as the input buffer.
		* Any extra space is filled with NUL padding before encryption.
		*
		* Return: 0 on success, -errno on failure
		*/
		static int fname_encrypt(struct inode *inode,
		const struct qstr iname, struct fscrypt_str oname)
		int fname_encrypt(struct inode inode, const struct qstr iname,
		u8 *out, unsigned int olen)
		{
		struct skcipher_request *req = NULL;
		DECLARE_CRYPTO_WAIT(wait);
		struct fscrypt_info *ci = inode->i_crypt_info;
		struct crypto_skcipher *tfm = ci->ci_ctfm;
		struct crypto_skcipher *tfm = inode->i_crypt_info->ci_ctfm;
		int res = 0;
		char iv[FS_CRYPTO_BLOCK_SIZE];
		struct scatterlist sg;
		int padding = 4 << (ci->ci_flags & FS_POLICY_FLAGS_PAD_MASK);
		unsigned int lim;
		unsigned int cryptlen;

		lim = inode->i_sb->s_cop->max_namelen(inode);
		if (iname->len <= 0 \|\| iname->len > lim)
		return -EIO;

		/*
		* Copy the filename to the output buffer for encrypting in-place and
		* pad it with the needed number of NUL bytes.
		*/
		cryptlen = max_t(unsigned int, iname->len, FS_CRYPTO_BLOCK_SIZE);
		cryptlen = round_up(cryptlen, padding);
		cryptlen = min(cryptlen, lim);
		memcpy(oname->name, iname->name, iname->len);
		memset(oname->name + iname->len, 0, cryptlen - iname->len);
		if (WARN_ON(olen < iname->len))
		return -ENOBUFS;
		memcpy(out, iname->name, iname->len);
		memset(out + iname->len, 0, olen - iname->len);

		/* Initialize the IV */
		memset(iv, 0, FS_CRYPTO_BLOCK_SIZE);
		@@ -62,8 +66,8 @@ static int fname_encrypt(struct inode *inode,
		skcipher_request_set_callback(req,
		CRYPTO_TFM_REQ_MAY_BACKLOG \| CRYPTO_TFM_REQ_MAY_SLEEP,
		crypto_req_done, &wait);
		sg_init_one(&sg, oname->name, cryptlen);
		skcipher_request_set_crypt(req, &sg, &sg, cryptlen, iv);
		sg_init_one(&sg, out, olen);
		skcipher_request_set_crypt(req, &sg, &sg, olen, iv);

		/* Do the encryption */
		res = crypto_wait_req(crypto_skcipher_encrypt(req), &wait);
		@@ -74,7 +78,6 @@ static int fname_encrypt(struct inode *inode,
		return res;
		}

		oname->len = cryptlen;
		return 0;
		}

		@@ -187,50 +190,52 @@ static int digest_decode(const char src, int len, char dst)
		return cp - dst;
		}

		u32 fscrypt_fname_encrypted_size(const struct inode *inode, u32 ilen)
		bool fscrypt_fname_encrypted_size(const struct inode *inode, u32 orig_len,
		u32 max_len, u32 *encrypted_len_ret)
		{
		int padding = 32;
		struct fscrypt_info *ci = inode->i_crypt_info;

		if (ci)
		padding = 4 << (ci->ci_flags & FS_POLICY_FLAGS_PAD_MASK);
		ilen = max(ilen, (u32)FS_CRYPTO_BLOCK_SIZE);
		return round_up(ilen, padding);
		int padding = 4 << (inode->i_crypt_info->ci_flags &
		FS_POLICY_FLAGS_PAD_MASK);
		u32 encrypted_len;

		if (orig_len > max_len)
		return false;
		encrypted_len = max(orig_len, (u32)FS_CRYPTO_BLOCK_SIZE);
		encrypted_len = round_up(encrypted_len, padding);
		*encrypted_len_ret = min(encrypted_len, max_len);
		return true;
		}
		EXPORT_SYMBOL(fscrypt_fname_encrypted_size);

		/**
		* fscrypt_fname_crypto_alloc_obuff() -
		* fscrypt_fname_alloc_buffer - allocate a buffer for presented filenames
		*
		* Allocates an output buffer that is sufficient for the crypto operation
		* specified by the context and the direction.
		* Allocate a buffer that is large enough to hold any decrypted or encoded
		* filename (null-terminated), for the given maximum encrypted filename length.
		*
		* Return: 0 on success, -errno on failure
		*/
		int fscrypt_fname_alloc_buffer(const struct inode *inode,
		u32 ilen, struct fscrypt_str *crypto_str)
		u32 max_encrypted_len,
		struct fscrypt_str *crypto_str)
		{
		u32 olen = fscrypt_fname_encrypted_size(inode, ilen);
		const u32 max_encoded_len =
		max_t(u32, BASE64_CHARS(FSCRYPT_FNAME_MAX_UNDIGESTED_SIZE),
		1 + BASE64_CHARS(sizeof(struct fscrypt_digested_name)));
		u32 max_presented_len;

		crypto_str->len = olen;
		olen = max(olen, max_encoded_len);
		max_presented_len = max(max_encoded_len, max_encrypted_len);

		/*
		* Allocated buffer can hold one more character to null-terminate the
		* string
		*/
		crypto_str->name = kmalloc(olen + 1, GFP_NOFS);
		if (!(crypto_str->name))
		crypto_str->name = kmalloc(max_presented_len + 1, GFP_NOFS);
		if (!crypto_str->name)
		return -ENOMEM;
		crypto_str->len = max_presented_len;
		return 0;
		}
		EXPORT_SYMBOL(fscrypt_fname_alloc_buffer);

		/**
		* fscrypt_fname_crypto_free_buffer() -
		* fscrypt_fname_free_buffer - free the buffer for presented filenames
		*
		* Frees the buffer allocated for crypto operation.
		* Free the buffer allocated by fscrypt_fname_alloc_buffer().
		*/
		void fscrypt_fname_free_buffer(struct fscrypt_str *crypto_str)
		{
		@@ -296,35 +301,6 @@ int fscrypt_fname_disk_to_usr(struct inode *inode,
		}
		EXPORT_SYMBOL(fscrypt_fname_disk_to_usr);

		/**
		* fscrypt_fname_usr_to_disk() - converts a filename from user space to disk
		* space
		*
		* The caller must have allocated sufficient memory for the @oname string.
		*
		* Return: 0 on success, -errno on failure
		*/
		int fscrypt_fname_usr_to_disk(struct inode *inode,
		const struct qstr *iname,
		struct fscrypt_str *oname)
		{
		if (fscrypt_is_dot_dotdot(iname)) {
		oname->name[0] = '.';
		oname->name[iname->len - 1] = '.';
		oname->len = iname->len;
		return 0;
		}
		if (inode->i_crypt_info)
		return fname_encrypt(inode, iname, oname);
		/*
		* Without a proper key, a user is not allowed to modify the filenames
		* in a directory. Consequently, a user space name cannot be mapped to
		* a disk-space name
		*/
		return -ENOKEY;
		}
		EXPORT_SYMBOL(fscrypt_fname_usr_to_disk);

		/**
		* fscrypt_setup_filename() - prepare to search a possibly encrypted directory
		* @dir: the directory that will be searched
		@@ -368,11 +344,17 @@ int fscrypt_setup_filename(struct inode dir, const struct qstr iname,
		return ret;

		if (dir->i_crypt_info) {
		ret = fscrypt_fname_alloc_buffer(dir, iname->len,
		&fname->crypto_buf);
		if (ret)
		return ret;
		ret = fname_encrypt(dir, iname, &fname->crypto_buf);
		if (!fscrypt_fname_encrypted_size(dir, iname->len,
		dir->i_sb->s_cop->max_namelen(dir),
		&fname->crypto_buf.len))
		return -ENAMETOOLONG;
		fname->crypto_buf.name = kmalloc(fname->crypto_buf.len,
		GFP_NOFS);
		if (!fname->crypto_buf.name)
		return -ENOMEM;

		ret = fname_encrypt(dir, iname, fname->crypto_buf.name,
		fname->crypto_buf.len);
		if (ret)
		goto errout;
		fname->disk_name.name = fname->crypto_buf.name;
		@@ -424,7 +406,7 @@ int fscrypt_setup_filename(struct inode dir, const struct qstr iname,
		return 0;

		errout:
		fscrypt_fname_free_buffer(&fname->crypto_buf);
		kfree(fname->crypto_buf.name);
		return ret;
		}
		EXPORT_SYMBOL(fscrypt_setup_filename);

fs/crypto/fscrypt_private.h

+31 −0

Original line number	Diff line number	Diff line
		@@ -49,6 +49,15 @@ struct fscrypt_context {

		#define FS_ENCRYPTION_CONTEXT_FORMAT_V1 1

		/**
		* For encrypted symlinks, the ciphertext length is stored at the beginning
		* of the string in little-endian format.
		*/
		struct fscrypt_symlink_data {
		__le16 len;
		char encrypted_path[1];
		} __packed;

		/*
		* A pointer to this structure is stored in the file system's in-core
		* representation of an inode.
		@@ -70,7 +79,22 @@ typedef enum {
		#define FS_CTX_REQUIRES_FREE_ENCRYPT_FL 0x00000001
		#define FS_CTX_HAS_BOUNCE_BUFFER_FL 0x00000002

		static inline bool fscrypt_valid_enc_modes(u32 contents_mode,
		u32 filenames_mode)
		{
		if (contents_mode == FS_ENCRYPTION_MODE_AES_128_CBC &&
		filenames_mode == FS_ENCRYPTION_MODE_AES_128_CTS)
		return true;

		if (contents_mode == FS_ENCRYPTION_MODE_AES_256_XTS &&
		filenames_mode == FS_ENCRYPTION_MODE_AES_256_CTS)
		return true;

		return false;
		}

		/* crypto.c */
		extern struct kmem_cache *fscrypt_info_cachep;
		extern int fscrypt_initialize(unsigned int cop_flags);
		extern struct workqueue_struct *fscrypt_read_workqueue;
		extern int fscrypt_do_page_crypto(const struct inode *inode,
		@@ -82,6 +106,13 @@ extern int fscrypt_do_page_crypto(const struct inode *inode,
		extern struct page fscrypt_alloc_bounce_page(struct fscrypt_ctx ctx,
		gfp_t gfp_flags);

		/* fname.c */
		extern int fname_encrypt(struct inode inode, const struct qstr iname,
		u8 *out, unsigned int olen);
		extern bool fscrypt_fname_encrypted_size(const struct inode *inode,
		u32 orig_len, u32 max_len,
		u32 *encrypted_len_ret);

		/* keyinfo.c */
		extern void __exit fscrypt_essiv_cleanup(void);