buffer: convert __block_write_full_page() to __block_write_full_folio()

Remove nine hidden calls to compound_head() by using a folio instead of a page.

Matthew Wilcox (Oracle) committed 3 years ago

Commit 53418a11 parent c1401fd5 files · +32 −32Browse files

Unified · Split

5 files

fs/buffer.c +27 −26
fs/gfs2/aops.c +2 −3
fs/ntfs/aops.c +1 −1
fs/reiserfs/inode.c +1 −1
include/linux/buffer_head.h +1 −1

  * WB_SYNC_ALL, the writes are posted using REQ_SYNC; this
  * causes the writes to be flagged as synchronous writes.
  */
-int __block_write_full_page(struct inode *inode, struct page *page,
+int __block_write_full_folio(struct inode *inode, struct folio *folio,
 			get_block_t *get_block, struct writeback_control *wbc,
 			bh_end_io_t *handler)
 {
 	int nr_underway = 0;
 	blk_opf_t write_flags = wbc_to_write_flags(wbc);
-	head = folio_create_buffers(page_folio(page), inode,
+	head = folio_create_buffers(folio, inode,
 				    (1 << BH_Dirty) | (1 << BH_Uptodate));
 	/*
 	 * Be very careful.  We have no exclusion from block_dirty_folio
 	 * here, and the (potentially unmapped) buffers may become dirty at
 	 * any time.  If a buffer becomes dirty here after we've inspected it
-	 * then we just miss that fact, and the page stays dirty.
+	 * then we just miss that fact, and the folio stays dirty.
 	 *
 	 * Buffers outside i_size may be dirtied by block_dirty_folio;
 	 * handle that here by just cleaning them.
 	blocksize = bh->b_size;
 	bbits = block_size_bits(blocksize);
-	block = (sector_t)page->index << (PAGE_SHIFT - bbits);
+	block = (sector_t)folio->index << (PAGE_SHIFT - bbits);
 	last_block = (i_size_read(inode) - 1) >> bbits;
 	/*
 		if (block > last_block) {
 			/*
 			 * mapped buffers outside i_size will occur, because
-			 * this page can be outside i_size when there is a
+			 * this folio can be outside i_size when there is a
 			 * truncate in progress.
 			 */
 			/*
 			continue;
 		/*
 		 * If it's a fully non-blocking write attempt and we cannot
-		 * lock the buffer then redirty the page.  Note that this can
+		 * lock the buffer then redirty the folio.  Note that this can
 		 * potentially cause a busy-wait loop from writeback threads
 		 * and kswapd activity, but those code paths have their own
 		 * higher-level throttling.
 		if (wbc->sync_mode != WB_SYNC_NONE) {
 			lock_buffer(bh);
 		} else if (!trylock_buffer(bh)) {
-			redirty_page_for_writepage(wbc, page);
+			folio_redirty_for_writepage(wbc, folio);
 			continue;
 		}
 		if (test_clear_buffer_dirty(bh)) {
 	} while ((bh = bh->b_this_page) != head);
 	/*
-	 * The page and its buffers are protected by PageWriteback(), so we can
+	 * The folio and its buffers are protected by the writeback flag,
-	 * drop the bh refcounts early.
+	 * so we can drop the bh refcounts early.
 	 */
-	BUG_ON(PageWriteback(page));
+	BUG_ON(folio_test_writeback(folio));
-	set_page_writeback(page);
+	folio_start_writeback(folio);
 	do {
 		struct buffer_head *next = bh->b_this_page;
 		}
 		bh = next;
 	} while (bh != head);
-	unlock_page(page);
+	folio_unlock(folio);
 	err = 0;
 done:
 	if (nr_underway == 0) {
 		/*
-		 * The page was marked dirty, but the buffers were
+		 * The folio was marked dirty, but the buffers were
 		 * clean.  Someone wrote them back by hand with
 		 * write_dirty_buffer/submit_bh.  A rare case.
 		 */
-		end_page_writeback(page);
+		folio_end_writeback(folio);
 		/*
-		 * The page and buffer_heads can be released at any time from
+		 * The folio and buffer_heads can be released at any time from
 		 * here on.
 		 */
 	}
 	 * ENOSPC, or some other error.  We may already have added some
 	 * blocks to the file, so we need to write these out to avoid
 	 * exposing stale data.
-	 * The page is currently locked and not marked for writeback
+	 * The folio is currently locked and not marked for writeback
 	 */
 	bh = head;
 	/* Recovery: lock and submit the mapped buffers */
 		} else {
 			/*
 			 * The buffer may have been set dirty during
-			 * attachment to a dirty page.
+			 * attachment to a dirty folio.
 			 */
 			clear_buffer_dirty(bh);
 		}
 	} while ((bh = bh->b_this_page) != head);
-	SetPageError(page);
+	folio_set_error(folio);
-	BUG_ON(PageWriteback(page));
+	BUG_ON(folio_test_writeback(folio));
-	mapping_set_error(page->mapping, err);
+	mapping_set_error(folio->mapping, err);
-	set_page_writeback(page);
+	folio_start_writeback(folio);
 	do {
 		struct buffer_head *next = bh->b_this_page;
 		if (buffer_async_write(bh)) {
 		}
 		bh = next;
 	} while (bh != head);
-	unlock_page(page);
+	folio_unlock(folio);
 	goto done;
 }
-EXPORT_SYMBOL(__block_write_full_page);
+EXPORT_SYMBOL(__block_write_full_folio);
 /*
  * If a page has any new buffers, zero them out here, and mark them uptodate
 int block_write_full_page(struct page *page, get_block_t *get_block,
 			struct writeback_control *wbc)
 {
+	struct folio *folio = page_folio(page);
 	struct inode * const inode = page->mapping->host;
 	loff_t i_size = i_size_read(inode);
 	const pgoff_t end_index = i_size >> PAGE_SHIFT;
 	/* Is the page fully inside i_size? */
 	if (page->index < end_index)
-		return __block_write_full_page(inode, page, get_block, wbc,
+		return __block_write_full_folio(inode, folio, get_block, wbc,
 					       end_buffer_async_write);
 	/* Is the page fully outside i_size? (truncate in progress) */
 	offset = i_size & (PAGE_SIZE-1);
 	if (page->index >= end_index+1 || !offset) {
-		unlock_page(page);
+		folio_unlock(folio);
 		return 0; /* don't care */
 	}
 	 * writes to that region are not written out to the file."
 	 */
 	zero_user_segment(page, offset, PAGE_SIZE);
-	return __block_write_full_page(inode, page, get_block, wbc,
+	return __block_write_full_folio(inode, folio, get_block, wbc,
 							end_buffer_async_write);
 }
 EXPORT_SYMBOL(block_write_full_page);

fs/gfs2/aops.c+2−3

@@ -107,9 +107,8 @@ static int gfs2_write_jdata_folio(struct folio *folio, · 106 unmodified lines
107	folio_zero_segment(folio, offset_in_folio(folio, i_size),	107	folio_zero_segment(folio, offset_in_folio(folio, i_size),
108	folio_size(folio));	108	folio_size(folio));
109		109
110	return __block_write_full_page(inode, &folio->page,	110	return __block_write_full_folio(inode, folio, gfs2_get_block_noalloc,
111	gfs2_get_block_noalloc, wbc,	111	wbc, end_buffer_async_write);
112	end_buffer_async_write);
113	}	112	}
114		113
115	/**	114	/**

fs/ntfs/aops.c+1−1

@@ -526,7 +526,7 @@ err_out: · 525 unmodified lines
526	*	526	*
527	* Return 0 on success and -errno on error.	527	* Return 0 on success and -errno on error.
528	*	528	*
529	* Based on ntfs_read_block() and __block_write_full_page().	529	* Based on ntfs_read_block() and __block_write_full_folio().
530	*/	530	*/
531	static int ntfs_write_block(struct page page, struct writeback_control wbc)	531	static int ntfs_write_block(struct page page, struct writeback_control wbc)
532	{	532	{

fs/reiserfs/inode.c+1−1

@@ -2506,7 +2506,7 @@ out: · 2505 unmodified lines
2506		2506
2507	/*	2507	/*
2508	* mason@suse.com: updated in 2.5.54 to follow the same general io	2508	* mason@suse.com: updated in 2.5.54 to follow the same general io
2509	* start/recovery path as __block_write_full_page, along with special	2509	* start/recovery path as __block_write_full_folio, along with special
2510	* code to handle reiserfs tails.	2510	* code to handle reiserfs tails.
2511	*/	2511	*/
2512	static int reiserfs_write_full_page(struct page *page,	2512	static int reiserfs_write_full_page(struct page *page,

include/linux/buffer_head.h+1−1

@@ -263,7 +263,7 @@ extern int buffer_heads_over_limit; · 262 unmodified lines
263	void block_invalidate_folio(struct folio *folio, size_t offset, size_t length);	263	void block_invalidate_folio(struct folio *folio, size_t offset, size_t length);
264	int block_write_full_page(struct page page, get_block_t get_block,	264	int block_write_full_page(struct page page, get_block_t get_block,
265	struct writeback_control *wbc);	265	struct writeback_control *wbc);
266	int __block_write_full_page(struct inode inode, struct page page,	266	int __block_write_full_folio(struct inode inode, struct folio folio,
267	get_block_t get_block, struct writeback_control wbc,	267	get_block_t get_block, struct writeback_control wbc,
268	bh_end_io_t *handler);	268	bh_end_io_t *handler);
269	int block_read_full_folio(struct folio , get_block_t );	269	int block_read_full_folio(struct folio , get_block_t );

buffer: convert __block_write_full_page() to __block_write_full_folio()

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code