ocfs2: Convert ocfs2_read_folio() to use a folio

Use the folio API throughout.  There are a few places where we convert
back to a page to call into the rest of the filesystem, so folio usage
needs to be pushed down to those functions later.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>

diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index 35d40a6..767df51 100644 (file)
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -277,16 +277,14 @@ out:
 
 static int ocfs2_read_folio(struct file *file, struct folio *folio)
 {
-       struct page *page = &folio->page;
-       struct inode *inode = page->mapping->host;
+       struct inode *inode = folio->mapping->host;
        struct ocfs2_inode_info *oi = OCFS2_I(inode);
-       loff_t start = (loff_t)page->index << PAGE_SHIFT;
+       loff_t start = folio_pos(folio);
        int ret, unlock = 1;
 
-       trace_ocfs2_readpage((unsigned long long)oi->ip_blkno,
-                            (page ? page->index : 0));
+       trace_ocfs2_readpage((unsigned long long)oi->ip_blkno, folio->index);
 
-       ret = ocfs2_inode_lock_with_page(inode, NULL, 0, page);
+       ret = ocfs2_inode_lock_with_page(inode, NULL, 0, &folio->page);
        if (ret != 0) {
                if (ret == AOP_TRUNCATED_PAGE)
                        unlock = 0;
@@ -296,11 +294,11 @@ static int ocfs2_read_folio(struct file *file, struct folio *folio)
 
        if (down_read_trylock(&oi->ip_alloc_sem) == 0) {
                /*
-                * Unlock the page and cycle ip_alloc_sem so that we don't
+                * Unlock the folio and cycle ip_alloc_sem so that we don't
                 * busyloop waiting for ip_alloc_sem to unlock
                 */
                ret = AOP_TRUNCATED_PAGE;
-               unlock_page(page);
+               folio_unlock(folio);
                unlock = 0;
                down_read(&oi->ip_alloc_sem);
                up_read(&oi->ip_alloc_sem);
@@ -313,21 +311,21 @@ static int ocfs2_read_folio(struct file *file, struct folio *folio)
         * block_read_full_folio->get_block freaks out if it is asked to read
         * beyond the end of a file, so we check here.  Callers
         * (generic_file_read, vm_ops->fault) are clever enough to check i_size
-        * and notice that the page they just read isn't needed.
+        * and notice that the folio they just read isn't needed.
         *
         * XXX sys_readahead() seems to get that wrong?
         */
        if (start >= i_size_read(inode)) {
-               zero_user(page, 0, PAGE_SIZE);
-               SetPageUptodate(page);
+               folio_zero_segment(folio, 0, folio_size(folio));
+               folio_mark_uptodate(folio);
                ret = 0;
                goto out_alloc;
        }
 
        if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL)
-               ret = ocfs2_readpage_inline(inode, page);
+               ret = ocfs2_readpage_inline(inode, &folio->page);
        else
-               ret = block_read_full_folio(page_folio(page), ocfs2_get_block);
+               ret = block_read_full_folio(folio, ocfs2_get_block);
        unlock = 0;
 
 out_alloc:
@@ -336,7 +334,7 @@ out_inode_unlock:
        ocfs2_inode_unlock(inode, 0);
 out:
        if (unlock)
-               unlock_page(page);
+               folio_unlock(folio);
        return ret;
 }