* [PATCH v2 01/10] ecryptfs: Convert ecryptfs_writepage() to ecryptfs_writepages()
2024-10-25 19:08 [PATCH v2 00/10] Convert ecryptfs to use folios Matthew Wilcox (Oracle)
@ 2024-10-25 19:08 ` Matthew Wilcox (Oracle)
2024-10-25 19:08 ` [PATCH v2 02/10] ecryptfs: Use a folio throughout ecryptfs_read_folio() Matthew Wilcox (Oracle)
` (10 subsequent siblings)
11 siblings, 0 replies; 13+ messages in thread
From: Matthew Wilcox (Oracle) @ 2024-10-25 19:08 UTC (permalink / raw)
To: Tyler Hicks
Cc: Matthew Wilcox (Oracle), ecryptfs, Christian Brauner,
linux-fsdevel
By adding a ->migrate_folio implementation, theree is no need to keep
the ->writepage implementation. The new writepages removes the
unnecessary call to SetPageUptodate(); the folio should already be
uptodate at this point.
Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
---
fs/ecryptfs/mmap.c | 41 ++++++++++++++++++++---------------------
1 file changed, 20 insertions(+), 21 deletions(-)
diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index ceda5555971a..92ea39d907de 100644
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -38,32 +38,30 @@ struct page *ecryptfs_get_locked_page(struct inode *inode, loff_t index)
return page;
}
-/**
- * ecryptfs_writepage
- * @page: Page that is locked before this call is made
- * @wbc: Write-back control structure
- *
- * Returns zero on success; non-zero otherwise
- *
+/*
* This is where we encrypt the data and pass the encrypted data to
* the lower filesystem. In OpenPGP-compatible mode, we operate on
* entire underlying packets.
*/
-static int ecryptfs_writepage(struct page *page, struct writeback_control *wbc)
+static int ecryptfs_writepages(struct address_space *mapping,
+ struct writeback_control *wbc)
{
- int rc;
-
- rc = ecryptfs_encrypt_page(page);
- if (rc) {
- ecryptfs_printk(KERN_WARNING, "Error encrypting "
- "page (upper index [0x%.16lx])\n", page->index);
- ClearPageUptodate(page);
- goto out;
+ struct folio *folio = NULL;
+ int error;
+
+ while ((folio = writeback_iter(mapping, wbc, folio, &error))) {
+ error = ecryptfs_encrypt_page(&folio->page);
+ if (error) {
+ ecryptfs_printk(KERN_WARNING,
+ "Error encrypting folio (index [0x%.16lx])\n",
+ folio->index);
+ folio_clear_uptodate(folio);
+ mapping_set_error(mapping, error);
+ }
+ folio_unlock(folio);
}
- SetPageUptodate(page);
-out:
- unlock_page(page);
- return rc;
+
+ return error;
}
static void strip_xattr_flag(char *page_virt,
@@ -548,9 +546,10 @@ const struct address_space_operations ecryptfs_aops = {
.dirty_folio = block_dirty_folio,
.invalidate_folio = block_invalidate_folio,
#endif
- .writepage = ecryptfs_writepage,
+ .writepages = ecryptfs_writepages,
.read_folio = ecryptfs_read_folio,
.write_begin = ecryptfs_write_begin,
.write_end = ecryptfs_write_end,
+ .migrate_folio = filemap_migrate_folio,
.bmap = ecryptfs_bmap,
};
--
2.43.0
^ permalink raw reply related [flat|nested] 13+ messages in thread* [PATCH v2 02/10] ecryptfs: Use a folio throughout ecryptfs_read_folio()
2024-10-25 19:08 [PATCH v2 00/10] Convert ecryptfs to use folios Matthew Wilcox (Oracle)
2024-10-25 19:08 ` [PATCH v2 01/10] ecryptfs: Convert ecryptfs_writepage() to ecryptfs_writepages() Matthew Wilcox (Oracle)
@ 2024-10-25 19:08 ` Matthew Wilcox (Oracle)
2024-10-25 19:08 ` [PATCH v2 03/10] ecryptfs: Convert ecryptfs_copy_up_encrypted_with_header() to take a folio Matthew Wilcox (Oracle)
` (9 subsequent siblings)
11 siblings, 0 replies; 13+ messages in thread
From: Matthew Wilcox (Oracle) @ 2024-10-25 19:08 UTC (permalink / raw)
To: Tyler Hicks
Cc: Matthew Wilcox (Oracle), ecryptfs, Christian Brauner,
linux-fsdevel
Remove the conversion to a struct page. Removes a few hidden calls to
compound_head(). Use 'err' instead of 'rc' for clarity.
Also remove the unnecessary call to ClearPageUptodate(); the uptodate
flag is already clear if this function is being called. That lets us
switch to folio_end_read() which does one atomic flag operation instead
of two.
Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
---
fs/ecryptfs/mmap.c | 50 +++++++++++++++++++++-------------------------
1 file changed, 23 insertions(+), 27 deletions(-)
diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index 92ea39d907de..25a756fec5c2 100644
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -178,55 +178,51 @@ ecryptfs_copy_up_encrypted_with_header(struct page *page,
*/
static int ecryptfs_read_folio(struct file *file, struct folio *folio)
{
- struct page *page = &folio->page;
+ struct inode *inode = folio->mapping->host;
struct ecryptfs_crypt_stat *crypt_stat =
- &ecryptfs_inode_to_private(page->mapping->host)->crypt_stat;
- int rc = 0;
+ &ecryptfs_inode_to_private(inode)->crypt_stat;
+ int err = 0;
if (!crypt_stat || !(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
- rc = ecryptfs_read_lower_page_segment(page, page->index, 0,
- PAGE_SIZE,
- page->mapping->host);
+ err = ecryptfs_read_lower_page_segment(&folio->page, folio->index, 0,
+ folio_size(folio),
+ inode);
} else if (crypt_stat->flags & ECRYPTFS_VIEW_AS_ENCRYPTED) {
if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR) {
- rc = ecryptfs_copy_up_encrypted_with_header(page,
+ err = ecryptfs_copy_up_encrypted_with_header(&folio->page,
crypt_stat);
- if (rc) {
+ if (err) {
printk(KERN_ERR "%s: Error attempting to copy "
"the encrypted content from the lower "
"file whilst inserting the metadata "
- "from the xattr into the header; rc = "
- "[%d]\n", __func__, rc);
+ "from the xattr into the header; err = "
+ "[%d]\n", __func__, err);
goto out;
}
} else {
- rc = ecryptfs_read_lower_page_segment(
- page, page->index, 0, PAGE_SIZE,
- page->mapping->host);
- if (rc) {
- printk(KERN_ERR "Error reading page; rc = "
- "[%d]\n", rc);
+ err = ecryptfs_read_lower_page_segment(&folio->page,
+ folio->index, 0, folio_size(folio),
+ inode);
+ if (err) {
+ printk(KERN_ERR "Error reading page; err = "
+ "[%d]\n", err);
goto out;
}
}
} else {
- rc = ecryptfs_decrypt_page(page);
- if (rc) {
+ err = ecryptfs_decrypt_page(&folio->page);
+ if (err) {
ecryptfs_printk(KERN_ERR, "Error decrypting page; "
- "rc = [%d]\n", rc);
+ "err = [%d]\n", err);
goto out;
}
}
out:
- if (rc)
- ClearPageUptodate(page);
- else
- SetPageUptodate(page);
- ecryptfs_printk(KERN_DEBUG, "Unlocking page with index = [0x%.16lx]\n",
- page->index);
- unlock_page(page);
- return rc;
+ ecryptfs_printk(KERN_DEBUG, "Unlocking folio with index = [0x%.16lx]\n",
+ folio->index);
+ folio_end_read(folio, err == 0);
+ return err;
}
/*
--
2.43.0
^ permalink raw reply related [flat|nested] 13+ messages in thread* [PATCH v2 03/10] ecryptfs: Convert ecryptfs_copy_up_encrypted_with_header() to take a folio
2024-10-25 19:08 [PATCH v2 00/10] Convert ecryptfs to use folios Matthew Wilcox (Oracle)
2024-10-25 19:08 ` [PATCH v2 01/10] ecryptfs: Convert ecryptfs_writepage() to ecryptfs_writepages() Matthew Wilcox (Oracle)
2024-10-25 19:08 ` [PATCH v2 02/10] ecryptfs: Use a folio throughout ecryptfs_read_folio() Matthew Wilcox (Oracle)
@ 2024-10-25 19:08 ` Matthew Wilcox (Oracle)
2024-10-25 19:08 ` [PATCH v2 04/10] ecryptfs: Convert ecryptfs_read_lower_page_segment() " Matthew Wilcox (Oracle)
` (8 subsequent siblings)
11 siblings, 0 replies; 13+ messages in thread
From: Matthew Wilcox (Oracle) @ 2024-10-25 19:08 UTC (permalink / raw)
To: Tyler Hicks
Cc: Matthew Wilcox (Oracle), ecryptfs, Christian Brauner,
linux-fsdevel, Pankaj Raghav
Both callers have a folio, so pass it in and use it throughout.
Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Pankaj Raghav <p.raghav@samsung.com>
---
fs/ecryptfs/mmap.c | 24 ++++++++++++------------
1 file changed, 12 insertions(+), 12 deletions(-)
diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index 25a756fec5c2..bd78a36ed479 100644
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -95,7 +95,7 @@ static void strip_xattr_flag(char *page_virt,
/**
* ecryptfs_copy_up_encrypted_with_header
- * @page: Sort of a ``virtual'' representation of the encrypted lower
+ * @folio: Sort of a ``virtual'' representation of the encrypted lower
* file. The actual lower file does not have the metadata in
* the header. This is locked.
* @crypt_stat: The eCryptfs inode's cryptographic context
@@ -104,7 +104,7 @@ static void strip_xattr_flag(char *page_virt,
* seeing, with the header information inserted.
*/
static int
-ecryptfs_copy_up_encrypted_with_header(struct page *page,
+ecryptfs_copy_up_encrypted_with_header(struct folio *folio,
struct ecryptfs_crypt_stat *crypt_stat)
{
loff_t extent_num_in_page = 0;
@@ -113,9 +113,9 @@ ecryptfs_copy_up_encrypted_with_header(struct page *page,
int rc = 0;
while (extent_num_in_page < num_extents_per_page) {
- loff_t view_extent_num = ((((loff_t)page->index)
+ loff_t view_extent_num = ((loff_t)folio->index
* num_extents_per_page)
- + extent_num_in_page);
+ + extent_num_in_page;
size_t num_header_extents_at_front =
(crypt_stat->metadata_size / crypt_stat->extent_size);
@@ -123,21 +123,21 @@ ecryptfs_copy_up_encrypted_with_header(struct page *page,
/* This is a header extent */
char *page_virt;
- page_virt = kmap_local_page(page);
+ page_virt = kmap_local_folio(folio, 0);
memset(page_virt, 0, PAGE_SIZE);
/* TODO: Support more than one header extent */
if (view_extent_num == 0) {
size_t written;
rc = ecryptfs_read_xattr_region(
- page_virt, page->mapping->host);
+ page_virt, folio->mapping->host);
strip_xattr_flag(page_virt + 16, crypt_stat);
ecryptfs_write_header_metadata(page_virt + 20,
crypt_stat,
&written);
}
kunmap_local(page_virt);
- flush_dcache_page(page);
+ flush_dcache_folio(folio);
if (rc) {
printk(KERN_ERR "%s: Error reading xattr "
"region; rc = [%d]\n", __func__, rc);
@@ -150,9 +150,9 @@ ecryptfs_copy_up_encrypted_with_header(struct page *page,
- crypt_stat->metadata_size);
rc = ecryptfs_read_lower_page_segment(
- page, (lower_offset >> PAGE_SHIFT),
+ &folio->page, (lower_offset >> PAGE_SHIFT),
(lower_offset & ~PAGE_MASK),
- crypt_stat->extent_size, page->mapping->host);
+ crypt_stat->extent_size, folio->mapping->host);
if (rc) {
printk(KERN_ERR "%s: Error attempting to read "
"extent at offset [%lld] in the lower "
@@ -189,8 +189,8 @@ static int ecryptfs_read_folio(struct file *file, struct folio *folio)
inode);
} else if (crypt_stat->flags & ECRYPTFS_VIEW_AS_ENCRYPTED) {
if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR) {
- err = ecryptfs_copy_up_encrypted_with_header(&folio->page,
- crypt_stat);
+ err = ecryptfs_copy_up_encrypted_with_header(folio,
+ crypt_stat);
if (err) {
printk(KERN_ERR "%s: Error attempting to copy "
"the encrypted content from the lower "
@@ -291,7 +291,7 @@ static int ecryptfs_write_begin(struct file *file,
} else if (crypt_stat->flags & ECRYPTFS_VIEW_AS_ENCRYPTED) {
if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR) {
rc = ecryptfs_copy_up_encrypted_with_header(
- &folio->page, crypt_stat);
+ folio, crypt_stat);
if (rc) {
printk(KERN_ERR "%s: Error attempting "
"to copy the encrypted content "
--
2.43.0
^ permalink raw reply related [flat|nested] 13+ messages in thread* [PATCH v2 04/10] ecryptfs: Convert ecryptfs_read_lower_page_segment() to take a folio
2024-10-25 19:08 [PATCH v2 00/10] Convert ecryptfs to use folios Matthew Wilcox (Oracle)
` (2 preceding siblings ...)
2024-10-25 19:08 ` [PATCH v2 03/10] ecryptfs: Convert ecryptfs_copy_up_encrypted_with_header() to take a folio Matthew Wilcox (Oracle)
@ 2024-10-25 19:08 ` Matthew Wilcox (Oracle)
2024-10-25 19:08 ` [PATCH v2 05/10] ecryptfs: Convert ecryptfs_write() to use " Matthew Wilcox (Oracle)
` (7 subsequent siblings)
11 siblings, 0 replies; 13+ messages in thread
From: Matthew Wilcox (Oracle) @ 2024-10-25 19:08 UTC (permalink / raw)
To: Tyler Hicks
Cc: Matthew Wilcox (Oracle), ecryptfs, Christian Brauner,
linux-fsdevel
All callers have a folio, so pass it in and use it directly. This will
not work for large folios, but I doubt anybody wants to use large folios
with ecryptfs.
Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
---
fs/ecryptfs/ecryptfs_kernel.h | 2 +-
fs/ecryptfs/mmap.c | 13 ++++++-------
fs/ecryptfs/read_write.c | 10 +++++-----
3 files changed, 12 insertions(+), 13 deletions(-)
diff --git a/fs/ecryptfs/ecryptfs_kernel.h b/fs/ecryptfs/ecryptfs_kernel.h
index c586c5db18b5..43f1b5ff987d 100644
--- a/fs/ecryptfs/ecryptfs_kernel.h
+++ b/fs/ecryptfs/ecryptfs_kernel.h
@@ -658,7 +658,7 @@ int ecryptfs_write_lower_page_segment(struct inode *ecryptfs_inode,
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 page *page_for_ecryptfs,
+int ecryptfs_read_lower_page_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/mmap.c b/fs/ecryptfs/mmap.c
index bd78a36ed479..1fc87c83e43c 100644
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -150,7 +150,7 @@ ecryptfs_copy_up_encrypted_with_header(struct folio *folio,
- crypt_stat->metadata_size);
rc = ecryptfs_read_lower_page_segment(
- &folio->page, (lower_offset >> PAGE_SHIFT),
+ folio, (lower_offset >> PAGE_SHIFT),
(lower_offset & ~PAGE_MASK),
crypt_stat->extent_size, folio->mapping->host);
if (rc) {
@@ -184,9 +184,8 @@ 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->page, folio->index, 0,
- folio_size(folio),
- inode);
+ err = ecryptfs_read_lower_page_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) {
err = ecryptfs_copy_up_encrypted_with_header(folio,
@@ -201,7 +200,7 @@ static int ecryptfs_read_folio(struct file *file, struct folio *folio)
}
} else {
- err = ecryptfs_read_lower_page_segment(&folio->page,
+ err = ecryptfs_read_lower_page_segment(folio,
folio->index, 0, folio_size(folio),
inode);
if (err) {
@@ -279,7 +278,7 @@ static int ecryptfs_write_begin(struct file *file,
if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
rc = ecryptfs_read_lower_page_segment(
- &folio->page, index, 0, PAGE_SIZE, mapping->host);
+ folio, index, 0, PAGE_SIZE, mapping->host);
if (rc) {
printk(KERN_ERR "%s: Error attempting to read "
"lower page segment; rc = [%d]\n",
@@ -305,7 +304,7 @@ static int ecryptfs_write_begin(struct file *file,
folio_mark_uptodate(folio);
} else {
rc = ecryptfs_read_lower_page_segment(
- &folio->page, index, 0, PAGE_SIZE,
+ folio, index, 0, PAGE_SIZE,
mapping->host);
if (rc) {
printk(KERN_ERR "%s: Error reading "
diff --git a/fs/ecryptfs/read_write.c b/fs/ecryptfs/read_write.c
index 3458f153a588..251e9f6c6972 100644
--- a/fs/ecryptfs/read_write.c
+++ b/fs/ecryptfs/read_write.c
@@ -228,7 +228,7 @@ int ecryptfs_read_lower(char *data, loff_t offset, size_t size,
/**
* ecryptfs_read_lower_page_segment
- * @page_for_ecryptfs: The page into which data for eCryptfs will be
+ * @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
* writing
@@ -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 page *page_for_ecryptfs,
+int ecryptfs_read_lower_page_segment(struct folio *folio_for_ecryptfs,
pgoff_t page_index,
size_t offset_in_page, size_t size,
struct inode *ecryptfs_inode)
@@ -252,12 +252,12 @@ int ecryptfs_read_lower_page_segment(struct page *page_for_ecryptfs,
loff_t offset;
int rc;
- offset = ((((loff_t)page_index) << PAGE_SHIFT) + offset_in_page);
- virt = kmap_local_page(page_for_ecryptfs);
+ offset = (loff_t)page_index * PAGE_SIZE + offset_in_page;
+ virt = kmap_local_folio(folio_for_ecryptfs, 0);
rc = ecryptfs_read_lower(virt, offset, size, ecryptfs_inode);
if (rc > 0)
rc = 0;
kunmap_local(virt);
- flush_dcache_page(page_for_ecryptfs);
+ flush_dcache_folio(folio_for_ecryptfs);
return rc;
}
--
2.43.0
^ permalink raw reply related [flat|nested] 13+ messages in thread* [PATCH v2 05/10] ecryptfs: Convert ecryptfs_write() to use a folio
2024-10-25 19:08 [PATCH v2 00/10] Convert ecryptfs to use folios Matthew Wilcox (Oracle)
` (3 preceding siblings ...)
2024-10-25 19:08 ` [PATCH v2 04/10] ecryptfs: Convert ecryptfs_read_lower_page_segment() " Matthew Wilcox (Oracle)
@ 2024-10-25 19:08 ` Matthew Wilcox (Oracle)
2024-10-25 19:08 ` [PATCH v2 06/10] ecryptfs: Convert ecryptfs_write_lower_page_segment() to take " Matthew Wilcox (Oracle)
` (6 subsequent siblings)
11 siblings, 0 replies; 13+ messages in thread
From: Matthew Wilcox (Oracle) @ 2024-10-25 19:08 UTC (permalink / raw)
To: Tyler Hicks
Cc: Matthew Wilcox (Oracle), ecryptfs, Christian Brauner,
linux-fsdevel, Pankaj Raghav
Remove ecryptfs_get_locked_page() and call read_mapping_folio()
directly. Use the folio throught this function.
Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Pankaj Raghav <p.raghav@samsung.com>
---
fs/ecryptfs/ecryptfs_kernel.h | 1 -
fs/ecryptfs/mmap.c | 16 ----------------
fs/ecryptfs/read_write.c | 25 +++++++++++++------------
3 files changed, 13 insertions(+), 29 deletions(-)
diff --git a/fs/ecryptfs/ecryptfs_kernel.h b/fs/ecryptfs/ecryptfs_kernel.h
index 43f1b5ff987d..f04aa24f6bcd 100644
--- a/fs/ecryptfs/ecryptfs_kernel.h
+++ b/fs/ecryptfs/ecryptfs_kernel.h
@@ -662,7 +662,6 @@ int ecryptfs_read_lower_page_segment(struct folio *folio_for_ecryptfs,
pgoff_t page_index,
size_t offset_in_page, size_t size,
struct inode *ecryptfs_inode);
-struct page *ecryptfs_get_locked_page(struct inode *inode, loff_t index);
int ecryptfs_parse_packet_length(unsigned char *data, size_t *size,
size_t *length_size);
int ecryptfs_write_packet_length(char *dest, size_t size,
diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index 1fc87c83e43c..f6b9390e720a 100644
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -22,22 +22,6 @@
#include <linux/unaligned.h>
#include "ecryptfs_kernel.h"
-/*
- * ecryptfs_get_locked_page
- *
- * Get one page from cache or lower f/s, return error otherwise.
- *
- * Returns locked and up-to-date page (if ok), with increased
- * refcnt.
- */
-struct page *ecryptfs_get_locked_page(struct inode *inode, loff_t index)
-{
- struct page *page = read_mapping_page(inode->i_mapping, index, NULL);
- if (!IS_ERR(page))
- lock_page(page);
- return page;
-}
-
/*
* This is where we encrypt the data and pass the encrypted data to
* the lower filesystem. In OpenPGP-compatible mode, we operate on
diff --git a/fs/ecryptfs/read_write.c b/fs/ecryptfs/read_write.c
index 251e9f6c6972..cddfdfced879 100644
--- a/fs/ecryptfs/read_write.c
+++ b/fs/ecryptfs/read_write.c
@@ -93,7 +93,6 @@ int ecryptfs_write_lower_page_segment(struct inode *ecryptfs_inode,
int ecryptfs_write(struct inode *ecryptfs_inode, char *data, loff_t offset,
size_t size)
{
- struct page *ecryptfs_page;
struct ecryptfs_crypt_stat *crypt_stat;
char *ecryptfs_page_virt;
loff_t ecryptfs_file_size = i_size_read(ecryptfs_inode);
@@ -111,6 +110,7 @@ int ecryptfs_write(struct inode *ecryptfs_inode, char *data, loff_t offset,
else
pos = offset;
while (pos < (offset + size)) {
+ struct folio *ecryptfs_folio;
pgoff_t ecryptfs_page_idx = (pos >> PAGE_SHIFT);
size_t start_offset_in_page = (pos & ~PAGE_MASK);
size_t num_bytes = (PAGE_SIZE - start_offset_in_page);
@@ -130,17 +130,18 @@ int ecryptfs_write(struct inode *ecryptfs_inode, char *data, loff_t offset,
if (num_bytes > total_remaining_zeros)
num_bytes = total_remaining_zeros;
}
- ecryptfs_page = ecryptfs_get_locked_page(ecryptfs_inode,
- ecryptfs_page_idx);
- if (IS_ERR(ecryptfs_page)) {
- rc = PTR_ERR(ecryptfs_page);
+ ecryptfs_folio = read_mapping_folio(ecryptfs_inode->i_mapping,
+ 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);
goto out;
}
- ecryptfs_page_virt = kmap_local_page(ecryptfs_page);
+ folio_lock(ecryptfs_folio);
+ ecryptfs_page_virt = kmap_local_folio(ecryptfs_folio, 0);
/*
* pos: where we're now writing, offset: where the request was
@@ -164,17 +165,17 @@ int ecryptfs_write(struct inode *ecryptfs_inode, char *data, loff_t offset,
data_offset += num_bytes;
}
kunmap_local(ecryptfs_page_virt);
- flush_dcache_page(ecryptfs_page);
- SetPageUptodate(ecryptfs_page);
- unlock_page(ecryptfs_page);
+ flush_dcache_folio(ecryptfs_folio);
+ folio_mark_uptodate(ecryptfs_folio);
+ folio_unlock(ecryptfs_folio);
if (crypt_stat->flags & ECRYPTFS_ENCRYPTED)
- rc = ecryptfs_encrypt_page(ecryptfs_page);
+ rc = ecryptfs_encrypt_page(&ecryptfs_folio->page);
else
rc = ecryptfs_write_lower_page_segment(ecryptfs_inode,
- ecryptfs_page,
+ &ecryptfs_folio->page,
start_offset_in_page,
data_offset);
- put_page(ecryptfs_page);
+ folio_put(ecryptfs_folio);
if (rc) {
printk(KERN_ERR "%s: Error encrypting "
"page; rc = [%d]\n", __func__, rc);
--
2.43.0
^ permalink raw reply related [flat|nested] 13+ messages in thread* [PATCH v2 06/10] ecryptfs: Convert ecryptfs_write_lower_page_segment() to take a folio
2024-10-25 19:08 [PATCH v2 00/10] Convert ecryptfs to use folios Matthew Wilcox (Oracle)
` (4 preceding siblings ...)
2024-10-25 19:08 ` [PATCH v2 05/10] ecryptfs: Convert ecryptfs_write() to use " Matthew Wilcox (Oracle)
@ 2024-10-25 19:08 ` Matthew Wilcox (Oracle)
2024-10-25 19:08 ` [PATCH v2 07/10] ecryptfs: Convert ecryptfs_encrypt_page() " Matthew Wilcox (Oracle)
` (5 subsequent siblings)
11 siblings, 0 replies; 13+ messages in thread
From: Matthew Wilcox (Oracle) @ 2024-10-25 19:08 UTC (permalink / raw)
To: Tyler Hicks
Cc: Matthew Wilcox (Oracle), ecryptfs, Christian Brauner,
linux-fsdevel
Both callers now have a folio, so pass it in and use it throughout.
Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
---
fs/ecryptfs/ecryptfs_kernel.h | 2 +-
fs/ecryptfs/mmap.c | 2 +-
fs/ecryptfs/read_write.c | 17 ++++++++---------
3 files changed, 10 insertions(+), 11 deletions(-)
diff --git a/fs/ecryptfs/ecryptfs_kernel.h b/fs/ecryptfs/ecryptfs_kernel.h
index f04aa24f6bcd..0cac8d3155ae 100644
--- a/fs/ecryptfs/ecryptfs_kernel.h
+++ b/fs/ecryptfs/ecryptfs_kernel.h
@@ -653,7 +653,7 @@ int ecryptfs_keyring_auth_tok_for_sig(struct key **auth_tok_key,
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,
- struct page *page_for_lower,
+ 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,
diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index f6b9390e720a..1c1eb9437505 100644
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -454,7 +454,7 @@ static int ecryptfs_write_end(struct file *file,
"(page w/ index = [0x%.16lx], to = [%d])\n", index, to);
if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)) {
rc = ecryptfs_write_lower_page_segment(ecryptfs_inode,
- &folio->page, 0, to);
+ folio, 0, to);
if (!rc) {
rc = copied;
fsstack_copy_inode_size(ecryptfs_inode,
diff --git a/fs/ecryptfs/read_write.c b/fs/ecryptfs/read_write.c
index cddfdfced879..665bcd7d1c8e 100644
--- a/fs/ecryptfs/read_write.c
+++ b/fs/ecryptfs/read_write.c
@@ -41,30 +41,29 @@ int ecryptfs_write_lower(struct inode *ecryptfs_inode, char *data,
/**
* ecryptfs_write_lower_page_segment
* @ecryptfs_inode: The eCryptfs inode
- * @page_for_lower: The page containing the data to be written to the
+ * @folio_for_lower: The folio containing the data to be written to the
* lower file
- * @offset_in_page: The offset in the @page_for_lower from which to
+ * @offset_in_page: The offset in the @folio_for_lower from which to
* start writing the data
- * @size: The amount of data from @page_for_lower to write to the
+ * @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
- * the contents of @page_for_lower to the lower inode.
+ * the contents of @folio_for_lower to the lower inode.
*
* Returns zero on success; non-zero otherwise
*/
int ecryptfs_write_lower_page_segment(struct inode *ecryptfs_inode,
- struct page *page_for_lower,
+ struct folio *folio_for_lower,
size_t offset_in_page, size_t size)
{
char *virt;
loff_t offset;
int rc;
- offset = ((((loff_t)page_for_lower->index) << PAGE_SHIFT)
- + offset_in_page);
- virt = kmap_local_page(page_for_lower);
+ offset = (loff_t)folio_for_lower->index * PAGE_SIZE + offset_in_page;
+ virt = kmap_local_folio(folio_for_lower, 0);
rc = ecryptfs_write_lower(ecryptfs_inode, virt, offset, size);
if (rc > 0)
rc = 0;
@@ -172,7 +171,7 @@ int ecryptfs_write(struct inode *ecryptfs_inode, char *data, loff_t offset,
rc = ecryptfs_encrypt_page(&ecryptfs_folio->page);
else
rc = ecryptfs_write_lower_page_segment(ecryptfs_inode,
- &ecryptfs_folio->page,
+ ecryptfs_folio,
start_offset_in_page,
data_offset);
folio_put(ecryptfs_folio);
--
2.43.0
^ permalink raw reply related [flat|nested] 13+ messages in thread* [PATCH v2 07/10] ecryptfs: Convert ecryptfs_encrypt_page() to take a folio
2024-10-25 19:08 [PATCH v2 00/10] Convert ecryptfs to use folios Matthew Wilcox (Oracle)
` (5 preceding siblings ...)
2024-10-25 19:08 ` [PATCH v2 06/10] ecryptfs: Convert ecryptfs_write_lower_page_segment() to take " Matthew Wilcox (Oracle)
@ 2024-10-25 19:08 ` Matthew Wilcox (Oracle)
2024-10-25 19:08 ` [PATCH v2 08/10] ecryptfs: Convert ecryptfs_decrypt_page() " Matthew Wilcox (Oracle)
` (4 subsequent siblings)
11 siblings, 0 replies; 13+ messages in thread
From: Matthew Wilcox (Oracle) @ 2024-10-25 19:08 UTC (permalink / raw)
To: Tyler Hicks
Cc: Matthew Wilcox (Oracle), ecryptfs, Christian Brauner,
linux-fsdevel
All three callers have a folio, so pass it in and use it throughout.
Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
---
fs/ecryptfs/crypto.c | 12 ++++++------
fs/ecryptfs/ecryptfs_kernel.h | 2 +-
fs/ecryptfs/mmap.c | 4 ++--
fs/ecryptfs/read_write.c | 2 +-
4 files changed, 10 insertions(+), 10 deletions(-)
diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
index 827278525fd9..995ae3a97d52 100644
--- a/fs/ecryptfs/crypto.c
+++ b/fs/ecryptfs/crypto.c
@@ -392,7 +392,7 @@ static int crypt_extent(struct ecryptfs_crypt_stat *crypt_stat,
/**
* ecryptfs_encrypt_page
- * @page: Page mapped from the eCryptfs inode for the file; contains
+ * @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
*
@@ -406,7 +406,7 @@ static int crypt_extent(struct ecryptfs_crypt_stat *crypt_stat,
*
* Returns zero on success; negative on error
*/
-int ecryptfs_encrypt_page(struct page *page)
+int ecryptfs_encrypt_page(struct folio *folio)
{
struct inode *ecryptfs_inode;
struct ecryptfs_crypt_stat *crypt_stat;
@@ -416,7 +416,7 @@ int ecryptfs_encrypt_page(struct page *page)
loff_t lower_offset;
int rc = 0;
- ecryptfs_inode = page->mapping->host;
+ ecryptfs_inode = folio->mapping->host;
crypt_stat =
&(ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat);
BUG_ON(!(crypt_stat->flags & ECRYPTFS_ENCRYPTED));
@@ -431,8 +431,8 @@ int ecryptfs_encrypt_page(struct page *page)
for (extent_offset = 0;
extent_offset < (PAGE_SIZE / crypt_stat->extent_size);
extent_offset++) {
- rc = crypt_extent(crypt_stat, enc_extent_page, page,
- extent_offset, ENCRYPT);
+ rc = crypt_extent(crypt_stat, enc_extent_page,
+ folio_page(folio, 0), extent_offset, ENCRYPT);
if (rc) {
printk(KERN_ERR "%s: Error encrypting extent; "
"rc = [%d]\n", __func__, rc);
@@ -440,7 +440,7 @@ int ecryptfs_encrypt_page(struct page *page)
}
}
- lower_offset = lower_offset_for_page(crypt_stat, page);
+ lower_offset = lower_offset_for_page(crypt_stat, &folio->page);
enc_extent_virt = kmap_local_page(enc_extent_page);
rc = ecryptfs_write_lower(ecryptfs_inode, enc_extent_virt, lower_offset,
PAGE_SIZE);
diff --git a/fs/ecryptfs/ecryptfs_kernel.h b/fs/ecryptfs/ecryptfs_kernel.h
index 0cac8d3155ae..bffced0c1d8f 100644
--- a/fs/ecryptfs/ecryptfs_kernel.h
+++ b/fs/ecryptfs/ecryptfs_kernel.h
@@ -569,7 +569,7 @@ 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 page *page);
+int ecryptfs_encrypt_page(struct folio *folio);
int ecryptfs_decrypt_page(struct page *page);
int ecryptfs_write_metadata(struct dentry *ecryptfs_dentry,
struct inode *ecryptfs_inode);
diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index 1c1eb9437505..b2c22f49ef6f 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->page);
+ error = ecryptfs_encrypt_page(folio);
if (error) {
ecryptfs_printk(KERN_WARNING,
"Error encrypting folio (index [0x%.16lx])\n",
@@ -476,7 +476,7 @@ static int ecryptfs_write_end(struct file *file,
"zeros in page with index = [0x%.16lx]\n", index);
goto out;
}
- rc = ecryptfs_encrypt_page(&folio->page);
+ rc = ecryptfs_encrypt_page(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 665bcd7d1c8e..b3b451c2b941 100644
--- a/fs/ecryptfs/read_write.c
+++ b/fs/ecryptfs/read_write.c
@@ -168,7 +168,7 @@ 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->page);
+ rc = ecryptfs_encrypt_page(ecryptfs_folio);
else
rc = ecryptfs_write_lower_page_segment(ecryptfs_inode,
ecryptfs_folio,
--
2.43.0
^ permalink raw reply related [flat|nested] 13+ messages in thread* [PATCH v2 08/10] ecryptfs: Convert ecryptfs_decrypt_page() to take a folio
2024-10-25 19:08 [PATCH v2 00/10] Convert ecryptfs to use folios Matthew Wilcox (Oracle)
` (6 preceding siblings ...)
2024-10-25 19:08 ` [PATCH v2 07/10] ecryptfs: Convert ecryptfs_encrypt_page() " Matthew Wilcox (Oracle)
@ 2024-10-25 19:08 ` Matthew Wilcox (Oracle)
2024-10-25 19:08 ` [PATCH v2 09/10] ecryptfs: Convert lower_offset_for_page() " Matthew Wilcox (Oracle)
` (3 subsequent siblings)
11 siblings, 0 replies; 13+ messages in thread
From: Matthew Wilcox (Oracle) @ 2024-10-25 19:08 UTC (permalink / raw)
To: Tyler Hicks
Cc: Matthew Wilcox (Oracle), ecryptfs, Christian Brauner,
linux-fsdevel
Both callers have a folio, so pass it in and use it throughout.
Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
---
fs/ecryptfs/crypto.c | 11 ++++++-----
fs/ecryptfs/ecryptfs_kernel.h | 2 +-
fs/ecryptfs/mmap.c | 4 ++--
3 files changed, 9 insertions(+), 8 deletions(-)
diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
index 995ae3a97d52..90d38da20f5c 100644
--- a/fs/ecryptfs/crypto.c
+++ b/fs/ecryptfs/crypto.c
@@ -461,7 +461,7 @@ int ecryptfs_encrypt_page(struct folio *folio)
/**
* ecryptfs_decrypt_page
- * @page: Page mapped from the eCryptfs inode for the file; data read
+ * @folio: Folio mapped from the eCryptfs inode for the file; data read
* and decrypted from the lower file will be written into this
* page
*
@@ -475,7 +475,7 @@ int ecryptfs_encrypt_page(struct folio *folio)
*
* Returns zero on success; negative on error
*/
-int ecryptfs_decrypt_page(struct page *page)
+int ecryptfs_decrypt_page(struct folio *folio)
{
struct inode *ecryptfs_inode;
struct ecryptfs_crypt_stat *crypt_stat;
@@ -484,13 +484,13 @@ int ecryptfs_decrypt_page(struct page *page)
loff_t lower_offset;
int rc = 0;
- ecryptfs_inode = page->mapping->host;
+ ecryptfs_inode = folio->mapping->host;
crypt_stat =
&(ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat);
BUG_ON(!(crypt_stat->flags & ECRYPTFS_ENCRYPTED));
- lower_offset = lower_offset_for_page(crypt_stat, page);
- page_virt = kmap_local_page(page);
+ lower_offset = lower_offset_for_page(crypt_stat, &folio->page);
+ page_virt = kmap_local_folio(folio, 0);
rc = ecryptfs_read_lower(page_virt, lower_offset, PAGE_SIZE,
ecryptfs_inode);
kunmap_local(page_virt);
@@ -504,6 +504,7 @@ int ecryptfs_decrypt_page(struct page *page)
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,
extent_offset, DECRYPT);
if (rc) {
diff --git a/fs/ecryptfs/ecryptfs_kernel.h b/fs/ecryptfs/ecryptfs_kernel.h
index bffced0c1d8f..1f562e75d0e4 100644
--- a/fs/ecryptfs/ecryptfs_kernel.h
+++ b/fs/ecryptfs/ecryptfs_kernel.h
@@ -570,7 +570,7 @@ void ecryptfs_destroy_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 page *page);
+int ecryptfs_decrypt_page(struct folio *folio);
int ecryptfs_write_metadata(struct dentry *ecryptfs_dentry,
struct inode *ecryptfs_inode);
int ecryptfs_read_metadata(struct dentry *ecryptfs_dentry);
diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index b2c22f49ef6f..60f0ac8744b5 100644
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -194,7 +194,7 @@ static int ecryptfs_read_folio(struct file *file, struct folio *folio)
}
}
} else {
- err = ecryptfs_decrypt_page(&folio->page);
+ err = ecryptfs_decrypt_page(folio);
if (err) {
ecryptfs_printk(KERN_ERR, "Error decrypting page; "
"err = [%d]\n", err);
@@ -305,7 +305,7 @@ static int ecryptfs_write_begin(struct file *file,
folio_zero_range(folio, 0, PAGE_SIZE);
folio_mark_uptodate(folio);
} else if (len < PAGE_SIZE) {
- rc = ecryptfs_decrypt_page(&folio->page);
+ rc = ecryptfs_decrypt_page(folio);
if (rc) {
printk(KERN_ERR "%s: Error decrypting "
"page at index [%ld]; "
--
2.43.0
^ permalink raw reply related [flat|nested] 13+ messages in thread* [PATCH v2 09/10] ecryptfs: Convert lower_offset_for_page() to take a folio
2024-10-25 19:08 [PATCH v2 00/10] Convert ecryptfs to use folios Matthew Wilcox (Oracle)
` (7 preceding siblings ...)
2024-10-25 19:08 ` [PATCH v2 08/10] ecryptfs: Convert ecryptfs_decrypt_page() " Matthew Wilcox (Oracle)
@ 2024-10-25 19:08 ` Matthew Wilcox (Oracle)
2024-10-25 19:08 ` [PATCH v2 10/10] ecryptfs: Pass the folio index to crypt_extent() Matthew Wilcox (Oracle)
` (2 subsequent siblings)
11 siblings, 0 replies; 13+ messages in thread
From: Matthew Wilcox (Oracle) @ 2024-10-25 19:08 UTC (permalink / raw)
To: Tyler Hicks
Cc: Matthew Wilcox (Oracle), ecryptfs, Christian Brauner,
linux-fsdevel
Both callers have a folio, so pass it in and use folio->index instead of
page->index.
Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
---
fs/ecryptfs/crypto.c | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
index 90d38da20f5c..bb65a3a5ee9b 100644
--- a/fs/ecryptfs/crypto.c
+++ b/fs/ecryptfs/crypto.c
@@ -328,10 +328,10 @@ static int crypt_scatterlist(struct ecryptfs_crypt_stat *crypt_stat,
* Convert an eCryptfs page index into a lower byte offset
*/
static loff_t lower_offset_for_page(struct ecryptfs_crypt_stat *crypt_stat,
- struct page *page)
+ struct folio *folio)
{
return ecryptfs_lower_header_size(crypt_stat) +
- ((loff_t)page->index << PAGE_SHIFT);
+ (loff_t)folio->index * PAGE_SIZE;
}
/**
@@ -440,7 +440,7 @@ int ecryptfs_encrypt_page(struct folio *folio)
}
}
- lower_offset = lower_offset_for_page(crypt_stat, &folio->page);
+ 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);
@@ -489,7 +489,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->page);
+ lower_offset = lower_offset_for_page(crypt_stat, folio);
page_virt = kmap_local_folio(folio, 0);
rc = ecryptfs_read_lower(page_virt, lower_offset, PAGE_SIZE,
ecryptfs_inode);
--
2.43.0
^ permalink raw reply related [flat|nested] 13+ messages in thread* [PATCH v2 10/10] ecryptfs: Pass the folio index to crypt_extent()
2024-10-25 19:08 [PATCH v2 00/10] Convert ecryptfs to use folios Matthew Wilcox (Oracle)
` (8 preceding siblings ...)
2024-10-25 19:08 ` [PATCH v2 09/10] ecryptfs: Convert lower_offset_for_page() " Matthew Wilcox (Oracle)
@ 2024-10-25 19:08 ` Matthew Wilcox (Oracle)
2024-11-05 15:01 ` [PATCH v2 00/10] Convert ecryptfs to use folios Matthew Wilcox
2024-11-05 16:21 ` Christian Brauner
11 siblings, 0 replies; 13+ messages in thread
From: Matthew Wilcox (Oracle) @ 2024-10-25 19:08 UTC (permalink / raw)
To: Tyler Hicks
Cc: Matthew Wilcox (Oracle), ecryptfs, Christian Brauner,
linux-fsdevel
We need to pass pages, not folios, to crypt_extent() as we may be
working with a plain page rather than a folio. But we need to know the
index in the file, so pass it in from the caller.
Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
---
fs/ecryptfs/crypto.c | 10 ++++++----
1 file changed, 6 insertions(+), 4 deletions(-)
diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
index bb65a3a5ee9b..69536cacdea8 100644
--- a/fs/ecryptfs/crypto.c
+++ b/fs/ecryptfs/crypto.c
@@ -340,6 +340,7 @@ static loff_t lower_offset_for_page(struct ecryptfs_crypt_stat *crypt_stat,
* encryption operation
* @dst_page: The page to write the result into
* @src_page: The page to read from
+ * @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
*
@@ -350,9 +351,9 @@ static loff_t lower_offset_for_page(struct ecryptfs_crypt_stat *crypt_stat,
static int crypt_extent(struct ecryptfs_crypt_stat *crypt_stat,
struct page *dst_page,
struct page *src_page,
+ pgoff_t page_index,
unsigned long extent_offset, int op)
{
- pgoff_t page_index = op == ENCRYPT ? src_page->index : dst_page->index;
loff_t extent_base;
char extent_iv[ECRYPTFS_MAX_IV_BYTES];
struct scatterlist src_sg, dst_sg;
@@ -432,7 +433,8 @@ int ecryptfs_encrypt_page(struct folio *folio)
extent_offset < (PAGE_SIZE / crypt_stat->extent_size);
extent_offset++) {
rc = crypt_extent(crypt_stat, enc_extent_page,
- folio_page(folio, 0), extent_offset, ENCRYPT);
+ folio_page(folio, 0), folio->index,
+ extent_offset, ENCRYPT);
if (rc) {
printk(KERN_ERR "%s: Error encrypting extent; "
"rc = [%d]\n", __func__, rc);
@@ -505,8 +507,8 @@ int ecryptfs_decrypt_page(struct folio *folio)
extent_offset < (PAGE_SIZE / crypt_stat->extent_size);
extent_offset++) {
struct page *page = folio_page(folio, 0);
- rc = crypt_extent(crypt_stat, page, page,
- extent_offset, DECRYPT);
+ rc = crypt_extent(crypt_stat, page, page, folio->index,
+ extent_offset, DECRYPT);
if (rc) {
printk(KERN_ERR "%s: Error decrypting extent; "
"rc = [%d]\n", __func__, rc);
--
2.43.0
^ permalink raw reply related [flat|nested] 13+ messages in thread* Re: [PATCH v2 00/10] Convert ecryptfs to use folios
2024-10-25 19:08 [PATCH v2 00/10] Convert ecryptfs to use folios Matthew Wilcox (Oracle)
` (9 preceding siblings ...)
2024-10-25 19:08 ` [PATCH v2 10/10] ecryptfs: Pass the folio index to crypt_extent() Matthew Wilcox (Oracle)
@ 2024-11-05 15:01 ` Matthew Wilcox
2024-11-05 16:21 ` Christian Brauner
11 siblings, 0 replies; 13+ messages in thread
From: Matthew Wilcox @ 2024-11-05 15:01 UTC (permalink / raw)
To: Christian Brauner; +Cc: ecryptfs, Tyler Hicks, linux-fsdevel
On Fri, Oct 25, 2024 at 08:08:10PM +0100, Matthew Wilcox (Oracle) wrote:
> The next step in the folio project is to remove page->index. This
> patchset does that for ecryptfs. As an unloved filesystem, I haven't
> made any effort to support large folios; this is just "keep it working".
> I have only compile tested this, but since it's a straightforward
> conversion I'm not expecting any problems beyond my fat fingers.
>
> v2:
> - Switch from 'rc' to 'err' in ecryptfs_read_folio
> - Use folio_end_read() in ecryptfs_read_folio
> - Remove kernel-doc warnings that 0day warned about
> - R-b tags from Pankaj
Christian, can you take this patch series through the vfs tree?
There's been no movement on it in two weeks, and i fear it will miss the
next merge window.
^ permalink raw reply [flat|nested] 13+ messages in thread* Re: [PATCH v2 00/10] Convert ecryptfs to use folios
2024-10-25 19:08 [PATCH v2 00/10] Convert ecryptfs to use folios Matthew Wilcox (Oracle)
` (10 preceding siblings ...)
2024-11-05 15:01 ` [PATCH v2 00/10] Convert ecryptfs to use folios Matthew Wilcox
@ 2024-11-05 16:21 ` Christian Brauner
11 siblings, 0 replies; 13+ messages in thread
From: Christian Brauner @ 2024-11-05 16:21 UTC (permalink / raw)
To: Matthew Wilcox (Oracle)
Cc: Christian Brauner, ecryptfs, linux-fsdevel, Tyler Hicks
On Fri, 25 Oct 2024 20:08:10 +0100, Matthew Wilcox (Oracle) wrote:
> The next step in the folio project is to remove page->index. This
> patchset does that for ecryptfs. As an unloved filesystem, I haven't
> made any effort to support large folios; this is just "keep it working".
> I have only compile tested this, but since it's a straightforward
> conversion I'm not expecting any problems beyond my fat fingers.
>
> v2:
> - Switch from 'rc' to 'err' in ecryptfs_read_folio
> - Use folio_end_read() in ecryptfs_read_folio
> - Remove kernel-doc warnings that 0day warned about
> - R-b tags from Pankaj
>
> [...]
I hope to be back on a regular schedule tomorrow.
I have been down with atypical pneumonia (who knows how I got that) and
have not been able to do anything for a while.
---
Applied to the vfs.ecryptfs branch of the vfs/vfs.git tree.
Patches in the vfs.ecryptfs branch should appear in linux-next soon.
Please report any outstanding bugs that were missed during review in a
new review to the original patch series allowing us to drop it.
It's encouraged to provide Acked-bys and Reviewed-bys even though the
patch has now been applied. If possible patch trailers will be updated.
Note that commit hashes shown below are subject to change due to rebase,
trailer updates or similar. If in doubt, please check the listed branch.
tree: https://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs.git
branch: vfs.ecryptfs
[01/10] ecryptfs: Convert ecryptfs_writepage() to ecryptfs_writepages()
https://git.kernel.org/vfs/vfs/c/807a11dab9dc
[02/10] ecryptfs: Use a folio throughout ecryptfs_read_folio()
https://git.kernel.org/vfs/vfs/c/064fe6b4752c
[03/10] ecryptfs: Convert ecryptfs_copy_up_encrypted_with_header() to take a folio
https://git.kernel.org/vfs/vfs/c/497eb79c3191
[04/10] ecryptfs: Convert ecryptfs_read_lower_page_segment() to take a folio
https://git.kernel.org/vfs/vfs/c/890d477a0fcd
[05/10] ecryptfs: Convert ecryptfs_write() to use a folio
https://git.kernel.org/vfs/vfs/c/4d3727fd065b
[06/10] ecryptfs: Convert ecryptfs_write_lower_page_segment() to take a folio
https://git.kernel.org/vfs/vfs/c/de5ced2721f9
[07/10] ecryptfs: Convert ecryptfs_encrypt_page() to take a folio
https://git.kernel.org/vfs/vfs/c/6b9c0e813743
[08/10] ecryptfs: Convert ecryptfs_decrypt_page() to take a folio
https://git.kernel.org/vfs/vfs/c/c15b81461df9
[09/10] ecryptfs: Convert lower_offset_for_page() to take a folio
https://git.kernel.org/vfs/vfs/c/bf64913dfe62
[10/10] ecryptfs: Pass the folio index to crypt_extent()
https://git.kernel.org/vfs/vfs/c/9b4bb822448b
^ permalink raw reply [flat|nested] 13+ messages in thread