pageout

/*
 * pageout is called by shrink_page_list() for each dirty page.
 * Calls ->writepage().
 */
static pageout_t pageout(struct page *page, struct address_space *mapping)
{
    /*
     * If the page is dirty, only perform writeback if that write
     * will be non-blocking.  To prevent this allocation from being
     * stalled by pagecache activity.  But note that there may be
     * stalls if we need to run get_block().  We could test
     * PagePrivate for that.
     *
     * If this process is currently in __generic_file_write_iter() against
     * this page's queue, we can perform writeback even if that
     * will block.
     *
     * If the page is swapcache, write it back even if that would
     * block, for some throttling. This happens by accident, because
     * swap_backing_dev_info is bust: it doesn't reflect the
     * congestion state of the swapdevs.  Easy to fix, if needed.
     */
    if (!is_page_cache_freeable(page))
        return PAGE_KEEP;
    if (!mapping) {
        /*
         * Some data journaling orphaned pages can have
         * page->mapping == NULL while being dirty with clean buffers.
         */
        if (page_has_private(page)) {
            if (try_to_free_buffers(page)) {
                ClearPageDirty(page);
                pr_info("%s: orphaned page\n", __func__);
                return PAGE_CLEAN;
            }
        }
        return PAGE_KEEP;
    }
    if (mapping->a_ops->writepage == NULL)
        return PAGE_ACTIVATE;
    if (!may_write_to_inode(mapping->host))
        return PAGE_KEEP;
 
    if (clear_page_dirty_for_io(page)) {
        int res;
        struct writeback_control wbc = {
            .sync_mode = WB_SYNC_NONE,
            .nr_to_write = SWAP_CLUSTER_MAX,
            .range_start = 0,
            .range_end = LLONG_MAX,
            .for_reclaim = 1,
        };
 
        SetPageReclaim(page);
        res = mapping->a_ops->writepage(page, &wbc);
        if (res < 0)
            handle_write_error(mapping, page, res);
        if (res == AOP_WRITEPAGE_ACTIVATE) {
            ClearPageReclaim(page);
            return PAGE_ACTIVATE;
        }
 
        if (!PageWriteback(page)) {
            /* synchronous write or broken a_ops? */
            ClearPageReclaim(page);
        }
        trace_mm_vmscan_writepage(page);
        inc_node_page_state(page, NR_VMSCAN_WRITE);
        return PAGE_SUCCESS;
    }
 
    return PAGE_CLEAN;
}
函数源码
