Chinaunix首页 | 论坛 | 博客

BugMan的刺激战场

首页　| 　博文目录　| 　关于我

BugMan

  • 博客访问： 1025822
  • 博文数量： 26
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 437
  • 用 户 组： 普通用户
  • 注册时间： 2019-09-08 12:19
个人简介

关于个人介绍，既然你诚心诚意的看了 我就大发慈悲的告诉你 为了防止世界被破坏 为了维护世界的和平 贯彻爱与真实的邪恶 可爱又迷人的反派角色 我们是穿梭在银河的火箭队 白洞,白色的明天在等着我们

文章分类

全部博文（26）

我的朋友
最近访客
推荐博文
相关博文
Linux内核函数之fork函数

分类： LINUX

2019-10-18 12:27:27

在<Linux内核之execve函数>中，我们知道execve是一个新程序运行的开始，那么很多要问fork呢？fork又有什么区别呢？fork通常是在编程中，为了创建多个进程而使用的API。他和execve的差别是：execve属于进程替换，通过<Linux内核之execve函数>分析，仔细的朋友应该发现了execve函数在启动新程序的时候，还是用的之前老程序的task_struct结构。因此，这样它的pid就不会变，只是需要从内存重新分配他需要的页表和内存。而fork则不一样，它会产生一个完全独立的新进程，新的task_struct结构，新的pid的，只是会有一个写时复制的功能（刚刚fork出来的进程和原进程一模一样，内存什么都一样，只有当前进程内存发生写访问的时候，会重建立新的映射表）。这里先不说映射表重映射的问题（COW机制），这个问题之后讲映射的时候会讲。

下面我们看看fork函数在内核的实现：

    点击(此处)折叠或打开



  3. long do_fork(unsigned long clone_flags,
  4.      unsigned long stack_start,
  5.      unsigned long stack_size,
  6.      int __user *parent_tidptr,
  7.      int __user *child_tidptr)
  8. {
  9.     // stack_start是新程序占地址，stack_size栈大小
  10.     return _do_fork(clone_flags, stack_start, stack_size,
  11.             parent_tidptr, child_tidptr, 0);
  12. }

  14. SYSCALL_DEFINE0(vfork)
  15. {   // 可以看到vfork产生的新进程内存空间和原始进程一样CLONE_VM 
  16.     return _do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, 0, 0, NULL, NULL, 0);
  17. }

  19. SYSCALL_DEFINE0(fork)
  20. {
  21.     return _do_fork(SIGCHLD, 0, 0, NULL, NULL, 0);
  22. }

  24. // 内核线程创建，也是调用的do_fork，只是参数不同
  25. pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
  26. {
  27.     // 注意，内核线程在stack_start和stack_sz传入的是线程回调函数和线程传参
  28.     return _do_fork(flags|CLONE_VM|CLONE_UNTRACED, (unsigned long)fn,
  29.                     (unsigned long)arg, NULL, NULL, 0);
  30. }

其中SYSCALL_DEFINE0是一个宏，表示这是一个不包含任何参数的系统调用，这个宏会产生一个sys_fork/sys_vfork函数。也就是当应用程序调用fork函数的时候，CPU产生系统调用中断，中断处理函数通过查表(sys_call_table)，通过对应的系统调用号找到sys_fork函数并开始执行(R7/W8存放的系统调用号，参数以此类推)，sys_fork函数到_do_fork并没有做什么操作，只是参数不同(fork：SIGCHLD, vfork：CLONE_VFORK)，这里kernel_thread、线程功能也会混着一起讲，因此现在直接到_do_fork函数，调用栈如下：
点击(此处)折叠或打开

  1. fork                 (user space)
  2. ---|----------------------------------------------------------------------------
  3.    v                （kernel space）
  4. el0_sync (arm64同步异常中断处理函数)
  5.     el0_svc （查找sys_call_table,获取到sys_execve函数地址，并运行）
  6.         sys_fork
  7.             do_fork
  8.                 _do_fork

_do_fork实现如下：
点击(此处)折叠或打开

  1. long _do_fork(unsigned long clone_flags,
  2.      unsigned long stack_start,
  3.      unsigned long stack_size,
  4.      int __user *parent_tidptr,
  5.      int __user *child_tidptr,
  6.      unsigned long tls)
  7. {
  8.     struct task_struct *p;
  9.     int trace = 0;
  10.     long nr;
  11.     
  12.     // ptrace相关设置，主要判断进入do_fork是哪个系统调用引起的
  13.     if (!(clone_flags & CLONE_UNTRACED)) {
  14.         if (clone_flags & CLONE_VFORK)
  15.             trace = PTRACE_EVENT_VFORK;
  16.         else if ((clone_flags & CSIGNAL) != SIGCHLD)
  17.             trace = PTRACE_EVENT_CLONE;
  18.         else
  19.             trace = PTRACE_EVENT_FORK;

  21.         if (likely(!ptrace_event_enabled(current, trace)))
  22.             trace = 0;
  23.     }
  24.     // 将当前进程的进程空间拷贝一份给p，p是新进程的task_struct
  25.     p = copy_process(clone_flags, stack_start, stack_size,
  26.              child_tidptr, NULL, trace, tls, NUMA_NO_NODE);
  27.     add_latent_entropy();
  28.     // 如果进程子进程复制成功，主进程就进入if语句，子进程不会进入这里，子进程直接进入
  29.     // ret_from_fork
  30.     if (!IS_ERR(p)) {
  31.         struct completion vfork;
  32.         struct pid *pid;

  34.         trace_sched_process_fork(current, p);
  35.         // 父进程获取新进程p的pid
  36.         pid = get_task_pid(p, PIDTYPE_PID);
  37.         nr = pid_vnr(pid);

  39.         if (clone_flags & CLONE_PARENT_SETTID)
  40.             put_user(nr, parent_tidptr);
  41.         // 查看父进程是否调用的vfork，如果是就初始化vfork_done完成函数
  42.         if (clone_flags & CLONE_VFORK) {
  43.             p->vfork_done = &vfork;
  44.             init_completion(&vfork);
  45.             get_task_struct(p);
  46.         }
  47.         // 将新进程p加入到run queue即加入到ready调度队列，此后p就会开始后参与调度
  48.         wake_up_new_task(p);

  50.         /* forking complete and child started to run, tell ptracer */
  51.         if (unlikely(trace))
  52.             ptrace_event_pid(trace, pid);
  53.         // 如果是vfork产生的进程，需要等待子进程先运行，直到子进程complete了父进程，
  54.         // vfork函数才返回。因此，vfork产生的子进程，总是优先于父进程运行。

  55.
  56.         //  vfork保证子进程先运行，在它调用exec或exit之后父进程才能调度运行,也就是当子
  57.         // 进程调用exec或者exit的时候， 会触发wake_up($vfork)的信号。
  58.         if (clone_flags & CLONE_VFORK) {
  59.             if (!wait_for_vfork_done(p, &vfork))
  60.                 ptrace_event_pid(PTRACE_EVENT_VFORK_DONE, pid);
  61.         }

  63.         put_pid(pid);
  64.     } else {
  65.         nr = PTR_ERR(p);
  66.     }
  67.     // 父进程在这里返回，返回子进程的pid号，这个pid会修改父进程返回的pt_regs[0]的值
  68.     // 子进程的返回值在copy_thread_tls里面已经设置,子进程不会运行这里
  70.     return nr;
  71. }

可以知道，fork是把当前进程复制一个一模一样的进程，除了栈、LR，其他内容都一样。

在do_fork函数中实现的wake_up_new_task函数在copy_process函数之后调用，主要是用于将子进程加入调度队列。它的实现如下：

点击(此处)折叠或打开

  1. void wake_up_new_task(struct task_struct *p)
  2. {
  3.     struct rq_flags rf;
  4.     struct rq *rq;

  6.     raw_spin_lock_irqsave(&p->pi_lock, rf.flags);
  7.     // 设置新进程P的状态为TASK_RUNNING
  8.     p->state = TASK_RUNNING;
  9. #ifdef CONFIG_SMP
  10.     // 进程添加到CPU负载均衡
  11.     __set_task_cpu(p, select_task_rq(p, task_cpu(p), SD_BALANCE_FORK, 0));
  12. #endif
  13.     // 获取当前p进程所在CPU的运行队列rq
  14.     rq = __task_rq_lock(p, &rf);
  15.     post_init_entity_util_avg(&p->se);
  16.     // 将进程p加入到rq队列，具体在以后进程调度章节说明（RUNNING状态）
  17.     activate_task(rq, p, 0);
  18.     p->on_rq = TASK_ON_RQ_QUEUED;
  19.     trace_sched_wakeup_new(p);
  20.     check_preempt_curr(rq, p, WF_FORK);
  21.    
  22. #ifdef CONFIG_SMP
  23.     // SMP相关，这里占时不知道干什么的
  24.     if (p->sched_class->task_woken) {
  25.         p->sched_class->task_woken(rq, p);
  26.     }
  27. #endif
  28.     task_rq_unlock(rq, p, &rf);
  29. }
在do_fork函数中的copy_process函数是今天的重点函数，该函数实现了进程复制的所有操作，实现如下：
点击(此处)折叠或打开
  1. static __latent_entropy struct task_struct *copy_process(
  2.                     unsigned long clone_flags,
  3.                     unsigned long stack_start,
  4.                     unsigned long stack_size,
  5.                     int __user *child_tidptr,
  6.                     struct pid *pid,
  7.                     int trace,
  8.                     unsigned long tls,
  9.                     int node)
  10. {
  11.     int retval;
  12.     struct task_struct *p;

  14.     // 这里省略掉一些参数检测
  15.     
  16.     // 将当前进程复制一份给新进程p
  17.     retval = -ENOMEM;
  18.     p = dup_task_struct(current, node);
  19.     if (!p)
  20.         goto fork_out;

  22.     ftrace_graph_init_task(p);

  24.     rt_mutex_init_task(p);

  26.     // 省略一些无用，chinaunix总说是敏感词汇的代码。

  28.     // 复制信用凭证
  29.     retval = copy_creds(p, clone_flags);
  30.     if (retval < 0)
  31.         goto bad_fork_free;
  32.     // 超过最大进程，返回
  33.     retval = -EAGAIN;
  34.     if (nr_threads >= max_threads)
  35.         goto bad_fork_cleanup_count;

  37.     delayacct_tsk_init(p);    /* Must remain after dup_task_struct() */
  38.     p->flags &= ~(PF_SUPERPRIV | PF_WQ_WORKER);
  39.     p->flags |= PF_FORKNOEXEC;
  40.     INIT_LIST_HEAD(&p->children);
  41.     INIT_LIST_HEAD(&p->sibling);
  42.     rcu_copy_process(p);
  43.     p->vfork_done = NULL;
  44.     spin_lock_init(&p->alloc_lock);
  45.     // 初始化信号挂起pending
  46.     init_sigpending(&p->pending);

  48.     // 这里省略初始化和时间等相关的杂项

  50.     // 初始化调度实体se，和调度器类，调度器章节将会描述
  51.     // 如果存在p->sched_class->task_fork，就执行
  52.     retval = sched_fork(clone_flags, p);
  53.     if (retval)
  54.         goto bad_fork_cleanup_policy;
  55.     // perf相关，这里不描述
  56.     retval = perf_event_init_task(p);
  57.     if (retval)
  58.         goto bad_fork_cleanup_policy;
  59.     //审计相关，这里不描述
  60.     retval = audit_alloc(p);
  61.     if (retval)
  62.         goto bad_fork_cleanup_perf;
  63.     // 进程共享内存链表初始化
  64.     shm_init_task(p);
  65.     retval = copy_semundo(clone_flags, p);
  66.     if (retval)
  67.         goto bad_fork_cleanup_audit;
  68.     // 将当前current进程的打开的fd描述复制一份到新进程->p->files
  69.     retval = copy_files(clone_flags, p);
  70.     if (retval)
  71.         goto bad_fork_cleanup_semundo;
  72.     // 将current进程的工作目录复制一份到新进程（pwd, /）-》p->fs
  73.     retval = copy_fs(clone_flags, p);
  74.     if (retval)
  75.         goto bad_fork_cleanup_files;
  76.     // 将Current进程的信号处理函数，赋值一份到新进程->p->sighand
  77.     retval = copy_sighand(clone_flags, p);
  78.     if (retval)
  79.         goto bad_fork_cleanup_fs;
  80.     // 通过current初始化一份信号共享结构（线程信号共享就用的这个结构，还有一些其他数据）
  81.     // p->signal
  82.     retval = copy_signal(clone_flags, p);
  83.     if (retval)
  84.         goto bad_fork_cleanup_sighand;
  85.     // 将current的映射页表拷贝一份到新进程，并设置成只读，为什么这么设置，
  86.     // 以后的虚拟内存章节会讲解。
  87.     // 即这就是为什么刚fork后，两个进程内存里面的值是一样的
  88.     retval = copy_mm(clone_flags, p);
  89.     if (retval)
  90.         goto bad_fork_cleanup_signal;
  91.     // 命名空间继承current的，即同一个命名空间
  92.     retval = copy_namespaces(clone_flags, p);
  93.     if (retval)
  94.         goto bad_fork_cleanup_mm;
  95.     // 赋值IO空间，tsk->io_context或者new_ioc->ioprio
  96.     retval = copy_io(clone_flags, p);
  97.     if (retval)
  98.         goto bad_fork_cleanup_namespaces;
  99.     // 拷贝每个进程不同的部分，这里非常重要，稍后详细说明
  100.     retval = copy_thread_tls(clone_flags, stack_start, stack_size, p, tls);
  101.     if (retval)
  102.         goto bad_fork_cleanup_io;

  104.     // 如果线程不是init_struct_pid（idle进程pid），就从新申请一个Pid
  105.     if (pid != &init_struct_pid) {
  106.         pid = alloc_pid(p->nsproxy->pid_ns_for_children);
  107.         if (IS_ERR(pid)) {
  108.             retval = PTR_ERR(pid);
  109.             goto bad_fork_cleanup_thread;
  110.         }
  111.     }
  112.     //省略一些赋值

  114.     // 如果是线程，则设置线程组组长为当前进程指向的组长，如果是进程则将组长设置成自己，
  115.     // 并初始化退出码
  116.     p->pid = pid_nr(pid);
  117.     if (clone_flags & CLONE_THREAD) { // 线程运行这里
  118.         p->exit_signal = -1;
  119.         p->group_leader = current->group_leader;
  120.         p->tgid = current->tgid; // 进程的tgid才是真的pid 即同一个线程组下的线程tgid相同，pid不同
  121.     } else {
  122.         if (clone_flags & CLONE_PARENT)
  123.             p->exit_signal = current->group_leader->exit_signal;
  124.         else
  125.             p->exit_signal = (clone_flags & CSIGNAL);
  126.         p->group_leader = p;
  127.         p->tgid = p->pid; //没有线程时，tgid==pid
  128.     }

  130.     p->nr_dirtied = 0;
  131.     p->nr_dirtied_pause = 128 >> (PAGE_SHIFT - 10);
  132.     p->dirty_paused_when = 0;

  134.     p->pdeath_signal = 0;
  135.     INIT_LIST_HEAD(&p->thread_group);
  136.     p->task_works = NULL;

  138.     // cgroup相关，这里不说明
  139.     threadgroup_change_begin(current);
  140.     retval = cgroup_can_fork(p);
  141.     if (retval)
  142.         goto bad_fork_free_pid;

  144.     write_lock_irq(&tasklist_lock);

  146.     // 设置父进程，如果是线程，父进程就是current的父进程。否则current就是新进程的父进程
  147.     if (clone_flags & (CLONE_PARENT|CLONE_THREAD)) {
  148.         p->real_parent = current->real_parent;
  149.         p->parent_exec_id = current->parent_exec_id;
  150.     } else {
  151.         p->real_parent = current;
  152.         p->parent_exec_id = current->self_exec_id;
  153.     }

  155.     // 省略一些与此无关的

  157.     // 
  158.     if (likely(p->pid)) {
  159.         ptrace_init_task(p, (clone_flags & CLONE_PTRACE) || trace);

  161.         //初始化pid结构到
  162.         init_task_pid(p, PIDTYPE_PID, pid);
  163.         if (thread_group_leader(p)) {//新进程是线程组组长，同样意味着它是进程 而不是线程
  164.            init_task_pid(p, PIDTYPE_PGID, task_pgrp(current));//将pid赋值到task->pid[PGID].pid
  165.           init_task_pid(p, PIDTYPE_SID, task_session(current));//将pid赋值到task->pid[SID].pid

  167.             // 是否是进程收养者，是，就设置成当前Pid空间的收养者（do_exit函数里面会用到）
  168.             if (is_child_reaper(pid)) {
  169.                 ns_of_pid(pid)->child_reaper = p;
  170.                 p->signal->flags |= SIGNAL_UNKILLABLE;
  171.             }

  173.             p->signal->leader_pid = pid;//因为是组长，因此将它的pid记录到leader_pid
  174.             p->signal->tty = tty_kref_get(current->signal->tty);
  175.             // 将进程p添加到它父进程的children链表
  176.             list_add_tail(&p->sibling, &p->real_parent->children);
  177.             // 将进程p添加到Init_task下面，即idle进程的tasks链表下面
  178.             list_add_tail_rcu(&p->tasks, &init_task.tasks);
  179.             // 将p添加到对应的pgid和sid链表（组，会话）
  180.             attach_pid(p, PIDTYPE_PGID);
  181.             attach_pid(p, PIDTYPE_SID);
  182.             __this_cpu_inc(process_counts);
  183.         } else {// 不是组长，说明是线程，增加线程数量
  184.             current->signal->nr_threads++;
  185.             atomic_inc(&current->signal->live);//增加线程live数量
  186.             atomic_inc(&current->signal->sigcnt);
  187.             list_add_tail_rcu(&p->thread_group, // 将线程p挂到组长的thread_group链表下面
  188.                      &p->group_leader->thread_group);
  189.             list_add_tail_rcu(&p->thread_node, // 将线程p挂到共享信号的thread_head链表下面（信号使用）
  190.                      &p->signal->thread_head);
  191.         }
  192.         // 添加到pid空间，并增加线程数
  193.         attach_pid(p, PIDTYPE_PID);
  194.         nr_threads++;
  195.     }

  197.     total_forks++;
  198.     //省略一些不重要的

  200.     // 返回新进程task_struct
  201.     return p;
  202.     // 省略失败处理细节
  203. }

在copy_process函数中的dup_task_struct函数实现如下，该函数用于从当前进程current的task_struct结构中，复制一份一模一样的给新进程p:
点击(此处)折叠或打开

  1. static struct task_struct *dup_task_struct(struct task_struct *orig, int node)
  2. {
  3.     struct task_struct *tsk;
  4.     unsigned long *stack;
  5.     struct vm_struct *stack_vm_area;
  6.     int err;
  7.     
  8.     // 这里传入的参数是NUMA_NO_NODE，表示申请内存的时候，从当前进程所在内存结点申请；内存结点将在伙伴子系统加以说明，这里不讲解；
  9.     if (node == NUMA_NO_NODE)
  10.         node = tsk_fork_get_node(orig);

  11.
  12.     // 从内存node结点申请一段内存作为新进程的tsk结构
  13.     tsk = alloc_task_struct_node(node);
  14.     if (!tsk)
  15.         return NULL;

  17.     // 从node结点申请一个新的栈地址
  18.     stack = alloc_thread_stack_node(tsk, node);
  19.     if (!stack)
  20.         goto free_tsk;

  22.     // 得到一个stack的vm_struct结构，这里不讲解
  23.     stack_vm_area = task_stack_vm_area(tsk);

  25.     // 这个函数 其实就是tsk = orig,即将current进程memcpy到tsk。
  26.     err = arch_dup_task_struct(tsk, orig);

  28.     // 将stack地址设置到tsk的记录栈地址的位置,替换掉从current拷贝来的栈（这是内核栈，
  29.     // 每个应用程序有两个栈，一个应用栈，一个内核栈；而内核线程只有内核栈.
  30.     // 因此，这里可以统一申请内核栈）
  31.     tsk->stack = stack;
  32.     // 如果定义了VMAP_STACK，就将stack vm_struct结构赋值
  33. #ifdef CONFIG_VMAP_STACK
  34.     tsk->stack_vm_area = stack_vm_area;
  35. #endif
  36.     // 增加引用计数
  37. #ifdef CONFIG_THREAD_INFO_IN_TASK
  38.     atomic_set(&tsk->stack_refcount, 1);
  39. #endif

  41.     if (err)
  42.         goto free_stack;

  44. #ifdef CONFIG_SECCOMP
  45.     tsk->seccomp.filter = NULL;
  46. #endif
  47.     // 将current的threadinfo结构拷贝一份到tsk,threadinfo待会儿会详细介绍。
  48.     setup_thread_stack(tsk, orig);
  49.     clear_user_return_notifier(tsk);
  50.     clear_tsk_need_resched(tsk);
  51.     // 设置栈的结束位置，用于检测栈溢出用的
  52.     set_task_stack_end_magic(tsk);

  54.     // 省略一些无关紧要的赋值

  56.     account_kernel_stack(tsk, 1);

  58.     kcov_task_init(tsk);
  59.     // 返回新进程的task_struct结构
  60.     return tsk;
  61. }

  63. static inline void setup_thread_stack(struct task_struct *p, struct task_struct *org)
  64. {
  65.     // 赋值current的thread_info结构，然后将task指向新进程
  66.     *task_thread_info(p) = *task_thread_info(org);
  67.     task_thread_info(p)->task = p;
  68. }

在申请新的进程task_struct结束后，我这里有必要说说进程的thread_info结构。thread_info结构是存放到内核的SP栈中的，原本Linux是直接将task_struct存放到SP当中，但是后来随着task_struct越来越大，因此，添加了一个thread_info结构做中间代理结构，达到通过sp能够获取到对应进程的task_struct结构的目的。thread_info在栈的位置如图：

如上图， 通常内核的栈大小为2个page，即8K，并且内核栈严格按照8K对齐，因此当获取到SP的指针的时候（sp current），只需要与上8k取反的值(sp & (~8k))就可以得到thread_info结构。thread_info->task就指向该进程的task_struct结构。由于内核栈是向下增长，因此，如果栈越界，首先破坏的是自己的thread_info结构，然后崩溃(咋们内核中使用的current起始就是一个宏，利用当前SP和thread_info反向找到自己的task_struct结构的，有兴趣的可以看看这个宏)。

copy_process函数中实现的copy_files函数比较简单，如下：

点击(此处)折叠或打开

  1. static int copy_files(unsigned long clone_flags, struct task_struct *tsk)
  2. {
  3.     struct files_struct *oldf, *newf;
  4.     int error = 0;

  6.     oldf = current->files;
  7.     if (!oldf)
  8.         goto out;

  10.     if (clone_flags & CLONE_FILES) {
  11.         atomic_inc(&oldf->count);
  12.         goto out;
  13.     }
  14.     // 复制一份current的files成newf
  15.     newf = dup_fd(oldf, &error);
  16.     if (!newf)
  17.         goto out;
  18.     // 将复制出来的newf赋值给files
  19.     tsk->files = newf;
  20.     error = 0;
  21. out:
  22.     return error;
  23. }

因此，从copy_files这一个简单的说明后，其他的copy_*函数，这里就不多做说明了， 有兴趣的，可以自己去看看，先主要说说copy_thread_tls函数。

copy_thread_tls是一个非常重要的函数，其主要是设置新进程的运行地址和寄存器值，实现如下：

点击(此处)折叠或打开

  1. struct cpu_context {
  2. unsigned long x19;
  3. unsigned long x20;
  4. unsigned long x21;
  5. unsigned long x22;
  6. unsigned long x23;
  7. unsigned long x24;
  8. unsigned long x25;
  9. unsigned long x26;
  10. unsigned long x27;
  11. unsigned long x28;
  12. unsigned long fp;
  13. unsigned long sp;
  14. unsigned long pc;
    };

  15. asmlinkage void ret_from_fork(void) asm("ret_from_fork");

  17. // 这个函数是和体系结构强相关的，这里我看的是armv8处理器
  18. int copy_thread(unsigned long clone_flags, unsigned long stack_start,
  19.         unsigned long stk_sz, struct task_struct *p)
  20. {
  21.     // 获取pt_regs地址： task->stack + THREAD_START_SP -1
  22.     // 其中task->stack起始存放的是thread_info，THREAD_START_SP = 16k - 16，
  23.     // 即在栈的最高地址存放的是寄存器值， pt_regs。
  24.     struct pt_regs *childregs = task_pt_regs(p);

  26.     // 将新进程的内核态需要的寄存器信息清0
  27.     memset(&p->thread.cpu_context, 0, sizeof(struct cpu_context));

  29.     // 发现新进程是一个应用进程，进入if语句
  30.     if (likely(!(p->flags & PF_KTHREAD))) {
  31.         // 复制current进程的用户态寄存器到新进程
  32.         *childregs = *current_pt_regs();
  33.         // 将新进程的返回值设置成0，regs[0] 就是X0寄存器，在ARM中X0作为返回值寄存器使用
  34.         // 因此当fork函数返回后，在子进程中，返回值是0
  35.         childregs->regs[0] = 0;

  37.    
  38.         *task_user_tls(p) = read_sysreg(tpidr_el0);
  39.         // 如果用户设置了栈的起始地址，就是设置用户栈的地址是stack_start
  40.         // 用户进程有两个栈，用户态的栈和内核态的栈，内核态的栈前面dup_task_struct的
  41.         // 时候申请了，这里是设置用户态的栈，由用户态指定
  42.         if (stack_start) {
  43.             if (is_compat_thread(task_thread_info(p)))
  44.                 childregs->compat_sp = stack_start;
  45.             else
  46.                 childregs->sp = stack_start;
  47.         }

  49.         // TLS相关的
  50.         if (clone_flags & CLONE_SETTLS)
  51.             p->thread.tp_value = childregs->regs[3];
  52.     } else { // 内核线程进入else语句
  53.         // 内核线程将childregs的CPU寄存器请0
  54.         memset(childregs, 0, sizeof(struct pt_regs));
  55.         childregs->pstate = PSR_MODE_EL1h;//设置CPU工作模式是EL1模式（用户进程在EL0模式）
  56.         if (IS_ENABLED(CONFIG_ARM64_UAO) &&
  57.          cpus_have_cap(ARM64_HAS_UAO))
  58.             childregs->pstate |= PSR_UAO_BIT;
  59.         // X19存放stack_start，从kernel_thread传入参数可以知道stack_start是线程回调函数
  60.         // X20存放内核线程传入参数（stk_sz：内核线程传入的线程函数传参）
  61.         p->thread.cpu_context.x19 = stack_start;
  62.         p->thread.cpu_context.x20 = stk_sz;
  63.     }
  64.     // 不管是内核线程还是应用线程，新进程执行的第一个函数时钟是ret_from_fork
  65.     p->thread.cpu_context.pc = (unsigned long)ret_from_fork;
  66.     // 设置CPU的栈指向childregs结构，方便返回的时候，弹出到寄存器。
  67.     p->thread.cpu_context.sp = (unsigned long)childregs;

  69.     ptrace_hw_copy_thread(p);

  71.     return 0;
  72. }

  74. static inline int copy_thread_tls(
  75.         unsigned long clone_flags, unsigned long sp, unsigned long arg,
  76.         struct task_struct *p, unsigned long tls)
  77. {
  78.     return copy_thread(clone_flags, sp, arg, p);
  79. }

经过了copy_thread_tls函数之后，新进程的运行环境就已经准备就绪，最后只需要将新进程的task_struct结构加入到run queue调度队列里面即可(wake_up_new_task函数)。一旦调度到新的进程，新的进程就从ret_from_fork函数开始运行，其中ret_from_fork函数实现如下：
点击(此处)折叠或打开

  1. ret_to_user:
  2.     disable_irq   // 禁止中断
  3.     ldr    x1, [tsk, #TI_FLAGS] // 读取tsk结构的TI_FLAGS位到x1寄存器
  4.     and    x2, x1, #_TIF_WORK_MASK  // 判断tsk的TI_FLAGS位是否置位
  5.     cbnz    x2, work_pending  // 这里用于检查是否有工作挂起。
  6. finish_ret_to_user:
  7.     enable_step_tsk x1, x2
  8.     kernel_exit 0     // 退出内核态EL1到EL0
  9. ENDPROC(ret_to_user)

  11. ENTRY(ret_from_fork)
  12.     bl    schedule_tail  // 进程调度的时候 会说明
  13.     cbz    x19, 1f  //从copy_thread_tls函数知道x19如果不为0那么，此进程就为内核线程。X19存放的是内核线程的回调函数。
  14.     mov    x0, x20 //从copy_thread_tls函数知道,如果是内核线程，那么x20内核线程的回调函数的传入参数
  15.     blr    x19  // x0存放传入的第一个参数，然后跳转到内核线程回调函数去执行。
  16. 1:    get_thread_info tsk  // 用户线程运行这里，通过ret_to_user返回到用户空间
  17.     b    ret_to_user   // 返回到应用空间
  18. ENDPROC(ret_from_fork)

应用程序fork的调用栈如下：

注：copy_mm函数会在以后讲解虚拟地址的时候详细讲解。


阅读(3439) | 评论(0) | 转发(0) |
1

上一篇：Linux内核之exit函数

下一篇：Linux内核函数之fork函数-总结

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6