本文主要是介绍2021-2022-1 20212811 《Linux内核原理与分析》第七周作业，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

long do_fork(unsigned long clone_flags, unsigned long stack_start,
        unsigned long stack_size, int __user *parent_tidptr,
        int __user *child_tidptr)

do_fork

struct task_struct *p;    //创建进程描述符指针
  int trace = 0;
  long nr;                  //子进程pid
  ...
  p = copy_process(clone_flags, stack_start, stack_size, 
              child_tidptr, NULL, trace);   //创建子进程的描述符和执行时所需的其他数据结构
 
  if (!IS_ERR(p))                            //如果 copy_process 执行成功
        struct completion vfork;             //定义完成量（一个执行单元等待另一个执行单元完成某事）
        struct pid *pid;
        ...
        pid = get_task_pid(p, PIDTYPE_PID);   //获得task结构体中的pid
        nr = pid_vnr(pid);                    //根据pid结构体中获得进程pid
        ...
        // 如果 clone_flags 包含 CLONE_VFORK 标志，就将完成量 vfork 赋值给进程描述符中的vfork_done字段，此处只是对完成量进行初始化
        if (clone_flags & CLONE_VFORK) {
            p->vfork_done = &vfork;
            init_completion(&vfork);
            get_task_struct(p);
        }
 
        wake_up_new_task(p);        //将子进程添加到调度器的队列，使之有机会获得CPU
 
        /* forking complete and child started to run, tell ptracer */
        ...
        // 如果 clone_flags 包含 CLONE_VFORK 标志，就将父进程插入等待队列直至程直到子进程释调用exec函数或退出，此处是具体的阻塞
        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;               //返回子进程pid（父进程的fork函数返回的值为子进程pid的原因）
do_fork()主要完成了调用 copy_process() 复制父进程信息、获得pid、调用 wake_up_new_task 将子进程加入调度器队列，为之分配 CPU、通过 clone_flags 标志做一些辅助工作。其中 copy_process()是创建一个进程内容的主要的代码。

（2）copy_process

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)
{
    int retval;
    struct task_struct *p;
    ...
    retval = security_task_create(clone_flags);//安全性检查
    ...
    p = dup_task_struct(current);   //复制PCB,为子进程创建内核栈、进程描述符
    ftrace_graph_init_task(p);
    ···
    
    retval = -EAGAIN;
    // 检查该用户的进程数是否超过限制
    if (atomic_read(&p->real_cred->user->processes) >=
            task_rlimit(p, RLIMIT_NPROC)) {
        // 检查该用户是否具有相关权限，不一定是root
        if (p->real_cred->user != INIT_USER &&
            !capable(CAP_SYS_RESOURCE) && !capable(CAP_SYS_ADMIN))
            goto bad_fork_free;
    }
    ...
    // 检查进程数量是否超过 max_threads，后者取决于内存的大小
    if (nr_threads >= max_threads)
        goto bad_fork_cleanup_count;
 
    if (!try_module_get(task_thread_info(p)->exec_domain->module))
        goto bad_fork_cleanup_count;
    ...
    spin_lock_init(&p->alloc_lock);          //初始化自旋锁
    init_sigpending(&p->pending);           //初始化挂起信号 
    posix_cpu_timers_init(p);               //初始化CPU定时器
    ···
    retval = sched_fork(clone_flags, p);  //初始化新进程调度程序数据结构，把新进程的状态设置为TASK_RUNNING,并禁止内核抢占
    ...
    // 复制所有的进程信息
    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);
    ...
	retval = copy_thread(clone_flags, stack_start, stack_size, p);// 初始化子进程内核栈
    ...
    //若传进来的pid指针和全局结构体变量init_struct_pid的地址不相同，就要为子进程分配新的pid
    if (pid != &init_struct_pid) {
        retval = -ENOMEM;
        pid = alloc_pid(p->nsproxy->pid_ns_for_children);
        if (!pid)
            goto bad_fork_cleanup_io;
    }
 
    ...
    p->pid = pid_nr(pid);    //根据pid结构体中获得进程pid
    //若 clone_flags 包含 CLONE_THREAD标志，说明子进程和父进程在同一个线程组
    if (clone_flags & CLONE_THREAD) {
        p->exit_signal = -1;
        p->group_leader = current->group_leader; //线程组的leader设为子进程的组leader
        p->tgid = current->tgid;       //子进程继承父进程的tgid
    } else {
        if (clone_flags & CLONE_PARENT)
            p->exit_signal = current->group_leader->exit_signal;
        else
            p->exit_signal = (clone_flags & CSIGNAL);
        p->group_leader = p;	      //子进程的组leader就是它自己
        
       
        p->tgid = p->pid;        //组号tgid是它自己的pid
    }
 
    ...
    
    if (likely(p->pid)) {
        ptrace_init_task(p, (clone_flags & CLONE_PTRACE) || trace);
 
        init_task_pid(p, PIDTYPE_PID, pid);
        if (thread_group_leader(p)) {
            ...
            // 将子进程加入它所在组的哈希链表中
            attach_pid(p, PIDTYPE_PGID);
            attach_pid(p, PIDTYPE_SID);
            __this_cpu_inc(process_counts);
        } else {
            ...
        }
        attach_pid(p, PIDTYPE_PID);
        nr_threads++;     //增加系统中的进程数目
    }
    ...
    return p;             //返回被创建的子进程描述符指针P
}

 在另一个shell中启动gdb，把内核加载进来，建立连接，并在内核开始函数start_kernel处设置断点，之后按下c继续执行程序，结果如下图所示：

 在gdb中continue执行到断点do_fork处

这篇关于2021-2022-1 20212811 《Linux内核原理与分析》第七周作业的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！