int do_writepages(struct address_space *mapping, struct writeback_control *wbc) { int ret; if (wbc->nr_to_write <= 0) return 0; if (mapping->a_ops->writepages) ret = mapping->a_ops->writepages(mapping, wbc); else ret = generic_writepages(mapping, wbc); return ret; }
/** * gfs2_writepages - Write a bunch of dirty pages back to disk * @mapping: The mapping to write * @wbc: Write-back control * * For journaled files and/or ordered writes this just falls back to the * kernel's default writepages path for now. We will probably want to change * that eventually (i.e. when we look at allocate on flush). * * For the data=writeback case though we can already ignore buffer heads * and write whole extents at once. This is a big reduction in the * number of I/O requests we send and the bmap calls we make in this case. */ static int gfs2_writepages(struct address_space *mapping, struct writeback_control *wbc) { struct inode *inode = mapping->host; struct gfs2_inode *ip = GFS2_I(inode); struct gfs2_sbd *sdp = GFS2_SB(inode); if (sdp->sd_args.ar_data == GFS2_DATA_WRITEBACK && !gfs2_is_jdata(ip)) return mpage_writepages(mapping, wbc, gfs2_get_block_noalloc); return generic_writepages(mapping, wbc); }
/** * mpage_writepages - walk the list of dirty pages of the given address space & writepage() all of them * @mapping: address space structure to write * @wbc: subtract the number of written pages from *@wbc->nr_to_write * @get_block: the filesystem's block mapper function. * If this is NULL then use a_ops->writepage. Otherwise, go * direct-to-BIO. * * This is a library function, which implements the writepages() * address_space_operation. * * If a page is already under I/O, generic_writepages() skips it, even * if it's dirty. This is desirable behaviour for memory-cleaning writeback, * but it is INCORRECT for data-integrity system calls such as fsync(). fsync() * and msync() need to guarantee that all the data which was dirty at the time * the call was made get new I/O started against them. If wbc->sync_mode is * WB_SYNC_ALL then we were called for data integrity and we must wait for * existing IO to complete. */ int mpage_writepages(struct address_space *mapping, struct writeback_control *wbc, get_block_t get_block) { struct blk_plug plug; int ret; blk_start_plug(&plug); if (!get_block) ret = generic_writepages(mapping, wbc); else { struct mpage_data mpd = { .bio = NULL, .last_block_in_bio = 0, .get_block = get_block, .use_writepage = 1, }; ret = write_cache_pages(mapping, wbc, __mpage_writepage, &mpd); if (mpd.bio) { int wr = (wbc->sync_mode == WB_SYNC_ALL ? WRITE_SYNC : WRITE); mpage_bio_submit(wr, mpd.bio); } } blk_finish_plug(&plug); return ret; } EXPORT_SYMBOL(mpage_writepages); int mpage_writepage(struct page *page, get_block_t get_block, struct writeback_control *wbc) { struct mpage_data mpd = { .bio = NULL, .last_block_in_bio = 0, .get_block = get_block, .use_writepage = 0, }; int ret = __mpage_writepage(page, wbc, &mpd); if (mpd.bio) { int wr = (wbc->sync_mode == WB_SYNC_ALL ? WRITE_SYNC : WRITE); mpage_bio_submit(wr, mpd.bio); } return ret; } EXPORT_SYMBOL(mpage_writepage);
int do_writepages(struct address_space *mapping, struct writeback_control *wbc) { int ret; #ifdef CONFIG_OPTIMIZE_SD_PERFORMANCE /* no need to write device if the operation is not used to format device */ if (imajor(mapping->host) && (wbc->sync_mode == WB_SYNC_NONE) && !mapping->host->format_used) return 0; #endif if (wbc->nr_to_write <= 0) return 0; if (mapping->a_ops->writepages) ret = mapping->a_ops->writepages(mapping, wbc); else ret = generic_writepages(mapping, wbc); #ifdef CONFIG_OPTIMIZE_SD_PERFORMANCE /* recover initial state of this inode */ if (mapping->host->format_used) mapping->host->format_used = 0; #endif return ret; }