深入理解 Linux 内核2

// arch/x86/kernel/process_64.c
struct task_struct *
__switch_to(struct task_struct *prev_p, struct task_struct *next_p)
{
  struct thread_struct *prev = &prev_p->thread;
  struct thread_struct *next = &next_p->thread;
  int cpu = smp_processor_id();
  struct tss_struct *tss = &per_cpu(init_tss, cpu);
  unsigned fsindex, gsindex;
  bool preload_fpu;

  /*
   * If the task has used fpu the last 5 timeslices, just do a full
   * restore of the math state immediately to avoid the trap; the
   * chances of needing FPU soon are obviously high now
   */
  preload_fpu = tsk_used_math(next_p) && next_p->fpu_counter > 5;

  /* we're going to use this soon, after a few expensive things */
  if (preload_fpu)
    prefetch(next->xstate);

  /*
   * Reload esp0, LDT and the page table pointer:
   */
  load_sp0(tss, next);

  /*
   * Switch DS and ES.
   * This won't pick up thread selector changes, but I guess that is ok.
   */
  savesegment(es, prev->es);
  if (unlikely(next->es | prev->es))
    loadsegment(es, next->es);

  savesegment(ds, prev->ds);
  if (unlikely(next->ds | prev->ds))
    loadsegment(ds, next->ds);


  /* We must save %fs and %gs before load_TLS() because
   * %fs and %gs may be cleared by load_TLS().
   *
   * (e.g. xen_load_tls())
   */
  savesegment(fs, fsindex);
  savesegment(gs, gsindex);

  load_TLS(next, cpu);

  /* Must be after DS reload */
  unlazy_fpu(prev_p);

  /* Make sure cpu is ready for new context */
  if (preload_fpu)
    clts();

  /*
   * Leave lazy mode, flushing any hypercalls made here.
   * This must be done before restoring TLS segments so
   * the GDT and LDT are properly updated, and must be
   * done before math_state_restore, so the TS bit is up
   * to date.
   */
  arch_end_context_switch(next_p);

  /*
   * Switch FS and GS.
   *
   * Segment register != 0 always requires a reload.  Also
   * reload when it has changed.  When prev process used 64bit
   * base always reload to avoid an information leak.
   */
  if (unlikely(fsindex | next->fsindex | prev->fs)) {
    loadsegment(fs, next->fsindex);
    /*
     * Check if the user used a selector != 0; if yes
     *  clear 64bit base, since overloaded base is always
     *  mapped to the Null selector
     */
    if (fsindex)
      prev->fs = 0;
  }
  /* when next process has a 64bit base use it */
  if (next->fs)
    wrmsrl(MSR_FS_BASE, next->fs);
  prev->fsindex = fsindex;

  if (unlikely(gsindex | next->gsindex | prev->gs)) {
    load_gs_index(next->gsindex);
    if (gsindex)
      prev->gs = 0;
  }
  if (next->gs)
    wrmsrl(MSR_KERNEL_GS_BASE, next->gs);
  prev->gsindex = gsindex;

  /*
   * Switch the PDA and FPU contexts.
   */
  prev->usersp = percpu_read(old_rsp);
  percpu_write(old_rsp, next->usersp);
  percpu_write(current_task, next_p);

  percpu_write(kernel_stack,
      (unsigned long)task_stack_page(next_p) +
      THREAD_SIZE - KERNEL_STACK_OFFSET);

  /*
   * Now maybe reload the debug registers and handle I/O bitmaps
   */
  if (unlikely(task_thread_info(next_p)->flags & _TIF_WORK_CTXSW_NEXT ||
         task_thread_info(prev_p)->flags & _TIF_WORK_CTXSW_PREV))
    __switch_to_xtra(prev_p, next_p, tss);

  /*
   * Preload the FPU context, now that we've determined that the
   * task is likely to be using it. 
   */
  if (preload_fpu)
    __math_state_restore();

  return prev_p;
}

__unlazy_fpu(prev_p);

init_tss[cpu].esp0 = next_p->thread.esp0;

cpu_gdt_table[cpu][6] = next_p->thread.tls_array[0];
cpu_gdt_table[cpu][7] = next_p->thread.tls_array[1];
cpu_gdt_table[cpu][8] = next_p->thread.tls_array[2];

movl %fs, 40(%esi)
movl %gs, 44(%esi)

movl 40(%ebx),%fs
movl 44(%ebx),%gs

if (prev_p->thread.io_bitmap_ptr || next_p->thread.io_bitmap_ptr)
  handle_io_bitmap(&next_p->thread, &init_tss[cpu]);

return prev_p;

movl %edi,%eax
ret

// kernel/fork.c
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;
  int trace = 0;
  long nr;

  /*
   * Do some preliminary argument and permissions checking before we
   * actually start allocating stuff
   */
  if (clone_flags & CLONE_NEWUSER) {
    if (clone_flags & CLONE_THREAD)
      return -EINVAL;
    /* hopefully this check will go away when userns support is
     * complete
     */
    if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SETUID) ||
        !capable(CAP_SETGID))
      return -EPERM;
  }

  /*
   * We hope to recycle these flags after 2.6.26
   */
  if (unlikely(clone_flags & CLONE_STOPPED)) {
    static int __read_mostly count = 100;

    if (count > 0 && printk_ratelimit()) {
      char comm[TASK_COMM_LEN];

      count--;
      printk(KERN_INFO "fork(): process `%s' used deprecated "
          "clone flags 0x%lx\n",
        get_task_comm(comm, current),
        clone_flags & CLONE_STOPPED);
    }
  }

  /*
   * When called from kernel_thread, don't do user tracing stuff.
   */
  if (likely(user_mode(regs)))
    trace = tracehook_prepare_clone(clone_flags);

  p = copy_process(clone_flags, stack_start, regs, stack_size,
       child_tidptr, NULL, trace);
  /*
   * Do this prior waking up the new thread - the thread pointer
   * might get invalid after that point, if the thread exits quickly.
   */
  if (!IS_ERR(p)) {
    struct completion vfork;

    trace_sched_process_fork(current, p);

    nr = task_pid_vnr(p);

    if (clone_flags & CLONE_PARENT_SETTID)
      put_user(nr, parent_tidptr);

    if (clone_flags & CLONE_VFORK) {
      p->vfork_done = &vfork;
      init_completion(&vfork);
    }

    audit_finish_fork(p);
    tracehook_report_clone(regs, clone_flags, nr, p);

    /*
     * We set PF_STARTING at creation in case tracing wants to
     * use this to distinguish a fully live task from one that
     * hasn't gotten to tracehook_report_clone() yet.  Now we
     * clear it and set the child going.
     */
    p->flags &= ~PF_STARTING;

    if (unlikely(clone_flags & CLONE_STOPPED)) {
      /*
       * We'll start up with an immediate SIGSTOP.
       */
      sigaddset(&p->pending.signal, SIGSTOP);
      set_tsk_thread_flag(p, TIF_SIGPENDING);
      __set_task_state(p, TASK_STOPPED);
    } else {
      wake_up_new_task(p, clone_flags);
    }

    tracehook_report_clone_complete(trace, regs,
            clone_flags, nr, p);

    if (clone_flags & CLONE_VFORK) {
      freezer_do_not_count();
      wait_for_completion(&vfork);
      freezer_count();
      tracehook_report_vfork_done(p, nr);
    }
  } else {
    nr = PTR_ERR(p);
  }
  return nr;
}

// kernel/fork.c
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;

  if ((clone_flags & (CLONE_NEWNS|CLONE_FS)) == (CLONE_NEWNS|CLONE_FS))
    return ERR_PTR(-EINVAL);

  /*
   * Thread groups must share signals as well, and detached threads
   * can only be started up within the thread group.
   */
  if ((clone_flags & CLONE_THREAD) && !(clone_flags & CLONE_SIGHAND))
    return ERR_PTR(-EINVAL);

  /*
   * Shared signal handlers imply shared VM. By way of the above,
   * thread groups also imply shared VM. Blocking this case allows
   * for various simplifications in other code.
   */
  if ((clone_flags & CLONE_SIGHAND) && !(clone_flags & CLONE_VM))
    return ERR_PTR(-EINVAL);

  /*
   * Siblings of global init remain as zombies on exit since they are
   * not reaped by their parent (swapper). To solve this and to avoid
   * multi-rooted process trees, prevent global and container-inits
   * from creating siblings.
   */
  if ((clone_flags & CLONE_PARENT) &&
        current->signal->flags & SIGNAL_UNKILLABLE)
    return ERR_PTR(-EINVAL);

  retval = security_task_create(clone_flags);
  if (retval)
    goto fork_out;

  retval = -ENOMEM;
  p = dup_task_struct(current);
  if (!p)
    goto fork_out;

  ftrace_graph_init_task(p);

  rt_mutex_init_task(p);

#ifdef CONFIG_PROVE_LOCKING
  DEBUG_LOCKS_WARN_ON(!p->hardirqs_enabled);
  DEBUG_LOCKS_WARN_ON(!p->softirqs_enabled);
#endif
  retval = -EAGAIN;
  if (atomic_read(&p->real_cred->user->processes) >=
      task_rlimit(p, RLIMIT_NPROC)) {
    if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RESOURCE) &&
        p->real_cred->user != INIT_USER)
      goto bad_fork_free;
  }

  retval = copy_creds(p, clone_flags);
  if (retval < 0)
    goto bad_fork_free;

  /*
   * If multiple threads are within copy_process(), then this check
   * triggers too late. This doesn't hurt, the check is only there
   * to stop root fork bombs.
   */
  retval = -EAGAIN;
  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;

  p->did_exec = 0;
  delayacct_tsk_init(p);  /* Must remain after dup_task_struct() */
  copy_flags(clone_flags, p);
  INIT_LIST_HEAD(&p->children);
  INIT_LIST_HEAD(&p->sibling);
  rcu_copy_process(p);
  p->vfork_done = NULL;
  spin_lock_init(&p->alloc_lock);

  init_sigpending(&p->pending);

  p->utime = cputime_zero;
  p->stime = cputime_zero;
  p->gtime = cputime_zero;
  p->utimescaled = cputime_zero;
  p->stimescaled = cputime_zero;
#ifndef CONFIG_VIRT_CPU_ACCOUNTING
  p->prev_utime = cputime_zero;
  p->prev_stime = cputime_zero;
#endif
#if defined(SPLIT_RSS_COUNTING)
  memset(&p->rss_stat, 0, sizeof(p->rss_stat));
#endif

  p->default_timer_slack_ns = current->timer_slack_ns;

  task_io_accounting_init(&p->ioac);
  acct_clear_integrals(p);

  posix_cpu_timers_init(p);

  p->lock_depth = -1;   /* -1 = no lock */
  do_posix_clock_monotonic_gettime(&p->start_time);
  p->real_start_time = p->start_time;
  monotonic_to_bootbased(&p->real_start_time);
  p->io_context = NULL;
  p->audit_context = NULL;
  cgroup_fork(p);
#ifdef CONFIG_NUMA
  p->mempolicy = mpol_dup(p->mempolicy);
  if (IS_ERR(p->mempolicy)) {
    retval = PTR_ERR(p->mempolicy);
    p->mempolicy = NULL;
    goto bad_fork_cleanup_cgroup;
  }
  mpol_fix_fork_child_flag(p);
#endif
#ifdef CONFIG_TRACE_IRQFLAGS
  p->irq_events = 0;
#ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
  p->hardirqs_enabled = 1;
#else
  p->hardirqs_enabled = 0;
#endif
  p->hardirq_enable_ip = 0;
  p->hardirq_enable_event = 0;
  p->hardirq_disable_ip = _THIS_IP_;
  p->hardirq_disable_event = 0;
  p->softirqs_enabled = 1;
  p->softirq_enable_ip = _THIS_IP_;
  p->softirq_enable_event = 0;
  p->softirq_disable_ip = 0;
  p->softirq_disable_event = 0;
  p->hardirq_context = 0;
  p->softirq_context = 0;
#endif
#ifdef CONFIG_LOCKDEP
  p->lockdep_depth = 0; /* no locks held yet */
  p->curr_chain_key = 0;
  p->lockdep_recursion = 0;
#endif

#ifdef CONFIG_DEBUG_MUTEXES
  p->blocked_on = NULL; /* not blocked yet */
#endif
#ifdef CONFIG_CGROUP_MEM_RES_CTLR
  p->memcg_batch.do_batch = 0;
  p->memcg_batch.memcg = NULL;
#endif

  p->bts = NULL;

  /* Perform scheduler related setup. Assign this task to a CPU. */
  sched_fork(p, clone_flags);

  retval = perf_event_init_task(p);
  if (retval)
    goto bad_fork_cleanup_policy;

  if ((retval = audit_alloc(p)))
    goto bad_fork_cleanup_policy;
  /* copy all the process information */
  if ((retval = copy_semundo(clone_flags, p)))
    goto bad_fork_cleanup_audit;
  if ((retval = copy_files(clone_flags, p)))
    goto bad_fork_cleanup_semundo;
  if ((retval = copy_fs(clone_flags, p)))
    goto bad_fork_cleanup_files;
  if ((retval = copy_sighand(clone_flags, p)))
    goto bad_fork_cleanup_fs;
  if ((retval = copy_signal(clone_flags, p)))
    goto bad_fork_cleanup_sighand;
  if ((retval = copy_mm(clone_flags, p)))
    goto bad_fork_cleanup_signal;
  if ((retval = copy_namespaces(clone_flags, p)))
    goto bad_fork_cleanup_mm;
  if ((retval = copy_io(clone_flags, p)))
    goto bad_fork_cleanup_namespaces;
  retval = copy_thread(clone_flags, stack_start, stack_size, p, regs);
  if (retval)
    goto bad_fork_cleanup_io;

  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;
  /*
   * Clear TID on mm_release()?
   */
  p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr: NULL;
#ifdef CONFIG_FUTEX
  p->robust_list = NULL;
#ifdef CONFIG_COMPAT
  p->compat_robust_list = NULL;
#endif
  INIT_LIST_HEAD(&p->pi_state_list);
  p->pi_state_cache = NULL;
#endif
  /*
   * sigaltstack should be cleared when sharing the same VM
   */
  if ((clone_flags & (CLONE_VM|CLONE_VFORK)) == CLONE_VM)
    p->sas_ss_sp = p->sas_ss_size = 0;

  /*
   * Syscall tracing and stepping should be turned off in the
   * child regardless of CLONE_PTRACE.
   */
  user_disable_single_step(p);
  clear_tsk_thread_flag(p, TIF_SYSCALL_TRACE);
#ifdef TIF_SYSCALL_EMU
  clear_tsk_thread_flag(p, TIF_SYSCALL_EMU);
#endif
  clear_all_latency_tracing(p);

  /* ok, now we should be set up.. */
  p->exit_signal = (clone_flags & CLONE_THREAD) ? -1 : (clone_flags & CSIGNAL);
  p->pdeath_signal = 0;
  p->exit_state = 0;

  /*
   * Ok, make it visible to the rest of the system.
   * We dont wake it up yet.
   */
  p->group_leader = p;
  INIT_LIST_HEAD(&p->thread_group);

  /* Now that the task is set up, run cgroup callbacks if
   * necessary. We need to run them before the task is visible
   * on the tasklist. */
  cgroup_fork_callbacks(p);
  cgroup_callbacks_done = 1;

  /* Need tasklist lock for parent etc handling! */
  write_lock_irq(&tasklist_lock);

  /* CLONE_PARENT re-uses the old parent */
  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);

  /*
   * Process group and session signals need to be delivered to just the
   * parent before the fork or both the parent and the child after the
   * fork. Restart if a signal comes in before we add the new process to
   * it's process group.
   * A fatal signal pending means that current will exit, so the new
   * thread can't slip out of an OOM kill (or normal SIGKILL).
   */
  recalc_sigpending();
  if (signal_pending(current)) {
    spin_unlock(&current->sighand->siglock);
    write_unlock_irq(&tasklist_lock);
    retval = -ERESTARTNOINTR;
    goto bad_fork_free_pid;
  }

  if (clone_flags & CLONE_THREAD) {
    atomic_inc(&current->signal->count);
    atomic_inc(&current->signal->live);
    p->group_leader = current->group_leader;
    list_add_tail_rcu(&p->thread_group, &p->group_leader->thread_group);
  }

  if (likely(p->pid)) {
    tracehook_finish_clone(p, clone_flags, trace);

    if (thread_group_leader(p)) {
      if (clone_flags & CLONE_NEWPID)
        p->nsproxy->pid_ns->child_reaper = p;

      p->signal->leader_pid = pid;
      tty_kref_put(p->signal->tty);
      p->signal->tty = tty_kref_get(current->signal->tty);
      attach_pid(p, PIDTYPE_PGID, task_pgrp(current));
      attach_pid(p, PIDTYPE_SID, task_session(current));
      list_add_tail(&p->sibling, &p->real_parent->children);
      list_add_tail_rcu(&p->tasks, &init_task.tasks);
      __get_cpu_var(process_counts)++;
    }
    attach_pid(p, PIDTYPE_PID, pid);
    nr_threads++;
  }

  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;

bad_fork_free_pid:
  if (pid != &init_struct_pid)
    free_pid(pid);
bad_fork_cleanup_io:
  if (p->io_context)
    exit_io_context(p);
bad_fork_cleanup_namespaces:
  exit_task_namespaces(p);
bad_fork_cleanup_mm:
  if (p->mm)
    mmput(p->mm);
bad_fork_cleanup_signal:
  if (!(clone_flags & CLONE_THREAD))
    __cleanup_signal(p->signal);
bad_fork_cleanup_sighand:
  __cleanup_sighand(p->sighand);
bad_fork_cleanup_fs:
  exit_fs(p); /* blocking */
bad_fork_cleanup_files:
  exit_files(p); /* blocking */
bad_fork_cleanup_semundo:
  exit_sem(p);
bad_fork_cleanup_audit:
  audit_free(p);
bad_fork_cleanup_policy:
  perf_event_free_task(p);
#ifdef CONFIG_NUMA
  mpol_put(p->mempolicy);
bad_fork_cleanup_cgroup:
#endif
  cgroup_exit(p, cgroup_callbacks_done);
  delayacct_tsk_free(p);
  module_put(task_thread_info(p)->exec_domain->module);
bad_fork_cleanup_count:
  atomic_dec(&p->cred->user->processes);
  exit_creds(p);
bad_fork_free:
  free_task(p);
fork_out:
  return ERR_PTR(retval);
}

// arch/x86/kernel/process.c
/*
 * Create a kernel thread
 */
int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
{
  struct pt_regs regs;

  memset(&regs, 0, sizeof(regs));

  regs.si = (unsigned long) fn;
  regs.di = (unsigned long) arg;

#ifdef CONFIG_X86_32
  regs.ds = __USER_DS;
  regs.es = __USER_DS;
  regs.fs = __KERNEL_PERCPU;
  regs.gs = __KERNEL_STACK_CANARY;
#else
  regs.ss = __KERNEL_DS;
#endif

  regs.orig_ax = -1;
  regs.ip = (unsigned long) kernel_thread_helper;
  regs.cs = __KERNEL_CS | get_kernel_rpl();
  regs.flags = X86_EFLAGS_IF | 0x2;

  /* Ok, create the new process.. */
  return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs, 0, NULL, NULL);
}
EXPORT_SYMBOL(kernel_thread);

do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs, 0, NULL, NULL);

// arch/x86/kernel/init_task.c
/*
 * Initial thread structure.
 *
 * We need to make sure that this is THREAD_SIZE aligned due to the
 * way process stacks are handled. This is done by having a special
 * "init_task" linker map entry..
 */
union thread_union init_thread_union __init_task_data =
  { INIT_THREAD_INFO(init_task) };

/*
 * Initial task structure.
 *
 * All other task structs will be allocated on slabs in fork.c
 */
struct task_struct init_task = INIT_TASK(init_task);
EXPORT_SYMBOL(init_task);

// include/linux/init_task.h
#define INIT_TASK(tsk)  \
{                 \
  .state    = 0,            \
  .stack    = &init_thread_info,        \
  .usage    = ATOMIC_INIT(2),       \
  .flags    = PF_KTHREAD,         \
  .lock_depth = -1,           \
  .prio   = MAX_PRIO-20,          \
  .static_prio  = MAX_PRIO-20,          \
  .normal_prio  = MAX_PRIO-20,          \
  .policy   = SCHED_NORMAL,         \
  .cpus_allowed = CPU_MASK_ALL,         \
  .mm   = NULL,           \
  .active_mm  = &init_mm,         \
  .se   = {           \
    .group_node   = LIST_HEAD_INIT(tsk.se.group_node),  \
  },                \
  .rt   = {           \
    .run_list = LIST_HEAD_INIT(tsk.rt.run_list),  \
    .time_slice = HZ,           \
    .nr_cpus_allowed = NR_CPUS,       \
  },                \
  .tasks    = LIST_HEAD_INIT(tsk.tasks),      \
  .pushable_tasks = PLIST_NODE_INIT(tsk.pushable_tasks, MAX_PRIO), \
  .ptraced  = LIST_HEAD_INIT(tsk.ptraced),      \
  .ptrace_entry = LIST_HEAD_INIT(tsk.ptrace_entry),   \
  .real_parent  = &tsk,           \
  .parent   = &tsk,           \
  .children = LIST_HEAD_INIT(tsk.children),     \
  .sibling  = LIST_HEAD_INIT(tsk.sibling),      \
  .group_leader = &tsk,           \
  .real_cred  = &init_cred,         \
  .cred   = &init_cred,         \
  .cred_guard_mutex =           \
     __MUTEX_INITIALIZER(tsk.cred_guard_mutex),   \
  .comm   = "swapper",          \
  .thread   = INIT_THREAD,          \
  .fs   = &init_fs,         \
  .files    = &init_files,          \
  .signal   = &init_signals,        \
  .sighand  = &init_sighand,        \
  .nsproxy  = &init_nsproxy,        \
  .pending  = {           \
    .list = LIST_HEAD_INIT(tsk.pending.list),   \
    .signal = {{0}}},         \
  .blocked  = {{0}},          \
  .alloc_lock = __SPIN_LOCK_UNLOCKED(tsk.alloc_lock),   \
  .journal_info = NULL,           \
  .cpu_timers = INIT_CPU_TIMERS(tsk.cpu_timers),    \
  .fs_excl  = ATOMIC_INIT(0),       \
  .pi_lock  = __RAW_SPIN_LOCK_UNLOCKED(tsk.pi_lock),  \
  .timer_slack_ns = 50000, /* 50 usec default slack */    \
  .pids = {             \
    [PIDTYPE_PID]  = INIT_PID_LINK(PIDTYPE_PID),    \
    [PIDTYPE_PGID] = INIT_PID_LINK(PIDTYPE_PGID),   \
    [PIDTYPE_SID]  = INIT_PID_LINK(PIDTYPE_SID),    \
  },                \
  .dirties = INIT_PROP_LOCAL_SINGLE(dirties),     \
  INIT_IDS              \
  INIT_PERF_EVENTS(tsk)           \
  INIT_TRACE_IRQFLAGS           \
  INIT_LOCKDEP              \
  INIT_FTRACE_GRAPH           \
  INIT_TRACE_RECURSION            \
  INIT_TASK_RCU_PREEMPT(tsk)          \
}


#define INIT_CPU_TIMERS(cpu_timers)         \
{                 \
  LIST_HEAD_INIT(cpu_timers[0]),          \
  LIST_HEAD_INIT(cpu_timers[1]),          \
  LIST_HEAD_INIT(cpu_timers[2]),          \
}

kernel_thread(init, NULL, CLONE_FS | CLONE_SIGHAND);

#       #include <linux/unistd.h>
       void exit_group(int status);

// kernel/exit.c
void do_group_exit(int exit_code)
{
  struct signal_struct *sig = current->signal;

  BUG_ON(exit_code & 0x80); /* core dumps don't get here */

  if (signal_group_exit(sig))
    exit_code = sig->group_exit_code;
  else if (!thread_group_empty(current)) {
    struct sighand_struct *const sighand = current->sighand;
    spin_lock_irq(&sighand->siglock);
    if (signal_group_exit(sig))
      /* Another thread got here before we took the lock.  */
      exit_code = sig->group_exit_code;
    else {
      sig->group_exit_code = exit_code;
      sig->flags = SIGNAL_GROUP_EXIT;
      zap_other_threads(current);
    }
    spin_unlock_irq(&sighand->siglock);
  }

  do_exit(exit_code);
  /* NOTREACHED */
}

// kernel/exit.c
void do_exit(long code)
{
  struct task_struct *tsk = current;
  int group_dead;

  profile_task_exit(tsk);

  WARN_ON(atomic_read(&tsk->fs_excl));

  if (unlikely(in_interrupt()))
    panic("Aiee, killing interrupt handler!");
  if (unlikely(!tsk->pid))
    panic("Attempted to kill the idle task!");

  tracehook_report_exit(&code);

  validate_creds_for_do_exit(tsk);

  /*
   * We're taking recursive faults here in do_exit. Safest is to just
   * leave this task alone and wait for reboot.
   */
  if (unlikely(tsk->flags & PF_EXITING)) {
    printk(KERN_ALERT
      "Fixing recursive fault but reboot is needed!\n");
    /*
     * We can do this unlocked here. The futex code uses
     * this flag just to verify whether the pi state
     * cleanup has been done or not. In the worst case it
     * loops once more. We pretend that the cleanup was
     * done as there is no way to return. Either the
     * OWNER_DIED bit is set by now or we push the blocked
     * task into the wait for ever nirwana as well.
     */
    tsk->flags |= PF_EXITPIDONE;
    set_current_state(TASK_UNINTERRUPTIBLE);
    schedule();
  }

  exit_irq_thread();

  exit_signals(tsk);  /* sets PF_EXITING */
  /*
   * tsk->flags are checked in the futex code to protect against
   * an exiting task cleaning up the robust pi futexes.
   */
  smp_mb();
  raw_spin_unlock_wait(&tsk->pi_lock);

  if (unlikely(in_atomic()))
    printk(KERN_INFO "note: %s[%d] exited with preempt_count %d\n",
        current->comm, task_pid_nr(current),
        preempt_count());

  acct_update_integrals(tsk);
  /* sync mm's RSS info before statistics gathering */
  if (tsk->mm)
    sync_mm_rss(tsk, tsk->mm);
  group_dead = atomic_dec_and_test(&tsk->signal->live);
  if (group_dead) {
    hrtimer_cancel(&tsk->signal->real_timer);
    exit_itimers(tsk->signal);
    if (tsk->mm)
      setmax_mm_hiwater_rss(&tsk->signal->maxrss, tsk->mm);
  }
  acct_collect(code, group_dead);
  if (group_dead)
    tty_audit_exit();
  if (unlikely(tsk->audit_context))
    audit_free(tsk);

  tsk->exit_code = code;
  taskstats_exit(tsk, group_dead);

  exit_mm(tsk);

  if (group_dead)
    acct_process();
  trace_sched_process_exit(tsk);

  exit_sem(tsk);
  exit_files(tsk);
  exit_fs(tsk);
  check_stack_usage();
  exit_thread();
  cgroup_exit(tsk, 1);

  if (group_dead)
    disassociate_ctty(1);

  module_put(task_thread_info(tsk)->exec_domain->module);

  proc_exit_connector(tsk);

  /*
   * FIXME: do that only when needed, using sched_exit tracepoint
   */
  flush_ptrace_hw_breakpoint(tsk);
  /*
   * Flush inherited counters to the parent - before the parent
   * gets woken up by child-exit notifications.
   */
  perf_event_exit_task(tsk);

  exit_notify(tsk, group_dead);
#ifdef CONFIG_NUMA
  mpol_put(tsk->mempolicy);
  tsk->mempolicy = NULL;
#endif
#ifdef CONFIG_FUTEX
  if (unlikely(current->pi_state_cache))
    kfree(current->pi_state_cache);
#endif
  /*
   * Make sure we are holding no locks:
   */
  debug_check_no_locks_held(tsk);
  /*
   * We can do this unlocked here. The futex code uses this flag
   * just to verify whether the pi state cleanup has been done
   * or not. In the worst case it loops once more.
   */
  tsk->flags |= PF_EXITPIDONE;

  if (tsk->io_context)
    exit_io_context(tsk);

  if (tsk->splice_pipe)
    __free_pipe_info(tsk->splice_pipe);

  validate_creds_for_do_exit(tsk);

  preempt_disable();
  exit_rcu();
  /* causes final put_task_struct in finish_task_switch(). */
  tsk->state = TASK_DEAD;
  schedule();
  BUG();
  /* Avoid "noreturn function does return".  */
  for (;;)
    cpu_relax();  /* For when BUG is null */
}

EXPORT_SYMBOL_GPL(do_exit);