Consolidate FS read I/O callbacks code
Subsystems (5)
v5 cover Consolidate FS read I/O callbacks code
This patchset moves the "FS read I/O callbacks" code into a file of its own (i.e. fs/read_callbacks.c) and modifies the generic do_mpage_readpge() to make use of the functionality provided.
"FS read I/O callbacks" code implements 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 duplication of code across filesystems. Also, "FS read I/O callbacks" source files will be built only if CONFIG_FS_ENCRYPTION is enabled.
The patchset also modifies fs/buffer.c to get file encryption/decryption to work with subpage-sized blocks.
The patches can also be obtained from
https://github.com/chandanr/linux.git at branch subpage-encryption-v5.
Changelog:
V4 -> V5:
1. Since F2FS uses its own workqueue and also since its decompression logic isn't an fs independent entity like fscrypt or fsverity, this patchset drops support for F2FS.
The patchset still helps in removing a copy of do_mpage_readpage() from Ext4 (i.e. ext4_readpage()) and also prevents a copy of block_read_full_page() from being added into Ext4 by adding support to "read callbacks" API invocations into block_read_full_page().
V3 -> V4:
1. A new buffer_head flag (i.e. BH_Read_Cb) is introduced to reliably check if a buffer head's content has to be decrypted.
2. Fix layering violation. Now the code flow for decryption happens as shown below, FS => read callbacks => fscrypt
3. Select FS_READ_CALLBACKS from FS specific kconfig file if FS_ENCRYPTION is enabled.
4. Make 'struct read_callbacks_ctx' an opaque structure.
5. Make use of FS' endio function rather than implementing one in read callbacks.
6. Make read_callbacks.h self-contained.
7. Split patchset to separate out ext4 and f2fs changes.
V2 -> V3:
1. Split the V2 patch "Consolidate 'read callbacks' into a new file" into three patches,
- Introduce the read_callbacks functionality.
- Convert encryption to use read_callbacks.
- Remove union from struct fscrypt_context.
2. fs/Kconfig
Do not explicitly set the default value of 'n' for FS_READ_CALLBACKS.
3. fs/crypto/Kconfig
Select CONFIG_FS_READ_CALLBACKS only if CONFIG_BLOCK is selected.
4. Remove verity associated code in read_callbacks code.
5. Introduce a callback argument to read_callbacks_setup() function which gets invoked for each page for bio. F2FS uses this to perform custom operations like decrementing the value of f2fs_sb_info->nr_pages[].
6. Encapsulate the details of "read callbacks" (e.g. Usage of "struct read_callbacks *ctx") within its own functions. When CONFIG_FS_READ_CALLBACKS is set to 'n', the corresponding stub functions return approriate error values.
7. Split fscrypt_decrypt() function into fscrypt_decrypt_bio() and fscrypt_decrypt_bh().
8. Split end_read_callbacks() function into end_read_callbacks_bio() and end_read_callbacks_bh().
V1 -> V2:
1. Removed the phrase "post_read_process" from file names and functions. Instead we now use the phrase "read_callbacks" in its place.
2. When performing changes associated with (1), the changes made by the patch "Remove the term 'bio' from post read processing" are made in the earlier patch "Consolidate 'read callbacks' into a new file". Hence the patch "Remove the term 'bio' from post read processing" is removed from the patchset.
RFC V2 -> V1:
1. Test and verify FS_CFLG_OWN_PAGES subset of fscrypt_encrypt_page() code by executing fstests on UBIFS.
2. Implement F2fs function call back to check if the contents of a page holding a verity file's data needs to be verified.
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 (7):
buffer_head: Introduce BH_Read_Cb flag
FS: Introduce read callbacks
fs/mpage.c: Integrate read callbacks fs/buffer.c: add decryption support via read_callbacks
ext4: Wire up ext4_readpage[s] to use mpage_readpage[s]
ext4: Enable encryption for subpage-sized blocks
fscrypt: remove struct fscrypt_ctx
Documentation/filesystems/fscrypt.rst | 4 +- fs/Kconfig | 3 + fs/Makefile | 1 + fs/buffer.c | 33 ++- fs/crypto/bio.c | 18 -- fs/crypto/crypto.c | 89 +------- fs/crypto/fscrypt_private.h | 3 - fs/ext4/Kconfig | 1 + fs/ext4/Makefile | 2 +- fs/ext4/inode.c | 5 +- fs/ext4/readpage.c | 295 -------------------------- fs/ext4/super.c | 7 - fs/f2fs/Kconfig | 1 + fs/mpage.c | 24 ++- fs/read_callbacks.c | 285 +++++++++++++++++++++++++ include/linux/buffer_head.h | 2 + include/linux/fscrypt.h | 32 --- include/linux/read_callbacks.h | 48 +++++ 18 files changed, 391 insertions(+), 462 deletions(-) delete mode 100644 fs/ext4/readpage.c create mode 100644 fs/read_callbacks.c create mode 100644 include/linux/read_callbacks.h
Signature · 1 line
2.19.1
PATCH RESEND v5 1/7 buffer_head: Introduce BH_Read_Cb flag
Decryption of file content encrypted using fscrypt relies on bio->bi_private holding a pointer to an encryption context i.e. Decryption operation is not performed for bios having a NULL value at bio->bi_private.
The same logic cannot be used on buffer heads because,
1. In Btrfs, write_dev_supers() sets bh->b_private to 'struct btrfs_device' pointer and submits the buffer head for a write operation.
1. In btrfs/146 test, the write operation fails and hence the endio function clears the BH_Uptodate flag.
2. A read operation initiated later will submit the buffer head to the block layer. During endio processing, bh_>b_private would have a non-NULL value.
2. Another instance is when an Ext4 metadata block with BH_Uptodate set and also part of the in-memory JBD list undergoes the following,
1. A sync() syscall is invoked by the userspace and the write operation on the metadata block is initiated.
2. Due to an I/O failure, the BH_Uptodate flag is cleared by end_buffer_async_write(). The bh->b_private member would be pointing to a journal head structure.
3. In such a case, a read operation invoked on the block mapped by the buffer head will initiate a read from the disk since the buffer head is missing the BH_Uptodate flag.
4. After the read I/O request is submitted, end_buffer_async_read()
will find a non-NULL value at bh->b_private.
This scenario was observed when executing generic/475 test case.
Hence this commit introduces a new buffer head flag to reliably check for decryption of a buffer head's contents after the block has been read from the disk.
--- include/linux/buffer_head.h | 2 ++ 1 file changed, 2 insertions(+)
include/linux/buffer_head.h +2 -0
@@ -38,6 +38,7 @@ enum bh_state_bits { BH_Meta,/* Buffer contains metadata */ BH_Prio,/* Buffer should be submitted with REQ_PRIO */ BH_Defer_Completion,/* Defer AIO completion to workqueue */ + BH_Read_Cb,/* Block's contents needs to be decrypted */ BH_PrivateStart,/* not a state bit, but the first bit available* for private allocation by other entities
@@ -134,6 +135,7 @@ BUFFER_FNS(Unwritten, unwritten) BUFFER_FNS(Meta, meta) BUFFER_FNS(Prio, prio) BUFFER_FNS(Defer_Completion, defer_completion) +BUFFER_FNS(Read_Cb, read_cb)#define bh_offset (bh) ((unsigned long)(bh)->b_data & ~PAGE_MASK)
Signature · 1 line
2.19.1
PATCH RESEND v5 2/7 FS: Introduce read callbacks
In reply to Chandan RajendraRead callbacks implements a state machine to be executed after a buffered read I/O is completed. They help in further processing the file data read from the backing store. Currently, decryption is the only post processing step to be supported.
The execution of the state machine is to be initiated by the endio function associated with the read operation.
--- fs/Kconfig | 3 + fs/Makefile | 1 + fs/ext4/Kconfig | 1 + fs/f2fs/Kconfig | 1 + fs/read_callbacks.c | 285 +++++++++++++++++++++++++++++++++ include/linux/read_callbacks.h | 48 ++++++ 6 files changed, 339 insertions(+) create mode 100644 fs/read_callbacks.c create mode 100644 include/linux/read_callbacks.h
fs/Kconfig +3 -0
@@ -20,6 +20,9 @@ if BLOCK config FS_IOMAP bool +config FS_READ_CALLBACKS + bool + source "fs/ext2/Kconfig" source "fs/ext4/Kconfig" source "fs/jbd2/Kconfig"
fs/Makefile +1 -0
@@ -53,6 +53,7 @@ obj-$(CONFIG_SYSCTL) += drop_caches.o obj-$(CONFIG_FHANDLE) += fhandle.o obj-$(CONFIG_FS_IOMAP) += iomap.o +obj-$(CONFIG_FS_READ_CALLBACKS) += read_callbacks.o obj-y += quota/
fs/ext4/Kconfig +1 -0
@@ -38,6 +38,7 @@ config EXT4_FS select CRYPTO select CRYPTO_CRC32C select FS_IOMAP + select FS_READ_CALLBACKS if FS_ENCRYPTION help This is the next generation of the ext3 filesystem.
fs/f2fs/Kconfig +1 -0
@@ -4,6 +4,7 @@ config F2FS_FS select CRYPTO select CRYPTO_CRC32 select F2FS_FS_XATTR if FS_ENCRYPTION + select FS_READ_CALLBACKS if FS_ENCRYPTION help F2FS is based on Log-structured File System (LFS), which supports versatile "flash-friendly" features. The design has been focused on
fs/read_callbacks.c new file +285 -0
285 lines not on this page · raw message
include/linux/read_callbacks.h new file +48 -0
48 lines not on this page · raw message
Signature · 1 line
2.19.1
PATCH RESEND v5 3/7 fs/mpage.c: Integrate read callbacks
In reply to Chandan RajendraThis commit adds code to make do_mpage_readpage() to be "read callbacks" aware i.e. for files requiring decryption, do_mpage_readpage() now sets up the read callbacks state machine when allocating a bio and later starts execution of the state machine after file data is read from the underlying disk.
--- fs/mpage.c | 24 +++++++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-)
fs/mpage.c +21 -3
@@ -30,6 +30,7 @@#include <linux/backing-dev.h> #include <linux/pagevec.h> #include <linux/cleancache.h> +#include <linux/read_callbacks.h> #include "internal.h" /*
@@ -44,7 +45,7 @@* status of that page is hard. See end_buffer_async_read() for the details. * There is no point in duplicating all that complexity. */ -static void mpage_end_io (struct bio *bio) +static void end_bio (struct bio *bio) {struct bio_vec *bv;int i;
@@ -52,13 +53,24 @@ static void mpage_end_io(struct bio *bio)bio_for_each_segment_all (bv, bio, i, iter_all) {struct page *page = bv->bv_page; -page_endio (page,bio_op (bio), -blk_status_to_errno (bio->bi_status)); +int err; + + err =blk_status_to_errno (bio->bi_status); + +if (!err &&read_callbacks_failed (page)) + err = -EIO ; + +page_endio (page,bio_op (bio), err); }bio_put (bio); } +static void mpage_end_io (struct bio *bio) +{ +read_callbacks_endio_bio (bio, end_bio); +} +static struct bio *mpage_bio_submit (int op,int op_flags,struct bio *bio) { bio->bi_end_io = mpage_end_io;
@@ -310,6 +322,12 @@ static struct bio *do_mpage_readpage(struct mpage_readpage_args *args) gfp);if (args->bio ==NULL ) goto confused; + +if (read_callbacks_setup_bio (inode, args->bio)) { +bio_put (args->bio); + args->bio =NULL ; + goto confused; + } } length = first_hole << blkbits;
Signature · 1 line
2.19.1
PATCH RESEND v5 4/7 fs/buffer.c: add decryption support via read_callbacks
In reply to Chandan RajendraThis commit sets up read_callbacks context for buffer heads whose contents need to be decrypted on endio.
--- fs/buffer.c | 33 ++++++++++++++++++++++----------- 1 file changed, 22 insertions(+), 11 deletions(-)
fs/buffer.c +22 -11
@@ -45,6 +45,7 @@#include <linux/bit_spinlock.h> #include <linux/pagevec.h> #include <linux/sched/mm.h> +#include <linux/read_callbacks.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_async_read (struct buffer_head *bh,int uptodate) {unsigned long flags;struct buffer_head *first;
@@ -257,8 +254,6 @@ 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);
@@ -306,6 +301,17 @@ static void end_buffer_async_read(struct buffer_head *bh, int uptodate)return ; } +/* +* I/O completion handler for block_read_full_page(). Pages are unlocked +* after the I/O completes and the read callbacks (if any) have executed. +*/ +static void __end_buffer_async_read (struct buffer_head *bh,int uptodate) +{ +BUG_ON (!buffer_async_read (bh)); + +read_callbacks_endio_bh (bh, uptodate, end_buffer_async_read); +} +/* * Completion handler for block_write_full_page() - pages which are unlocked * during I/O, and which have PageWriteback cleared upon I/O completion.
@@ -378,7 +384,7 @@ EXPORT_SYMBOL(end_buffer_async_write);*/ static void mark_buffer_async_read (struct buffer_head *bh) { - bh->b_end_io = end_buffer_async_read; + bh->b_end_io = __end_buffer_async_read;set_buffer_async_read (bh); }
@@ -2293,10 +2299,15 @@ int block_read_full_page(struct page *page, get_block_t *get_block)*/ for (i =0 ; i < nr; i++) { bh = arr[i]; -if (buffer_uptodate (bh)) -end_buffer_async_read (bh,1 ); -else +if (buffer_uptodate (bh)) { +__end_buffer_async_read (bh,1 ); + }else { +if (WARN_ON (read_callbacks_setup_bh (inode, bh))) { +__end_buffer_async_read (bh,0 ); +continue ; + }submit_bh (REQ_OP_READ ,0 , bh); + } }return 0 ; }
Signature · 1 line
2.19.1
PATCH RESEND v5 5/7 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
@@ -3361,8 +3361,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; }
@@ -3377,7 +3376,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
PATCH RESEND v5 6/7 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.4, 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
@@ -4322,13 +4322,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
PATCH RESEND v5 7/7 fscrypt: remove struct fscrypt_ctx
In reply to Chandan RajendraCommit "fscrypt: remove the 'write' part of struct fscrypt_ctx" reduced "struct fscrypt_ctx" to be used only for decryption. With "read callbacks" being integrated into Ext4, we don't use "struct fscrypt_ctx" anymore. Hence this commit removes the structure and the associated code.
--- fs/crypto/bio.c | 18 -------- fs/crypto/crypto.c | 89 +------------------------------------ fs/crypto/fscrypt_private.h | 3 -- include/linux/fscrypt.h | 32 ------------- 4 files changed, 2 insertions(+), 140 deletions(-)
fs/crypto/bio.c +0 -18
@@ -51,24 +51,6 @@ void fscrypt_decrypt_bio(struct bio *bio) }EXPORT_SYMBOL (fscrypt_decrypt_bio); -static void completion_pages (struct work_struct *work) -{ - 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); -bio_put (bio); -} - -void fscrypt_enqueue_decrypt_bio (struct fscrypt_ctx *ctx,struct bio *bio) -{ -INIT_WORK (&ctx->work, completion_pages); - ctx->bio = bio; -fscrypt_enqueue_decrypt_work (&ctx->work); -} -EXPORT_SYMBOL (fscrypt_enqueue_decrypt_bio); -int fscrypt_zeroout_range (const struct inode *inode,pgoff_t lblk,sector_t pblk,unsigned int len) {
fs/crypto/crypto.c +2 -87
146 lines not on this page · raw message
fs/crypto/fscrypt_private.h +0 -3
@@ -93,9 +93,6 @@ typedef enum {FS_ENCRYPT , } fscrypt_direction_t; -#define FS_CTX_REQUIRES_FREE_ENCRYPT_FL 0x00000001 -#define FS_CTX_HAS_BOUNCE_BUFFER_FL 0x00000002 -static inline bool fscrypt_valid_enc_modes (u32 contents_mode,u32 filenames_mode) {
include/linux/fscrypt.h +0 -32
@@ -19,7 +19,6 @@#define FS_CRYPTO_BLOCK_SIZE 16 -struct fscrypt_ctx ;struct fscrypt_info ;struct fscrypt_str {
@@ -63,18 +62,6 @@ struct fscrypt_operations {unsigned int max_namelen; }; -/* Decryption work */ -struct fscrypt_ctx { -union { -struct { -struct bio *bio; -struct work_struct work; - }; -struct list_head free_list;/* Free list */ - }; -u8 flags;/* Flags */ -}; -static inline bool fscrypt_has_encryption_key (const struct inode *inode) {/* pairs with cmpxchg_release() in fscrypt_get_encryption_info() */
@@ -101,8 +88,6 @@ static inline void fscrypt_handle_d_move(struct dentry *dentry)/* crypto.c */ 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_pagecache_blocks(struct page *page, unsigned int len,
@@ -233,8 +218,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 int fscrypt_zeroout_range (const struct inode *,pgoff_t ,sector_t ,unsigned int );
@@ -279,16 +262,6 @@ static inline void fscrypt_enqueue_decrypt_work(struct work_struct *work) { } -static inline struct fscrypt_ctx *fscrypt_get_ctx (gfp_t gfp_flags) -{ -return ERR_PTR (-EOPNOTSUPP ); -} - -static inline void fscrypt_release_ctx (struct fscrypt_ctx *ctx) -{ -return ; -} - static inline struct page *fscrypt_encrypt_pagecache_blocks(struct page *page, unsigned int len, unsigned int offs,
@@ -430,11 +403,6 @@ 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 int fscrypt_zeroout_range (const struct inode *inode,pgoff_t lblk,sector_t pblk,unsigned int len) {
Signature · 1 line
2.19.1
Quoted 14 lines · Chandan Rajendra
This patchset moves the "FS read I/O callbacks" code into a file of its own (i.e.
fs/read_callbacks.c) and modifies the genericdo_mpage_readpge()to make use of the functionality provided."FS read I/O callbacks" code implements 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 duplication of code across filesystems. Also, "FS read I/O callbacks" source files will be built only if
CONFIG_FS_ENCRYPTIONis enabled.
Quoted 6 lines
The patchset also modifies
fs/buffer.cto get file encryption/decryption to work with subpage-sized blocks.The patches can also be obtained from
https://github.com/chandanr/linux.git at branch subpage-encryption-v5.
Al Viro and Ted,
Can you please take a look at this patchset? I have addressed all the review comments that was provided up until version V4.
Ted,
Please let me know the if there is anything remaining from my side to get Ext4 encryption working in subpage blocksize scenario.
Quoted 100 lines
Changelog:
V4 -> V5:
1. Since F2FS uses its own workqueue and also since its decompression logic isn't an fs independent entity like fscrypt or fsverity, this patchset drops support for F2FS.
The patchset still helps in removing a copy ofdo_mpage_readpage()from Ext4 (i.e.ext4_readpage()) and also prevents a copy ofblock_read_full_page()from being added into Ext4 by adding support to "read callbacks" API invocations intoblock_read_full_page().V3 -> V4:
1. A newbuffer_headflag (i.e.BH_Read_Cb) is introduced to reliably check if a buffer head's content has to be decrypted.
2. Fix layering violation. Now the code flow for decryption happens as shown below, FS => read callbacks => fscrypt
3. SelectFS_READ_CALLBACKSfrom FS specific kconfig file ifFS_ENCRYPTIONis enabled.
4. Make 'structread_callbacks_ctx' an opaque structure.
5. Make use of FS' endio function rather than implementing one in read callbacks.
6. Makeread_callbacks.hself-contained.
7. Split patchset to separate out ext4 and f2fs changes.V2 -> V3:
1. Split the V2 patch "Consolidate 'read callbacks' into a new file" into three patches,
- Introduce theread_callbacksfunctionality.
- Convert encryption to useread_callbacks.
- Remove union from structfscrypt_context.
2. fs/Kconfig
Do not explicitly set the default value of 'n' forFS_READ_CALLBACKS.
3.fs/crypto/Kconfig
SelectCONFIG_FS_READ_CALLBACKSonly ifCONFIG_BLOCKis selected.
4. Remove verity associated code inread_callbackscode.
5. Introduce a callback argument toread_callbacks_setup()function which gets invoked for each page for bio. F2FS uses this to perform custom operations like decrementing the value of f2fs_sb_info->nr_pages[].
6. Encapsulate the details of "read callbacks" (e.g. Usage of "structread_callbacks*ctx") within its own functions. WhenCONFIG_FS_READ_CALLBACKSis set to 'n', the corresponding stub functions return approriate error values.
7. Splitfscrypt_decrypt()function intofscrypt_decrypt_bio()andfscrypt_decrypt_bh().
8. Splitend_read_callbacks()function intoend_read_callbacks_bio()andend_read_callbacks_bh().V1 -> V2:
1. Removed the phrase "post_read_process" from file names and functions. Instead we now use the phrase "read_callbacks" in its place.
2. When performing changes associated with (1), the changes made by the patch "Remove the term 'bio' from post read processing" are made in the earlier patch "Consolidate 'read callbacks' into a new file". Hence the patch "Remove the term 'bio' from post read processing" is removed from the patchset.RFC V2 -> V1:
1. Test and verifyFS_CFLG_OWN_PAGESsubset offscrypt_encrypt_page()code by executing fstests on UBIFS.
2. Implement F2fs function call back to check if the contents of a page holding a verity file's data needs to be verified.RFC V1 -> RFC V2:
1. Describe the purpose of "Post processing code" in the cover letter.
2. Fix build errors whenCONFIG_FS_VERITYis enabled.Chandan Rajendra (7):
buffer_head: IntroduceBH_Read_Cbflag
FS: Introduce read callbacks
fs/mpage.c: Integrate read callbacksfs/buffer.c: add decryption support viaread_callbacks
ext4: Wire up ext4_readpage[s] to use mpage_readpage[s]
ext4: Enable encryption for subpage-sized blocks
fscrypt: remove structfscrypt_ctxDocumentation/filesystems/fscrypt.rst | 4 +- fs/Kconfig | 3 + fs/Makefile | 1 + fs/buffer.c | 33 ++- fs/crypto/bio.c | 18 -- fs/crypto/crypto.c | 89 +------- fs/crypto/fscrypt_private.h | 3 - fs/ext4/Kconfig | 1 + fs/ext4/Makefile | 2 +- fs/ext4/inode.c | 5 +- fs/ext4/readpage.c | 295 -------------------------- fs/ext4/super.c | 7 - fs/f2fs/Kconfig | 1 + fs/mpage.c | 24 ++- fs/read_callbacks.c | 285 +++++++++++++++++++++++++ include/linux/buffer_head.h | 2 + include/linux/fscrypt.h | 32 --- include/linux/read_callbacks.h | 48 +++++ 18 files changed, 391 insertions(+), 462 deletions(-) delete mode 100644 fs/ext4/readpage.c create mode 100644 fs/read_callbacks.c create mode 100644 include/linux/read_callbacks.h
Signature · 1 line
chandan