透明大页

透明大页（transparent hugepages）和普通大页的区别是，透明大页 可以实时配置，不需要重启配置就可以生效，第二个是，利用khugepage thread 分配，不用在开机的时候预留，第三是透明大页 不再依赖hugetlbfs。透明大页映射的时机有两个。

要使用透明大页，就需要想之前一样通过通过 mount hugetlbfs。来实现，而是通过user space使用的时候调用fadvise()/madvise()的时候设定advise/within_size

第一个：handle_mm_fault->__handle_mm_fault

static int __handle_mm_fault(struct vm_area_struct *vma, unsigned long address,

        unsigned int flags)

{

    struct fault_env fe = {

        .vma = vma,

        .address = address,

        .flags = flags,

    };

    struct mm_struct *mm = vma->vm_mm;

    pgd_t *pgd;

    pud_t *pud;

    pgd = pgd_offset(mm, address);

    pud = pud_alloc(mm, pgd, address);

    if (!pud)

        return VM_FAULT_OOM;

    fe.pmd = pmd_alloc(mm, pud, address);

    if (!fe.pmd)

        return VM_FAULT_OOM;

    if (pmd_none(*fe.pmd) && transparent_hugepage_enabled(vma)) {

        int ret = create_huge_pmd(&fe);

        if (!(ret & VM_FAULT_FALLBACK))

            return ret;

    } else {

        pmd_t orig_pmd = *fe.pmd;

        int ret;

        barrier();

        if (pmd_trans_huge(orig_pmd) || pmd_devmap(orig_pmd)) {

            if (pmd_protnone(orig_pmd) && vma_is_accessible(vma))

                return do_huge_pmd_numa_page(&fe, orig_pmd);

            if ((fe.flags & FAULT_FLAG_WRITE) &&

                    !pmd_write(orig_pmd)) {

                ret = wp_huge_pmd(&fe, orig_pmd);

                if (!(ret & VM_FAULT_FALLBACK))

                    return ret;

            } else {

                huge_pmd_set_accessed(&fe, orig_pmd);

                return 0;

            }

        }

    }

    return handle_pte_fault(&fe);

}

在这个函数中就通过transparent_hugepage_enabled 来判断是否是能了透明大页，如果使能了透明大页，就调用create_huge_pmd 来申请pmd。

第二个：相对第一个是在缺页fault的时候发生，第二个则是有一个专门的守护进程在将4k page转成2M等大页.

这个thread执行的主体如下：

static int khugepaged(void *none)

{

    struct mm_slot *mm_slot;

    set_freezable();

    set_user_nice(current, MAX_NICE);

    while (!kthread_should_stop()) {

        khugepaged_do_scan();

        khugepaged_wait_work();

    }

    spin_lock(&khugepaged_mm_lock);

    mm_slot = khugepaged_scan.mm_slot;

    khugepaged_scan.mm_slot = NULL;

    if (mm_slot)

        collect_mm_slot(mm_slot);

    spin_unlock(&khugepaged_mm_lock);

    return 0;

}

khugepaged_do_scan->khugepaged_scan_mm_slot

static unsigned int khugepaged_scan_mm_slot(unsigned int pages,

                        struct page **hpage)

    __releases(&khugepaged_mm_lock)

    __acquires(&khugepaged_mm_lock)

{

    struct mm_slot *mm_slot;

    struct mm_struct *mm;

    struct vm_area_struct *vma;

    int progress = 0;

    VM_BUG_ON(!pages);

    VM_BUG_ON(NR_CPUS != 1 && !spin_is_locked(&khugepaged_mm_lock));

    if (khugepaged_scan.mm_slot)

        mm_slot = khugepaged_scan.mm_slot;

    else {

        mm_slot = list_entry(khugepaged_scan.mm_head.next,

                     struct mm_slot, mm_node);

        khugepaged_scan.address = 0;

        khugepaged_scan.mm_slot = mm_slot;

    }

    spin_unlock(&khugepaged_mm_lock);

    mm = mm_slot->mm;

    down_read(&mm->mmap_sem);

    if (unlikely(khugepaged_test_exit(mm)))

        vma = NULL;

    else

        vma = find_vma(mm, khugepaged_scan.address);

    progress++;

    for (; vma; vma = vma->vm_next) {

        unsigned long hstart, hend;

        cond_resched();

        if (unlikely(khugepaged_test_exit(mm))) {

            progress++;

            break;

        }

        if (!hugepage_vma_check(vma)) {

skip:

            progress++;

            continue;

        }

        hstart = (vma->vm_start + ~HPAGE_PMD_MASK) & HPAGE_PMD_MASK;

        hend = vma->vm_end & HPAGE_PMD_MASK;

        if (hstart >= hend)

            goto skip;

        if (khugepaged_scan.address > hend)

            goto skip;

        if (khugepaged_scan.address < hstart)

            khugepaged_scan.address = hstart;

        VM_BUG_ON(khugepaged_scan.address & ~HPAGE_PMD_MASK);

        while (khugepaged_scan.address < hend) {

            int ret;

            cond_resched();

            if (unlikely(khugepaged_test_exit(mm)))

                goto breakouterloop;

            VM_BUG_ON(khugepaged_scan.address < hstart ||

                  khugepaged_scan.address + HPAGE_PMD_SIZE >

                  hend);

            if (shmem_file(vma->vm_file)) {

                struct file *file;

                pgoff_t pgoff = linear_page_index(vma,

                        khugepaged_scan.address);

                if (!shmem_huge_enabled(vma))

                    goto skip;

                file = get_file(vma->vm_file);

                up_read(&mm->mmap_sem);

                ret = 1;

                khugepaged_scan_shmem(mm, file->f_mapping,

                        pgoff, hpage);

                fput(file);

            } else {

                ret = khugepaged_scan_pmd(mm, vma,

                        khugepaged_scan.address,

                        hpage);

            }

            /* move to next address */

            khugepaged_scan.address += HPAGE_PMD_SIZE;

            progress += HPAGE_PMD_NR;

            if (ret)

                /* we released mmap_sem so break loop */

                goto breakouterloop_mmap_sem;

            if (progress >= pages)

                goto breakouterloop;

        }

    }

}

在这个函数中通过for循环通过hugepage_vma_check来检查是否要将4Kpage的页转成大页.