Remove last traces of ->sync_page

through sync_buffer() running blk_run_address_space(mapping). Or the caller

can do it explicity through blk_unplug(bdev). So in the read case,

the queue gets explicitly unplugged as part of waiting for completion on that

buffer. For page driven IO, the address space ->sync_page() takes care of

doing the blk_run_address_space().

buffer.

Aside:

  This is kind of controversial territory, as it's not clear if plugging is

prototypes:

	int (*writepage)(struct page *page, struct writeback_control *wbc);

	int (*readpage)(struct file *, struct page *);

	int (*sync_page)(struct page *);

	int (*writepages)(struct address_space *, struct writeback_control *);

	int (*set_page_dirty)(struct page *page);

	int (*readpages)(struct file *filp, struct address_space *mapping,

			PageLocked(page)	i_mutex

writepage:		yes, unlocks (see below)

readpage:		yes, unlocks

sync_page:		maybe

writepages:

set_page_dirty		no

readpages:

swap_activate:		no

swap_deactivate:	no

	->write_begin(), ->write_end(), ->sync_page() and ->readpage()

may be called from the request handler (/dev/loop).

	->write_begin(), ->write_end() and ->readpage() may be called from

the request handler (/dev/loop).

	->readpage() unlocks the page, either synchronously or via I/O

completion.

radix tree.  This incoherency can lead to all sorts of hard-to-debug problems

in the filesystem like having dirty inodes at umount and losing written data.

	->sync_page() locking rules are not well-defined - usually it is called

with lock on page, but that is not guaranteed. Considering the currently

existing instances of this method ->sync_page() itself doesn't look

well-defined...

	->writepages() is used for periodic writeback and for syscall-initiated

sync operations.  The address_space should start I/O against at least

*nr_to_write pages.  *nr_to_write must be decremented for each page which is

writing out the whole address_space.

The Writeback tag is used by filemap*wait* and sync_page* functions,

via filemap_fdatawait_range, to wait for all writeback to

complete.  While waiting ->sync_page (if defined) will be called on

each page that is found to require writeback.

via filemap_fdatawait_range, to wait for all writeback to complete.

An address_space handler may attach extra information to a page,

typically using the 'private' field in the 'struct page'.  If such

The read process essentially only requires 'readpage'.  The write

process is more complicated and uses write_begin/write_end or

set_page_dirty to write data into the address_space, and writepage,

sync_page, and writepages to writeback data to storage.

set_page_dirty to write data into the address_space, and writepage

and writepages to writeback data to storage.

Adding and removing pages to/from an address_space is protected by the

inode's i_mutex.

const struct address_space_operations zisofs_aops = {

	.readpage = zisofs_readpage,

	/* No sync_page operation supported? */

	/* No bmap operation supported */

};

	/* Need this to sanity check attribute list references to $MFT. */

	vi->i_generation = ni->seq_no = le16_to_cpu(m->sequence_number);

	/* Provides readpage() and sync_page() for map_mft_record(). */

	/* Provides readpage() for map_mft_record(). */

	vi->i_mapping->a_ops = &ntfs_mst_aops;

	ctx = ntfs_attr_get_search_ctx(ni, m);