ecryptfs: Convert ecryptfs_write() to use a folio

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>
Link: https://lore.kernel.org/r/20241025190822.1319162-6-willy@infradead.org
Reviewed-by: Pankaj Raghav <p.raghav@samsung.com>
Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/fs/ecryptfs/ecryptfs_kernel.h b/fs/ecryptfs/ecryptfs_kernel.h
index 43f1b5f..f04aa24 100644 (file)
--- 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 1fc87c8..f6b9390 100644 (file)
--- 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 251e9f6..cddfdfc 100644 (file)
--- 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);