请问初始化新进程的函数在哪里？

新进程是通过克隆旧进程或说克隆当前进程而创建。新任务通过一个系统调用( f o r k或
c l o n e )而创建，克隆过程发生在核心模式下的内核中，在系统调用的末尾会有一个新进程等待
调度器选中它并运行。一个新的t a s k _ s t r u c t数据结构被从系统物理内存分配，以及一页或多页
物理内存作为克隆的进程的栈(用户的和核心的)。一个进程标识符可能会被创建：一个在系统
进程标识符集合中唯一的标识符。然而，克隆的进程完全有理由保存其父进程的标识符。新
的t a s k _ s t r u c t新加入到t a s k向量并且老的(当前)进程的t a s k _ s t r u c t的内容被复制到克隆出的
t a s k _ s t r u c t中。
当克隆进程时， L i n u x允许两个进程共享资源而不是有两份独立的副本。这种共享可用于
进程的文件、信号处理器和虚拟内存。当资源被共享时，它们的c o u n t字段将被递增，以便在
两个进程都结束访问它们之前Linux 不会回收这些资源。举例来说，如果克隆的进程将共享虚
拟内存，其t a s k _ s t r u c t将包含指向原先进程的m m _ s t r u c t的指针并且该m m _ s t r u c t将把其c o u n t
字段递增以表明当前共享该页的进程数。
克隆一个进程的虚拟内存是很有技巧性的。一个新的v m _ a r e a _ s t r u c t集合以及它们拥有的
m m _ s t r u c t数据结构，还有被克隆的进程的页表必须被产生出来。在这时没有进程的任何虚拟
内存被复制。复制将是一件很困难和冗长的工作，因为一些虚拟内存在物理内存，一些在进
程正在执行的可执行映像中，还可能有一些在交换文件中；相反， L i n u x使用称为“写时复制
(copy on write)”的技巧，这意味着仅当两个进程试图写它时虚拟内存才会被复制。任何虚拟
内存只要没被写，即使它可以被写，也将在两个进程间共享而不会引起任何危害。只读的内
存(比如可执行代码)总是被共享。为了使“写时复制”工作，可写区域将其页表项标识为只读
并且v m _ a r e a _ s t r u c t数据结构描述为它们被标识成”写时复制”。当一个进程试图写该虚拟内
存时将产生一个页故障。正是在此时L i n u x将产生该内存的一个副本，并修改两个进程的页表
和虚拟内存数据结构。 

int copy_page_range(struct mm_struct *dst, struct mm_struct *src,
            struct vm_area_struct *vma)
{
    pgd_t * src_pgd, * dst_pgd;
    unsigned long address = vma->vm_start;
    unsigned long end = vma->vm_end;
    unsigned long cow;

    if (is_vm_hugetlb_page(vma))
        return copy_hugetlb_page_range(dst, src, vma);

    cow = (vma->vm_flags & (VM_SHARED | VM_MAYWRITE)) == VM_MAYWRITE;
    src_pgd = pgd_offset(src, address)-1;
    dst_pgd = pgd_offset(dst, address)-1;

    for (;;) {
        pmd_t * src_pmd, * dst_pmd;

        src_pgd++; dst_pgd++;
        
        /* copy_pmd_range */
        
        if (pgd_none(*src_pgd))
            goto skip_copy_pmd_range;
        if (unlikely(pgd_bad(*src_pgd))) {
            pgd_ERROR(*src_pgd);
            pgd_clear(src_pgd);
skip_copy_pmd_range:    address = (address + PGDIR_SIZE) & PGDIR_MASK;
            if (!address || (address >= end))
                goto out;
            continue;
        }

        src_pmd = pmd_offset(src_pgd, address);
        dst_pmd = pmd_alloc(dst, dst_pgd, address);
        if (!dst_pmd)
            goto nomem;

        do {
            pte_t * src_pte, * dst_pte;
        
            /* copy_pte_range */
        
            if (pmd_none(*src_pmd))
                goto skip_copy_pte_range;
            if (unlikely(pmd_bad(*src_pmd))) {
                pmd_ERROR(*src_pmd);
                pmd_clear(src_pmd);
skip_copy_pte_range:
                address = (address + PMD_SIZE) & PMD_MASK;
                if (address >= end)
                    goto out;
                goto cont_copy_pmd_range;
            }

            dst_pte = pte_alloc_map(dst, dst_pmd, address);
            if (!dst_pte)
                goto nomem;
            spin_lock(&src->page_table_lock);    
            src_pte = pte_offset_map_nested(src_pmd, address);
            do {
                pte_t pte = *src_pte;
                struct page *page;
                unsigned long pfn;

                /* copy_one_pte */

                if (pte_none(pte))
                    goto cont_copy_pte_range_noset;
                /* pte contains position in swap, so copy. */
                if (!pte_present(pte)) {
                    if (!pte_file(pte))
                        swap_duplicate(pte_to_swp_entry(pte));
                    set_pte(dst_pte, pte);
                    goto cont_copy_pte_range_noset;
                }
                pfn = pte_pfn(pte);
                /* the pte points outside of valid memory, the
                 * mapping is assumed to be good, meaningful
                 * and not mapped via rmap - duplicate the
                 * mapping as is.
                 */
                page = NULL;
                if (pfn_valid(pfn)) 
                    page = pfn_to_page(pfn); 

                if (!page || PageReserved(page)) {
                    set_pte(dst_pte, pte);
                    goto cont_copy_pte_range_noset;
                }

                /*
                 * If it's a COW mapping, write protect it both
                 * in the parent and the child
                 */
                if (cow) {
                    ptep_set_wrprotect(src_pte);
                    pte = *src_pte;
                }

                /*
                 * If it's a shared mapping, mark it clean in
                 * the child
                 */
                if (vma->vm_flags & VM_SHARED)
                    pte = pte_mkclean(pte);
                pte = pte_mkold(pte);
                get_page(page);
                dst->rss++;
                set_pte(dst_pte, pte);
                page_dup_rmap(page);
cont_copy_pte_range_noset:
                address += PAGE_SIZE;
                if (address >= end) {
                    pte_unmap_nested(src_pte);
                    pte_unmap(dst_pte);
                    goto out_unlock;
                }
                src_pte++;
                dst_pte++;
            } while ((unsigned long)src_pte & PTE_TABLE_MASK);
            pte_unmap_nested(src_pte-1);
            pte_unmap(dst_pte-1);
            spin_unlock(&src->page_table_lock);
            cond_resched_lock(&dst->page_table_lock);
cont_copy_pmd_range:
            src_pmd++;
            dst_pmd++;
        } while ((unsigned long)src_pmd & PMD_TABLE_MASK);
    }
out_unlock:
    spin_unlock(&src->page_table_lock);
out:
    return 0;
nomem:
    return -ENOMEM;
}