从 Linux 源码的角度解释进程

ps -ef

long do_fork(unsigned long clone_flags,
         unsigned long stack_start,
         struct pt_regs *regs,
         unsigned long stack_size,
         int __user *parent_tidptr,
         int __user *child_tidptr)
{

long do_fork(unsigned long clone_flags,
         unsigned long stack_start,
         struct pt_regs *regs,
         unsigned long stack_size,
         int __user *parent_tidptr,
         int __user *child_tidptr)
{
   struct task_struct *p;
   p = copy_process(clone_flags, stack_start, regs, stack_size,
      child_tidptr, NULL, trace);
}

static struct task_struct *copy_process(unsigned long clone_flags,
       unsigned long stack_start,
       struct pt_regs *regs,
       unsigned long stack_size,
       int __user *child_tidptr,
       struct pid *pid,
       int trace)
{
   int retval;
   struct task_struct *p;
   int cgroup_callbacks_done = 0;
   // 分配一个结构体
   p = dup_task_struct(current);
   if (!p)
    goto fork_out;
   ftrace_graph_init_task(p);

   rt_mutex_init_task(p);
   p->bts = NULL;
   // 分配pid
   if (pid != &init_struct_pid) {
    retval = -ENOMEM;
    pid = alloc_pid(p->nsproxy->pid_ns);
    if (!pid)
     goto bad_fork_cleanup_io;

    if (clone_flags & CLONE_NEWPID) {
     retval = pid_ns_prepare_proc(p->nsproxy->pid_ns);
     if (retval < 0)
      goto bad_fork_free_pid;
    }
   }

   p->pid = pid_nr(pid);
   p->tgid = p->pid;
   if (clone_flags & CLONE_THREAD)
    p->tgid = current->tgid;

   if (current->nsproxy != p->nsproxy) {
    retval = ns_cgroup_clone(p, pid);
    if (retval)
     goto bad_fork_free_pid;
   }

   p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ? child_tidptr : NULL;
   p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr: NULL;

   // 设置该进程的一些cgroup选项
   p->exit_signal = (clone_flags & CLONE_THREAD) ? -1 : (clone_flags & CSIGNAL);
   p->pdeath_signal = 0;
   p->exit_state = 0;
   p->group_leader = p;
   INIT_LIST_HEAD(&p->thread_group);
   cgroup_fork_callbacks(p);
   cgroup_callbacks_done = 1;
   write_lock_irq(&tasklist_lock);
   if (clone_flags & (CLONE_PARENT|CLONE_THREAD)) {
    p->real_parent = current->real_parent;
    p->parent_exec_id = current->parent_exec_id;
   } else {
    p->real_parent = current;
    p->parent_exec_id = current->self_exec_id;
   }
   spin_lock(&current->sighand->siglock);
   recalc_sigpending();
   if (signal_pending(current)) {
    spin_unlock(&current->sighand->siglock);
    write_unlock_irq(&tasklist_lock);
    retval = -ERESTARTNOINTR;
    goto bad_fork_free_pid;
   }
   total_forks++;
   spin_unlock(&current->sighand->siglock);
   write_unlock_irq(&tasklist_lock);
   proc_fork_connector(p);
   cgroup_post_fork(p);
   perf_event_fork(p);
   return p;
}

struct sched_entity {
 struct load_weight load;  /* for load-balancing */
 struct rb_node  run_node;
 struct list_head group_node;
 unsigned int  on_rq;

 u64   exec_start;
 u64   sum_exec_runtime;
 u64   vruntime;
 u64   prev_sum_exec_runtime;

 u64   last_wakeup;
 u64   avg_overlap;

 u64   nr_migrations;

 u64   start_runtime;
 u64   avg_wakeup;
 }

static void update_curr(struct cfs_rq *cfs_rq)
{
 struct sched_entity *curr = cfs_rq->curr;
 u64 now = rq_of(cfs_rq)->clock;
 unsigned long delta_exec;

 if (unlikely(!curr))
  return;

 /*
  * Get the amount of time the current task was running
  * since the last time we changed load (this cannot
  * overflow on 32 bits):
  */
 delta_exec = (unsigned long)(now - curr->exec_start);
 if (!delta_exec)
  return;

 __update_curr(cfs_rq, curr, delta_exec);
 curr->exec_start = now;

 if (entity_is_task(curr)) {
  struct task_struct *curtask = task_of(curr);

  trace_sched_stat_runtime(curtask, delta_exec, curr->vruntime);
  cpuacct_charge(curtask, delta_exec);
  account_group_exec_runtime(curtask, delta_exec);
 }
}

static struct sched_entity *pick_next_entity(struct cfs_rq *cfs_rq)
{
 struct sched_entity *se = __pick_next_entity(cfs_rq);
 struct sched_entity *left = se;

 if (cfs_rq->next && wakeup_preempt_entity(cfs_rq->next, left) < 1)
  se = cfs_rq->next;

 /*
  * Prefer last buddy, try to return the CPU to a preempted task.
  */
 if (cfs_rq->last && wakeup_preempt_entity(cfs_rq->last, left) < 1)
  se = cfs_rq->last;

 clear_buddies(cfs_rq, se);

 return se;
}

static void forget_original_parent(struct task_struct *father)
{
 struct task_struct *p, *n, *reaper;
 LIST_HEAD(dead_children);

 exit_ptrace(father);

 write_lock_irq(&tasklist_lock);
 reaper = find_new_reaper(father);

 list_for_each_entry_safe(p, n, &father->children, sibling) {
  struct task_struct *t = p;
  do {
   t->real_parent = reaper;
   if (t->parent == father) {
    BUG_ON(task_ptrace(t));
    t->parent = t->real_parent;
   }
   if (t->pdeath_signal)
    group_send_sig_info(t->pdeath_signal,
          SEND_SIG_NOINFO, t);
  } while_each_thread(p, t);
  reparent_leader(father, p, &dead_children);
 }
 write_unlock_irq(&tasklist_lock);

 BUG_ON(!list_empty(&father->children));

 list_for_each_entry_safe(p, n, &dead_children, sibling) {
  list_del_init(&p->sibling);
  release_task(p);
 }
}

static struct task_struct *find_new_reaper(struct task_struct *father)
{
 struct pid_namespace *pid_ns = task_active_pid_ns(father);
 struct task_struct *thread;

 thread = father;
 while_each_thread(father, thread) {
  if (thread->flags & PF_EXITING)
   continue;
  if (unlikely(pid_ns->child_reaper == father))
   pid_ns->child_reaper = thread;
  return thread;
 }

 if (unlikely(pid_ns->child_reaper == father)) {
  write_unlock_irq(&tasklist_lock);
  if (unlikely(pid_ns == &init_pid_ns))
   panic("Attempted to kill init!");

  zap_pid_ns_processes(pid_ns);
  write_lock_irq(&tasklist_lock);
  /*
   * We can not clear ->child_reaper or leave it alone.
   * There may by stealth EXIT_DEAD tasks on ->children,
   * forget_original_parent() must move them somewhere.
   */
  pid_ns->child_reaper = init_pid_ns.child_reaper;
 }

 return pid_ns->child_reaper;
}