* [PATCH 1/7] ecryptfs: remove struct ecryptfs_page_crypt_context
2026-10-15 1:35 [PATCH 0/7] ecryptfs: remove the remaining struct page usage Tal Zussman
@ 2026-10-15 1:35 ` Tal Zussman
2026-10-15 1:35 ` [PATCH 2/7] ecryptfs: use a folio and a buffer in crypt_extent() Tal Zussman
` (6 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: Tal Zussman @ 2026-10-15 1:35 UTC (permalink / raw)
To: Tyler Hicks; +Cc: ecryptfs, linux-kernel, Matthew Wilcox (Oracle), Tal Zussman
This has been unused since commit b6c1d8fcbade ("eCryptfs: remove
unused functions and kmem_cache") in 2007. Remove it.
Signed-off-by: Tal Zussman <tz2294@columbia.edu>
---
fs/ecryptfs/ecryptfs_kernel.h | 11 -----------
1 file changed, 11 deletions(-)
diff --git a/fs/ecryptfs/ecryptfs_kernel.h b/fs/ecryptfs/ecryptfs_kernel.h
index 3baccd4143e8..ff5cef83c79c 100644
--- a/fs/ecryptfs/ecryptfs_kernel.h
+++ b/fs/ecryptfs/ecryptfs_kernel.h
@@ -64,17 +64,6 @@ struct ecryptfs_auth_tok_list {
struct ecryptfs_crypt_stat;
struct ecryptfs_mount_crypt_stat;
-struct ecryptfs_page_crypt_context {
- struct page *page;
-#define ECRYPTFS_PREPARE_COMMIT_MODE 0
-#define ECRYPTFS_WRITEPAGE_MODE 1
- unsigned int mode;
- union {
- struct file *lower_file;
- struct writeback_control *wbc;
- } param;
-};
-
#if defined(CONFIG_ENCRYPTED_KEYS) || defined(CONFIG_ENCRYPTED_KEYS_MODULE)
static inline struct ecryptfs_auth_tok *
ecryptfs_get_encrypted_key_payload_data(struct key *key)
--
2.39.5
^ permalink raw reply [flat|nested] 9+ messages in thread* [PATCH 2/7] ecryptfs: use a folio and a buffer in crypt_extent()
2026-10-15 1:35 [PATCH 0/7] ecryptfs: remove the remaining struct page usage Tal Zussman
2026-10-15 1:35 ` [PATCH 1/7] ecryptfs: remove struct ecryptfs_page_crypt_context Tal Zussman
@ 2026-10-15 1:35 ` Tal Zussman
2026-10-15 1:35 ` [PATCH 3/7] ecryptfs: use kzalloc() for the header buffer Tal Zussman
` (5 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: Tal Zussman @ 2026-10-15 1:35 UTC (permalink / raw)
To: Tyler Hicks; +Cc: ecryptfs, linux-kernel, Matthew Wilcox (Oracle), Tal Zussman
crypt_extent() currently takes its source and destination as pages, so
ecryptfs_encrypt_page() and ecryptfs_decrypt_page() have to pass
folio_page() of the folio they are given, and the ciphertext buffer in
ecryptfs_encrypt_page() is allocated as a page to match.
The source is a page cache folio, so pass it as one and set up its
scatterlist with sg_set_folio(). The destination is not: it is a
temporary buffer that is only needed to be able to write to the lower
file. There is no reason for it to be a page or folio. Convert it to a
buffer instead, with NULL meaning the operation is done in place on
the folio, which is what ecryptfs_decrypt_page() does.
ecryptfs_encrypt_page() can then kmalloc() it and write it out without
mapping it. Allocate the buffer with GFP_KERNEL. There was no reason to
use GFP_USER as it had previously been doing.
Signed-off-by: Tal Zussman <tz2294@columbia.edu>
---
fs/ecryptfs/crypto.c | 47 ++++++++++++++++++++---------------------------
1 file changed, 20 insertions(+), 27 deletions(-)
diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
index e67119b6029c..9b8b0c5a81cd 100644
--- a/fs/ecryptfs/crypto.c
+++ b/fs/ecryptfs/crypto.c
@@ -271,8 +271,9 @@ static loff_t lower_offset_for_page(struct ecryptfs_crypt_stat *crypt_stat,
* crypt_extent
* @crypt_stat: crypt_stat containing cryptographic context for the
* encryption operation
- * @dst_page: The page to write the result into
- * @src_page: The page to read from
+ * @folio: The folio to read from
+ * @dst: The buffer to write the result into, or NULL to crypt the
+ * folio in place
* @page_index: The offset in the file (in units of PAGE_SIZE)
* @extent_offset: Page extent offset for use in generating IV
* @op: ENCRYPT or DECRYPT to indicate the desired operation
@@ -282,14 +283,12 @@ static loff_t lower_offset_for_page(struct ecryptfs_crypt_stat *crypt_stat,
* Return zero on success; non-zero otherwise
*/
static int crypt_extent(struct ecryptfs_crypt_stat *crypt_stat,
- struct page *dst_page,
- struct page *src_page,
- pgoff_t page_index,
+ struct folio *folio, void *dst, pgoff_t page_index,
unsigned long extent_offset, int op)
{
loff_t extent_base;
char extent_iv[ECRYPTFS_MAX_IV_BYTES];
- struct scatterlist src_sg, dst_sg;
+ struct scatterlist src_sg, dst_sg, *dst_sgp = &src_sg;
size_t extent_size = crypt_stat->extent_size;
int rc;
@@ -297,14 +296,15 @@ static int crypt_extent(struct ecryptfs_crypt_stat *crypt_stat,
ecryptfs_derive_iv(extent_iv, crypt_stat, extent_base + extent_offset);
sg_init_table(&src_sg, 1);
- sg_init_table(&dst_sg, 1);
-
- sg_set_page(&src_sg, src_page, extent_size,
- extent_offset * extent_size);
- sg_set_page(&dst_sg, dst_page, extent_size,
- extent_offset * extent_size);
+ sg_set_folio(&src_sg, folio, extent_size,
+ extent_offset * extent_size);
+ if (dst) {
+ sg_init_one(&dst_sg, dst + extent_offset * extent_size,
+ extent_size);
+ dst_sgp = &dst_sg;
+ }
- rc = crypt_scatterlist(crypt_stat, &dst_sg, &src_sg, extent_size,
+ rc = crypt_scatterlist(crypt_stat, dst_sgp, &src_sg, extent_size,
extent_iv, op);
if (rc < 0) {
printk(KERN_ERR "%s: Error attempting to crypt page with "
@@ -321,7 +321,7 @@ static int crypt_extent(struct ecryptfs_crypt_stat *crypt_stat,
* ecryptfs_encrypt_page
* @folio: Folio mapped from the eCryptfs inode for the file; contains
* decrypted content that needs to be encrypted (to a temporary
- * page; not in place) and written out to the lower file
+ * buffer; not in place) and written out to the lower file
*
* Encrypt an eCryptfs page. This is done on a per-extent basis. Note
* that eCryptfs pages may straddle the lower pages -- for instance,
@@ -338,7 +338,6 @@ int ecryptfs_encrypt_page(struct folio *folio)
struct inode *ecryptfs_inode;
struct ecryptfs_crypt_stat *crypt_stat;
char *enc_extent_virt;
- struct page *enc_extent_page = NULL;
loff_t extent_offset;
loff_t lower_offset;
int rc = 0;
@@ -347,8 +346,8 @@ int ecryptfs_encrypt_page(struct folio *folio)
crypt_stat =
&(ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat);
BUG_ON(!(crypt_stat->flags & ECRYPTFS_ENCRYPTED));
- enc_extent_page = alloc_page(GFP_USER);
- if (!enc_extent_page) {
+ enc_extent_virt = kmalloc(PAGE_SIZE, GFP_KERNEL);
+ if (!enc_extent_virt) {
rc = -ENOMEM;
ecryptfs_printk(KERN_ERR, "Error allocating memory for "
"encrypted extent\n");
@@ -358,9 +357,8 @@ int ecryptfs_encrypt_page(struct folio *folio)
for (extent_offset = 0;
extent_offset < (PAGE_SIZE / crypt_stat->extent_size);
extent_offset++) {
- rc = crypt_extent(crypt_stat, enc_extent_page,
- folio_page(folio, 0), folio->index,
- extent_offset, ENCRYPT);
+ rc = crypt_extent(crypt_stat, folio, enc_extent_virt,
+ folio->index, extent_offset, ENCRYPT);
if (rc) {
printk(KERN_ERR "%s: Error encrypting extent; "
"rc = [%d]\n", __func__, rc);
@@ -369,10 +367,8 @@ int ecryptfs_encrypt_page(struct folio *folio)
}
lower_offset = lower_offset_for_page(crypt_stat, folio);
- enc_extent_virt = kmap_local_page(enc_extent_page);
rc = ecryptfs_write_lower(ecryptfs_inode, enc_extent_virt, lower_offset,
PAGE_SIZE);
- kunmap_local(enc_extent_virt);
if (rc < 0) {
ecryptfs_printk(KERN_ERR,
"Error attempting to write lower page; rc = [%d]\n",
@@ -381,9 +377,7 @@ int ecryptfs_encrypt_page(struct folio *folio)
}
rc = 0;
out:
- if (enc_extent_page) {
- __free_page(enc_extent_page);
- }
+ kfree(enc_extent_virt);
return rc;
}
@@ -432,8 +426,7 @@ int ecryptfs_decrypt_page(struct folio *folio)
for (extent_offset = 0;
extent_offset < (PAGE_SIZE / crypt_stat->extent_size);
extent_offset++) {
- struct page *page = folio_page(folio, 0);
- rc = crypt_extent(crypt_stat, page, page, folio->index,
+ rc = crypt_extent(crypt_stat, folio, NULL, folio->index,
extent_offset, DECRYPT);
if (rc) {
printk(KERN_ERR "%s: Error decrypting extent; "
--
2.39.5
^ permalink raw reply [flat|nested] 9+ messages in thread* [PATCH 3/7] ecryptfs: use kzalloc() for the header buffer
2026-10-15 1:35 [PATCH 0/7] ecryptfs: remove the remaining struct page usage Tal Zussman
2026-10-15 1:35 ` [PATCH 1/7] ecryptfs: remove struct ecryptfs_page_crypt_context Tal Zussman
2026-10-15 1:35 ` [PATCH 2/7] ecryptfs: use a folio and a buffer in crypt_extent() Tal Zussman
@ 2026-10-15 1:35 ` Tal Zussman
2026-10-15 1:35 ` [PATCH 4/7] ecryptfs: use sg_init_one() instead of virt_to_scatterlist() Tal Zussman
` (4 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: Tal Zussman @ 2026-10-15 1:35 UTC (permalink / raw)
To: Tyler Hicks; +Cc: ecryptfs, linux-kernel, Matthew Wilcox (Oracle), Tal Zussman
ecryptfs_write_metadata() is only called when a file is created,
where ecryptfs_set_default_sizes() has set metadata_size to
ECRYPTFS_MINIMUM_HEADER_EXTENT_SIZE (8 KiB), or PAGE_SIZE if that is
larger. That is an acceptable size for kmalloc(), and the buffer is
only written out with kernel_write() or as an xattr, so it doesn't
need to be page-aligned. Allocate it with kzalloc() and remove
ecryptfs_get_zeroed_pages().
Signed-off-by: Tal Zussman <tz2294@columbia.edu>
---
fs/ecryptfs/crypto.c | 19 +++----------------
1 file changed, 3 insertions(+), 16 deletions(-)
diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
index 9b8b0c5a81cd..6a014872e919 100644
--- a/fs/ecryptfs/crypto.c
+++ b/fs/ecryptfs/crypto.c
@@ -998,17 +998,6 @@ ecryptfs_write_metadata_to_xattr(struct dentry *ecryptfs_dentry,
return rc;
}
-static unsigned long ecryptfs_get_zeroed_pages(gfp_t gfp_mask,
- unsigned int order)
-{
- struct page *page;
-
- page = alloc_pages(gfp_mask | __GFP_ZERO, order);
- if (page)
- return (unsigned long) page_address(page);
- return 0;
-}
-
/**
* ecryptfs_write_metadata
* @ecryptfs_dentry: The eCryptfs dentry, which should be negative
@@ -1027,7 +1016,6 @@ int ecryptfs_write_metadata(struct dentry *ecryptfs_dentry,
{
struct ecryptfs_crypt_stat *crypt_stat =
&ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat;
- unsigned int order;
char *virt;
size_t virt_len;
size_t size = 0;
@@ -1046,15 +1034,14 @@ int ecryptfs_write_metadata(struct dentry *ecryptfs_dentry,
goto out;
}
virt_len = crypt_stat->metadata_size;
- order = get_order(virt_len);
/* Released in this function */
- virt = (char *)ecryptfs_get_zeroed_pages(GFP_KERNEL, order);
+ virt = kzalloc(virt_len, GFP_KERNEL);
if (!virt) {
printk(KERN_ERR "%s: Out of memory\n", __func__);
rc = -ENOMEM;
goto out;
}
- /* Zeroed page ensures the in-header unencrypted i_size is set to 0 */
+ /* Zeroed buffer ensures the in-header unencrypted i_size is set to 0 */
rc = ecryptfs_write_headers_virt(virt, virt_len, &size, crypt_stat,
ecryptfs_dentry);
if (unlikely(rc)) {
@@ -1074,7 +1061,7 @@ int ecryptfs_write_metadata(struct dentry *ecryptfs_dentry,
goto out_free;
}
out_free:
- free_pages((unsigned long)virt, order);
+ kfree(virt);
out:
return rc;
}
--
2.39.5
^ permalink raw reply [flat|nested] 9+ messages in thread* [PATCH 4/7] ecryptfs: use sg_init_one() instead of virt_to_scatterlist()
2026-10-15 1:35 [PATCH 0/7] ecryptfs: remove the remaining struct page usage Tal Zussman
` (2 preceding siblings ...)
2026-10-15 1:35 ` [PATCH 3/7] ecryptfs: use kzalloc() for the header buffer Tal Zussman
@ 2026-10-15 1:35 ` Tal Zussman
2026-10-15 1:35 ` [PATCH 5/7] ecryptfs: zero the tail of the last folio in place on truncate Tal Zussman
` (3 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: Tal Zussman @ 2026-10-15 1:35 UTC (permalink / raw)
To: Tyler Hicks; +Cc: ecryptfs, linux-kernel, Matthew Wilcox (Oracle), Tal Zussman
Every caller passes a kmalloc()-ed buffer or an array inside a kmalloc()-ed
structure, which is physically contiguous and so fits in one
scatterlist entry. Use sg_init_one(), which can't fail, drop the
two-entry arrays and their length checks, and remove
virt_to_scatterlist() and the unused ECRYPTFS_MAX_SCATTERLIST_LEN.
Signed-off-by: Tal Zussman <tz2294@columbia.edu>
---
fs/ecryptfs/crypto.c | 46 -----------------
fs/ecryptfs/ecryptfs_kernel.h | 2 -
fs/ecryptfs/keystore.c | 114 +++++++++---------------------------------
3 files changed, 25 insertions(+), 137 deletions(-)
diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
index 6a014872e919..f0e67b48917f 100644
--- a/fs/ecryptfs/crypto.c
+++ b/fs/ecryptfs/crypto.c
@@ -149,50 +149,6 @@ void ecryptfs_destroy_mount_crypt_stat(
memset(mount_crypt_stat, 0, sizeof(struct ecryptfs_mount_crypt_stat));
}
-/**
- * virt_to_scatterlist
- * @addr: Virtual address
- * @size: Size of data; should be an even multiple of the block size
- * @sg: Pointer to scatterlist array; set to NULL to obtain only
- * the number of scatterlist structs required in array
- * @sg_size: Max array size
- *
- * Fills in a scatterlist array with page references for a passed
- * virtual address.
- *
- * Returns the number of scatterlist structs in array used
- */
-int virt_to_scatterlist(const void *addr, int size, struct scatterlist *sg,
- int sg_size)
-{
- int i = 0;
- struct page *pg;
- int offset;
- int remainder_of_page;
-
- sg_init_table(sg, sg_size);
-
- while (size > 0 && i < sg_size) {
- pg = virt_to_page(addr);
- offset = offset_in_page(addr);
- sg_set_page(&sg[i], pg, 0, offset);
- remainder_of_page = PAGE_SIZE - offset;
- if (size >= remainder_of_page) {
- sg[i].length = remainder_of_page;
- addr += remainder_of_page;
- size -= remainder_of_page;
- } else {
- sg[i].length = size;
- addr += size;
- size = 0;
- }
- i++;
- }
- if (size > 0)
- return -ENOMEM;
- return i;
-}
-
/**
* crypt_scatterlist
* @crypt_stat: Pointer to the crypt_stat struct to initialize.
@@ -438,8 +394,6 @@ int ecryptfs_decrypt_page(struct folio *folio)
return rc;
}
-#define ECRYPTFS_MAX_SCATTERLIST_LEN 4
-
/**
* ecryptfs_init_crypt_ctx
* @crypt_stat: Uninitialized crypt stats structure
diff --git a/fs/ecryptfs/ecryptfs_kernel.h b/fs/ecryptfs/ecryptfs_kernel.h
index ff5cef83c79c..6a74a2bfc833 100644
--- a/fs/ecryptfs/ecryptfs_kernel.h
+++ b/fs/ecryptfs/ecryptfs_kernel.h
@@ -541,8 +541,6 @@ int ecryptfs_encrypt_and_encode_filename(
struct ecryptfs_mount_crypt_stat *mount_crypt_stat,
const char *name, size_t name_size);
void ecryptfs_dump_hex(char *data, int bytes);
-int virt_to_scatterlist(const void *addr, int size, struct scatterlist *sg,
- int sg_size);
int ecryptfs_compute_root_iv(struct ecryptfs_crypt_stat *crypt_stat);
void ecryptfs_rotate_iv(unsigned char *iv);
void ecryptfs_init_crypt_stat(struct ecryptfs_crypt_stat *crypt_stat);
diff --git a/fs/ecryptfs/keystore.c b/fs/ecryptfs/keystore.c
index 51651314b7a6..051f7948cf52 100644
--- a/fs/ecryptfs/keystore.c
+++ b/fs/ecryptfs/keystore.c
@@ -595,8 +595,8 @@ struct ecryptfs_write_tag_70_packet_silly_stack {
struct mutex *tfm_mutex;
char *block_aligned_filename;
struct ecryptfs_auth_tok *auth_tok;
- struct scatterlist src_sg[2];
- struct scatterlist dst_sg[2];
+ struct scatterlist src_sg;
+ struct scatterlist dst_sg;
struct crypto_skcipher *skcipher_tfm;
struct skcipher_request *skcipher_req;
char iv[ECRYPTFS_MAX_IV_BYTES];
@@ -751,24 +751,9 @@ ecryptfs_write_tag_70_packet(char *dest, size_t *remaining_bytes,
}
memcpy(&s->block_aligned_filename[s->num_rand_bytes], filename,
filename_size);
- rc = virt_to_scatterlist(s->block_aligned_filename,
- s->block_aligned_filename_size, s->src_sg, 2);
- if (rc < 1) {
- printk(KERN_ERR "%s: Internal error whilst attempting to "
- "convert filename memory to scatterlist; rc = [%d]. "
- "block_aligned_filename_size = [%zd]\n", __func__, rc,
- s->block_aligned_filename_size);
- goto out_free_unlock;
- }
- rc = virt_to_scatterlist(&dest[s->i], s->block_aligned_filename_size,
- s->dst_sg, 2);
- if (rc < 1) {
- printk(KERN_ERR "%s: Internal error whilst attempting to "
- "convert encrypted filename memory to scatterlist; "
- "rc = [%d]. block_aligned_filename_size = [%zd]\n",
- __func__, rc, s->block_aligned_filename_size);
- goto out_free_unlock;
- }
+ sg_init_one(&s->src_sg, s->block_aligned_filename,
+ s->block_aligned_filename_size);
+ sg_init_one(&s->dst_sg, &dest[s->i], s->block_aligned_filename_size);
/* The characters in the first block effectively do the job
* of the IV here, so we just use 0's for the IV. Note the
* constraint that ECRYPTFS_FILENAME_MIN_RANDOM_PREPEND_BYTES
@@ -787,7 +772,7 @@ ecryptfs_write_tag_70_packet(char *dest, size_t *remaining_bytes,
mount_crypt_stat->global_default_fn_cipher_key_bytes);
goto out_free_unlock;
}
- skcipher_request_set_crypt(s->skcipher_req, s->src_sg, s->dst_sg,
+ skcipher_request_set_crypt(s->skcipher_req, &s->src_sg, &s->dst_sg,
s->block_aligned_filename_size, s->iv);
rc = crypto_skcipher_encrypt(s->skcipher_req);
if (rc) {
@@ -823,8 +808,8 @@ struct ecryptfs_parse_tag_70_packet_silly_stack {
struct mutex *tfm_mutex;
char *decrypted_filename;
struct ecryptfs_auth_tok *auth_tok;
- struct scatterlist src_sg[2];
- struct scatterlist dst_sg[2];
+ struct scatterlist src_sg;
+ struct scatterlist dst_sg;
struct crypto_skcipher *skcipher_tfm;
struct skcipher_request *skcipher_req;
char fnek_sig_hex[ECRYPTFS_SIG_SIZE_HEX + 1];
@@ -943,15 +928,8 @@ ecryptfs_parse_tag_70_packet(char **filename, size_t *filename_size,
goto out;
}
mutex_lock(s->tfm_mutex);
- rc = virt_to_scatterlist(&data[(*packet_size)],
- s->block_aligned_filename_size, s->src_sg, 2);
- if (rc < 1) {
- printk(KERN_ERR "%s: Internal error whilst attempting to "
- "convert encrypted filename memory to scatterlist; "
- "rc = [%d]. block_aligned_filename_size = [%zd]\n",
- __func__, rc, s->block_aligned_filename_size);
- goto out_unlock;
- }
+ sg_init_one(&s->src_sg, &data[(*packet_size)],
+ s->block_aligned_filename_size);
(*packet_size) += s->block_aligned_filename_size;
s->decrypted_filename = kmalloc(s->block_aligned_filename_size,
GFP_KERNEL);
@@ -959,15 +937,8 @@ ecryptfs_parse_tag_70_packet(char **filename, size_t *filename_size,
rc = -ENOMEM;
goto out_unlock;
}
- rc = virt_to_scatterlist(s->decrypted_filename,
- s->block_aligned_filename_size, s->dst_sg, 2);
- if (rc < 1) {
- printk(KERN_ERR "%s: Internal error whilst attempting to "
- "convert decrypted filename memory to scatterlist; "
- "rc = [%d]. block_aligned_filename_size = [%zd]\n",
- __func__, rc, s->block_aligned_filename_size);
- goto out_free_unlock;
- }
+ sg_init_one(&s->dst_sg, s->decrypted_filename,
+ s->block_aligned_filename_size);
s->skcipher_req = skcipher_request_alloc(s->skcipher_tfm, GFP_KERNEL);
if (!s->skcipher_req) {
@@ -1007,7 +978,7 @@ ecryptfs_parse_tag_70_packet(char **filename, size_t *filename_size,
mount_crypt_stat->global_default_fn_cipher_key_bytes);
goto out_free_unlock;
}
- skcipher_request_set_crypt(s->skcipher_req, s->src_sg, s->dst_sg,
+ skcipher_request_set_crypt(s->skcipher_req, &s->src_sg, &s->dst_sg,
s->block_aligned_filename_size, s->iv);
rc = crypto_skcipher_decrypt(s->skcipher_req);
if (rc) {
@@ -1625,8 +1596,8 @@ static int
decrypt_passphrase_encrypted_session_key(struct ecryptfs_auth_tok *auth_tok,
struct ecryptfs_crypt_stat *crypt_stat)
{
- struct scatterlist dst_sg[2];
- struct scatterlist src_sg[2];
+ struct scatterlist dst_sg;
+ struct scatterlist src_sg;
struct mutex *tfm_mutex;
struct crypto_skcipher *tfm;
struct skcipher_request *req = NULL;
@@ -1648,28 +1619,12 @@ decrypt_passphrase_encrypted_session_key(struct ecryptfs_auth_tok *auth_tok,
crypt_stat->cipher, rc);
goto out;
}
- rc = virt_to_scatterlist(auth_tok->session_key.encrypted_key,
- auth_tok->session_key.encrypted_key_size,
- src_sg, 2);
- if (rc < 1 || rc > 2) {
- printk(KERN_ERR "Internal error whilst attempting to convert "
- "auth_tok->session_key.encrypted_key to scatterlist; "
- "expected rc = 1; got rc = [%d]. "
- "auth_tok->session_key.encrypted_key_size = [%d]\n", rc,
- auth_tok->session_key.encrypted_key_size);
- goto out;
- }
+ sg_init_one(&src_sg, auth_tok->session_key.encrypted_key,
+ auth_tok->session_key.encrypted_key_size);
auth_tok->session_key.decrypted_key_size =
auth_tok->session_key.encrypted_key_size;
- rc = virt_to_scatterlist(auth_tok->session_key.decrypted_key,
- auth_tok->session_key.decrypted_key_size,
- dst_sg, 2);
- if (rc < 1 || rc > 2) {
- printk(KERN_ERR "Internal error whilst attempting to convert "
- "auth_tok->session_key.decrypted_key to scatterlist; "
- "expected rc = 1; got rc = [%d]\n", rc);
- goto out;
- }
+ sg_init_one(&dst_sg, auth_tok->session_key.decrypted_key,
+ auth_tok->session_key.decrypted_key_size);
mutex_lock(tfm_mutex);
req = skcipher_request_alloc(tfm, GFP_KERNEL);
if (!req) {
@@ -1692,7 +1647,7 @@ decrypt_passphrase_encrypted_session_key(struct ecryptfs_auth_tok *auth_tok,
rc = -EINVAL;
goto out;
}
- skcipher_request_set_crypt(req, src_sg, dst_sg,
+ skcipher_request_set_crypt(req, &src_sg, &dst_sg,
auth_tok->session_key.encrypted_key_size,
NULL);
rc = crypto_skcipher_decrypt(req);
@@ -2166,8 +2121,8 @@ write_tag_3_packet(char *dest, size_t *remaining_bytes,
size_t i;
size_t encrypted_session_key_valid = 0;
char session_key_encryption_key[ECRYPTFS_MAX_KEY_BYTES];
- struct scatterlist dst_sg[2];
- struct scatterlist src_sg[2];
+ struct scatterlist dst_sg;
+ struct scatterlist src_sg;
struct mutex *tfm_mutex = NULL;
u8 cipher_code;
size_t packet_size_length;
@@ -2242,27 +2197,8 @@ write_tag_3_packet(char *dest, size_t *remaining_bytes,
ecryptfs_printk(KERN_DEBUG, "Session key encryption key:\n");
ecryptfs_dump_hex(session_key_encryption_key, 16);
}
- rc = virt_to_scatterlist(crypt_stat->key, key_rec->enc_key_size,
- src_sg, 2);
- if (rc < 1 || rc > 2) {
- ecryptfs_printk(KERN_ERR, "Error generating scatterlist "
- "for crypt_stat session key; expected rc = 1; "
- "got rc = [%d]. key_rec->enc_key_size = [%zd]\n",
- rc, key_rec->enc_key_size);
- rc = -ENOMEM;
- goto out;
- }
- rc = virt_to_scatterlist(key_rec->enc_key, key_rec->enc_key_size,
- dst_sg, 2);
- if (rc < 1 || rc > 2) {
- ecryptfs_printk(KERN_ERR, "Error generating scatterlist "
- "for crypt_stat encrypted session key; "
- "expected rc = 1; got rc = [%d]. "
- "key_rec->enc_key_size = [%zd]\n", rc,
- key_rec->enc_key_size);
- rc = -ENOMEM;
- goto out;
- }
+ sg_init_one(&src_sg, crypt_stat->key, key_rec->enc_key_size);
+ sg_init_one(&dst_sg, key_rec->enc_key, key_rec->enc_key_size);
mutex_lock(tfm_mutex);
rc = crypto_skcipher_setkey(tfm, session_key_encryption_key,
crypt_stat->key_size);
@@ -2289,7 +2225,7 @@ write_tag_3_packet(char *dest, size_t *remaining_bytes,
rc = 0;
ecryptfs_printk(KERN_DEBUG, "Encrypting [%zd] bytes of the key\n",
crypt_stat->key_size);
- skcipher_request_set_crypt(req, src_sg, dst_sg,
+ skcipher_request_set_crypt(req, &src_sg, &dst_sg,
(*key_rec).enc_key_size, NULL);
rc = crypto_skcipher_encrypt(req);
mutex_unlock(tfm_mutex);
--
2.39.5
^ permalink raw reply [flat|nested] 9+ messages in thread* [PATCH 5/7] ecryptfs: zero the tail of the last folio in place on truncate
2026-10-15 1:35 [PATCH 0/7] ecryptfs: remove the remaining struct page usage Tal Zussman
` (3 preceding siblings ...)
2026-10-15 1:35 ` [PATCH 4/7] ecryptfs: use sg_init_one() instead of virt_to_scatterlist() Tal Zussman
@ 2026-10-15 1:35 ` Tal Zussman
2026-10-15 1:35 ` [PATCH 6/7] ecryptfs: rename functions to refer to folios Tal Zussman
` (2 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: Tal Zussman @ 2026-10-15 1:35 UTC (permalink / raw)
To: Tyler Hicks; +Cc: ecryptfs, linux-kernel, Matthew Wilcox (Oracle), Tal Zussman
A shrinking truncate zeroes the rest of the folio that holds the new
end of the file by copying from the zero page through ecryptfs_write().
Zero the folio in place with folio_zero_range() instead, the way the
truncate helpers in other filesystems do, and encrypt it to the lower
file. This no longer bumps i_size to the end of the folio and writes
that to the metadata before the real size is written. It also removes
the last struct page usage in ecryptfs.
Signed-off-by: Tal Zussman <tz2294@columbia.edu>
---
fs/ecryptfs/inode.c | 49 ++++++++++++++++++++++++++++++++++++-------------
1 file changed, 36 insertions(+), 13 deletions(-)
diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index 525297c7ebd8..c743b0f2ab4b 100644
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -718,6 +718,34 @@ upper_size_to_lower_size(struct ecryptfs_crypt_stat *crypt_stat,
return lower_size;
}
+/**
+ * ecryptfs_zero_tail
+ * @inode: The ecryptfs inode
+ * @pos: The file offset from which to zero
+ *
+ * Zero the folio that holds @pos from @pos to its end, and write the
+ * result out to the lower file.
+ *
+ * Returns zero on success; non-zero otherwise
+ */
+static int ecryptfs_zero_tail(struct inode *inode, loff_t pos)
+{
+ struct folio *folio;
+ size_t from;
+ int rc;
+
+ folio = read_mapping_folio(inode->i_mapping, pos >> PAGE_SHIFT, NULL);
+ if (IS_ERR(folio))
+ return PTR_ERR(folio);
+ from = offset_in_folio(folio, pos);
+ folio_lock(folio);
+ folio_zero_range(folio, from, folio_size(folio) - from);
+ folio_unlock(folio);
+ rc = ecryptfs_encrypt_page(folio);
+ folio_put(folio);
+ return rc;
+}
+
/**
* __ecryptfs_truncate
* @dentry: The ecryptfs layer dentry
@@ -739,7 +767,6 @@ static int __ecryptfs_truncate(struct dentry *dentry, const struct iattr *ia)
loff_t lower_size_before_truncate;
loff_t lower_size_after_truncate;
struct iattr lower_ia;
- size_t num_zeros;
int rc;
ecryptfs_iattr_to_lower(&lower_ia, ia);
@@ -788,19 +815,15 @@ static int __ecryptfs_truncate(struct dentry *dentry, const struct iattr *ia)
}
/*
- * We're chopping off all the pages down to the page in which
- * ia->ia_size is located. Fill in the end of that page from
- * (ia->ia_size & ~PAGE_MASK) to PAGE_SIZE with zeros.
+ * We're chopping off all the folios down to the folio in which
+ * ia->ia_size is located. Fill in the end of that folio from
+ * ia->ia_size with zeros.
*/
- num_zeros = PAGE_SIZE - (ia->ia_size & ~PAGE_MASK);
- if (num_zeros) {
- rc = ecryptfs_write(inode, page_address(ZERO_PAGE(0)),
- ia->ia_size, num_zeros);
- if (rc) {
- pr_err("Error attempting to zero out the remainder of the end page on reducing truncate; rc = [%d]\n",
- rc);
- goto out;
- }
+ rc = ecryptfs_zero_tail(inode, ia->ia_size);
+ if (rc) {
+ pr_err("Error attempting to zero out the remainder of the end folio on reducing truncate; rc = [%d]\n",
+ rc);
+ goto out;
}
truncate_setsize(inode, ia->ia_size);
rc = ecryptfs_write_inode_size_to_metadata(inode);
--
2.39.5
^ permalink raw reply [flat|nested] 9+ messages in thread* [PATCH 6/7] ecryptfs: rename functions to refer to folios
2026-10-15 1:35 [PATCH 0/7] ecryptfs: remove the remaining struct page usage Tal Zussman
` (4 preceding siblings ...)
2026-10-15 1:35 ` [PATCH 5/7] ecryptfs: zero the tail of the last folio in place on truncate Tal Zussman
@ 2026-10-15 1:35 ` Tal Zussman
2026-10-15 1:35 ` [PATCH 7/7] ecryptfs: refer to folios in comments and printk strings Tal Zussman
2026-10-22 16:30 ` [PATCH 0/7] ecryptfs: remove the remaining struct page usage Tal Zussman
7 siblings, 0 replies; 9+ messages in thread
From: Tal Zussman @ 2026-10-15 1:35 UTC (permalink / raw)
To: Tyler Hicks; +Cc: ecryptfs, linux-kernel, Matthew Wilcox (Oracle), Tal Zussman
ecryptfs_encrypt_page(), ecryptfs_decrypt_page(),
ecryptfs_read_lower_page_segment(), ecryptfs_write_lower_page_segment(),
lower_offset_for_page() and fill_zeros_to_end_of_page() all take a folio
now. Rename them accordingly.
Signed-off-by: Tal Zussman <tz2294@columbia.edu>
---
fs/ecryptfs/crypto.c | 16 ++++++++--------
fs/ecryptfs/ecryptfs_kernel.h | 8 ++++----
fs/ecryptfs/inode.c | 2 +-
fs/ecryptfs/mmap.c | 26 +++++++++++++-------------
fs/ecryptfs/read_write.c | 12 ++++++------
5 files changed, 32 insertions(+), 32 deletions(-)
diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
index f0e67b48917f..bbaeb9a38db0 100644
--- a/fs/ecryptfs/crypto.c
+++ b/fs/ecryptfs/crypto.c
@@ -212,11 +212,11 @@ static int crypt_scatterlist(struct ecryptfs_crypt_stat *crypt_stat,
}
/*
- * lower_offset_for_page
+ * lower_offset_for_folio
*
* Convert an eCryptfs page index into a lower byte offset
*/
-static loff_t lower_offset_for_page(struct ecryptfs_crypt_stat *crypt_stat,
+static loff_t lower_offset_for_folio(struct ecryptfs_crypt_stat *crypt_stat,
struct folio *folio)
{
return ecryptfs_lower_header_size(crypt_stat) +
@@ -274,7 +274,7 @@ static int crypt_extent(struct ecryptfs_crypt_stat *crypt_stat,
}
/**
- * ecryptfs_encrypt_page
+ * ecryptfs_encrypt_folio
* @folio: Folio mapped from the eCryptfs inode for the file; contains
* decrypted content that needs to be encrypted (to a temporary
* buffer; not in place) and written out to the lower file
@@ -289,7 +289,7 @@ static int crypt_extent(struct ecryptfs_crypt_stat *crypt_stat,
*
* Returns zero on success; negative on error
*/
-int ecryptfs_encrypt_page(struct folio *folio)
+int ecryptfs_encrypt_folio(struct folio *folio)
{
struct inode *ecryptfs_inode;
struct ecryptfs_crypt_stat *crypt_stat;
@@ -322,7 +322,7 @@ int ecryptfs_encrypt_page(struct folio *folio)
}
}
- lower_offset = lower_offset_for_page(crypt_stat, folio);
+ lower_offset = lower_offset_for_folio(crypt_stat, folio);
rc = ecryptfs_write_lower(ecryptfs_inode, enc_extent_virt, lower_offset,
PAGE_SIZE);
if (rc < 0) {
@@ -338,7 +338,7 @@ int ecryptfs_encrypt_page(struct folio *folio)
}
/**
- * ecryptfs_decrypt_page
+ * ecryptfs_decrypt_folio
* @folio: Folio mapped from the eCryptfs inode for the file; data read
* and decrypted from the lower file will be written into this
* page
@@ -353,7 +353,7 @@ int ecryptfs_encrypt_page(struct folio *folio)
*
* Returns zero on success; negative on error
*/
-int ecryptfs_decrypt_page(struct folio *folio)
+int ecryptfs_decrypt_folio(struct folio *folio)
{
struct inode *ecryptfs_inode;
struct ecryptfs_crypt_stat *crypt_stat;
@@ -367,7 +367,7 @@ int ecryptfs_decrypt_page(struct folio *folio)
&(ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat);
BUG_ON(!(crypt_stat->flags & ECRYPTFS_ENCRYPTED));
- lower_offset = lower_offset_for_page(crypt_stat, folio);
+ lower_offset = lower_offset_for_folio(crypt_stat, folio);
page_virt = kmap_local_folio(folio, 0);
rc = ecryptfs_read_lower(page_virt, lower_offset, PAGE_SIZE,
ecryptfs_inode);
diff --git a/fs/ecryptfs/ecryptfs_kernel.h b/fs/ecryptfs/ecryptfs_kernel.h
index 6a74a2bfc833..5c7cfb956455 100644
--- a/fs/ecryptfs/ecryptfs_kernel.h
+++ b/fs/ecryptfs/ecryptfs_kernel.h
@@ -549,8 +549,8 @@ void ecryptfs_destroy_mount_crypt_stat(
struct ecryptfs_mount_crypt_stat *mount_crypt_stat);
int ecryptfs_init_crypt_ctx(struct ecryptfs_crypt_stat *crypt_stat);
int ecryptfs_write_inode_size_to_metadata(struct inode *ecryptfs_inode);
-int ecryptfs_encrypt_page(struct folio *folio);
-int ecryptfs_decrypt_page(struct folio *folio);
+int ecryptfs_encrypt_folio(struct folio *folio);
+int ecryptfs_decrypt_folio(struct folio *folio);
int ecryptfs_write_metadata(struct dentry *ecryptfs_dentry,
struct inode *ecryptfs_inode);
int ecryptfs_read_metadata(struct dentry *ecryptfs_dentry);
@@ -633,13 +633,13 @@ int ecryptfs_keyring_auth_tok_for_sig(struct key **auth_tok_key,
char *sig);
int ecryptfs_write_lower(struct inode *ecryptfs_inode, char *data,
loff_t offset, size_t size);
-int ecryptfs_write_lower_page_segment(struct inode *ecryptfs_inode,
+int ecryptfs_write_lower_folio_segment(struct inode *ecryptfs_inode,
struct folio *folio_for_lower,
size_t offset_in_page, size_t size);
int ecryptfs_write(struct inode *inode, char *data, loff_t offset, size_t size);
int ecryptfs_read_lower(char *data, loff_t offset, size_t size,
struct inode *ecryptfs_inode);
-int ecryptfs_read_lower_page_segment(struct folio *folio_for_ecryptfs,
+int ecryptfs_read_lower_folio_segment(struct folio *folio_for_ecryptfs,
pgoff_t page_index,
size_t offset_in_page, size_t size,
struct inode *ecryptfs_inode);
diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index c743b0f2ab4b..ffd6da87c8ca 100644
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -741,7 +741,7 @@ static int ecryptfs_zero_tail(struct inode *inode, loff_t pos)
folio_lock(folio);
folio_zero_range(folio, from, folio_size(folio) - from);
folio_unlock(folio);
- rc = ecryptfs_encrypt_page(folio);
+ rc = ecryptfs_encrypt_folio(folio);
folio_put(folio);
return rc;
}
diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index 07a6c8448100..d841610644ed 100644
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -34,7 +34,7 @@ static int ecryptfs_writepages(struct address_space *mapping,
int error;
while ((folio = writeback_iter(mapping, wbc, folio, &error))) {
- error = ecryptfs_encrypt_page(folio);
+ error = ecryptfs_encrypt_folio(folio);
if (error) {
ecryptfs_printk(KERN_WARNING,
"Error encrypting folio (index [0x%.16lx])\n",
@@ -133,7 +133,7 @@ ecryptfs_copy_up_encrypted_with_header(struct folio *folio,
((view_extent_num * crypt_stat->extent_size)
- crypt_stat->metadata_size);
- rc = ecryptfs_read_lower_page_segment(
+ rc = ecryptfs_read_lower_folio_segment(
folio, (lower_offset >> PAGE_SHIFT),
(lower_offset & ~PAGE_MASK),
crypt_stat->extent_size, folio->mapping->host);
@@ -168,7 +168,7 @@ static int ecryptfs_read_folio(struct file *file, struct folio *folio)
int err = 0;
if (!crypt_stat || !(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
- err = ecryptfs_read_lower_page_segment(folio, folio->index, 0,
+ err = ecryptfs_read_lower_folio_segment(folio, folio->index, 0,
folio_size(folio), inode);
} else if (crypt_stat->flags & ECRYPTFS_VIEW_AS_ENCRYPTED) {
if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR) {
@@ -184,7 +184,7 @@ static int ecryptfs_read_folio(struct file *file, struct folio *folio)
}
} else {
- err = ecryptfs_read_lower_page_segment(folio,
+ err = ecryptfs_read_lower_folio_segment(folio,
folio->index, 0, folio_size(folio),
inode);
if (err) {
@@ -194,7 +194,7 @@ static int ecryptfs_read_folio(struct file *file, struct folio *folio)
}
}
} else {
- err = ecryptfs_decrypt_page(folio);
+ err = ecryptfs_decrypt_folio(folio);
if (err) {
ecryptfs_printk(KERN_ERR, "Error decrypting page; "
"err = [%d]\n", err);
@@ -211,7 +211,7 @@ static int ecryptfs_read_folio(struct file *file, struct folio *folio)
/*
* Called with lower inode mutex held.
*/
-static int fill_zeros_to_end_of_page(struct folio *folio, unsigned int to)
+static int fill_zeros_to_end_of_folio(struct folio *folio, unsigned int to)
{
struct inode *inode = folio->mapping->host;
int end_byte_in_page;
@@ -261,7 +261,7 @@ static int ecryptfs_write_begin(const struct kiocb *iocb,
&ecryptfs_inode_to_private(mapping->host)->crypt_stat;
if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
- rc = ecryptfs_read_lower_page_segment(
+ rc = ecryptfs_read_lower_folio_segment(
folio, index, 0, PAGE_SIZE, mapping->host);
if (rc) {
printk(KERN_ERR "%s: Error attempting to read "
@@ -287,7 +287,7 @@ static int ecryptfs_write_begin(const struct kiocb *iocb,
}
folio_mark_uptodate(folio);
} else {
- rc = ecryptfs_read_lower_page_segment(
+ rc = ecryptfs_read_lower_folio_segment(
folio, index, 0, PAGE_SIZE,
mapping->host);
if (rc) {
@@ -305,7 +305,7 @@ static int ecryptfs_write_begin(const struct kiocb *iocb,
folio_zero_range(folio, 0, PAGE_SIZE);
folio_mark_uptodate(folio);
} else if (len < PAGE_SIZE) {
- rc = ecryptfs_decrypt_page(folio);
+ rc = ecryptfs_decrypt_folio(folio);
if (rc) {
printk(KERN_ERR "%s: Error decrypting "
"page at index [%ld]; "
@@ -443,10 +443,10 @@ static int ecryptfs_write_end(const struct kiocb *iocb,
&ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat;
int rc;
- ecryptfs_printk(KERN_DEBUG, "Calling fill_zeros_to_end_of_page"
+ ecryptfs_printk(KERN_DEBUG, "Calling fill_zeros_to_end_of_folio"
"(page w/ index = [0x%.16lx], to = [%d])\n", index, to);
if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
- rc = ecryptfs_write_lower_page_segment(ecryptfs_inode,
+ rc = ecryptfs_write_lower_folio_segment(ecryptfs_inode,
folio, 0, to);
if (!rc) {
rc = copied;
@@ -463,13 +463,13 @@ static int ecryptfs_write_end(const struct kiocb *iocb,
folio_mark_uptodate(folio);
}
/* Fills in zeros if 'to' goes beyond inode size */
- rc = fill_zeros_to_end_of_page(folio, to);
+ rc = fill_zeros_to_end_of_folio(folio, to);
if (rc) {
ecryptfs_printk(KERN_WARNING, "Error attempting to fill "
"zeros in page with index = [0x%.16lx]\n", index);
goto out;
}
- rc = ecryptfs_encrypt_page(folio);
+ rc = ecryptfs_encrypt_folio(folio);
if (rc) {
ecryptfs_printk(KERN_WARNING, "Error encrypting page (upper "
"index [0x%.16lx])\n", index);
diff --git a/fs/ecryptfs/read_write.c b/fs/ecryptfs/read_write.c
index b3b451c2b941..611f74061441 100644
--- a/fs/ecryptfs/read_write.c
+++ b/fs/ecryptfs/read_write.c
@@ -39,7 +39,7 @@ int ecryptfs_write_lower(struct inode *ecryptfs_inode, char *data,
}
/**
- * ecryptfs_write_lower_page_segment
+ * ecryptfs_write_lower_folio_segment
* @ecryptfs_inode: The eCryptfs inode
* @folio_for_lower: The folio containing the data to be written to the
* lower file
@@ -54,7 +54,7 @@ int ecryptfs_write_lower(struct inode *ecryptfs_inode, char *data,
*
* Returns zero on success; non-zero otherwise
*/
-int ecryptfs_write_lower_page_segment(struct inode *ecryptfs_inode,
+int ecryptfs_write_lower_folio_segment(struct inode *ecryptfs_inode,
struct folio *folio_for_lower,
size_t offset_in_page, size_t size)
{
@@ -168,9 +168,9 @@ int ecryptfs_write(struct inode *ecryptfs_inode, char *data, loff_t offset,
folio_mark_uptodate(ecryptfs_folio);
folio_unlock(ecryptfs_folio);
if (crypt_stat->flags & ECRYPTFS_ENCRYPTED)
- rc = ecryptfs_encrypt_page(ecryptfs_folio);
+ rc = ecryptfs_encrypt_folio(ecryptfs_folio);
else
- rc = ecryptfs_write_lower_page_segment(ecryptfs_inode,
+ rc = ecryptfs_write_lower_folio_segment(ecryptfs_inode,
ecryptfs_folio,
start_offset_in_page,
data_offset);
@@ -227,7 +227,7 @@ int ecryptfs_read_lower(char *data, loff_t offset, size_t size,
}
/**
- * ecryptfs_read_lower_page_segment
+ * ecryptfs_read_lower_folio_segment
* @folio_for_ecryptfs: The folio into which data for eCryptfs will be
* written
* @page_index: Page index in @page_for_ecryptfs from which to start
@@ -243,7 +243,7 @@ int ecryptfs_read_lower(char *data, loff_t offset, size_t size,
*
* Returns zero on success; non-zero otherwise
*/
-int ecryptfs_read_lower_page_segment(struct folio *folio_for_ecryptfs,
+int ecryptfs_read_lower_folio_segment(struct folio *folio_for_ecryptfs,
pgoff_t page_index,
size_t offset_in_page, size_t size,
struct inode *ecryptfs_inode)
--
2.39.5
^ permalink raw reply [flat|nested] 9+ messages in thread* [PATCH 7/7] ecryptfs: refer to folios in comments and printk strings
2026-10-15 1:35 [PATCH 0/7] ecryptfs: remove the remaining struct page usage Tal Zussman
` (5 preceding siblings ...)
2026-10-15 1:35 ` [PATCH 6/7] ecryptfs: rename functions to refer to folios Tal Zussman
@ 2026-10-15 1:35 ` Tal Zussman
2026-10-22 16:30 ` [PATCH 0/7] ecryptfs: remove the remaining struct page usage Tal Zussman
7 siblings, 0 replies; 9+ messages in thread
From: Tal Zussman @ 2026-10-15 1:35 UTC (permalink / raw)
To: Tyler Hicks; +Cc: ecryptfs, linux-kernel, Matthew Wilcox (Oracle), Tal Zussman
Update the comments and printk strings to refer to folios instead of
pages. While at it, join the strings that were split across lines, use
pr_err() for the printk(KERN_ERR) calls among them, and fix the block
comment style.
Signed-off-by: Tal Zussman <tz2294@columbia.edu>
---
fs/ecryptfs/crypto.c | 17 ++++++++---------
fs/ecryptfs/mmap.c | 36 +++++++++++++++++-------------------
fs/ecryptfs/read_write.c | 36 ++++++++++++++++++------------------
3 files changed, 43 insertions(+), 46 deletions(-)
diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
index bbaeb9a38db0..d426dc95517c 100644
--- a/fs/ecryptfs/crypto.c
+++ b/fs/ecryptfs/crypto.c
@@ -214,7 +214,7 @@ static int crypt_scatterlist(struct ecryptfs_crypt_stat *crypt_stat,
/*
* lower_offset_for_folio
*
- * Convert an eCryptfs page index into a lower byte offset
+ * Convert an eCryptfs folio index into a lower byte offset
*/
static loff_t lower_offset_for_folio(struct ecryptfs_crypt_stat *crypt_stat,
struct folio *folio)
@@ -263,9 +263,8 @@ static int crypt_extent(struct ecryptfs_crypt_stat *crypt_stat,
rc = crypt_scatterlist(crypt_stat, dst_sgp, &src_sg, extent_size,
extent_iv, op);
if (rc < 0) {
- printk(KERN_ERR "%s: Error attempting to crypt page with "
- "page_index = [%ld], extent_offset = [%ld]; "
- "rc = [%d]\n", __func__, page_index, extent_offset, rc);
+ pr_err("%s: Error attempting to crypt folio with page_index = [%ld], extent_offset = [%ld]; rc = [%d]\n",
+ __func__, page_index, extent_offset, rc);
goto out;
}
rc = 0;
@@ -279,8 +278,8 @@ static int crypt_extent(struct ecryptfs_crypt_stat *crypt_stat,
* decrypted content that needs to be encrypted (to a temporary
* buffer; not in place) and written out to the lower file
*
- * Encrypt an eCryptfs page. This is done on a per-extent basis. Note
- * that eCryptfs pages may straddle the lower pages -- for instance,
+ * Encrypt an eCryptfs folio. This is done on a per-extent basis. Note
+ * that eCryptfs folios may straddle the lower pages -- for instance,
* if the file was created on a machine with an 8K page size
* (resulting in an 8K header), and then the file is copied onto a
* host with a 32K page size, then when reading page 0 of the eCryptfs
@@ -341,10 +340,10 @@ int ecryptfs_encrypt_folio(struct folio *folio)
* ecryptfs_decrypt_folio
* @folio: Folio mapped from the eCryptfs inode for the file; data read
* and decrypted from the lower file will be written into this
- * page
+ * folio
*
- * Decrypt an eCryptfs page. This is done on a per-extent basis. Note
- * that eCryptfs pages may straddle the lower pages -- for instance,
+ * Decrypt an eCryptfs folio. This is done on a per-extent basis. Note
+ * that eCryptfs folios may straddle the lower pages -- for instance,
* if the file was created on a machine with an 8K page size
* (resulting in an 8K header), and then the file is copied onto a
* host with a 32K page size, then when reading page 0 of the eCryptfs
diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index d841610644ed..305231cd5336 100644
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -188,16 +188,16 @@ static int ecryptfs_read_folio(struct file *file, struct folio *folio)
folio->index, 0, folio_size(folio),
inode);
if (err) {
- printk(KERN_ERR "Error reading page; err = "
- "[%d]\n", err);
+ pr_err("Error reading folio; err = [%d]\n",
+ err);
goto out;
}
}
} else {
err = ecryptfs_decrypt_folio(folio);
if (err) {
- ecryptfs_printk(KERN_ERR, "Error decrypting page; "
- "err = [%d]\n", err);
+ ecryptfs_printk(KERN_ERR, "Error decrypting folio; err = [%d]\n",
+ err);
goto out;
}
}
@@ -264,8 +264,7 @@ static int ecryptfs_write_begin(const struct kiocb *iocb,
rc = ecryptfs_read_lower_folio_segment(
folio, index, 0, PAGE_SIZE, mapping->host);
if (rc) {
- printk(KERN_ERR "%s: Error attempting to read "
- "lower page segment; rc = [%d]\n",
+ pr_err("%s: Error attempting to read lower folio segment; rc = [%d]\n",
__func__, rc);
folio_clear_uptodate(folio);
goto out;
@@ -291,8 +290,7 @@ static int ecryptfs_write_begin(const struct kiocb *iocb,
folio, index, 0, PAGE_SIZE,
mapping->host);
if (rc) {
- printk(KERN_ERR "%s: Error reading "
- "page; rc = [%d]\n",
+ pr_err("%s: Error reading folio; rc = [%d]\n",
__func__, rc);
folio_clear_uptodate(folio);
goto out;
@@ -307,9 +305,7 @@ static int ecryptfs_write_begin(const struct kiocb *iocb,
} else if (len < PAGE_SIZE) {
rc = ecryptfs_decrypt_folio(folio);
if (rc) {
- printk(KERN_ERR "%s: Error decrypting "
- "page at index [%ld]; "
- "rc = [%d]\n",
+ pr_err("%s: Error decrypting folio at index [%ld]; rc = [%d]\n",
__func__, folio->index, rc);
folio_clear_uptodate(folio);
goto out;
@@ -333,8 +329,10 @@ static int ecryptfs_write_begin(const struct kiocb *iocb,
}
}
}
- /* Writing to a new page, and creating a small hole from start
- * of page? Zero it out. */
+ /*
+ * Writing to a new folio, and creating a small hole from start
+ * of folio? Zero it out.
+ */
if ((i_size_read(mapping->host) == prev_page_end_size)
&& (pos != 0))
folio_zero_range(folio, 0, PAGE_SIZE);
@@ -443,8 +441,8 @@ static int ecryptfs_write_end(const struct kiocb *iocb,
&ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat;
int rc;
- ecryptfs_printk(KERN_DEBUG, "Calling fill_zeros_to_end_of_folio"
- "(page w/ index = [0x%.16lx], to = [%d])\n", index, to);
+ ecryptfs_printk(KERN_DEBUG, "Calling fill_zeros_to_end_of_folio(folio w/ index = [0x%.16lx], to = [%d])\n",
+ index, to);
if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
rc = ecryptfs_write_lower_folio_segment(ecryptfs_inode,
folio, 0, to);
@@ -465,14 +463,14 @@ static int ecryptfs_write_end(const struct kiocb *iocb,
/* Fills in zeros if 'to' goes beyond inode size */
rc = fill_zeros_to_end_of_folio(folio, to);
if (rc) {
- ecryptfs_printk(KERN_WARNING, "Error attempting to fill "
- "zeros in page with index = [0x%.16lx]\n", index);
+ ecryptfs_printk(KERN_WARNING, "Error attempting to fill zeros in folio with index = [0x%.16lx]\n",
+ index);
goto out;
}
rc = ecryptfs_encrypt_folio(folio);
if (rc) {
- ecryptfs_printk(KERN_WARNING, "Error encrypting page (upper "
- "index [0x%.16lx])\n", index);
+ ecryptfs_printk(KERN_WARNING, "Error encrypting folio (upper index [0x%.16lx])\n",
+ index);
goto out;
}
if (pos + copied > i_size_read(ecryptfs_inode)) {
diff --git a/fs/ecryptfs/read_write.c b/fs/ecryptfs/read_write.c
index 611f74061441..a1949c769225 100644
--- a/fs/ecryptfs/read_write.c
+++ b/fs/ecryptfs/read_write.c
@@ -48,8 +48,8 @@ int ecryptfs_write_lower(struct inode *ecryptfs_inode, char *data,
* @size: The amount of data from @folio_for_lower to write to the
* lower file
*
- * Determines the byte offset in the file for the given page and
- * offset within the page, maps the page, and makes the call to write
+ * Determines the byte offset in the file for the given folio and
+ * offset within the folio, maps the folio, and makes the call to write
* the contents of @folio_for_lower to the lower inode.
*
* Returns zero on success; non-zero otherwise
@@ -80,7 +80,7 @@ int ecryptfs_write_lower_folio_segment(struct inode *ecryptfs_inode,
* @size: The number of bytes to write from @data
*
* Write an arbitrary amount of data to an arbitrary location in the
- * eCryptfs inode page cache. This is done on a page-by-page, and then
+ * eCryptfs inode page cache. This is done on a folio-by-folio, and then
* by an extent-by-extent, basis; individual extents are encrypted and
* written to the lower page cache (via VFS writes). This function
* takes care of all the address translation to locations in the lower
@@ -133,10 +133,8 @@ int ecryptfs_write(struct inode *ecryptfs_inode, char *data, loff_t offset,
ecryptfs_page_idx, NULL);
if (IS_ERR(ecryptfs_folio)) {
rc = PTR_ERR(ecryptfs_folio);
- printk(KERN_ERR "%s: Error getting page at "
- "index [%ld] from eCryptfs inode "
- "mapping; rc = [%d]\n", __func__,
- ecryptfs_page_idx, rc);
+ pr_err("%s: Error getting folio at index [%ld] from eCryptfs inode mapping; rc = [%d]\n",
+ __func__, ecryptfs_page_idx, rc);
goto out;
}
folio_lock(ecryptfs_folio);
@@ -146,11 +144,13 @@ int ecryptfs_write(struct inode *ecryptfs_inode, char *data, loff_t offset,
* pos: where we're now writing, offset: where the request was
* If current pos is before request, we are filling zeros
* If we are at or beyond request, we are writing the *data*
- * If we're in a fresh page beyond eof, zero it in either case
+ * If we're in a fresh folio beyond eof, zero it in either case
*/
if (pos < offset || !start_offset_in_page) {
- /* We are extending past the previous end of the file.
- * Fill in zero values to the end of the page */
+ /*
+ * We are extending past the previous end of the file.
+ * Fill in zero values to the end of the folio.
+ */
memset(((char *)ecryptfs_page_virt
+ start_offset_in_page), 0,
PAGE_SIZE - start_offset_in_page);
@@ -176,8 +176,8 @@ int ecryptfs_write(struct inode *ecryptfs_inode, char *data, loff_t offset,
data_offset);
folio_put(ecryptfs_folio);
if (rc) {
- printk(KERN_ERR "%s: Error encrypting "
- "page; rc = [%d]\n", __func__, rc);
+ pr_err("%s: Error encrypting folio; rc = [%d]\n",
+ __func__, rc);
goto out;
}
pos += num_bytes;
@@ -230,16 +230,16 @@ int ecryptfs_read_lower(char *data, loff_t offset, size_t size,
* ecryptfs_read_lower_folio_segment
* @folio_for_ecryptfs: The folio into which data for eCryptfs will be
* written
- * @page_index: Page index in @page_for_ecryptfs from which to start
+ * @page_index: Page index in @folio_for_ecryptfs from which to start
* writing
- * @offset_in_page: Offset in @page_for_ecryptfs from which to start
+ * @offset_in_page: Offset in @folio_for_ecryptfs from which to start
* writing
- * @size: The number of bytes to write into @page_for_ecryptfs
+ * @size: The number of bytes to write into @folio_for_ecryptfs
* @ecryptfs_inode: The eCryptfs inode
*
- * Determines the byte offset in the file for the given page and
- * offset within the page, maps the page, and makes the call to read
- * the contents of @page_for_ecryptfs from the lower inode.
+ * Determines the byte offset in the file for the given folio and
+ * offset within the folio, maps the folio, and makes the call to read
+ * the contents of @folio_for_ecryptfs from the lower inode.
*
* Returns zero on success; non-zero otherwise
*/
--
2.39.5
^ permalink raw reply [flat|nested] 9+ messages in thread* Re: [PATCH 0/7] ecryptfs: remove the remaining struct page usage
2026-10-15 1:35 [PATCH 0/7] ecryptfs: remove the remaining struct page usage Tal Zussman
` (6 preceding siblings ...)
2026-10-15 1:35 ` [PATCH 7/7] ecryptfs: refer to folios in comments and printk strings Tal Zussman
@ 2026-10-22 16:30 ` Tal Zussman
7 siblings, 0 replies; 9+ messages in thread
From: Tal Zussman @ 2026-10-22 16:30 UTC (permalink / raw)
To: Tyler Hicks; +Cc: ecryptfs, linux-kernel, Matthew Wilcox (Oracle)
On 10/14/26 9:35 PM, Tal Zussman wrote:
> Convert the page cache side of the encryption path to folios, and use
> plain kernel memory for the buffers that were only pages because of the
> old interfaces: the ciphertext block, the header buffer from
> ecryptfs_get_zeroed_pages(), and the scatterlists built by
> virt_to_scatterlist(). Also make a shrinking truncate zero the tail of
> the last folio in place, as other filesystems do, instead of copying
> from the zero page through the write path. After this, fs/ecryptfs has
> no struct page usage left.
>
> Ran cleanly with fsx and fsstress on ecryptfs over ext4 in the default,
> xattr, and passthrough mount options.
>
> ---
> Tal Zussman (7):
> ecryptfs: remove struct ecryptfs_page_crypt_context
> ecryptfs: use a folio and a buffer in crypt_extent()
> ecryptfs: use kzalloc() for the header buffer
> ecryptfs: use sg_init_one() instead of virt_to_scatterlist()
> ecryptfs: zero the tail of the last folio in place on truncate
> ecryptfs: rename functions to refer to folios
> ecryptfs: refer to folios in comments and printk strings
>
Sashiko found some issues with patches 4 and 5. I'll send v2 with fixes
soon.
Thanks,
Tal
^ permalink raw reply [flat|nested] 9+ messages in thread