__collapse_huge_page_isolate()

static int __collapse_huge_page_isolate(struct vm_area_struct *vma,
                                        unsigned long address,
                                        pte_t *pte)
{
        struct page *page;
        pte_t *_pte;
        int referenced = 0, none = 0, ro = 0;
        bool read_only_pte = false;
        for (_pte = pte; _pte < pte+HPAGE_PMD_NR;
             _pte++, address += PAGE_SIZE) {
                pte_t pteval = *_pte;

                if (!pte_write(pteval)) {
                        read_only_pte = true;
                        if (++ro > khugepaged_max_ptes_none)
                                goto out;
                }

                if (pte_none(pteval)) {
                        if (++none <= khugepaged_max_ptes_none)
                                continue;
                        else
                                goto out;
                }
                if (!pte_present(pteval))
                        goto out;
                page = vm_normal_page(vma, address, pteval);
                if (unlikely(!page))
                        goto out;

                if (read_only_pte) {
                        read_only_pte = false;
                        if (PageLRU(page))
				pr_info("mm: read-only pte on the page lru\n");
                        else
                       		pr_info("mm: read-only pte is not on the page lru\n");
                        if (PageSwapCache(page)) {
                                pr_info("mm: read-only pte on the swap cache\n");
                                pr_info("before reuse_swap_page(), page count: %d\n",
                                        page_count(page));
                                reuse_swap_page(page);
                        } else {
                                pr_info("mm: read-only pte is not on swap cache\n");
                        }
                        pr_info("page count : %d\n", page_count(page));
                }

                VM_BUG_ON_PAGE(PageCompound(page), page);
                VM_BUG_ON_PAGE(!PageAnon(page), page);
                VM_BUG_ON_PAGE(!PageSwapBacked(page), page);

                /* cannot use mapcount: can't collapse if there's a gup pin */
                if (page_count(page) != 1 + !!PageSwapCache(page))
                        goto out;

                /*
                 * We can do it before isolate_lru_page because the
                 * page can't be freed from under us. NOTE: PG_lock
                 * is needed to serialize against split_huge_page
                 * when invoked from the VM.
                 */
                if (!trylock_page(page))
                        goto out;
                /*
                 * Isolate the page to avoid collapsing an hugepage
                 * currently in use by the VM.
                 */
                if (isolate_lru_page(page)) {
                        unlock_page(page);
                        goto out;
                }
                /* 0 stands for page_is_file_cache(page) == false */
                inc_zone_page_state(page, NR_ISOLATED_ANON + 0);
		VM_BUG_ON_PAGE(!PageLocked(page), page);
                VM_BUG_ON_PAGE(PageLRU(page), page);

                /* If there is no mapped pte young don't collapse the page */
                if (pte_young(pteval) || PageReferenced(page) ||
                    mmu_notifier_test_young(vma->vm_mm, address))
                        referenced = 1;
        }
        if (likely(referenced))
                return 1;
out:
        release_pte_pages(pte, _pte);
        return 0;
}