页面换入

static inline int handle_pte_fault(struct mm_struct *mm,
    struct vm_area_struct * vma, unsigned long address,
    int write_access, pte_t * pte)
{
    pte_t entry;

    /*
     * We need the page table lock to synchronize with kswapd
     * and the SMP-safe atomic PTE updates.
     */
    spin_lock(&mm->page_table_lock);
    entry = *pte;
    if (!pte_present(entry)) {检查是否在内存中
        /*
         * If it truly wasn't present, we know that kswapd
         * and the PTE updates will not touch it later. So
         * drop the lock.
         */
        spin_unlock(&mm->page_table_lock);
        if (pte_none(entry))
            return do_no_page(mm, vma, address, write_access, pte);//映射没有建立
        return do_swap_page(mm, vma, address, pte, pte_to_swp_entry(entry), write_access);//没有建立映射，从交换设备换入
    }

    if (write_access) {
        if (!pte_write(entry))
            return do_wp_page(mm, vma, address, pte, entry);

        entry = pte_mkdirty(entry);
    }
    entry = pte_mkyoung(entry);
    establish_pte(vma, address, pte, entry);
    spin_unlock(&mm->page_table_lock);
    return 1;
}


static int do_swap_page(struct mm_struct * mm,
    struct vm_area_struct * vma, unsigned long address,
    pte_t * page_table, swp_entry_t entry, int write_access)
{
    struct page *page = lookup_swap_cache(entry);//是否还在交换区中
    pte_t pte;

    if (!page) {
        lock_kernel();
        swapin_readahead(entry);//预读
        page = read_swap_cache(entry);//再读
        unlock_kernel();
        if (!page)
            return -1;
/*对i386为空操作*/
        flush_page_to_ram(page);
        flush_icache_page(vma, page);
    }

    mm->rss++;

    pte = mk_pte(page, vma->vm_page_prot);

    /*
     * Freeze the "shared"ness of the page, ie page_count + swap_count.
     * Must lock page before transferring our swap count to already
     * obtained page count.
     */
    lock_page(page);
    swap_free(entry);
    if (write_access && !is_page_shared(page))
        pte = pte_mkwrite(pte_mkdirty(pte));
    UnlockPage(page);

    set_pte(page_table, pte);
    /* No need to invalidate - it was non-present before */
    update_mmu_cache(vma, address, pte);//空操作
    return 1;    /* Minor fault */
}

#define read_swap_cache(entry) read_swap_cache_async(entry, 1);
/*
 * Locate a page of swap in physical memory, reserving swap cache space
 * and reading the disk if it is not already cached. If wait==0, we are
 * only doing readahead, so don't worry if the page is already locked.
 *
 * A failure return means that either the page allocation failed or that
 * the swap entry is no longer in use.
 */

struct page * read_swap_cache_async(swp_entry_t entry, int wait)
{
    struct page *found_page = 0, *new_page;
    unsigned long new_page_addr;

    /*
     * Make sure the swap entry is still in use.
     */
    if (!swap_duplicate(entry))    /* Account for the swap cache */递增页面共享技术
        goto out;
    /*
     * Look for the page in the swap cache.
     */
    found_page = lookup_swap_cache(entry);
    if (found_page)
        goto out_free_swap;

    new_page_addr = __get_free_page(GFP_USER);
    if (!new_page_addr)
        goto out_free_swap;    /* Out of memory */
    new_page = virt_to_page(new_page_addr);

    /*
     * Check the swap cache again, in case we stalled above.
     */
    found_page = lookup_swap_cache(entry);
    if (found_page)
        goto out_free_page;
    /*
     * Add it to the swap cache and read its contents.
     */
    lock_page(new_page);
    add_to_swap_cache(new_page, entry);
    rw_swap_page(READ, new_page, wait);
    return new_page;

out_free_page:
    page_cache_release(new_page);
out_free_swap:
    swap_free(entry);
out:
    return found_page;
}