fscrypt, ext4: prepare for blocksize != PAGE_SIZE
Subsystems (5)
Eric Biggers
maintainerv2 cover fscrypt, ext4: prepare for blocksize != PAGE_SIZE
Hello,
This patchset prepares fs/crypto/, and partially ext4, for the 'blocksize != PAGE_SIZE' case.
This basically contains the encryption changes from Chandan Rajendra's patchset "[V2,00/13] Consolidate FS read I/O callbacks code"
(https://patchwork.kernel.org/project/linux-fscrypt/list/?series=111039)
that don't require introducing the read_callbacks and don't depend on fsverity stuff. But they've been reworked to clean things up a lot.
I'd like to apply this patchset for 5.3 in order to make things forward for ext4 encryption with 'blocksize != PAGE_SIZE'.
AFAICT, after this patchset the only thing stopping ext4 encryption from working with blocksize != PAGE_SIZE is the lack of encryption support in block_read_full_page(), which the read_callbacks will address.
This patchset applies to v5.2-rc1, and it can also be retrieved from git at https://git.kernel.org/pub/scm/linux/kernel/git/ebiggers/linux.git
branch "fscrypt-subpage-blocks-prep".
Changed since v1 (minor cleanups only):
- In "fscrypt: simplify bounce page handling", also remove the definition of FS_CTX_HAS_BOUNCE_BUFFER_FL.
- In "ext4: decrypt only the needed blocks in ext4_block_write_begin()", simplify the code slightly by moving the IS_ENCRYPTED() check.
- Change __fscrypt_decrypt_bio() in a separate patch rather than as part of "fscrypt: support decrypting multiple filesystem blocks per page". The resulting code is the same, so I kept Chandan's Reviewed-by.
- Improve the commit message of
"fscrypt: introduce fscrypt_decrypt_block_inplace()".
Chandan Rajendra (3):
ext4: clear BH_Uptodate flag on decryption error
ext4: decrypt only the needed blocks in ext4_block_write_begin()
ext4: decrypt only the needed block in __ext4_block_zero_page_range()
Eric Biggers (11):
fscrypt: simplify bounce page handling
fscrypt: remove the "write" part of struct fscrypt_ctx
fscrypt: rename fscrypt_do_page_crypto() to fscrypt_crypt_block()
fscrypt: clean up some BUG_ON()s in block encryption/decryption
fscrypt: introduce fscrypt_encrypt_block_inplace()
fscrypt: support encrypting multiple filesystem blocks per page
fscrypt: handle blocksize < PAGE_SIZE in fscrypt_zeroout_range()
fscrypt: introduce fscrypt_decrypt_block_inplace()
fscrypt: support decrypting multiple filesystem blocks per page
fscrypt: decrypt only the needed blocks in __fscrypt_decrypt_bio()
ext4: encrypt only up to last block in ext4_bio_write_page()
fs/crypto/bio.c | 73 +++------ fs/crypto/crypto.c | 299 ++++++++++++++++++++---------------- fs/crypto/fscrypt_private.h | 15 +- fs/ext4/inode.c | 37 +++-- fs/ext4/page-io.c | 44 +++--- fs/f2fs/data.c | 17 +- fs/ubifs/crypto.c | 19 +-- include/linux/fscrypt.h | 96 ++++++++---- 8 files changed, 319 insertions(+), 281 deletions(-)
Signature · 8 lines
2.21.0.1020.gf2820cf01a-goog _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Eric Biggers
maintainerPATCH v2 1/14 fscrypt: simplify bounce page handling
From: Eric Biggers <[email protected]>
Currently, bounce page handling for writes to encrypted files is unnecessarily complicated. A fscrypt_ctx is allocated along with each bounce page, page_private(bounce_page) points to this fscrypt_ctx, and fscrypt_ctx::w::control_page points to the original pagecache page.
However, because writes don't use the fscrypt_ctx for anything else, there's no reason why page_private(bounce_page) can't just point to the original pagecache page directly.
Therefore, this patch makes this change. In the process, it also cleans up the API exposed to filesystems that allows testing whether a page is a bounce page, getting the pagecache page from a bounce page, and freeing a bounce page.
--- fs/crypto/bio.c | 38 ++----------- fs/crypto/crypto.c | 104 ++++++++++++------------------------ fs/crypto/fscrypt_private.h | 4 +- fs/ext4/page-io.c | 36 +++++-------- fs/f2fs/data.c | 12 ++--- include/linux/fscrypt.h | 38 ++++++++----- 6 files changed, 84 insertions(+), 148 deletions(-)
fs/crypto/bio.c +5 -33
@@ -70,46 +70,18 @@ void fscrypt_enqueue_decrypt_bio(struct fscrypt_ctx *ctx, struct bio *bio) }EXPORT_SYMBOL (fscrypt_enqueue_decrypt_bio); -void fscrypt_pullback_bio_page (struct page **page,bool restore) -{ -struct fscrypt_ctx *ctx; -struct page *bounce_page; - -/* The bounce data pages are unmapped. */ -if ((*page)->mapping) -return ; - -/* The bounce data page is unmapped. */ - bounce_page = *page; - ctx = (struct fscrypt_ctx *)page_private (bounce_page); - -/* restore control page */ - *page = ctx->w.control_page; - -if (restore) -fscrypt_restore_control_page (bounce_page); -} -EXPORT_SYMBOL (fscrypt_pullback_bio_page); -int fscrypt_zeroout_range (const struct inode *inode,pgoff_t lblk,sector_t pblk,unsigned int len) { -struct fscrypt_ctx *ctx; -struct page *ciphertext_page =NULL ; +struct page *ciphertext_page;struct bio *bio;int ret, err =0 ;BUG_ON (inode->i_sb->s_blocksize !=PAGE_SIZE ); - ctx =fscrypt_get_ctx (GFP_NOFS ); -if (IS_ERR (ctx)) -return PTR_ERR (ctx); - - ciphertext_page =fscrypt_alloc_bounce_page (ctx,GFP_NOWAIT ); -if (IS_ERR (ciphertext_page)) { - err =PTR_ERR (ciphertext_page); - goto errout; - } + ciphertext_page =fscrypt_alloc_bounce_page (GFP_NOWAIT ); +if (!ciphertext_page) +return -ENOMEM ;while (len--) { err = fscrypt_do_page_crypto(inode, FS_ENCRYPT, lblk,
@@ -147,7 +119,7 @@ int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk, } err =0 ; errout: -fscrypt_release_ctx (ctx); +fscrypt_free_bounce_page (ciphertext_page);return err; }EXPORT_SYMBOL (fscrypt_zeroout_range);
fs/crypto/crypto.c +34 -70
170 lines not on this page · raw message
fs/crypto/fscrypt_private.h +1 -3
@@ -94,7 +94,6 @@ typedef enum { } fscrypt_direction_t;#define FS_CTX_REQUIRES_FREE_ENCRYPT_FL 0x00000001 -#define FS_CTX_HAS_BOUNCE_BUFFER_FL 0x00000002static inline bool fscrypt_valid_enc_modes (u32 contents_mode,u32 filenames_mode)
@@ -123,8 +122,7 @@ extern int fscrypt_do_page_crypto(const struct inode *inode,struct page *dest_page, unsigned int len, unsigned int offs, gfp_t gfp_flags); -extern struct page *fscrypt_alloc_bounce_page (struct fscrypt_ctx *ctx, -gfp_t gfp_flags); +extern struct page *fscrypt_alloc_bounce_page (gfp_t gfp_flags);extern const struct dentry_operations fscrypt_d_ops; extern void __printf(3, 4) __cold
fs/ext4/page-io.c +13 -23
@@ -66,9 +66,7 @@ static void ext4_finish_bio(struct bio *bio)bio_for_each_segment_all (bvec, bio, iter_all) {struct page *page = bvec->bv_page; -#ifdef CONFIG_FS_ENCRYPTION -struct page *data_page =NULL ; -#endif +struct page *bounce_page =NULL ;struct buffer_head *bh, *head;unsigned bio_start = bvec->bv_offset;unsigned bio_end = bio_start + bvec->bv_len;
@@ -78,13 +76,10 @@ static void ext4_finish_bio(struct bio *bio)if (!page)continue ; -#ifdef CONFIG_FS_ENCRYPTION -if (!page->mapping) { -/* The bounce data pages are unmapped. */ - data_page = page; -fscrypt_pullback_bio_page (&page, false); +if (fscrypt_is_bounce_page (page)) { + bounce_page = page; + page =fscrypt_pagecache_page (bounce_page); } -#endif if (bio->bi_status) {SetPageError (page);
@@ -111,10 +106,7 @@ static void ext4_finish_bio(struct bio *bio)bit_spin_unlock (BH_Uptodate_Lock, &head->b_state);local_irq_restore (flags);if (!under_io) { -#ifdef CONFIG_FS_ENCRYPTION -if (data_page) -fscrypt_restore_control_page (data_page); -#endif +fscrypt_free_bounce_page (bounce_page);end_page_writeback (page); } }
@@ -415,7 +407,7 @@ int ext4_bio_write_page(struct ext4_io_submit *io, struct writeback_control *wbc, bool keep_towrite) { -struct page *data_page =NULL ; +struct page *bounce_page =NULL ;struct inode *inode = page->mapping->host;unsigned block_start;struct buffer_head *bh, *head;
@@ -479,10 +471,10 @@ int ext4_bio_write_page(struct ext4_io_submit *io,gfp_t gfp_flags =GFP_NOFS ; retry_encrypt: - data_page =fscrypt_encrypt_page (inode, page,PAGE_SIZE ,0 , - page->index, gfp_flags); -if (IS_ERR (data_page)) { - ret =PTR_ERR (data_page); + bounce_page =fscrypt_encrypt_page (inode, page,PAGE_SIZE ,0 , + page->index, gfp_flags); +if (IS_ERR (bounce_page)) { + ret =PTR_ERR (bounce_page);if (ret == -ENOMEM && wbc->sync_mode ==WB_SYNC_ALL ) {if (io->io_bio) {ext4_io_submit (io);
@@ -491,7 +483,7 @@ int ext4_bio_write_page(struct ext4_io_submit *io, gfp_flags |= __GFP_NOFAIL; goto retry_encrypt; } - data_page =NULL ; + bounce_page =NULL ; goto out; } }
@@ -500,8 +492,7 @@ int ext4_bio_write_page(struct ext4_io_submit *io, do { if (!buffer_async_write(bh)) continue; - ret = io_submit_add_bh(io, inode, - data_page ? data_page : page, bh); + ret = io_submit_add_bh(io, inode, bounce_page ?: page, bh); if (ret) { /* * We only get here on ENOMEM. Not much else
@@ -517,8 +508,7 @@ int ext4_bio_write_page(struct ext4_io_submit *io,/* Error stopped previous loop? Clean up buffers... */ if (ret) { out: -if (data_page) -fscrypt_restore_control_page (data_page); +fscrypt_free_bounce_page (bounce_page);printk_ratelimited (KERN_ERR "%s: ret = %d\n" , __func__, ret);redirty_page_for_writepage (wbc, page); do {
fs/f2fs/data.c +5 -7
@@ -185,7 +185,7 @@ static void f2fs_write_end_io(struct bio *bio)continue ; } -fscrypt_pullback_bio_page (&page, true); +fscrypt_finalize_bounce_page (&page);if (unlikely (bio->bi_status)) {mapping_set_error (page->mapping, -EIO );
@@ -362,10 +362,9 @@ static bool __has_merged_page(struct f2fs_bio_info *io, struct inode *inode,bio_for_each_segment_all (bvec, io->bio, iter_all) { -if (bvec->bv_page->mapping) - target = bvec->bv_page; -else - target =fscrypt_control_page (bvec->bv_page); + target = bvec->bv_page; +if (fscrypt_is_bounce_page (target)) + target =fscrypt_pagecache_page (target);if (inode && inode == target->mapping->host)return true;
@@ -1900,8 +1899,7 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio) err =f2fs_inplace_write_data (fio);if (err) {if (f2fs_encrypted_file (inode)) -fscrypt_pullback_bio_page (&fio->encrypted_page, - true); +fscrypt_finalize_bounce_page (&fio->encrypted_page);if (PageWriteback (page))end_page_writeback (page); }else {
include/linux/fscrypt.h +26 -12
@@ -112,12 +112,17 @@ extern struct page *fscrypt_encrypt_page(const struct inode *, struct page *,extern int fscrypt_decrypt_page (const struct inode *,struct page *,unsigned int ,unsigned int ,u64 ); -static inline struct page *fscrypt_control_page (struct page *page) +static inline bool fscrypt_is_bounce_page (struct page *page) { -return ((struct fscrypt_ctx *)page_private (page))->w.control_page; +return page->mapping ==NULL ; } -extern void fscrypt_restore_control_page (struct page *); +static inline struct page *fscrypt_pagecache_page (struct page *bounce_page) +{ +return (struct page *)page_private (bounce_page); +} + +extern void fscrypt_free_bounce_page (struct page *bounce_page);/* policy.c */ extern int fscrypt_ioctl_set_policy (struct file *,const void __user *);
@@ -223,7 +228,6 @@ static inline bool fscrypt_match_name(const struct fscrypt_name *fname,extern void fscrypt_decrypt_bio (struct bio *);extern void fscrypt_enqueue_decrypt_bio (struct fscrypt_ctx *ctx,struct bio *bio); -extern void fscrypt_pullback_bio_page (struct page **,bool );extern int fscrypt_zeroout_range (const struct inode *,pgoff_t ,sector_t ,unsigned int );
@@ -300,15 +304,19 @@ static inline int fscrypt_decrypt_page(const struct inode *inode,return -EOPNOTSUPP ; } -static inline struct page *fscrypt_control_page (struct page *page) +static inline bool fscrypt_is_bounce_page (struct page *page) +{ +return false; +} + +static inline struct page *fscrypt_pagecache_page (struct page *bounce_page) {WARN_ON_ONCE (1 );return ERR_PTR (-EINVAL ); } -static inline void fscrypt_restore_control_page (struct page *page) +static inline void fscrypt_free_bounce_page (struct page *bounce_page) { -return ; }/* policy.c */
@@ -410,11 +418,6 @@ static inline void fscrypt_enqueue_decrypt_bio(struct fscrypt_ctx *ctx, { } -static inline void fscrypt_pullback_bio_page (struct page **page,bool restore) -{ -return ; -} -static inline int fscrypt_zeroout_range (const struct inode *inode,pgoff_t lblk,sector_t pblk,unsigned int len) {
@@ -692,4 +695,15 @@ static inline int fscrypt_encrypt_symlink(struct inode *inode, return 0; } +/* If *pagep is a bounce page, free it and set *pagep to the pagecache page */ +static inline void fscrypt_finalize_bounce_page (struct page **pagep) +{ +struct page *page = *pagep; + +if (fscrypt_is_bounce_page (page)) { + *pagep =fscrypt_pagecache_page (page); +fscrypt_free_bounce_page (page); + } +} +#endif /* _LINUX_FSCRYPT_H */
Signature · 8 lines
2.21.0.1020.gf2820cf01a-goog _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Eric Biggers
maintainerPATCH v2 2/14 fscrypt: remove the "write" part of struct fscrypt_ctx
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
Now that fscrypt_ctx is not used for writes, remove the 'w' fields.
--- fs/crypto/bio.c | 11 +++++------ fs/crypto/crypto.c | 14 +++++++------- include/linux/fscrypt.h | 7 ++----- 3 files changed, 14 insertions(+), 18 deletions(-)
fs/crypto/bio.c +5 -6
@@ -53,9 +53,8 @@ EXPORT_SYMBOL(fscrypt_decrypt_bio);static void completion_pages (struct work_struct *work) { -struct fscrypt_ctx *ctx = - container_of(work, struct fscrypt_ctx, r.work); -struct bio *bio = ctx->r.bio; + struct fscrypt_ctx *ctx = container_of(work, struct fscrypt_ctx, work); +struct bio *bio = ctx->bio;__fscrypt_decrypt_bio (bio, true);fscrypt_release_ctx (ctx);
@@ -64,9 +63,9 @@ static void completion_pages(struct work_struct *work)void fscrypt_enqueue_decrypt_bio (struct fscrypt_ctx *ctx,struct bio *bio) { -INIT_WORK (&ctx->r.work, completion_pages); - ctx->r.bio = bio; -fscrypt_enqueue_decrypt_work (&ctx->r.work); +INIT_WORK (&ctx->work, completion_pages); + ctx->bio = bio; +fscrypt_enqueue_decrypt_work (&ctx->work); }EXPORT_SYMBOL (fscrypt_enqueue_decrypt_bio);
fs/crypto/crypto.c +7 -7
@@ -58,11 +58,11 @@ void fscrypt_enqueue_decrypt_work(struct work_struct *work)EXPORT_SYMBOL (fscrypt_enqueue_decrypt_work);/** -* fscrypt_release_ctx() - Releases an encryption context -* @ctx: The encryption context to release. +* fscrypt_release_ctx() - Release a decryption context +* @ctx: The decryption context to release. * -* If the encryption context was allocated from the pre-allocated pool, returns -* it to that pool. Else, frees it. +* If the decryption context was allocated from the pre-allocated pool, return +* it to that pool. Else, free it. */ void fscrypt_release_ctx (struct fscrypt_ctx *ctx) {
@@ -79,12 +79,12 @@ void fscrypt_release_ctx(struct fscrypt_ctx *ctx)EXPORT_SYMBOL (fscrypt_release_ctx);/** -* fscrypt_get_ctx() - Gets an encryption context +* fscrypt_get_ctx() - Get a decryption context * @gfp_flags: The gfp flag for memory allocation * -* Allocates and initializes an encryption context. +* Allocate and initialize a decryption context. * -* Return: A new encryption context on success; an ERR_PTR() otherwise. +* Return: A new decryption context on success; an ERR_PTR() otherwise. */ struct fscrypt_ctx *fscrypt_get_ctx (gfp_t gfp_flags) {
include/linux/fscrypt.h +2 -5
@@ -63,16 +63,13 @@ struct fscrypt_operations {unsigned int max_namelen; }; +/* Decryption work */ struct fscrypt_ctx {union { -struct { -struct page *bounce_page;/* Ciphertext page */ -struct page *control_page;/* Original page */ - } w;struct {struct bio *bio;struct work_struct work; - } r; + };struct list_head free_list;/* Free list */ };u8 flags;/* Flags */
Signature · 8 lines
2.21.0.1020.gf2820cf01a-goog _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Eric Biggers
maintainerPATCH v2 3/14 fscrypt: rename fscrypt_do_page_crypto() to fscrypt_crypt_block()
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
fscrypt_do_page_crypto() only does a single encryption or decryption operation, with a single logical block number (single IV). So it actually operates on a filesystem block, not a "page" per se. To reflect this, rename it to fscrypt_crypt_block().
--- fs/crypto/bio.c | 6 +++--- fs/crypto/crypto.c | 24 ++++++++++++------------ fs/crypto/fscrypt_private.h | 11 +++++------ 3 files changed, 20 insertions(+), 21 deletions(-)
fs/crypto/bio.c +3 -3
@@ -83,9 +83,9 @@ int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk,return -ENOMEM ;while (len--) { - err =fscrypt_do_page_crypto (inode,FS_ENCRYPT , lblk, -ZERO_PAGE (0 ), ciphertext_page, -PAGE_SIZE ,0 ,GFP_NOFS ); + err =fscrypt_crypt_block (inode,FS_ENCRYPT , lblk, +ZERO_PAGE (0 ), ciphertext_page, +PAGE_SIZE ,0 ,GFP_NOFS );if (err) goto errout;
fs/crypto/crypto.c +12 -12
@@ -147,10 +147,11 @@ void fscrypt_generate_iv(union fscrypt_iv *iv, u64 lblk_num,crypto_cipher_encrypt_one (ci->ci_essiv_tfm, iv->raw, iv->raw); } -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, -unsigned int offs,gfp_t gfp_flags) +/* Encrypt or decrypt a single filesystem block of file contents */ +int fscrypt_crypt_block (const struct inode *inode,fscrypt_direction_t rw, +u64 lblk_num,struct page *src_page, +struct page *dest_page,unsigned int len, +unsigned int offs,gfp_t gfp_flags) {union fscrypt_iv iv;struct skcipher_request *req =NULL ;
@@ -227,9 +228,9 @@ struct page *fscrypt_encrypt_page(const struct inode *inode,if (inode->i_sb->s_cop->flags &FS_CFLG_OWN_PAGES ) {/* with inplace-encryption we just encrypt the page */ - err =fscrypt_do_page_crypto (inode,FS_ENCRYPT , lblk_num, page, - ciphertext_page, len, offs, - gfp_flags); + err =fscrypt_crypt_block (inode,FS_ENCRYPT , lblk_num, page, + ciphertext_page, len, offs, + gfp_flags);if (err)return ERR_PTR (err);
@@ -243,9 +244,8 @@ struct page *fscrypt_encrypt_page(const struct inode *inode,if (!ciphertext_page)return ERR_PTR (-ENOMEM ); - err =fscrypt_do_page_crypto (inode,FS_ENCRYPT , lblk_num, - page, ciphertext_page, len, offs, - gfp_flags); + err =fscrypt_crypt_block (inode,FS_ENCRYPT , lblk_num, page, + ciphertext_page, len, offs, gfp_flags);if (err) {fscrypt_free_bounce_page (ciphertext_page);return ERR_PTR (err);
@@ -277,8 +277,8 @@ int fscrypt_decrypt_page(const struct inode *inode, struct page *page,if (!(inode->i_sb->s_cop->flags &FS_CFLG_OWN_PAGES ))BUG_ON (!PageLocked (page)); -return fscrypt_do_page_crypto (inode,FS_DECRYPT , lblk_num, page, page, - len, offs,GFP_NOFS ); +return fscrypt_crypt_block (inode,FS_DECRYPT , lblk_num, page, page, + len, offs,GFP_NOFS ); }EXPORT_SYMBOL (fscrypt_decrypt_page);
fs/crypto/fscrypt_private.h +5 -6
@@ -116,12 +116,11 @@ static inline bool fscrypt_valid_enc_modes(u32 contents_mode,/* crypto.c */ extern struct kmem_cache *fscrypt_info_cachep;extern int fscrypt_initialize (unsigned int cop_flags); -extern 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,unsigned int offs, -gfp_t gfp_flags); +extern int fscrypt_crypt_block (const struct inode *inode, +fscrypt_direction_t rw,u64 lblk_num, +struct page *src_page,struct page *dest_page, +unsigned int len,unsigned int offs, +gfp_t gfp_flags);extern struct page *fscrypt_alloc_bounce_page (gfp_t gfp_flags);extern const struct dentry_operations fscrypt_d_ops;
Signature · 8 lines
2.21.0.1020.gf2820cf01a-goog _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Eric Biggers
maintainerPATCH v2 4/14 fscrypt: clean up some BUG_ON()s in block encryption/decryption
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
Replace some BUG_ON()s with WARN_ON_ONCE() and returning an error code, and move the check for len divisible by FS_CRYPTO_BLOCK_SIZE into fscrypt_crypt_block() so that it's done for both encryption and decryption, not just encryption.
--- fs/crypto/crypto.c | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-)
fs/crypto/crypto.c +9 -6
@@ -161,7 +161,10 @@ int fscrypt_crypt_block(const struct inode *inode, fscrypt_direction_t rw,struct crypto_skcipher *tfm = ci->ci_ctfm;int res =0 ; -BUG_ON (len ==0 ); +if (WARN_ON_ONCE (len <=0 )) +return -EINVAL ; +if (WARN_ON_ONCE (len %FS_CRYPTO_BLOCK_SIZE !=0 )) +return -EINVAL ;fscrypt_generate_iv (&iv, lblk_num, ci);
@@ -224,8 +227,6 @@ struct page *fscrypt_encrypt_page(const struct inode *inode,struct page *ciphertext_page = page;int err; -BUG_ON (len %FS_CRYPTO_BLOCK_SIZE !=0 ); -if (inode->i_sb->s_cop->flags &FS_CFLG_OWN_PAGES ) {/* with inplace-encryption we just encrypt the page */ err = fscrypt_crypt_block(inode, FS_ENCRYPT, lblk_num, page,
@@ -237,7 +238,8 @@ struct page *fscrypt_encrypt_page(const struct inode *inode,return ciphertext_page; } -BUG_ON (!PageLocked (page)); +if (WARN_ON_ONCE (!PageLocked (page))) +return ERR_PTR (-EINVAL );/* The encryption operation will require a bounce page. */ ciphertext_page =fscrypt_alloc_bounce_page (gfp_flags);
@@ -274,8 +276,9 @@ EXPORT_SYMBOL(fscrypt_encrypt_page);int fscrypt_decrypt_page (const struct inode *inode,struct page *page,unsigned int len,unsigned int offs,u64 lblk_num) { -if (!(inode->i_sb->s_cop->flags &FS_CFLG_OWN_PAGES )) -BUG_ON (!PageLocked (page)); +if (WARN_ON_ONCE (!PageLocked (page) && + !(inode->i_sb->s_cop->flags &FS_CFLG_OWN_PAGES ))) +return -EINVAL ;return fscrypt_crypt_block (inode,FS_DECRYPT , lblk_num, page, page, len, offs,GFP_NOFS );
Signature · 8 lines
2.21.0.1020.gf2820cf01a-goog _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Eric Biggers
maintainerPATCH v2 5/14 fscrypt: introduce fscrypt_encrypt_block_inplace()
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
fscrypt_encrypt_page() behaves very differently depending on whether the filesystem set FS_CFLG_OWN_PAGES in its fscrypt_operations. This makes the function difficult to understand and document. It also makes it so that all callers have to provide inode and lblk_num, when fscrypt could determine these itself for pagecache pages.
Therefore, move the FS_CFLG_OWN_PAGES behavior into a new function fscrypt_encrypt_block_inplace().
This is in preparation for allowing encryption on ext4 filesystems with blocksize != PAGE_SIZE.
--- fs/crypto/crypto.c | 50 +++++++++++++++++++++++++---------------- fs/ubifs/crypto.c | 12 +++++----- include/linux/fscrypt.h | 13 +++++++++++ 3 files changed, 50 insertions(+), 25 deletions(-)
fs/crypto/crypto.c +31 -19
@@ -199,8 +199,7 @@ int fscrypt_crypt_block(const struct inode *inode, fscrypt_direction_t rw,/** * fscypt_encrypt_page() - Encrypts a page * @inode: The inode for which the encryption should take place -* @page: The page to encrypt. Must be locked for bounce-page -* encryption. +* @page: The page to encrypt. Must be locked. * @len: Length of data to encrypt in @page and encrypted * data in returned page. * @offs: Offset of data within @page and returned
@@ -210,10 +209,9 @@ int fscrypt_crypt_block(const struct inode *inode, fscrypt_direction_t rw,* previously written data. * @gfp_flags: The gfp flag for memory allocation * -* Encrypts @page. If the filesystem set FS_CFLG_OWN_PAGES, then the data is -* encrypted in-place and @page is returned. Else, a bounce page is allocated, -* the data is encrypted into the bounce page, and the bounce page is returned. -* The caller is responsible for calling fscrypt_free_bounce_page(). +* Encrypts @page. A bounce page is allocated, the data is encrypted into the +* bounce page, and the bounce page is returned. The caller is responsible for +* calling fscrypt_free_bounce_page(). * * Return: A page containing the encrypted data on success, else an ERR_PTR() */
@@ -224,24 +222,12 @@ struct page *fscrypt_encrypt_page(const struct inode *inode, u64 lblk_num, gfp_t gfp_flags) { -struct page *ciphertext_page = page; +struct page *ciphertext_page;int err; -if (inode->i_sb->s_cop->flags &FS_CFLG_OWN_PAGES ) { -/* with inplace-encryption we just encrypt the page */ - err =fscrypt_crypt_block (inode,FS_ENCRYPT , lblk_num, page, - ciphertext_page, len, offs, - gfp_flags); -if (err) -return ERR_PTR (err); - -return ciphertext_page; - } -if (WARN_ON_ONCE (!PageLocked (page)))return ERR_PTR (-EINVAL ); -/* The encryption operation will require a bounce page. */ ciphertext_page =fscrypt_alloc_bounce_page (gfp_flags);if (!ciphertext_page)return ERR_PTR (-ENOMEM );
@@ -258,6 +244,32 @@ struct page *fscrypt_encrypt_page(const struct inode *inode, }EXPORT_SYMBOL (fscrypt_encrypt_page); +/** +* fscrypt_encrypt_block_inplace() - Encrypt a filesystem block in-place +* @inode: The inode to which this block belongs +* @page: The page containing the block to encrypt +* @len: Size of block to encrypt. Doesn't need to be a multiple of the +* fs block size, but must be a multiple of FS_CRYPTO_BLOCK_SIZE. +* @offs: Byte offset within @page at which the block to encrypt begins +* @lblk_num: Filesystem logical block number of the block, i.e. the 0-based +* number of the block within the file +* @gfp_flags: Memory allocation flags +* +* Encrypt a possibly-compressed filesystem block that is located in an +* arbitrary page, not necessarily in the original pagecache page. The @inode +* and @lblk_num must be specified, as they can't be determined from @page. +* +* Return: 0 on success; -errno on failure +*/ +int fscrypt_encrypt_block_inplace (const struct inode *inode,struct page *page, +unsigned int len,unsigned int offs, +u64 lblk_num,gfp_t gfp_flags) +{ +return fscrypt_crypt_block (inode,FS_ENCRYPT , lblk_num, page, page, + len, offs, gfp_flags); +} +EXPORT_SYMBOL (fscrypt_encrypt_block_inplace); +/** * fscrypt_decrypt_page() - Decrypts a page in-place * @inode: The corresponding inode for the page to decrypt.
fs/ubifs/crypto.c +6 -6
@@ -29,8 +29,8 @@ int ubifs_encrypt(const struct inode *inode, struct ubifs_data_node *dn, {struct ubifs_info *c = inode->i_sb->s_fs_info;void *p = &dn->data; -struct page *ret;unsigned int pad_len =round_up (in_len,UBIFS_CIPHER_BLOCK_SIZE ); +int err;ubifs_assert (c, pad_len <= *out_len); dn->compr_size =cpu_to_le16 (in_len);
@@ -39,11 +39,11 @@ int ubifs_encrypt(const struct inode *inode, struct ubifs_data_node *dn,if (pad_len != in_len)memset (p + in_len,0 , pad_len - in_len); - ret =fscrypt_encrypt_page (inode,virt_to_page (&dn->data), pad_len, -offset_in_page (&dn->data), block,GFP_NOFS ); -if (IS_ERR (ret)) { -ubifs_err (c,"fscrypt_encrypt_page failed: %ld" ,PTR_ERR (ret)); -return PTR_ERR (ret); + err =fscrypt_encrypt_block_inplace (inode,virt_to_page (p), pad_len, +offset_in_page (p), block,GFP_NOFS ); +if (err) { +ubifs_err (c,"fscrypt_encrypt_block_inplace() failed: %d" , err); +return err; } *out_len = pad_len;
include/linux/fscrypt.h +13 -0
@@ -106,6 +106,10 @@ extern void fscrypt_release_ctx(struct fscrypt_ctx *);extern struct page *fscrypt_encrypt_page (const struct inode *,struct page *,unsigned int ,unsigned int ,u64 ,gfp_t ); +extern int fscrypt_encrypt_block_inplace (const struct inode *inode, +struct page *page,unsigned int len, +unsigned int offs,u64 lblk_num, +gfp_t gfp_flags);extern int fscrypt_decrypt_page (const struct inode *,struct page *,unsigned int ,unsigned int ,u64 );
@@ -293,6 +297,15 @@ static inline struct page *fscrypt_encrypt_page(const struct inode *inode,return ERR_PTR (-EOPNOTSUPP ); } +static inline int fscrypt_encrypt_block_inplace (const struct inode *inode, +struct page *page, +unsigned int len, +unsigned int offs,u64 lblk_num, +gfp_t gfp_flags) +{ +return -EOPNOTSUPP ; +} + static inline int fscrypt_decrypt_page(const struct inode *inode, struct page *page, unsigned int len, unsigned int offs,
Signature · 8 lines
2.21.0.1020.gf2820cf01a-goog _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Eric Biggers
maintainerPATCH v2 6/14 fscrypt: support encrypting multiple filesystem blocks per page
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
Rename fscrypt_encrypt_page() to fscrypt_encrypt_pagecache_blocks() and redefine its behavior to encrypt all filesystem blocks from the given region of the given page, rather than assuming that the region consists of just one filesystem block. Also remove the 'inode' and 'lblk_num' parameters, since they can be retrieved from the page as it's already assumed to be a pagecache page.
This is in preparation for allowing encryption on ext4 filesystems with blocksize != PAGE_SIZE.
This is based on work by Chandan Rajendra.
--- fs/crypto/crypto.c | 67 ++++++++++++++++++++++++----------------- fs/ext4/page-io.c | 4 +-- fs/f2fs/data.c | 5 +-- include/linux/fscrypt.h | 17 ++++++----- 4 files changed, 53 insertions(+), 40 deletions(-)
fs/crypto/crypto.c +39 -28
@@ -121,8 +121,8 @@ struct page *fscrypt_alloc_bounce_page(gfp_t gfp_flags)/** * fscrypt_free_bounce_page() - free a ciphertext bounce page * -* Free a bounce page that was allocated by fscrypt_encrypt_page(), or by -* fscrypt_alloc_bounce_page() directly. +* Free a bounce page that was allocated by fscrypt_encrypt_pagecache_blocks(), +* or by fscrypt_alloc_bounce_page() directly. */ void fscrypt_free_bounce_page (struct page *bounce_page) {
@@ -197,52 +197,63 @@ int fscrypt_crypt_block(const struct inode *inode, fscrypt_direction_t rw, }/** -* fscypt_encrypt_page() - Encrypts a page -* @inode: The inode for which the encryption should take place -* @page: The page to encrypt. Must be locked. -* @len: Length of data to encrypt in @page and encrypted -* data in returned page. -* @offs: Offset of data within @page and returned -* page holding encrypted data. -* @lblk_num: Logical block number. This must be unique for multiple -* calls with same inode, except when overwriting -* previously written data. -* @gfp_flags: The gfp flag for memory allocation +* fscrypt_encrypt_pagecache_blocks() - Encrypt filesystem blocks from a pagecache page +* @page: The locked pagecache page containing the block(s) to encrypt +* @len: Total size of the block(s) to encrypt. Must be a nonzero +* multiple of the filesystem's block size. +* @offs: Byte offset within @page of the first block to encrypt. Must be +* a multiple of the filesystem's block size. +* @gfp_flags: Memory allocation flags +* +* A new bounce page is allocated, and the specified block(s) are encrypted into +* it. In the bounce page, the ciphertext block(s) will be located at the same +* offsets at which the plaintext block(s) were located in the source page; any +* other parts of the bounce page will be left uninitialized. However, normally +* blocksize == PAGE_SIZE and the whole page is encrypted at once. * -* Encrypts @page. A bounce page is allocated, the data is encrypted into the -* bounce page, and the bounce page is returned. The caller is responsible for -* calling fscrypt_free_bounce_page(). +* This is for use by the filesystem's ->writepages() method. * -* Return: A page containing the encrypted data on success, else an ERR_PTR() +* Return: the new encrypted bounce page on success; an ERR_PTR() on failure */ -struct page *fscrypt_encrypt_page (const struct inode *inode, -struct page *page, -unsigned int len, -unsigned int offs, -u64 lblk_num,gfp_t gfp_flags) +struct page *fscrypt_encrypt_pagecache_blocks (struct page *page, +unsigned int len, +unsigned int offs, +gfp_t gfp_flags) { +const struct inode *inode = page->mapping->host; +const unsigned int blockbits = inode->i_blkbits; +const unsigned int blocksize =1 << blockbits;struct page *ciphertext_page; +u64 lblk_num = ((u64 )page->index << (PAGE_SHIFT - blockbits)) + + (offs >> blockbits); +unsigned int i;int err;if (WARN_ON_ONCE (!PageLocked (page)))return ERR_PTR (-EINVAL ); +if (WARN_ON_ONCE (len <=0 || !IS_ALIGNED (len | offs, blocksize))) +return ERR_PTR (-EINVAL ); + ciphertext_page =fscrypt_alloc_bounce_page (gfp_flags);if (!ciphertext_page)return ERR_PTR (-ENOMEM ); - err =fscrypt_crypt_block (inode,FS_ENCRYPT , lblk_num, page, - ciphertext_page, len, offs, gfp_flags); -if (err) { -fscrypt_free_bounce_page (ciphertext_page); -return ERR_PTR (err); +for (i = offs; i < offs + len; i += blocksize, lblk_num++) { + err =fscrypt_crypt_block (inode,FS_ENCRYPT , lblk_num, + page, ciphertext_page, + blocksize, i, gfp_flags); +if (err) { +fscrypt_free_bounce_page (ciphertext_page); +return ERR_PTR (err); + } }SetPagePrivate (ciphertext_page);set_page_private (ciphertext_page, (unsigned long )page);return ciphertext_page; } -EXPORT_SYMBOL (fscrypt_encrypt_page); +EXPORT_SYMBOL (fscrypt_encrypt_pagecache_blocks);/** * fscrypt_encrypt_block_inplace() - Encrypt a filesystem block in-place
fs/ext4/page-io.c +2 -2
@@ -471,8 +471,8 @@ int ext4_bio_write_page(struct ext4_io_submit *io,gfp_t gfp_flags =GFP_NOFS ; retry_encrypt: - bounce_page =fscrypt_encrypt_page (inode, page,PAGE_SIZE ,0 , - page->index, gfp_flags); + bounce_page =fscrypt_encrypt_pagecache_blocks (page,PAGE_SIZE , +0 , gfp_flags);if (IS_ERR (bounce_page)) { ret =PTR_ERR (bounce_page);if (ret == -ENOMEM && wbc->sync_mode ==WB_SYNC_ALL ) {
fs/f2fs/data.c +3 -2
@@ -1726,8 +1726,9 @@ static int encrypt_one_page(struct f2fs_io_info *fio)f2fs_wait_on_block_writeback (inode, fio->old_blkaddr); retry_encrypt: - fio->encrypted_page =fscrypt_encrypt_page (inode, fio->page, -PAGE_SIZE ,0 , fio->page->index, gfp_flags); + fio->encrypted_page =fscrypt_encrypt_pagecache_blocks (fio->page, +PAGE_SIZE ,0 , + gfp_flags);if (IS_ERR (fio->encrypted_page)) {/* flush pending IOs and wait for a while in the ENOMEM case */ if (PTR_ERR (fio->encrypted_page) == -ENOMEM ) {
include/linux/fscrypt.h +9 -8
@@ -103,9 +103,11 @@ static inline void fscrypt_handle_d_move(struct dentry *dentry)extern void fscrypt_enqueue_decrypt_work (struct work_struct *);extern struct fscrypt_ctx *fscrypt_get_ctx (gfp_t );extern void fscrypt_release_ctx (struct fscrypt_ctx *); -extern struct page *fscrypt_encrypt_page (const struct inode *,struct page *, -unsigned int ,unsigned int , -u64 ,gfp_t ); + +extern struct page *fscrypt_encrypt_pagecache_blocks (struct page *page, +unsigned int len, +unsigned int offs, +gfp_t gfp_flags); extern int fscrypt_encrypt_block_inplace(const struct inode *inode, struct page *page, unsigned int len, unsigned int offs, u64 lblk_num,
@@ -288,11 +290,10 @@ static inline void fscrypt_release_ctx(struct fscrypt_ctx *ctx)return ; } -static inline struct page *fscrypt_encrypt_page (const struct inode *inode, -struct page *page, -unsigned int len, -unsigned int offs, -u64 lblk_num,gfp_t gfp_flags) +static inline struct page *fscrypt_encrypt_pagecache_blocks (struct page *page, +unsigned int len, +unsigned int offs, +gfp_t gfp_flags) {return ERR_PTR (-EOPNOTSUPP ); }
Signature · 8 lines
2.21.0.1020.gf2820cf01a-goog _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Eric Biggers
maintainerPATCH v2 7/14 fscrypt: handle blocksize < PAGE_SIZE in fscrypt_zeroout_range()
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
Adjust fscrypt_zeroout_range() to encrypt a block at a time rather than a page at a time, so that it works when blocksize < PAGE_SIZE.
This isn't optimized for performance, but then again this function already wasn't optimized for performance. As a future optimization, we could submit much larger bios here.
This is in preparation for allowing encryption on ext4 filesystems with blocksize != PAGE_SIZE.
This is based on work by Chandan Rajendra.
--- fs/crypto/bio.c | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-)
fs/crypto/bio.c +6 -9
@@ -72,12 +72,12 @@ EXPORT_SYMBOL(fscrypt_enqueue_decrypt_bio);int fscrypt_zeroout_range (const struct inode *inode,pgoff_t lblk,sector_t pblk,unsigned int len) { +const unsigned int blockbits = inode->i_blkbits; +const unsigned int blocksize =1 << blockbits;struct page *ciphertext_page;struct bio *bio;int ret, err =0 ; -BUG_ON (inode->i_sb->s_blocksize !=PAGE_SIZE ); - ciphertext_page =fscrypt_alloc_bounce_page (GFP_NOWAIT );if (!ciphertext_page)return -ENOMEM ;
@@ -85,7 +85,7 @@ int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk,while (len--) { err =fscrypt_crypt_block (inode,FS_ENCRYPT , lblk,ZERO_PAGE (0 ), ciphertext_page, -PAGE_SIZE ,0 ,GFP_NOFS ); + blocksize,0 ,GFP_NOFS );if (err) goto errout;
@@ -95,14 +95,11 @@ int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk, goto errout; }bio_set_dev (bio, inode->i_sb->s_bdev); - bio->bi_iter.bi_sector = - pblk << (inode->i_sb->s_blocksize_bits -9 ); + bio->bi_iter.bi_sector = pblk << (blockbits -9 );bio_set_op_attrs (bio,REQ_OP_WRITE ,0 ); - ret =bio_add_page (bio, ciphertext_page, - inode->i_sb->s_blocksize,0 ); -if (ret != inode->i_sb->s_blocksize) { + ret =bio_add_page (bio, ciphertext_page, blocksize,0 ); +if (WARN_ON (ret != blocksize)) {/* should never happen! */ -WARN_ON (1 );bio_put (bio); err = -EIO ; goto errout;
Signature · 8 lines
2.21.0.1020.gf2820cf01a-goog _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Eric Biggers
maintainerPATCH v2 8/14 fscrypt: introduce fscrypt_decrypt_block_inplace()
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
Currently fscrypt_decrypt_page() does one of two logically distinct things depending on whether FS_CFLG_OWN_PAGES is set in the filesystem'sfscrypt_operations: decrypt a pagecache page in-place, or decrypt a filesystem block in-place in any page. Currently these happen to share the same implementation, but this conflates the notion of blocks and pages. It also makes it so that all callers have to provide inode and lblk_num, when fscrypt could determine these itself for pagecache pages.
Therefore, move the FS_CFLG_OWN_PAGES behavior into a new function fscrypt_decrypt_block_inplace(). This mirrors fscrypt_encrypt_block_inplace().
This is in preparation for allowing encryption on ext4 filesystems with blocksize != PAGE_SIZE.
--- fs/crypto/crypto.c | 31 +++++++++++++++++++++++++++---- fs/ubifs/crypto.c | 7 ++++--- include/linux/fscrypt.h | 11 +++++++++++ 3 files changed, 42 insertions(+), 7 deletions(-)
fs/crypto/crypto.c +27 -4
@@ -284,8 +284,7 @@ EXPORT_SYMBOL(fscrypt_encrypt_block_inplace);/** * fscrypt_decrypt_page() - Decrypts a page in-place * @inode: The corresponding inode for the page to decrypt. -* @page: The page to decrypt. Must be locked in case -* it is a writeback page (FS_CFLG_OWN_PAGES unset). +* @page: The page to decrypt. Must be locked. * @len: Number of bytes in @page to be decrypted. * @offs: Start of data in @page. * @lblk_num: Logical block number.
@@ -299,8 +298,7 @@ EXPORT_SYMBOL(fscrypt_encrypt_block_inplace);int fscrypt_decrypt_page (const struct inode *inode,struct page *page,unsigned int len,unsigned int offs,u64 lblk_num) { -if (WARN_ON_ONCE (!PageLocked (page) && - !(inode->i_sb->s_cop->flags &FS_CFLG_OWN_PAGES ))) +if (WARN_ON_ONCE (!PageLocked (page)))return -EINVAL ; return fscrypt_crypt_block(inode, FS_DECRYPT, lblk_num, page, page,
@@ -308,6 +306,31 @@ int fscrypt_decrypt_page(const struct inode *inode, struct page *page, }EXPORT_SYMBOL (fscrypt_decrypt_page); +/** +* fscrypt_decrypt_block_inplace() - Decrypt a filesystem block in-place +* @inode: The inode to which this block belongs +* @page: The page containing the block to decrypt +* @len: Size of block to decrypt. Doesn't need to be a multiple of the +* fs block size, but must be a multiple of FS_CRYPTO_BLOCK_SIZE. +* @offs: Byte offset within @page at which the block to decrypt begins +* @lblk_num: Filesystem logical block number of the block, i.e. the 0-based +* number of the block within the file +* +* Decrypt a possibly-compressed filesystem block that is located in an +* arbitrary page, not necessarily in the original pagecache page. The @inode +* and @lblk_num must be specified, as they can't be determined from @page. +* +* Return: 0 on success; -errno on failure +*/ +int fscrypt_decrypt_block_inplace (const struct inode *inode,struct page *page, +unsigned int len,unsigned int offs, +u64 lblk_num) +{ +return fscrypt_crypt_block (inode,FS_DECRYPT , lblk_num, page, page, + len, offs,GFP_NOFS ); +} +EXPORT_SYMBOL (fscrypt_decrypt_block_inplace); +/* * Validate dentries in encrypted directories to make sure we aren't potentially * caching stale dentries after a key has been added.
fs/ubifs/crypto.c +4 -3
@@ -64,10 +64,11 @@ int ubifs_decrypt(const struct inode *inode, struct ubifs_data_node *dn, }ubifs_assert (c, dlen <=UBIFS_BLOCK_SIZE ); - err =fscrypt_decrypt_page (inode,virt_to_page (&dn->data), dlen, -offset_in_page (&dn->data), block); + err =fscrypt_decrypt_block_inplace (inode,virt_to_page (&dn->data), + dlen,offset_in_page (&dn->data), + block);if (err) { -ubifs_err (c,"fscrypt_decrypt_page failed: %i" , err); +ubifs_err (c,"fscrypt_decrypt_block_inplace() failed: %d" , err);return err; } *out_len = clen;
include/linux/fscrypt.h +11 -0
@@ -114,6 +114,9 @@ extern int fscrypt_encrypt_block_inplace(const struct inode *inode, gfp_t gfp_flags);extern int fscrypt_decrypt_page (const struct inode *,struct page *,unsigned int ,unsigned int ,u64 ); +extern int fscrypt_decrypt_block_inplace (const struct inode *inode, +struct page *page,unsigned int len, +unsigned int offs,u64 lblk_num);static inline bool fscrypt_is_bounce_page (struct page *page) {
@@ -315,6 +318,14 @@ static inline int fscrypt_decrypt_page(const struct inode *inode,return -EOPNOTSUPP ; } +static inline int fscrypt_decrypt_block_inplace (const struct inode *inode, +struct page *page, +unsigned int len, +unsigned int offs,u64 lblk_num) +{ +return -EOPNOTSUPP ; +} +static inline bool fscrypt_is_bounce_page (struct page *page) {return false;
Signature · 8 lines
2.21.0.1020.gf2820cf01a-goog _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Eric Biggers
maintainerPATCH v2 9/14 fscrypt: support decrypting multiple filesystem blocks per page
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
Rename fscrypt_decrypt_page() to fscrypt_decrypt_pagecache_blocks() and redefine its behavior to decrypt all filesystem blocks in the given region of the given page, rather than assuming that the region consists of just one filesystem block. Also remove the 'inode' and 'lblk_num' parameters, since they can be retrieved from the page as it's already assumed to be a pagecache page.
This is in preparation for allowing encryption on ext4 filesystems with blocksize != PAGE_SIZE.
This is based on work by Chandan Rajendra.
--- fs/crypto/bio.c | 3 +-- fs/crypto/crypto.c | 46 ++++++++++++++++++++++++++++------------- fs/ext4/inode.c | 7 +++---- include/linux/fscrypt.h | 12 +++++------ 4 files changed, 42 insertions(+), 26 deletions(-)
fs/crypto/bio.c +1 -2
@@ -33,8 +33,7 @@ static void __fscrypt_decrypt_bio(struct bio *bio, bool done)bio_for_each_segment_all (bv, bio, iter_all) {struct page *page = bv->bv_page; -int ret =fscrypt_decrypt_page (page->mapping->host, page, -PAGE_SIZE ,0 , page->index); +int ret =fscrypt_decrypt_pagecache_blocks (page,PAGE_SIZE ,0 );if (ret)SetPageError (page);
fs/crypto/crypto.c +32 -14
61 lines not on this page · raw message
fs/ext4/inode.c +3 -4
@@ -1232,8 +1232,7 @@ static int ext4_block_write_begin(struct page *page, loff_t pos, unsigned len,if (unlikely (err))page_zero_new_buffers (page, from, to);else if (decrypt) - err =fscrypt_decrypt_page (page->mapping->host, page, -PAGE_SIZE ,0 , page->index); + err =fscrypt_decrypt_pagecache_blocks (page,PAGE_SIZE ,0 ); return err; }#endif
@@ -4066,8 +4065,8 @@ static int __ext4_block_zero_page_range(handle_t *handle,/* We expect the key to be set. */ BUG_ON (!fscrypt_has_encryption_key (inode));BUG_ON (blocksize !=PAGE_SIZE ); -WARN_ON_ONCE (fscrypt_decrypt_page (page->mapping->host, - page,PAGE_SIZE ,0 , page->index)); +WARN_ON_ONCE (fscrypt_decrypt_pagecache_blocks ( + page,PAGE_SIZE ,0 )); } }if (ext4_should_journal_data (inode)) {
include/linux/fscrypt.h +6 -6
@@ -112,8 +112,9 @@ extern int fscrypt_encrypt_block_inplace(const struct inode *inode, struct page *page, unsigned int len, unsigned int offs, u64 lblk_num, gfp_t gfp_flags); -extern int fscrypt_decrypt_page (const struct inode *,struct page *,unsigned int , -unsigned int ,u64 ); + +extern int fscrypt_decrypt_pagecache_blocks (struct page *page,unsigned int len, +unsigned int offs);extern int fscrypt_decrypt_block_inplace (const struct inode *inode,struct page *page,unsigned int len,unsigned int offs,u64 lblk_num);
@@ -310,10 +311,9 @@ static inline int fscrypt_encrypt_block_inplace(const struct inode *inode,return -EOPNOTSUPP ; } -static inline int fscrypt_decrypt_page (const struct inode *inode, -struct page *page, -unsigned int len,unsigned int offs, -u64 lblk_num) +static inline int fscrypt_decrypt_pagecache_blocks (struct page *page, +unsigned int len, +unsigned int offs) {return -EOPNOTSUPP ; }
Signature · 8 lines
2.21.0.1020.gf2820cf01a-goog _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Eric Biggers
maintainerPATCH v2 10/14 fscrypt: decrypt only the needed blocks in __fscrypt_decrypt_bio()
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
In __fscrypt_decrypt_bio(), only decrypt the blocks that actually comprise the bio, rather than assuming blocksize == PAGE_SIZE and decrypting the entirety of every page used in the bio.
This is in preparation for allowing encryption on ext4 filesystems with blocksize != PAGE_SIZE.
This is based on work by Chandan Rajendra.
--- fs/crypto/bio.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
fs/crypto/bio.c +2 -2
@@ -33,8 +33,8 @@ static void __fscrypt_decrypt_bio(struct bio *bio, bool done)bio_for_each_segment_all (bv, bio, iter_all) {struct page *page = bv->bv_page; -int ret =fscrypt_decrypt_pagecache_blocks (page,PAGE_SIZE ,0 ); - +int ret =fscrypt_decrypt_pagecache_blocks (page, bv->bv_len, + bv->bv_offset);if (ret)SetPageError (page);else if (done)
Signature · 8 lines
2.21.0.1020.gf2820cf01a-goog _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Eric Biggers
maintainerPATCH v2 11/14 ext4: clear BH_Uptodate flag on decryption error
In reply to Eric BiggersFrom: Chandan Rajendra <[email protected]>
If decryption fails, ext4_block_write_begin() can return with the page's buffer_head marked with the BH_Uptodate flag. This commit clears the BH_Uptodate flag in such cases.
--- fs/ext4/inode.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
fs/ext4/inode.c +6 -2
@@ -1229,10 +1229,14 @@ static int ext4_block_write_begin(struct page *page, loff_t pos, unsigned len,if (!buffer_uptodate (*wait_bh)) err = -EIO; } -if (unlikely (err)) +if (unlikely (err)) {page_zero_new_buffers (page, from, to); -else if (decrypt) + }else if (decrypt) { err =fscrypt_decrypt_pagecache_blocks (page,PAGE_SIZE ,0 ); +if (err) +clear_buffer_uptodate (*wait_bh); + } +return err; }#endif
Signature · 8 lines
2.21.0.1020.gf2820cf01a-goog _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Eric Biggers
maintainerPATCH v2 12/14 ext4: decrypt only the needed blocks in ext4_block_write_begin()
In reply to Eric BiggersFrom: Chandan Rajendra <[email protected]>
In ext4_block_write_begin(), only decrypt the blocks that actually need to be decrypted (up to two blocks which intersect the boundaries of the region that will be written to), rather than assuming blocksize == PAGE_SIZE and decrypting the whole page.
This is in preparation for allowing encryption on ext4 filesystems with blocksize != PAGE_SIZE.
(EB: rebase onto previous changes, improve the commit message,
and move the check for encrypted inode)
--- fs/ext4/inode.c | 29 ++++++++++++++++++----------- 1 file changed, 18 insertions(+), 11 deletions(-)
fs/ext4/inode.c +18 -11
@@ -1164,8 +1164,9 @@ static int ext4_block_write_begin(struct page *page, loff_t pos, unsigned len,int err =0 ;unsigned blocksize = inode->i_sb->s_blocksize;unsigned bbits; -struct buffer_head *bh, *head, *wait[2 ], **wait_bh = wait; -bool decrypt = false; +struct buffer_head *bh, *head, *wait[2 ]; +int nr_wait =0 ; +int i;BUG_ON (!PageLocked (page));BUG_ON (from >PAGE_SIZE );
@@ -1217,24 +1218,30 @@ static int ext4_block_write_begin(struct page *page, loff_t pos, unsigned len, !buffer_unwritten(bh) && (block_start < from || block_end > to)) {ll_rw_block (REQ_OP_READ ,0 ,1 , &bh); - *wait_bh++ = bh; - decrypt =IS_ENCRYPTED (inode) &&S_ISREG (inode->i_mode); + wait[nr_wait++] = bh; } }/* * If we issued read requests, let them complete. */ -while (wait_bh > wait) { -wait_on_buffer (*--wait_bh); -if (!buffer_uptodate (*wait_bh)) +for (i =0 ; i < nr_wait; i++) { +wait_on_buffer (wait[i]); +if (!buffer_uptodate (wait[i])) err = -EIO ; }if (unlikely (err)) {page_zero_new_buffers (page, from, to); - }else if (decrypt) { - err =fscrypt_decrypt_pagecache_blocks (page,PAGE_SIZE ,0 ); -if (err) -clear_buffer_uptodate (*wait_bh); + }else if (IS_ENCRYPTED (inode) &&S_ISREG (inode->i_mode)) { +for (i =0 ; i < nr_wait; i++) { +int err2; + + err2 =fscrypt_decrypt_pagecache_blocks (page, blocksize, +bh_offset (wait[i])); +if (err2) { +clear_buffer_uptodate (wait[i]); + err = err2; + } + } }return err;
Signature · 8 lines
2.21.0.1020.gf2820cf01a-goog _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Eric Biggers
maintainerPATCH v2 13/14 ext4: decrypt only the needed block in __ext4_block_zero_page_range()
In reply to Eric BiggersFrom: Chandan Rajendra <[email protected]>
In __ext4_block_zero_page_range(), only decrypt the block that actually needs to be decrypted, rather than assuming blocksize == PAGE_SIZE and decrypting the whole page.
This is in preparation for allowing encryption on ext4 filesystems with blocksize != PAGE_SIZE.
(EB: rebase onto previous changes, improve the commit message, and use
bh_offset())
--- fs/ext4/inode.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
fs/ext4/inode.c +1 -2
@@ -4075,9 +4075,8 @@ static int __ext4_block_zero_page_range(handle_t *handle,if (S_ISREG (inode->i_mode) &&IS_ENCRYPTED (inode)) {/* We expect the key to be set. */ BUG_ON (!fscrypt_has_encryption_key (inode)); -BUG_ON (blocksize !=PAGE_SIZE );WARN_ON_ONCE (fscrypt_decrypt_pagecache_blocks ( - page,PAGE_SIZE ,0 )); + page, blocksize,bh_offset (bh))); } }if (ext4_should_journal_data (inode)) {
Signature · 8 lines
2.21.0.1020.gf2820cf01a-goog _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Eric Biggers
maintainerPATCH v2 14/14 ext4: encrypt only up to last block in ext4_bio_write_page()
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
As an optimization, don't encrypt blocks fully beyond i_size, since those definitely won't need to be written out. Also add a comment.
This is in preparation for allowing encryption on ext4 filesystems with blocksize != PAGE_SIZE.
This is based on work by Chandan Rajendra.
--- fs/ext4/page-io.c | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-)
fs/ext4/page-io.c +9 -1
@@ -467,11 +467,19 @@ int ext4_bio_write_page(struct ext4_io_submit *io, bh = head =page_buffers (page); +/* +* If any blocks are being written to an encrypted file, encrypt them +* into a bounce page. For simplicity, just encrypt until the last +* block which might be needed. This may cause some unneeded blocks +* (e.g. holes) to be unnecessarily encrypted, but this is rare and +* can't happen in the common case of blocksize == PAGE_SIZE. +*/ if (IS_ENCRYPTED (inode) &&S_ISREG (inode->i_mode) && nr_to_submit) {gfp_t gfp_flags =GFP_NOFS ; +unsigned int enc_bytes =round_up (len,i_blocksize (inode)); retry_encrypt: - bounce_page =fscrypt_encrypt_pagecache_blocks (page,PAGE_SIZE , + bounce_page =fscrypt_encrypt_pagecache_blocks (page, enc_bytes,0 , gfp_flags);if (IS_ERR (bounce_page)) { ret =PTR_ERR (bounce_page);
Signature · 8 lines
2.21.0.1020.gf2820cf01a-goog _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Quoted 55 lines · Eric Biggers
Hello,
This patchset prepares
fs/crypto/, and partially ext4, for the 'blocksize !=PAGE_SIZE' case.This basically contains the encryption changes from Chandan Rajendra's patchset "[V2,00/13] Consolidate FS read I/O callbacks code"
(https://patchwork.kernel.org/project/linux-fscrypt/list/?series=111039)
that don't require introducing theread_callbacksand don't depend on fsverity stuff. But they've been reworked to clean things up a lot.I'd like to apply this patchset for 5.3 in order to make things forward for ext4 encryption with 'blocksize !=
PAGE_SIZE'.AFAICT, after this patchset the only thing stopping ext4 encryption from working with blocksize !=
PAGE_SIZEis the lack of encryption support inblock_read_full_page(), which theread_callbackswill address.This patchset applies to v5.2-rc1, and it can also be retrieved from git at https://git.kernel.org/pub/scm/linux/kernel/git/ebiggers/linux.git
branch "fscrypt-subpage-blocks-prep".Changed since v1 (minor cleanups only):
- In "fscrypt: simplify bounce page handling", also remove the definition of
FS_CTX_HAS_BOUNCE_BUFFER_FL.- In "ext4: decrypt only the needed blocks in
ext4_block_write_begin()", simplify the code slightly by moving theIS_ENCRYPTED()check.- Change
__fscrypt_decrypt_bio()in a separate patch rather than as part of "fscrypt: support decrypting multiple filesystem blocks per page". The resulting code is the same, so I kept Chandan's Reviewed-by.- Improve the commit message of
"fscrypt: introducefscrypt_decrypt_block_inplace()".Chandan Rajendra (3):
ext4: clearBH_Uptodateflag on decryption error
ext4: decrypt only the needed blocks inext4_block_write_begin()
ext4: decrypt only the needed block in__ext4_block_zero_page_range()Eric Biggers (11):
fscrypt: simplify bounce page handling
fscrypt: remove the "write" part of structfscrypt_ctx
fscrypt: renamefscrypt_do_page_crypto()tofscrypt_crypt_block()
fscrypt: clean up some BUG_ON()s in block encryption/decryption
fscrypt: introducefscrypt_encrypt_block_inplace()
fscrypt: support encrypting multiple filesystem blocks per page
fscrypt: handle blocksize <PAGE_SIZEinfscrypt_zeroout_range()
fscrypt: introducefscrypt_decrypt_block_inplace()
fscrypt: support decrypting multiple filesystem blocks per page
fscrypt: decrypt only the needed blocks in__fscrypt_decrypt_bio()
ext4: encrypt only up to last block inext4_bio_write_page()
Quoted 10 lines
fs/crypto/bio.c | 73 +++------ fs/crypto/crypto.c | 299 ++++++++++++++++++++---------------- fs/crypto/fscrypt_private.h | 15 +- fs/ext4/inode.c | 37 +++-- fs/ext4/page-io.c | 44 +++--- fs/f2fs/data.c | 17 +- fs/ubifs/crypto.c | 19 +-- include/linux/fscrypt.h | 96 ++++++++---- 8 files changed, 319 insertions(+), 281 deletions(-)
I've applied this series to fscrypt.git for 5.3.
- Eric
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel