Linux内核15-内核如何创建进程

long _do_fork(unsigned long clone_flags,
          unsigned long stack_start,
          unsigned long stack_size,
          int __user *parent_tidptr,
          int __user *child_tidptr,
          unsigned long tls)
{
    struct task_struct *p;
    int trace = 0;
    long nr;

    /*
     * 当从kernel_thread调用或CLONE_UNTRACED被设置时，不需要报告event
     * 否则，报告使用哪种fork类型的event
     */
    if (!(clone_flags & CLONE_UNTRACED)) {
        if (clone_flags & CLONE_VFORK)
            trace = PTRACE_EVENT_VFORK;
        else if ((clone_flags & CSIGNAL) != SIGCHLD)
            trace = PTRACE_EVENT_CLONE;
        else
            trace = PTRACE_EVENT_FORK;

        if (likely(!ptrace_event_enabled(current, trace)))
            trace = 0;
    }
    /* 拷贝进程描述符 */
    p = copy_process(clone_flags, stack_start, stack_size,
             child_tidptr, NULL, trace, tls, NUMA_NO_NODE);
    /*
     * 在唤醒新线程之前，先检查指针是否合法
     * 因为如果线程创建后立即退出的话，线程指针可能会非法
     */
    if (!IS_ERR(p)) {
        struct completion vfork;
        struct pid *pid;

        trace_sched_process_fork(current, p);

        /* 分配PID */
        pid = get_task_pid(p, PIDTYPE_PID);
        nr = pid_vnr(pid);

        /* 把新进程PID写入到父进程的用户态变量中。*/
        if (clone_flags & CLONE_PARENT_SETTID)
            put_user(nr, parent_tidptr);

        /* 如果实现的是vfork调用，则完成completion机制，确保父进程后续运行 */
        if (clone_flags & CLONE_VFORK) {
            p->vfork_done = &vfork;
            init_completion(&vfork);
            get_task_struct(p);
        }

        /* 唤醒新进程 */
        wake_up_new_task(p);

        /* fork过程完成，子进程开始运行，并告知ptracer */
        if (unlikely(trace))
            ptrace_event_pid(trace, pid);

        /*
         * 如果实现的vfork调用，则将父进程插入等待队列，并挂起父进程
         * 直到子进程释放自己的内存空间，也就是，保证子进程先行于父进程
         */
        if (clone_flags & CLONE_VFORK) {
            if (!wait_for_vfork_done(p, &vfork))
                ptrace_event_pid(PTRACE_EVENT_VFORK_DONE, pid);
        }
        put_pid(pid);
    } else {
        nr = PTR_ERR(p);
    }
    return nr;
}

static struct task_struct *copy_process(unsigned long clone_flags,
                    unsigned long stack_start,
                    unsigned long stack_size,
                    int __user *child_tidptr,
                    struct pid *pid,
                    int trace,
                    unsigned long tls,
                    int node)
{
    // 1. 检查参数clone_flags，一些标志组合是否合理
    // ...

    // 2. 其它的安全检查
    retval = security_task_create(clone_flags);

    // 3. 分配一个新的task_struct结构，与父进程完全相同，只是stack不同
    p = dup_task_struct(current, node);

    // 4. 检查该用户的进程数是否超过限制
    if (atomic_read(&p->real_cred->user->processes) >=
            task_rlimit(p, RLIMIT_NPROC)) {
        // 检查该用户是否具有相关权限，不一定是root
        if (p->real_cred->user != INIT_USER &&
            // ...
    }

    // 5. 检查进程数量是否超过max_threads，后者取决于内存的大小
    if (nr_threads >= max_threads)
    // ...

    // 6. 进程描述符相关变量初始化

    // 7. 完成调度器相关数据结构的初始化
    retval = sched_fork(clone_flags, p);

    // 8. 拷贝所有的进程信息
    shm_init_task(p);
    retval = copy_semundo(clone_flags, p);
    retval = copy_files(clone_flags, p);
    retval = copy_fs(clone_flags, p);
    retval = copy_sighand(clone_flags, p);
    retval = copy_signal(clone_flags, p);
    retval = copy_mm(clone_flags, p);
    retval = copy_namespaces(clone_flags, p);
    retval = copy_io(clone_flags, p);

    // 9. 设置子进程的pid
    retval = copy_thread_tls(clone_flags, stack_start, stack_size, p, tls);

    // ...

    // 10. 设置子进程的PID
    p->pid = pid_nr(pid);

    // 11. 根据是创建线程还是进程设置线程组组长、进程组组长等等信息
    // ...

    // 12. 将pid加入PIDTYPE_PID这个散列表
    if (likely(p->pid)) {
        // ..
        attach_pid(p, PIDTYPE_PID);
        nr_threads++;
    }

    // 释放资源，善后处理
    return p;
err:
    // 错误处理
}

childregs->ax = 0;
p->thread.ip = (unsigned long) ret_from_fork;