Consolidate Post read processing code
Subsystems (6)
v2 cover Consolidate Post read processing code
This patchset moves the "post read processing" code into a file of its own (i.e. fs/post_read_process.c) and modifies the generic do_mpage_readpge() to make use of the functionality provided.
"Post read processing" implements code to track the state machine that needs to be executed after reading data from files that are encrypted and/or have verity metadata associated with them.
With these changes in place, the patchset changes Ext4 to use mpage_readpage[s] instead of its own custom ext4_readpage[s]() functions. This is done to reduce duplicity of code across filesystems. Also, Post read processing source files will be built only if one of CONFIG_FS_ENCRYPTION and CONFIG_FS_VERITY is enabled.
Members of "struct fscrypt_ctx" that tracked status of a "write" operation are now made an anonymous structure since the decryption state tracking members are now moved into "struct post_read_ctx".
The patchset also modifies fs/buffer.c and fscrypt functionality to get file encryption/decryption to work with subpage-sized blocks.
The following fixes from Eric Biggers are prerequisites for this patchset,
fscrypt: fix race where ->lookup() marks plaintext dentry as ciphertext
fscrypt: only set dentry_operations on ciphertext dentries
fscrypt: clear DCACHE_ENCRYPTED_NAME when unaliasing directory
fscrypt: fix race allowing rename() and link() of ciphertext dentries
fscrypt: clean up and improve dentry revalidation
The patches can also be obtained from, "https://github.com/chandanr/linux.git subpage-encryption"
TODO:
1. The subset of the fscrypt_encrypt_page() that deals with FS_CFLG_OWN_PAGES case still needs to be tested. UBIFS seems to be the only user of this piece of code.
2. Verity changes needs to be added for F2FS and I will add them in the next patchset based on the review comments obtained for the current patchset.
Changelog:
RFC V1 -> RFC V2:
1. Describe the purpose of "Post processing code" in the cover letter.
2. Fix build errors when CONFIG_FS_VERITY is enabled.
Chandan Rajendra (14):
ext4: Clear BH_Uptodate flag on decryption error Consolidate "post read processing" into a new file
fsverity: Add call back to decide if verity check has to be performed
fsverity: Add call back to determine readpage limit fs/mpage.c: Integrate post read processing
ext4: Wire up ext4_readpage[s] to use mpage_readpage[s] Remove the term "bio" from post read processing
Add decryption support for sub-pagesized blocks
ext4: Decrypt all boundary blocks when doing buffered write
ext4: Decrypt the block that needs to be partially zeroed
fscrypt_encrypt_page: Loop across all blocks mapped by a page range
ext4: Compute logical block and the page range to be encrypted
fscrypt_zeroout_range: Encrypt all zeroed out blocks of a page
ext4: Enable encryption for subpage-sized blocks
Documentation/filesystems/fscrypt.rst | 4 +- fs/Makefile | 4 + fs/buffer.c | 85 +++-- fs/crypto/bio.c | 109 ++++--- fs/crypto/crypto.c | 73 +++-- fs/crypto/fscrypt_private.h | 3 + fs/ext4/Makefile | 2 +- fs/ext4/ext4.h | 2 - fs/ext4/inode.c | 47 ++- fs/ext4/page-io.c | 9 +- fs/ext4/readpage.c | 445 -------------------------- fs/ext4/super.c | 40 ++- fs/f2fs/data.c | 148 ++------- fs/f2fs/super.c | 9 +- fs/mpage.c | 51 ++- fs/post_read_process.c | 155 +++++++++ fs/verity/verify.c | 12 + include/linux/buffer_head.h | 1 + include/linux/fscrypt.h | 20 +- include/linux/fsverity.h | 2 + include/linux/post_read_process.h | 22 ++ 21 files changed, 511 insertions(+), 732 deletions(-) delete mode 100644 fs/ext4/readpage.c create mode 100644 fs/post_read_process.c create mode 100644 include/linux/post_read_process.h
Signature · 1 line
2.19.1
RFC PATCH v2 1/14 ext4: Clear BH_Uptodate flag on decryption error
On an error return from fscrypt_decrypt_page(), ext4_block_write_begin() can return with the page's buffer_head marked with 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
@@ -1225,11 +1225,15 @@ 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_page (page->mapping->host, page,PAGE_SIZE ,0 , page->index); +if (err) +clear_buffer_uptodate (*wait_bh); + } +return err; }#endif
Signature · 1 line
2.19.1
RFC PATCH v2 2/14 Consolidate "post read processing" into a new file
In reply to Chandan RajendraThe post read processing code is used by both Ext4 and F2FS. Hence to remove duplicity, this commit moves the code into include/linux/post_read_process.h and fs/post_read_process.c.
The corresponding decrypt and verity "work" functions have been moved inside fscrypt and fsverity sources. With these in place, the post processing code now has to just invoke enqueue functions provided by fscrypt and fsverity.
--- fs/Makefile | 4 + fs/crypto/bio.c | 23 ++--- fs/crypto/crypto.c | 17 ++-- fs/crypto/fscrypt_private.h | 3 + fs/ext4/ext4.h | 2 - fs/ext4/readpage.c | 154 +----------------------------- fs/ext4/super.c | 9 +- fs/f2fs/data.c | 146 ++++------------------------ fs/f2fs/super.c | 9 +- fs/post_read_process.c | 136 ++++++++++++++++++++++++++ fs/verity/verify.c | 12 +++ include/linux/fscrypt.h | 20 +--- include/linux/post_read_process.h | 21 ++++ 13 files changed, 220 insertions(+), 336 deletions(-) create mode 100644 fs/post_read_process.c create mode 100644 include/linux/post_read_process.h
fs/Makefile +4 -0
@@ -21,6 +21,10 @@ else obj-y += no-block.o endif +ifeq (y, $(firstword $(filter y,$(CONFIG_FS_ENCRYPTION) $(CONFIG_FS_VERITY)))) +obj-y += post_read_process.o +endif + obj-$(CONFIG_PROC_FS) += proc_namespace.o obj-y += notify/
fs/crypto/bio.c +8 -15
@@ -24,6 +24,8 @@#include <linux/module.h> #include <linux/bio.h> #include <linux/namei.h> +#include <linux/post_read_process.h> +#include "fscrypt_private.h" static void __fscrypt_decrypt_bio (struct bio *bio,bool done)
@@ -54,24 +56,15 @@ void fscrypt_decrypt_bio(struct bio *bio) }EXPORT_SYMBOL (fscrypt_decrypt_bio); -static void completion_pages (struct work_struct *work) +void fscrypt_decrypt_work (struct work_struct *work) { -struct fscrypt_ctx *ctx = - container_of(work, struct fscrypt_ctx, r.work); -struct bio *bio = ctx->r.bio; +struct bio_post_read_ctx *ctx = + container_of(work, struct bio_post_read_ctx, work); -__fscrypt_decrypt_bio (bio, true); -fscrypt_release_ctx (ctx); -bio_put (bio); -} +fscrypt_decrypt_bio (ctx->bio); -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); +bio_post_read_processing (ctx); } -EXPORT_SYMBOL (fscrypt_enqueue_decrypt_bio);void fscrypt_pullback_bio_page (struct page **page,bool restore) {
@@ -87,7 +80,7 @@ void fscrypt_pullback_bio_page(struct page **page, bool restore) ctx = (struct fscrypt_ctx *)page_private (bounce_page);/* restore control page */ - *page = ctx->w.control_page; + *page = ctx->control_page;if (restore)fscrypt_restore_control_page (bounce_page);
fs/crypto/crypto.c +9 -8
@@ -53,6 +53,7 @@ struct kmem_cache *fscrypt_info_cachep;void fscrypt_enqueue_decrypt_work (struct work_struct *work) { +INIT_WORK (work, fscrypt_decrypt_work);queue_work (fscrypt_read_workqueue, work); }EXPORT_SYMBOL (fscrypt_enqueue_decrypt_work);
@@ -70,11 +71,11 @@ void fscrypt_release_ctx(struct fscrypt_ctx *ctx) {unsigned long flags; -if (ctx->flags &FS_CTX_HAS_BOUNCE_BUFFER_FL && ctx->w.bounce_page) { -mempool_free (ctx->w.bounce_page, fscrypt_bounce_page_pool); - ctx->w.bounce_page =NULL ; +if (ctx->flags &FS_CTX_HAS_BOUNCE_BUFFER_FL && ctx->bounce_page) { +mempool_free (ctx->bounce_page, fscrypt_bounce_page_pool); + ctx->bounce_page =NULL ; } - ctx->w.control_page =NULL ; + ctx->control_page =NULL ;if (ctx->flags &FS_CTX_REQUIRES_FREE_ENCRYPT_FL ) {kmem_cache_free (fscrypt_ctx_cachep, ctx); }else {
@@ -194,11 +195,11 @@ int fscrypt_do_page_crypto(const struct inode *inode, fscrypt_direction_t rw,struct page *fscrypt_alloc_bounce_page (struct fscrypt_ctx *ctx,gfp_t gfp_flags) { - ctx->w.bounce_page =mempool_alloc (fscrypt_bounce_page_pool, gfp_flags); -if (ctx->w.bounce_page ==NULL ) + ctx->bounce_page =mempool_alloc (fscrypt_bounce_page_pool, gfp_flags); +if (ctx->bounce_page ==NULL )return ERR_PTR (-ENOMEM ); ctx->flags |=FS_CTX_HAS_BOUNCE_BUFFER_FL ; -return ctx->w.bounce_page; +return ctx->bounce_page; }/**
@@ -267,7 +268,7 @@ struct page *fscrypt_encrypt_page(const struct inode *inode,if (IS_ERR (ciphertext_page)) goto errout; - ctx->w.control_page = page; + ctx->control_page = page; err =fscrypt_do_page_crypto (inode,FS_ENCRYPT , lblk_num, page, ciphertext_page, len, offs, gfp_flags);
fs/crypto/fscrypt_private.h +3 -0
@@ -114,6 +114,9 @@ static inline bool fscrypt_valid_enc_modes(u32 contents_mode,return false; } +/* bio.c */ +void fscrypt_decrypt_work (struct work_struct *work); +/* crypto.c */ extern struct kmem_cache *fscrypt_info_cachep;extern int fscrypt_initialize (unsigned int cop_flags);
fs/ext4/ext4.h +0 -2
@@ -3127,8 +3127,6 @@ static inline void ext4_set_de_type(struct super_block *sb,extern int ext4_mpage_readpages (struct address_space *mapping,struct list_head *pages,struct page *page,unsigned nr_pages,bool is_readahead); -extern int __init ext4_init_post_read_processing (void ); -extern void ext4_exit_post_read_processing (void );/* symlink.c */ extern const struct inode_operations ext4_encrypted_symlink_inode_operations;
fs/ext4/readpage.c +2 -152
181 lines not on this page · raw message
fs/ext4/super.c +1 -8
@@ -6101,10 +6101,6 @@ static int __init ext4_init_fs(void)return err; err =ext4_init_pending (); -if (err) - goto out7; - - err =ext4_init_post_read_processing ();if (err) goto out6;
@@ -6146,10 +6142,8 @@ static int __init ext4_init_fs(void) out4:ext4_exit_pageio (); out5: -ext4_exit_post_read_processing (); -out6:ext4_exit_pending (); -out7: +out6:ext4_exit_es ();return err;
@@ -6166,7 +6160,6 @@ static void __exit ext4_exit_fs(void)ext4_exit_sysfs ();ext4_exit_system_zone ();ext4_exit_pageio (); -ext4_exit_post_read_processing ();ext4_exit_es ();ext4_exit_pending (); }
fs/f2fs/data.c +20 -126
198 lines not on this page · raw message
fs/f2fs/super.c +2 -7
@@ -3633,15 +3633,11 @@ static int __init init_f2fs_fs(void) err =register_filesystem (&f2fs_fs_type);if (err) goto free_shrinker; +f2fs_create_root_stats (); - err =f2fs_init_post_read_processing (); -if (err) - goto free_root_stats; +return 0 ; -free_root_stats: -f2fs_destroy_root_stats (); -unregister_filesystem (&f2fs_fs_type); free_shrinker:unregister_shrinker (&f2fs_shrinker_info); free_sysfs:
@@ -3662,7 +3658,6 @@ static int __init init_f2fs_fs(void) static void __exit exit_f2fs_fs(void) { -f2fs_destroy_post_read_processing ();f2fs_destroy_root_stats ();unregister_filesystem (&f2fs_fs_type);unregister_shrinker (&f2fs_shrinker_info);
fs/post_read_process.c new file +136 -0
136 lines not on this page · raw message
fs/verity/verify.c +12 -0
@@ -13,6 +13,7 @@#include <linux/pagemap.h> #include <linux/ratelimit.h> #include <linux/scatterlist.h> +#include <linux/post_read_process.h> struct workqueue_struct *fsverity_read_workqueue;
@@ -284,6 +285,16 @@ void fsverity_verify_bio(struct bio *bio)EXPORT_SYMBOL_GPL (fsverity_verify_bio);#endif /* CONFIG_BLOCK */ +static void fsverity_verify_work (struct work_struct *work) +{ +struct bio_post_read_ctx *ctx = + container_of(work, struct bio_post_read_ctx, work); + +fsverity_verify_bio (ctx->bio); + +bio_post_read_processing (ctx); +} +/** * fsverity_enqueue_verify_work - enqueue work on the fs-verity workqueue *
@@ -291,6 +302,7 @@ EXPORT_SYMBOL_GPL(fsverity_verify_bio);*/ void fsverity_enqueue_verify_work (struct work_struct *work) { +INIT_WORK (work, fsverity_verify_work);queue_work (fsverity_read_workqueue, work); }EXPORT_SYMBOL_GPL (fsverity_enqueue_verify_work);
include/linux/fscrypt.h +2 -18
@@ -68,11 +68,7 @@ struct fscrypt_ctx {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 */
@@ -113,7 +109,7 @@ extern int fscrypt_decrypt_page(const struct inode *, struct page *, unsigned instatic inline struct page *fscrypt_control_page (struct page *page) { -return ((struct fscrypt_ctx *)page_private (page))->w.control_page; +return ((struct fscrypt_ctx *)page_private (page))->control_page; }extern void fscrypt_restore_control_page (struct page *);
@@ -218,9 +214,6 @@ static inline bool fscrypt_match_name(const struct fscrypt_name *fname, }/* bio.c */ -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 );
@@ -390,15 +383,6 @@ static inline bool fscrypt_match_name(const struct fscrypt_name *fname,return !memcmp (de_name, fname->disk_name.name, fname->disk_name.len); } -/* bio.c */ -static inline void fscrypt_decrypt_bio (struct bio *bio) -{ -} - -static inline void fscrypt_enqueue_decrypt_bio (struct fscrypt_ctx *ctx, -struct bio *bio) -{ -}static inline void fscrypt_pullback_bio_page (struct page **page,bool restore) {
include/linux/post_read_process.h new file +21 -0
@@ -0,0 +1,21 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _POST_READ_PROCESS_H +#define _POST_READ_PROCESS_H + +struct bio_post_read_ctx { +struct bio *bio; +struct inode *inode; +struct work_struct work; +unsigned int cur_step; +unsigned int enabled_steps; +}; + +void end_bio_post_read_processing (struct bio *bio); +void bio_post_read_processing (struct bio_post_read_ctx *ctx); +struct bio_post_read_ctx *get_bio_post_read_ctx (struct inode *inode, +struct bio *bio, +pgoff_t index); +void put_bio_post_read_ctx (struct bio_post_read_ctx *ctx); +bool bio_post_read_required (struct bio *bio); + +#endif /* _POST_READ_PROCESS_H */
Signature · 1 line
2.19.1
RFC PATCH v2 3/14 fsverity: Add call back to decide if verity check has to be performed
In reply to Chandan RajendraExt4 and F2FS store verity metadata in data extents (beyond inode->i_size) associated with a file. But other filesystems might choose alternative means to store verity metadata. Hence this commit adds a callback function pointer to 'struct fsverity_operations' to help in deciding if verity operation needs to performed against a page-cache page holding file data.
--- fs/ext4/super.c | 6 ++++++ fs/post_read_process.c | 4 +++- include/linux/fsverity.h | 1 + 3 files changed, 10 insertions(+), 1 deletion(-)
fs/ext4/super.c +6 -0
@@ -1428,10 +1428,16 @@ static struct page *ext4_read_verity_metadata_page(struct inode *inode, return read_mapping_page(inode->i_mapping, index, NULL); } +static bool ext4_verity_required (struct inode *inode,pgoff_t index) +{ +return index < (i_size_read (inode) +PAGE_SIZE -1 ) >>PAGE_SHIFT ; +} +static const struct fsverity_operations ext4_verityops = { .set_verity = ext4_set_verity, .get_metadata_end = ext4_get_verity_metadata_end, .read_metadata_page = ext4_read_verity_metadata_page, + .verity_required = ext4_verity_required, };#endif /* CONFIG_FS_VERITY */
fs/post_read_process.c +3 -1
@@ -86,7 +86,9 @@ struct bio_post_read_ctx *get_bio_post_read_ctx(struct inode *inode, post_read_steps |=1 <<STEP_DECRYPT ;#ifdef CONFIG_FS_VERITY if (inode->i_verity_info !=NULL && - (index < ((i_size_read (inode) +PAGE_SIZE -1 ) >>PAGE_SHIFT ))) + ((inode->i_sb->s_vop->verity_required + && inode->i_sb->s_vop->verity_required (inode, index)) + || (inode->i_sb->s_vop->verity_required ==NULL ))) post_read_steps |=1 <<STEP_VERITY ;#endif if (post_read_steps) {
include/linux/fsverity.h +1 -0
@@ -18,6 +18,7 @@ struct fsverity_operations {int (*set_verity)(struct inode *inode,loff_t data_i_size);int (*get_metadata_end)(struct inode *inode,loff_t *metadata_end_ret);struct page *(*read_metadata_page)(struct inode *inode,pgoff_t index); +bool (*verity_required)(struct inode *inode,pgoff_t index); };#ifdef CONFIG_FS_VERITY
Signature · 1 line
2.19.1
RFC PATCH v2 4/14 fsverity: Add call back to determine readpage limit
In reply to Chandan RajendraExt4 and F2FS store verity metadata beyond i_size. This commit adds a call back pointer to "struct fsverity_operations" which helps in determining the the real file size limit upto which data can be read from the file.
This call back will be required in order to get do_mpage_readpage() to read files having verity metadata appended beyond i_size.
--- fs/ext4/super.c | 18 ++++++++++++++++++ include/linux/fsverity.h | 1 + 2 files changed, 19 insertions(+)
fs/ext4/super.c +18 -0
@@ -1428,6 +1428,23 @@ static struct page *ext4_read_verity_metadata_page(struct inode *inode,return read_mapping_page (inode->i_mapping, index,NULL ); } +static loff_t ext4_readpage_limit (struct inode *inode) +{ +#ifdef CONFIG_FS_VERITY +if (IS_VERITY (inode)) { +if (inode->i_verity_info) +/* limit to end of metadata region */ +return fsverity_full_i_size (inode); +/* +* fsverity_info is currently being set up and no user reads are +* allowed yet. It's easiest to just not enforce a limit yet. +*/ +return inode->i_sb->s_maxbytes; + } +#endif +return i_size_read (inode); +} +static bool ext4_verity_required (struct inode *inode,pgoff_t index) {return index < (i_size_read (inode) +PAGE_SIZE -1 ) >>PAGE_SHIFT ;
@@ -1438,6 +1455,7 @@ static const struct fsverity_operations ext4_verityops = { .get_metadata_end = ext4_get_verity_metadata_end, .read_metadata_page = ext4_read_verity_metadata_page, .verity_required = ext4_verity_required, + .readpage_limit = ext4_readpage_limit, };#endif /* CONFIG_FS_VERITY */
include/linux/fsverity.h +1 -0
@@ -19,6 +19,7 @@ struct fsverity_operations {int (*get_metadata_end)(struct inode *inode,loff_t *metadata_end_ret);struct page *(*read_metadata_page)(struct inode *inode,pgoff_t index);bool (*verity_required)(struct inode *inode,pgoff_t index); +loff_t (*readpage_limit)(struct inode *inode); };#ifdef CONFIG_FS_VERITY
Signature · 1 line
2.19.1
RFC PATCH v2 5/14 fs/mpage.c: Integrate post read processing
In reply to Chandan RajendraThis commit adds code to make do_mpage_readpage() to be "post read processing" aware i.e. for files requiring decryption/verification, do_mpage_readpage() now allocates a context structure and assigns the corresponding pointer to bio->bi_private. At endio time, a non-zero bio->bi_private indicates that after the read operation is performed, the bio's payload needs to be processed further before handing over the data to user space.
The context structure is used for tracking the state machine associated with post read processing.
--- fs/mpage.c | 51 ++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 48 insertions(+), 3 deletions(-)
fs/mpage.c +48 -3
@@ -30,6 +30,10 @@#include <linux/backing-dev.h> #include <linux/pagevec.h> #include <linux/cleancache.h> +#include <linux/fsverity.h> +#if defined(CONFIG_FS_ENCRYPTION ) || defined(CONFIG_FS_VERITY ) +#include <linux/post_read_process.h> +#endif #include "internal.h" /*
@@ -50,6 +54,20 @@ static void mpage_end_io(struct bio *bio)int i;struct bvec_iter_all iter_all; +#if defined(CONFIG_FS_ENCRYPTION ) || defined(CONFIG_FS_VERITY ) +if (!bio->bi_status && bio->bi_private) { +struct bio_post_read_ctx *ctx; + + ctx = bio->bi_private; + +bio_post_read_processing (ctx); +return ; + } + +if (bio->bi_private) +put_bio_post_read_ctx ((struct bio_post_read_ctx *)(bio->bi_private)); +#endif +bio_for_each_segment_all (bv, bio, i, iter_all) {struct page *page = bv->bv_page; page_endio(page, bio_op(bio),
@@ -189,7 +207,13 @@ static struct bio *do_mpage_readpage(struct mpage_readpage_args *args) block_in_file = (sector_t )page->index << (PAGE_SHIFT - blkbits); last_block = block_in_file + args->nr_pages * blocks_per_page; - last_block_in_file = (i_size_read (inode) + blocksize -1 ) >> blkbits; +#ifdef CONFIG_FS_VERITY +if (IS_VERITY (inode) && inode->i_sb->s_vop->readpage_limit) + last_block_in_file = inode->i_sb->s_vop->readpage_limit (inode); + else +#endif + last_block_in_file = (i_size_read (inode) + blocksize -1 ) + >> blkbits;if (last_block > last_block_in_file) last_block = last_block_in_file; page_block =0 ;
@@ -277,6 +301,14 @@ static struct bio *do_mpage_readpage(struct mpage_readpage_args *args)if (first_hole != blocks_per_page) {zero_user_segment (page, first_hole << blkbits,PAGE_SIZE );if (first_hole ==0 ) { +#ifdef CONFIG_FS_VERITY +if (IS_VERITY (inode)) { +if (!fsverity_check_hole (inode, page)) { +SetPageError (page); + goto confused; + } + } +#endif SetPageUptodate (page);unlock_page (page); goto out;
@@ -299,7 +331,11 @@ static struct bio *do_mpage_readpage(struct mpage_readpage_args *args) alloc_new:if (args->bio ==NULL ) { -if (first_hole == blocks_per_page) { +#if defined(CONFIG_FS_ENCRYPTION ) || defined(CONFIG_FS_VERITY ) +struct bio_post_read_ctx *ctx; +#endif +if (first_hole == blocks_per_page + && !(IS_ENCRYPTED (inode) ||IS_VERITY (inode))) {if (!bdev_read_page (bdev, blocks[0 ] << (blkbits -9 ), page)) goto out;
@@ -310,6 +346,15 @@ static struct bio *do_mpage_readpage(struct mpage_readpage_args *args) gfp);if (args->bio ==NULL ) goto confused; + +#if defined(CONFIG_FS_ENCRYPTION ) || defined(CONFIG_FS_VERITY ) + ctx =get_bio_post_read_ctx (inode, args->bio, page->index); +if (IS_ERR (ctx)) { +bio_put (args->bio); + args->bio =NULL ; + goto confused; + } +#endif } length = first_hole << blkbits;
@@ -331,7 +376,7 @@ static struct bio *do_mpage_readpage(struct mpage_readpage_args *args) confused:if (args->bio) args->bio =mpage_bio_submit (REQ_OP_READ , op_flags, args->bio); -if (!PageUptodate (page)) +if (!PageUptodate (page) && !PageError (page))block_read_full_page (page, args->get_block);else unlock_page (page);
Signature · 1 line
2.19.1
RFC PATCH v2 6/14 ext4: Wire up ext4_readpage[s] to use mpage_readpage[s]
In reply to Chandan RajendraNow that do_mpage_readpage() is "post read process" aware, this commit gets ext4_readpage[s] to use mpage_readpage[s] and deletes ext4's readpage.c since the associated functionality is not required anymore.
--- fs/ext4/Makefile | 2 +- fs/ext4/inode.c | 5 +- fs/ext4/readpage.c | 295 --------------------------------------------- 3 files changed, 3 insertions(+), 299 deletions(-) delete mode 100644 fs/ext4/readpage.c
fs/ext4/Makefile +1 -1
@@ -8,7 +8,7 @@ obj-$(CONFIG_EXT4_FS) += ext4.o ext4-y := balloc.o bitmap.o block_validity.o dir.o ext4_jbd2.o extents.o \ extents_status.o file.o fsmap.o fsync.o hash.o ialloc.o \ indirect.o inline.o inode.o ioctl.o mballoc.o migrate.o \ - mmp.o move_extent.o namei.o page-io.o readpage.o resize.o \ + mmp.o move_extent.o namei.o page-io.o resize.o \ super.o symlink.o sysfs.o xattr.o xattr_trusted.o xattr_user.o ext4-$(CONFIG_EXT4_FS_POSIX_ACL) += acl.o
fs/ext4/inode.c +2 -3
@@ -3353,8 +3353,7 @@ static int ext4_readpage(struct file *file, struct page *page) ret =ext4_readpage_inline (inode, page);if (ret == -EAGAIN ) -return ext4_mpage_readpages (page->mapping,NULL , page,1 , - false); +return mpage_readpage (page, ext4_get_block);return ret; }
@@ -3369,7 +3368,7 @@ ext4_readpages(struct file *file, struct address_space *mapping,if (ext4_has_inline_data (inode))return 0 ; -return ext4_mpage_readpages (mapping, pages,NULL , nr_pages, true); +return mpage_readpages (mapping, pages, nr_pages, ext4_get_block); } static void ext4_invalidatepage(struct page *page, unsigned int offset,
fs/ext4/readpage.c deleted +0 -295
295 lines not on this page · raw message
Signature · 1 line
2.19.1
RFC PATCH v2 7/14 Remove the term "bio" from post read processing
In reply to Chandan RajendraFor block size < page size, apart from handling bios, post read processing needs to handle buffer heads. Hence this commit removes the term "bio" from the identifiers associated with post read processing.
--- fs/crypto/bio.c | 6 ++-- fs/f2fs/data.c | 10 +++--- fs/mpage.c | 10 +++--- fs/post_read_process.c | 56 +++++++++++++++---------------- fs/verity/verify.c | 6 ++-- include/linux/post_read_process.h | 16 ++++----- 6 files changed, 52 insertions(+), 52 deletions(-)
fs/crypto/bio.c +3 -3
@@ -58,12 +58,12 @@ EXPORT_SYMBOL(fscrypt_decrypt_bio);void fscrypt_decrypt_work (struct work_struct *work) { -struct bio_post_read_ctx *ctx = - container_of(work, struct bio_post_read_ctx, work); +struct post_read_ctx *ctx = + container_of(work, struct post_read_ctx, work);fscrypt_decrypt_bio (ctx->bio); -bio_post_read_processing (ctx); +post_read_processing (ctx); }void fscrypt_pullback_bio_page (struct page **page,bool restore)
fs/f2fs/data.c +5 -5
@@ -89,10 +89,10 @@ static void __read_end_io(struct bio *bio)#if defined(CONFIG_FS_ENCRYPTION ) || defined(CONFIG_FS_VERITY )if (bio->bi_private) { -struct bio_post_read_ctx *ctx; +struct post_read_ctx *ctx; ctx = bio->bi_private; -put_bio_post_read_ctx (ctx); +put_post_read_ctx (ctx); }#endif bio_put (bio);
@@ -108,7 +108,7 @@ static void f2fs_read_end_io(struct bio *bio)#if defined(CONFIG_FS_ENCRYPTION ) || defined(CONFIG_FS_VERITY )if (!bio->bi_status && bio->bi_private) { -bio_post_read_processing ((struct bio_post_read_ctx *)(bio->bi_private)); +post_read_processing ((struct post_read_ctx *)(bio->bi_private));return ; }#endif
@@ -514,7 +514,7 @@ static struct bio *f2fs_grab_read_bio(struct inode *inode, block_t blkaddr,struct f2fs_sb_info *sbi =F2FS_I_SB (inode);struct bio *bio;#if defined(CONFIG_FS_ENCRYPTION ) || defined(CONFIG_FS_VERITY ) -struct bio_post_read_ctx *ctx; +struct post_read_ctx *ctx;#endif if (!f2fs_is_valid_blkaddr (sbi, blkaddr,DATA_GENERIC ))return ERR_PTR (-EFAULT );
@@ -527,7 +527,7 @@ static struct bio *f2fs_grab_read_bio(struct inode *inode, block_t blkaddr,bio_set_op_attrs (bio,REQ_OP_READ , op_flag);#if defined(CONFIG_FS_ENCRYPTION ) || defined(CONFIG_FS_VERITY ) - ctx =get_bio_post_read_ctx (inode, bio, first_idx); + ctx =get_post_read_ctx (inode, bio, first_idx);if (IS_ERR (ctx)) {bio_put (bio);return (struct bio *)ctx;
fs/mpage.c +5 -5
@@ -56,16 +56,16 @@ static void mpage_end_io(struct bio *bio)#if defined(CONFIG_FS_ENCRYPTION ) || defined(CONFIG_FS_VERITY )if (!bio->bi_status && bio->bi_private) { -struct bio_post_read_ctx *ctx; +struct post_read_ctx *ctx; ctx = bio->bi_private; -bio_post_read_processing (ctx); +post_read_processing (ctx);return ; }if (bio->bi_private) -put_bio_post_read_ctx ((struct bio_post_read_ctx *)(bio->bi_private)); +put_post_read_ctx ((struct post_read_ctx *)(bio->bi_private));#endif bio_for_each_segment_all (bv, bio, i, iter_all) {
@@ -332,7 +332,7 @@ static struct bio *do_mpage_readpage(struct mpage_readpage_args *args) alloc_new:if (args->bio ==NULL ) {#if defined(CONFIG_FS_ENCRYPTION ) || defined(CONFIG_FS_VERITY ) -struct bio_post_read_ctx *ctx; +struct post_read_ctx *ctx;#endif if (first_hole == blocks_per_page && !(IS_ENCRYPTED (inode) ||IS_VERITY (inode))) {
@@ -348,7 +348,7 @@ static struct bio *do_mpage_readpage(struct mpage_readpage_args *args) goto confused;#if defined(CONFIG_FS_ENCRYPTION ) || defined(CONFIG_FS_VERITY ) - ctx =get_bio_post_read_ctx (inode, args->bio, page->index); + ctx =get_post_read_ctx (inode, args->bio, page->index);if (IS_ERR (ctx)) {bio_put (args->bio); args->bio =NULL ;
fs/post_read_process.c +28 -28
117 lines not on this page · raw message
fs/verity/verify.c +3 -3
@@ -287,12 +287,12 @@ EXPORT_SYMBOL_GPL(fsverity_verify_bio);static void fsverity_verify_work (struct work_struct *work) { -struct bio_post_read_ctx *ctx = - container_of(work, struct bio_post_read_ctx, work); +struct post_read_ctx *ctx = + container_of(work, struct post_read_ctx, work);fsverity_verify_bio (ctx->bio); -bio_post_read_processing (ctx); +post_read_processing (ctx); }/**
include/linux/post_read_process.h +8 -8
@@ -2,7 +2,7 @@ #ifndef _POST_READ_PROCESS_H #define _POST_READ_PROCESS_H -struct bio_post_read_ctx { +struct post_read_ctx { struct bio *bio; struct inode *inode; struct work_struct work;
@@ -10,12 +10,12 @@ struct bio_post_read_ctx { unsigned int enabled_steps; }; -void end_bio_post_read_processing (struct bio *bio); -void bio_post_read_processing (struct bio_post_read_ctx *ctx); -struct bio_post_read_ctx *get_bio_post_read_ctx (struct inode *inode, -struct bio *bio, -pgoff_t index); -void put_bio_post_read_ctx (struct bio_post_read_ctx *ctx); -bool bio_post_read_required (struct bio *bio); +void end_post_read_processing (struct bio *bio); +void post_read_processing (struct post_read_ctx *ctx); +struct post_read_ctx *get_post_read_ctx (struct inode *inode, +struct bio *bio, +pgoff_t index); +void put_post_read_ctx (struct post_read_ctx *ctx); +bool post_read_required (struct bio *bio);#endif /* _POST_READ_PROCESS_H */
Signature · 1 line
2.19.1
RFC PATCH v2 8/14 Add decryption support for sub-pagesized blocks
In reply to Chandan RajendraTo support decryption of sub-pagesized blocks this commit adds code to,
1. Track buffer head in "struct post_read_ctx".
2. Pass buffer head argument to all "post read" processing functions.
3. In the corresponding endio, loop across all the blocks mapped by the page, decrypting each block in turn.
--- fs/buffer.c | 85 +++++++++++++++++++++++-------- fs/crypto/bio.c | 48 +++++++++++------ fs/crypto/crypto.c | 19 ++++++- fs/f2fs/data.c | 2 +- fs/mpage.c | 2 +- fs/post_read_process.c | 53 ++++++++++++------- include/linux/buffer_head.h | 1 + include/linux/post_read_process.h | 5 +- 8 files changed, 154 insertions(+), 61 deletions(-)
fs/buffer.c +64 -21
@@ -45,6 +45,7 @@#include <linux/bit_spinlock.h> #include <linux/pagevec.h> #include <linux/sched/mm.h> +#include <linux/post_read_process.h> #include <trace/events/block.h> static int fsync_buffers_list (spinlock_t *lock,struct list_head *list);
@@ -245,11 +246,7 @@ __find_get_block_slow(struct block_device *bdev, sector_t block)return ret; } -/* -* I/O completion handler for block_read_full_page() - pages -* which come unlocked at the end of I/O. -*/ -static void end_buffer_async_read (struct buffer_head *bh,int uptodate) +void end_buffer_page_read (struct buffer_head *bh) {unsigned long flags;struct buffer_head *first;
@@ -257,17 +254,7 @@ static void end_buffer_async_read(struct buffer_head *bh, int uptodate)struct page *page;int page_uptodate =1 ; -BUG_ON (!buffer_async_read (bh)); - page = bh->b_page; -if (uptodate) { -set_buffer_uptodate (bh); - }else { -clear_buffer_uptodate (bh); -buffer_io_error (bh,", async page read" ); -SetPageError (page); - } -/* * Be _very_ careful from here on. Bad things can happen if * two buffer heads end IO at almost the same time and both
@@ -305,6 +292,46 @@ static void end_buffer_async_read(struct buffer_head *bh, int uptodate)local_irq_restore (flags);return ; } +EXPORT_SYMBOL (end_buffer_page_read); + +/* +* I/O completion handler for block_read_full_page() - pages +* which come unlocked at the end of I/O. +*/ +static void end_buffer_async_read (struct buffer_head *bh,int uptodate) +{ +struct page *page; + +BUG_ON (!buffer_async_read (bh)); + +#if defined(CONFIG_FS_ENCRYPTION ) || defined(CONFIG_FS_VERITY ) +if (uptodate && bh->b_private) { +struct post_read_ctx *ctx = bh->b_private; + +post_read_processing (ctx); +return ; + } + +if (bh->b_private) { +struct post_read_ctx *ctx = bh->b_private; + +WARN_ON (uptodate); +put_post_read_ctx (ctx); + } +#endif + page = bh->b_page; +if (uptodate) { +set_buffer_uptodate (bh); + }else { +clear_buffer_uptodate (bh); +buffer_io_error (bh,", async page read" ); +SetPageError (page); + } + +end_buffer_page_read (bh); + +return ; +}/* * Completion handler for block_write_full_page() - pages which are unlocked
@@ -2220,7 +2247,11 @@ int block_read_full_page(struct page *page, get_block_t *get_block) {struct inode *inode = page->mapping->host;sector_t iblock, lblock; -struct buffer_head *bh, *head, *arr[MAX_BUF_PER_PAGE ]; +struct buffer_head *bh, *head; +struct { +sector_t blk_nr; +struct buffer_head *bh; + } arr[MAX_BUF_PER_PAGE ];unsigned int blocksize, bbits;int nr, i;int fully_mapped =1 ;
@@ -2262,7 +2293,9 @@ int block_read_full_page(struct page *page, get_block_t *get_block)if (buffer_uptodate (bh))continue ; } - arr[nr++] = bh; + arr[nr].blk_nr = iblock; + arr[nr].bh = bh; + ++nr; }while (i++, iblock++, (bh = bh->b_this_page) != head);if (fully_mapped)
@@ -2281,7 +2314,7 @@ int block_read_full_page(struct page *page, get_block_t *get_block)/* Stage two: lock the buffers */ for (i =0 ; i < nr; i++) { - bh = arr[i]; + bh = arr[i].bh;lock_buffer (bh);mark_buffer_async_read (bh); }
@@ -2292,11 +2325,21 @@ int block_read_full_page(struct page *page, get_block_t *get_block)* the underlying blockdev brought it uptodate (the sct fix). */ for (i =0 ; i < nr; i++) { - bh = arr[i]; -if (buffer_uptodate (bh)) + bh = arr[i].bh; +if (buffer_uptodate (bh)) {end_buffer_async_read (bh,1 ); -else + }else { +#if defined(CONFIG_FS_ENCRYPTION ) || defined(CONFIG_FS_VERITY ) +struct post_read_ctx *ctx; + + ctx =get_post_read_ctx (inode,NULL , bh, arr[i].blk_nr); +if (WARN_ON (IS_ERR (ctx))) { +end_buffer_async_read (bh,0 ); +continue ; + } +#endif submit_bh (REQ_OP_READ ,0 , bh); + } }return 0 ; }
fs/crypto/bio.c +32 -16
76 lines not on this page · raw message
fs/crypto/crypto.c +17 -2
@@ -305,11 +305,26 @@ 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) { +int i, page_nr_blks; +int err =0 ; +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 ); + page_nr_blks = len >> inode->i_blkbits; + +for (i =0 ; i < page_nr_blks; i++) { + err =fscrypt_do_page_crypto (inode,FS_DECRYPT , lblk_num, + page, page,i_blocksize (inode), offs, +GFP_NOFS ); +if (err) +break ; + + ++lblk_num; + offs +=i_blocksize (inode); + } + +return err; }EXPORT_SYMBOL (fscrypt_decrypt_page);
fs/f2fs/data.c +1 -1
@@ -527,7 +527,7 @@ static struct bio *f2fs_grab_read_bio(struct inode *inode, block_t blkaddr,bio_set_op_attrs (bio,REQ_OP_READ , op_flag);#if defined(CONFIG_FS_ENCRYPTION ) || defined(CONFIG_FS_VERITY ) - ctx =get_post_read_ctx (inode, bio, first_idx); + ctx =get_post_read_ctx (inode, bio,NULL , first_idx);if (IS_ERR (ctx)) {bio_put (bio);return (struct bio *)ctx;
fs/mpage.c +1 -1
@@ -348,7 +348,7 @@ static struct bio *do_mpage_readpage(struct mpage_readpage_args *args) goto confused;#if defined(CONFIG_FS_ENCRYPTION ) || defined(CONFIG_FS_VERITY ) - ctx =get_post_read_ctx (inode, args->bio, page->index); + ctx =get_post_read_ctx (inode, args->bio,NULL , page->index);if (IS_ERR (ctx)) {bio_put (args->bio); args->bio =NULL ;
fs/post_read_process.c +35 -18
108 lines not on this page · raw message
include/linux/buffer_head.h +1 -0
@@ -165,6 +165,7 @@ void create_empty_buffers(struct page *, unsigned long,void end_buffer_read_sync (struct buffer_head *bh,int uptodate);void end_buffer_write_sync (struct buffer_head *bh,int uptodate);void end_buffer_async_write (struct buffer_head *bh,int uptodate); +void end_buffer_page_read (struct buffer_head *bh);/* Things to do with buffers at mapping->private_list */ void mark_buffer_dirty_inode (struct buffer_head *bh,struct inode *inode);
include/linux/post_read_process.h +3 -2
@@ -3,6 +3,7 @@#define _POST_READ_PROCESS_Hstruct post_read_ctx { +struct buffer_head *bh;struct bio *bio;struct inode *inode;struct work_struct work;
@@ -10,12 +11,12 @@ struct post_read_ctx { unsigned int enabled_steps; }; -void end_post_read_processing (struct bio *bio); +void end_post_read_processing (struct bio *bio,struct buffer_head *bh);void post_read_processing (struct post_read_ctx *ctx);struct post_read_ctx *get_post_read_ctx (struct inode *inode,struct bio *bio, +struct buffer_head *bh,pgoff_t index);void put_post_read_ctx (struct post_read_ctx *ctx); -bool post_read_required (struct bio *bio);#endif /* _POST_READ_PROCESS_H */
Signature · 1 line
2.19.1
RFC PATCH v2 9/14 ext4: Decrypt all boundary blocks when doing buffered write
In reply to Chandan RajendraWith subpage sized blocks, ext4_block_write_begin() can have up to two blocks to decrypt. Hence this commit invokes fscrypt_decrypt_page() for each of those blocks.
--- fs/ext4/inode.c | 33 +++++++++++++++++++++++---------- 1 file changed, 23 insertions(+), 10 deletions(-)
fs/ext4/inode.c +23 -10
@@ -1156,12 +1156,14 @@ static int ext4_block_write_begin(struct page *page, loff_t pos, unsigned len,unsigned to = from + len;struct inode *inode = page->mapping->host;unsigned block_start, block_end; -sector_t block; +sector_t block, page_blk_nr;int err =0 ;unsigned blocksize = inode->i_sb->s_blocksize;unsigned bbits; -struct buffer_head *bh, *head, *wait[2 ], **wait_bh = wait; +struct buffer_head *bh, *head, *wait[2 ]; +int nr_wait =0 ;bool decrypt = false; +int i;BUG_ON (!PageLocked (page));BUG_ON (from >PAGE_SIZE );
@@ -1213,25 +1215,36 @@ 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; + wait[nr_wait++] = bh; decrypt =IS_ENCRYPTED (inode) &&S_ISREG (inode->i_mode); } }/* * 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_page (page->mapping->host, page, -PAGE_SIZE ,0 , page->index); -if (err) -clear_buffer_uptodate (*wait_bh); + page_blk_nr = (sector_t )page->index << (PAGE_SHIFT - bbits); + +for (i =0 ; i < nr_wait; i++) { +int err2; + + block = page_blk_nr + (bh_offset (wait[i]) >> bbits); + err2 =fscrypt_decrypt_page (page->mapping->host, page, + wait[i]->b_size, +bh_offset (wait[i]), + block); +if (err2) { +clear_buffer_uptodate (wait[i]); + err = err2; + } + } }return err;
Signature · 1 line
2.19.1
RFC PATCH v2 10/14 ext4: Decrypt the block that needs to be partially zeroed
In reply to Chandan Rajendra__ext4_block_zero_page_range decrypts the entire page. This commit decrypts the block to be partially zeroed instead of the whole page.
--- fs/ext4/inode.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
fs/ext4/inode.c +3 -2
@@ -4080,9 +4080,10 @@ 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_page (page->mapping->host, - page,PAGE_SIZE ,0 , page->index)); + page, blocksize, +round_down (offset, blocksize), + iblock)); } }if (ext4_should_journal_data (inode)) {
Signature · 1 line
2.19.1
RFC PATCH v2 11/14 fscrypt_encrypt_page: Loop across all blocks mapped by a page range
In reply to Chandan RajendraFor subpage-sized blocks, this commit now encrypts all blocks mapped by a page range.
--- fs/crypto/crypto.c | 37 +++++++++++++++++++++++++------------ 1 file changed, 25 insertions(+), 12 deletions(-)
fs/crypto/crypto.c +25 -12
@@ -242,18 +242,26 @@ struct page *fscrypt_encrypt_page(const struct inode *inode, {struct fscrypt_ctx *ctx;struct page *ciphertext_page = page; +int i, page_nr_blks;int err;BUG_ON (len %FS_CRYPTO_BLOCK_SIZE !=0 ); + page_nr_blks = len >> inode->i_blkbits; +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); -if (err) -return ERR_PTR (err); - +for (i =0 ; i < page_nr_blks; i++) { + err =fscrypt_do_page_crypto (inode,FS_ENCRYPT , + lblk_num, page, + ciphertext_page, +i_blocksize (inode), offs, + gfp_flags); +if (err) +return ERR_PTR (err); + ++lblk_num; + offs +=i_blocksize (inode); + }return ciphertext_page; }
@@ -269,12 +277,17 @@ struct page *fscrypt_encrypt_page(const struct inode *inode, goto errout; ctx->control_page = page; - err =fscrypt_do_page_crypto (inode,FS_ENCRYPT , lblk_num, - page, ciphertext_page, len, offs, - gfp_flags); -if (err) { - ciphertext_page =ERR_PTR (err); - goto errout; + +for (i =0 ; i < page_nr_blks; i++) { + err =fscrypt_do_page_crypto (inode,FS_ENCRYPT , lblk_num, + page, ciphertext_page,i_blocksize (inode), offs, + gfp_flags); +if (err) { + ciphertext_page =ERR_PTR (err); + goto errout; + } + ++lblk_num; + offs +=i_blocksize (inode); }SetPagePrivate (ciphertext_page);set_page_private (ciphertext_page, (unsigned long )ctx);
Signature · 1 line
2.19.1
RFC PATCH v2 12/14 ext4: Compute logical block and the page range to be encrypted
In reply to Chandan RajendraFor subpage-sized blocks, the initial logical block number mapped by a page can be different from page->index. Hence this commit adds code to compute the first logical block mapped by the page and also the page range to be encrypted.
--- fs/ext4/page-io.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-)
fs/ext4/page-io.c +7 -2
@@ -418,6 +418,7 @@ int ext4_bio_write_page(struct ext4_io_submit *io, {struct page *data_page =NULL ;struct inode *inode = page->mapping->host; +u64 page_blk;unsigned block_start;struct buffer_head *bh, *head;int ret =0 ;
@@ -478,10 +479,14 @@ int ext4_bio_write_page(struct ext4_io_submit *io,if (IS_ENCRYPTED (inode) &&S_ISREG (inode->i_mode) && nr_to_submit) {gfp_t gfp_flags =GFP_NOFS ; +unsigned int page_bytes; + + page_bytes =round_up (len,i_blocksize (inode)); + page_blk = page->index << (PAGE_SHIFT - inode->i_blkbits); retry_encrypt: - data_page =fscrypt_encrypt_page (inode, page,PAGE_SIZE ,0 , - page->index, gfp_flags); + data_page =fscrypt_encrypt_page (inode, page, page_bytes,0 , + page_blk, gfp_flags);if (IS_ERR (data_page)) { ret =PTR_ERR (data_page);if (ret == -ENOMEM && wbc->sync_mode ==WB_SYNC_ALL ) {
Signature · 1 line
2.19.1
RFC PATCH v2 13/14 fscrypt_zeroout_range: Encrypt all zeroed out blocks of a page
In reply to Chandan RajendraFor subpage-sized blocks, this commit adds code to encrypt all zeroed out blocks mapped by a page.
--- fs/crypto/bio.c | 40 ++++++++++++++++++---------------------- 1 file changed, 18 insertions(+), 22 deletions(-)
fs/crypto/bio.c +18 -22
@@ -106,29 +106,23 @@ 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 bio *bio; +u64 total_bytes, page_bytes;int ret, err =0 ; -BUG_ON (inode->i_sb->s_blocksize !=PAGE_SIZE ); - - ctx =fscrypt_get_ctx (inode,GFP_NOFS ); -if (IS_ERR (ctx)) -return PTR_ERR (ctx); + total_bytes = len << inode->i_blkbits; - ciphertext_page =fscrypt_alloc_bounce_page (ctx,GFP_NOWAIT ); -if (IS_ERR (ciphertext_page)) { - err =PTR_ERR (ciphertext_page); - goto errout; - } +while (total_bytes) { + page_bytes =min_t (u64, total_bytes,PAGE_SIZE ); -while (len--) { - err =fscrypt_do_page_crypto (inode,FS_ENCRYPT , lblk, -ZERO_PAGE (0 ), ciphertext_page, -PAGE_SIZE ,0 ,GFP_NOFS ); -if (err) + ciphertext_page =fscrypt_encrypt_page (inode,ZERO_PAGE (0 ), + page_bytes,0 , lblk,GFP_NOFS ); +if (IS_ERR (ciphertext_page)) { + err =PTR_ERR (ciphertext_page); + ciphertext_page =NULL ; goto errout; + } bio =bio_alloc (GFP_NOWAIT ,1 );if (!bio) {
@@ -139,9 +133,8 @@ int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk, bio->bi_iter.bi_sector = pblk << (inode->i_sb->s_blocksize_bits -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, page_bytes,0 ); +if (ret != page_bytes) {/* should never happen! */ WARN_ON (1 );bio_put (bio);
@@ -154,12 +147,15 @@ int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk,bio_put (bio);if (err) goto errout; - lblk++; - pblk++; + + lblk += page_bytes >> inode->i_blkbits; + pblk += page_bytes >> inode->i_blkbits; + total_bytes -= page_bytes; } err =0 ; errout: -fscrypt_release_ctx (ctx); +if (!IS_ERR_OR_NULL (ciphertext_page)) +fscrypt_restore_control_page (ciphertext_page);return err; }EXPORT_SYMBOL (fscrypt_zeroout_range);
Signature · 1 line
2.19.1
RFC PATCH v2 14/14 ext4: Enable encryption for subpage-sized blocks
In reply to Chandan RajendraNow that we have the code to support encryption for subpage-sized blocks, this commit removes the conditional check in filesystem mount code.
The commit also changes the support statement in Documentation/filesystems/fscrypt.rst to reflect the fact that encryption of filesystems with blocksize less than page size now works.
--- Documentation/filesystems/fscrypt.rst | 4 ++-- fs/ext4/super.c | 7 ------- 2 files changed, 2 insertions(+), 9 deletions(-)
Documentation/filesystems/fscrypt.rst +2 -2
@@ -213,8 +213,8 @@ Contents encryption ------------------- For file contents, each filesystem block is encrypted independently. -Currently, only the case where the filesystem block size is equal to -the system's page size (usually 4096 bytes) is supported. +Starting from Linux kernel 5.3, encryption of filesystems with block +size less than system's page size is supported. Each block's IV is set to the logical block number within the file as a little endian number, except that:
fs/ext4/super.c +0 -7
@@ -4433,13 +4433,6 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) } } -if ((DUMMY_ENCRYPTION_ENABLED (sbi) ||ext4_has_feature_encrypt (sb)) && - (blocksize !=PAGE_SIZE )) { -ext4_msg (sb,KERN_ERR , -"Unsupported blocksize for fs encryption" ); - goto failed_mount_wq; - } -if (DUMMY_ENCRYPTION_ENABLED (sbi) && !sb_rdonly (sb) && !ext4_has_feature_encrypt (sb)) {ext4_set_feature_encrypt (sb);
Signature · 1 line
2.19.1