buffer: make block_write_full_page() handle large folios correctly

			struct writeback_control *wbc)

{

	struct folio *folio = page_folio(page);

	struct inode * const inode = page->mapping->host;

	struct inode * const inode = folio->mapping->host;

	loff_t i_size = i_size_read(inode);

	const pgoff_t end_index = i_size >> PAGE_SHIFT;

	unsigned offset;

	/* Is the page fully inside i_size? */

	if (page->index < end_index)

	/* Is the folio fully inside i_size? */

	if (folio_pos(folio) + folio_size(folio) <= i_size)

		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) {

	/* Is the folio fully outside i_size? (truncate in progress) */

	if (folio_pos(folio) >= i_size) {

		folio_unlock(folio);

		return 0; /* don't care */

	}

	/*

	 * The page straddles i_size.  It must be zeroed out on each and every

	 * The folio straddles i_size.  It must be zeroed out on each and every

	 * writepage invocation because it may be mmapped.  "A file is mapped

	 * in multiples of the page size.  For a file that is not a multiple of

	 * the page size, the remaining memory is zeroed when mapped, and

	 * writes to that region are not written out to the file."

	 */

	zero_user_segment(page, offset, PAGE_SIZE);

	folio_zero_segment(folio, offset_in_folio(folio, i_size),

			folio_size(folio));

	return __block_write_full_folio(inode, folio, get_block, wbc,

			end_buffer_async_write);

}