Linux 内核源代码情景分析（二）（上）

// include/linux/sched.h
#define TASK_RUNNING    0
#define TASK_INTERRUPTIBLE  1
#define TASK_UNINTERRUPTIBLE  2
#define TASK_ZOMBIE   4
#define TASK_STOPPED    8

       #include <unistd.h>
       pid_t fork(void);

       #include <sched.h>
       int clone(int (*fn)(void *), void *child_stack,
                 int flags, void *arg, ...
                 /* pid_t *ptid, struct user_desc *tls, pid_t *ctid */ );
 

// kernel/fork.c
/*
 *  Ok, this is the main fork-routine. It copies the system process
 * information (task[nr]) and sets up the necessary registers. It also
 * copies the data segment in its entirety.  The "stack_start" and
 * "stack_top" arguments are simply passed along to the platform
 * specific copy_thread() routine.  Most platforms ignore stack_top.
 * For an example that's using stack_top, see
 * arch/ia64/kernel/process.c.
 */
int do_fork(unsigned long clone_flags, unsigned long stack_start,
      struct pt_regs *regs, unsigned long stack_size)
{
  int retval = -ENOMEM;
  struct task_struct *p;
  // 第560行的宏操作DECLARE_MUTEX_LOCKED()定义和创建了一个用于进程间互斥和同步的信
  // 号量，其定义和实现见第6章“进程间通信”。
  DECLARE_MUTEX_LOCKED(sem);

  // 参数 clone_flags 由两部分组成，其最低的字行为信号类型，用以规定子进程去世时应该向父进程
  // 发出的信号。我们也经看到，对于fork()和vfork()这个信号就是SIGCHLD，而对__clone()则该位段
  // 可由调用者决定。第二部分是一些表示资源和特性的标志位，这些标志位是在
  // include/linux/sched.h 中定义的：
  // 对于fork()，这一部分为全0，表现对有关的资源都要复制而不是通过指针共享。向对vfbrk()，
  // 则为 CLONE_VFORK | CLONE_VM ，表示父、子进程共用(用户)虚存区间，并且当子进程释放其虚
  // 存区间时要唤醒父进程。至于__clone()，则这一部分完全由调用者设定而作为参数传递下来。其中标
  // 志位CLONE_PID有特殊的作用，当这个标志位为1时，父、子进程(线程)共用同一个进程号，也
  // 就是说，子进程虽然有其自己的task_struct数据结构，却使用父进程的pid。但是，只有0号进程，也
  // 就是系统中的原始进程(实际上是线程)，才允许这样来调用__clone()，所以564行对此加以检查。
  if (clone_flags & CLONE_PID) {
    /* This is only allowed from the boot up thread */
    if (current->pid)
      return -EPERM;
  }
  
  current->vfork_sem = &sem;
// 接着，通过alloc_task_struct()为子进程分配两个连续的物理页而，低端用作子进程的task_struct 
// 结构，高端则用作其系统空间堆栈.
  p = alloc_task_struct();
  if (!p)
    goto fork_out;
    
// 注意574行的赋值为整个数据结构的赋值。这样，父进程的整个 task_struct 就被复制到了子进程
// 的数据结构中。经编译以后，这样的赋值是用memcpyS实现的，所以效率很高。
  *p = *current;

  retval = -EAGAIN;
// 在task_struct结构中有个指针user，用来指向一个user_struct结构。一个用户常常有许多个进程，
// 所以有关用户的一些信息并不专属于某一个进程。这样，属于同一用户的进程就可以通过指针user共
// 享这些信息。显然，每个用户有且只有一个user_struct结构。结构中有个计数器count，对属于该用户
// 的进程数量计数。可想而知，内核线程并不属于某个用户，所以其task_struct中的user指针为0。这个
// 数据结构的定义在include/lmux/sched.h中：
//
// 各进程的 task_struct 结构中还有个数组 rlim，对该进程占用各种资源的数量作出限制，而 
// rlim[RLIMIT_NPROC] 就规定了该进程所属的用户可以拥有的进程数量。所以，如果当前进程是
// 一个用户进程，并且该用户拥有的进程数量己经达到了规定的限制值，就再不允许它 fork()
// 了。
  if (atomic_read(&p->user->processes) >= p->rlim[RLIMIT_NPROC].rlim_cur)
    goto bad_fork_free;
  atomic_inc(&p->user->__count);
  atomic_inc(&p->user->processes);
  /*
   * Counter increases are protected by
   * the kernel lock so nr_threads can't
   * increase under us (but it may decrease).
   */
// 那么，对于不属于任何用户的内核线程怎么办呢？ 587行中的两个计数器就是为进程的总量而设的。
  if (nr_threads >= max_threads)
    goto bad_fork_cleanup_count;

// 一个进程除了属于某一个用户之外，还属于某个“执行域”。总的来说，Linux是Unix的一个变种，
// 并且符合POSIX的规定。但是，有很多版本的操作系统同样是Unix变种，同样符合POSIX规定，互
// 相之间在实现细节上却仍然有明显的不同。例如，AT&T的Sys V和BSD4.2就有相当的不同，而Sun
// 的Solaris又有区别，这就形成了不同的执行域。如果一个进程所执行的程序是为Solaris开发的，那么
// 这个进程就属于Solaris执行域PER_SOLARIS。当然，在Linux上运行的绝大多数程序都属于Linux
// 执行域。在task_struct结构中有一个指针exec_domain，可以指向一个exec_domain数据结构。
// 那是在 include/linux/personality.h 中定义的
  get_exec_domain(p->exec_domain);

// 同样的道理，每个进程所执行的程序属于某种可执行映象格式，如a.out格式、elf格式、甚至java
// 虚拟机格式。对这些不同格式的支持通常是通过动态安装的驱动模块来实现的。所以task_struct结构
// 中还有一个指向 linux_binfmt 数据结构的指针binfmt ， 而 do_fork()中593行的 
// __MOD_INC_USE_COUNT() 就是对有关模块的使用计数器进行操作。
  if (p->binfmt && p->binfmt->module)
    __MOD_INC_USE_COUNT(p->binfmt->module);

  p->did_exec = 0;
  p->swappable = 0;
// 为什么要在597行把状态设成TASK_UNINTERRUPTIBLE呢？这是因为在 get_pid()中产生一个
// 新pid的操作必须是独占的，当前进程可能会因为一时进不了临界区而只好暂时进入睡眠状态等待，
// 所以才事先把状态设成 UNINTERRUPTIBLE。
  p->state = TASK_UNINTERRUPTIBLE;
// 函数 copy_flags() 将参数clone_flags中的标志位略加补充和变换，然后写入p->flags，
// 这个函数的代码也在fork.c中。读者可以自己阅读。
  copy_flags(clone_flags, p);
// 至于600行的 get_pid()，则根据clone_flags中标志位CLONE_PID的值，或返回父进程(当前进
// 程)的pid，或返回一个新的pid放在了进程的task_struct中。函数get_pid()的代码也在fork.c 中
  p->pid = get_pid(clone_flags);

  p->run_list.next = NULL;
  p->run_list.prev = NULL;

  if ((clone_flags & CLONE_VFORK) || !(clone_flags & CLONE_PARENT)) {
    p->p_opptr = current;
    if (!(p->ptrace & PT_PTRACED))
      p->p_pptr = current;
  }
  p->p_cptr = NULL;
// 我们在前一节中提到过 wait4()和wait3()， 一个进程可以停下来等待其子进程完成使命。为此，在 
// task_struct 中设置了一个队列头部 wait_chldexit，前面在复制task_struct结构时把这也照抄了
// 过来，而子进程此时尚未“出生”，当然谈不上子进程的等待队列，所以要在611行中加以初始化。
  init_waitqueue_head(&p->wait_chldexit);
  p->vfork_sem = NULL;
  spin_lock_init(&p->alloc_lock);

// 类似地，对各种信息量也要加以初始化。这里615和616行是对子进程的待处理信号队列以及有
// 关结构成分的初始化。对这些与信号有关的结构成分我们将在“进程间通信”的信号一节中详细介绍。
// 接下来是对 task_struct 结构中各种计时变量的初始化，我们将在“进程调度” 一节中介绍这些变量。
// 在这里我们不关心对多处理器SMP结构的特殊考虑，所以也跳过627一637行。
  p->sigpending = 0;
  init_sigpending(&p->pending);

  p->it_real_value = p->it_virt_value = p->it_prof_value = 0;
  p->it_real_incr = p->it_virt_incr = p->it_prof_incr = 0;
  init_timer(&p->real_timer);
  p->real_timer.data = (unsigned long) p;

  p->leader = 0;    /* session leadership doesn't inherit */
  p->tty_old_pgrp = 0;
  p->times.tms_utime = p->times.tms_stime = 0;
  p->times.tms_cutime = p->times.tms_cstime = 0;
#ifdef CONFIG_SMP
  {
    int i;
    p->has_cpu = 0;
    p->processor = current->processor;
    /* ?? should we just memset this ?? */
    for(i = 0; i < smp_num_cpus; i++)
      p->per_cpu_utime[i] = p->per_cpu_stime[i] = 0;
    spin_lock_init(&p->sigmask_lock);
  }
#endif
  p->lock_depth = -1;   /* -1 = no lock */
// 最后，task_struct 结构中的 start_time 表示进程创建的时间，向全局变量jiffies的数值就是以时钟
// 中断周期为单位的从系统初始化开始至此时的时间。
// 至此，对 task_struct 数据结构的复制与初始化就基本完成了。下面就轮到其他的资源了：
  p->start_time = jiffies;

  retval = -ENOMEM;
  /* copy all the process information */
// 函数copy_files()有条件地复制已打开文件的控制结构，这种复制只有在clone_flags中
// CLONE_FILES 标志位为 0 时才真正进行，否则就只是共享父进程的已打开文件。当一个进程有己打开
// 文件时，task_struct 结构中的指针files指向一个files_struct数据结构，否则为0。
// 所有与终端设备tty相联系的用户进程的头三个文件，即stdin、stdout、及stderr，都是预先打开的，
// 所以指针一般不会是 0。数据结构 files_struct 是在include/linux/sched.h中定义的
//（详见“文件系统”一章），copy_files() 的代码则还是在fork.c中：
  if (copy_files(clone_flags, p))
    goto bad_fork_cleanup;
// 除 files_struct 数据结构外，还有个fs_struct数据结构也是与文件系统有关的，也要通过共享或复
// 制遗传给子进程。类似地，copy_fs()也是只有在clone_flags中CLONE_FS标志位为 0 时才加以复制。
// task_struct 结构中的指针指向一个fs_struct数据结构，结构中记录的是进程的根目录root、当前工作目
// 录pwd、一个用于文件操作权限管理的umask，还有一个计数器，其定义在include/linux/fs_struct.h中
// （详见“文件系统”一章）。函数copy_fs()连同几个有关低层函数的代码也在kernel/fork.c中。我们把这些代
// 码留给读者：
  if (copy_fs(clone_flags, p))
    goto bad_fork_cleanup_files;
// 接着是关于对信号的处理方式。是否复制父进程对信号的处理是由标志位CLONE_SIGHAND控
// 制的。信号基本上是一种进程间通信手段，信号之于一个进程就好像中断之于一个处理器。进程可以
// 为各种信号设置用于该信号的处理程序，就好像系统可以为各个中断源设置相应的中断服务程序一样.
// 如果一个进程设置了信号处理程序，其task_struct结构中的指针sig就指向一个signal_struct数据结构。
// 这种结构是在include/linux/sched.h中定义的：
  if (copy_sighand(clone_flags, p))
    goto bad_fork_cleanup_fs;
// 然后是用户空间的继承。进程的task_struct结构中有个指针mm，读者已经相当熟悉了，它指向一
// 个代表着进程的用户空间的mm_struct数据结构。由于内核线程并不拥有用户空间，所以在内核线程
// 的task_struct结构中该指针为0。有关mm_struct及其下属的vm_area_struct等数据结构已经在第2章
// 中介绍过，这里不再重复。
  if (copy_mm(clone_flags, p))
    goto bad_fork_cleanup_sighand;

// 当 CPU 从 copy_mm() 回到 do_fork() 中时，所有需要有条件复制的资源都已经处理完了。
// 读者不妨回顾一下，当系统调用fork()通过sys_fork()进入do_fork()时，其clone_flags为SIGCHLD，
// 也就是说，所有的标志位均为0，所以copy_files() 、copy_fs() 、copy_sighand()以及copy_mm()
// 全部真正执行了，这四项资源全都复制了。而当vfork()经过sys_vfork进入do_fork()时，
// 则其clone_flags为 VFORK|CLONE_VM|SIGHLD，所以只执行了 copy_files() 、copy_fs()以及 
// copy_sighand()；而 copy_mm()，则因标志位 CLONE_VM 为1，只是通过指针共享其父进程的mm_struct，
// 并没有一份自己的副本。这也就是说，经vfork()复制的是个线程，只能靠共享其父进程的存储空间度日，
// 包括用户空间堆栈在内。至于 __clone()，则取决于调用时的参数。当然，最终还得取决于父进程具有
// 什么资源， 要是父进程没有已打开文件，那么即使执行了 copy_files()，也还是空的。
// 
// 回到do_fork()的代码111。前面已通过alloc_task_struct()分配了两个连续的页间，其低端用作
// task_struct结构，已经基本上复制好了；而用作系统空间堆栈的高端，却还没有复制。现在就由
// copy_thread()来做这件事了。这个函数的代码在 arch/i386/kernel/process.c 中：
  retval = copy_thread(0, clone_flags, stack_start, stack_size, p, regs);
  if (retval)
    goto bad_fork_cleanup_sighand;
  p->semundo = NULL;
  
  /* Our parent execution domain becomes current domain
     These must match for thread signalling to apply */
// 代码中的 parent_exec_id 表示父进程的执行域，self_exec_id 为本进程的执行域，swappable
// 表示本进程的存储页面可以被换出，exit_signal 为本进程执行exit()时应向父进程发出的信号，
// pdeath_signal 为要求父进程在执行exit()时向本进程发出的信号。   
  p->parent_exec_id = p->self_exec_id;

  /* ok, now we should be set up.. */
  p->swappable = 1;
  p->exit_signal = clone_flags & CSIGNAL;
  p->pdeath_signal = 0;

  /*
   * "share" dynamic priority between parent and child, thus the
   * total amount of dynamic priorities in the system doesnt change,
   * more scheduling fairness. This is only important in the first
   * timeslice, on the long run the scheduling behaviour is unchanged.
   */
// 此外，task_struct 结构中 counter 字段的值就是进程的运行时间配额，这里将父进程的时间配额分成
// 两半，让父、子进程各有原值的一半。
  p->counter = (current->counter + 1) >> 1;
  current->counter >>= 1;
  if (!current->counter)
    current->need_resched = 1;

  /*
   * Ok, add it to the run-queues and make it
   * visible to the rest of the system.
   *
   * Let it rip!
   */
  retval = p->pid;
  p->tgid = retval;
  INIT_LIST_HEAD(&p->thread_group);
  write_lock_irq(&tasklist_lock);
// 如果创建的是线程，则还要通过task_struct结构中的队列头thread_group与父进程链接起来，
// 形成一个 “线程组”。
  if (clone_flags & CLONE_THREAD) {
    p->tgid = current->tgid;
    list_add(&p->thread_group, &current->thread_group);
  }
// 接着，就要让子进程进入它的关系网了。先通过SET_LTNKS(p)将子进程的task_struct结构链入内核的
// 进程队列，然后又通过hash_pid()将其链入按其pid计算得的杂凑队列。有关这些队列的详情可参看
// “进程”以及“进程的调度与切换”两节中的有关叙述。  
  SET_LINKS(p);
  hash_pid(p);
  nr_threads++;
  write_unlock_irq(&tasklist_lock);

  if (p->ptrace & PT_PTRACED)
    send_sig(SIGSTOP, p, 1);
// 最后，通过 wake_up_process() 将子进程“唤醒”， 也就是将其挂入可执行进程队列等待调度。
// 有关详情可参看“过程的睡眠与唤醒” 一节。
  wake_up_process(p);   /* do this last */
  ++total_forks;
// 至此，新进程的创建已经完成了，并且已经挂入了可运行进程的队列接受调度。子进程与父进程
// 在用户空间中具有相同的返回地址，然后才会因用户空间中程序的安排而分开。同时，由于当父进程
// (当前进程)从系统调用返回的前夕可能会接受调度，所以，到底谁会先返回到用户空间是不确定的。
// 不过，一般而言，由于父、子进程适用相同的调度政策，而父进程在可执行进程队列中排在子进程前
// 面，所以父进程先运行的可能较大。

fork_out:
// 还有一种特殊情况要考虑。当调用do_fork()的参数中CLONE_VFORK标志位为1时，一定要保
// 证让子进程先运行，一直到了进程通过系统调用execve()执行一个新的可执行程序或者通过
// 系统调用 exit() 退出系统时，才可以恢复父进程的运行。为什么呢？这要从用户空间的复制
// 或共享这个问题说起。 前面读者已经看到，在创建子进程时，对于父进程的用户空间可以通过
// 复制父进程的 mm_struct 及其下属的各个vm_area_struct数据结构，再加上父进程的页面目录和页面表
// 来继承；也可以简单地复制父进程的task_struct结构中指向其mm_struct结构的指针来共享，具体取决于
// CLONE_VM标志位的值。 当CLONE_VM标志位为1，因而父、子进程通过指针共享用户空间时，
// 父、子进程是在真正的意义上共享用户空间，父进程写入其用户空间的内容同时也“写入”了进程的用户空间，
// 反之亦然。如果说， 在这种情况下父、子进程各自对其数据区的写入可能会引起问题的话，
// 那么对堆栈区的写入可就是致命的了。而每次对子程序的调用都是对堆栈区的写入！由此可见，
// 在这样的情况下绝不能让两个进程都回到用户空间并发地运行；否则，必然是两个进程最终都乱来
// 一气或者因非法越界访问而死亡。解决的办法只能是“扣留”其中一个进程，而只让一个进程回到用户空间，
// 直到两个进程不再共享它们的用户空间或其中一个进程(必然是回到用户空间运行的那个进程)消亡为止。
// 所以，do_fork()中的703行利704行在CLONE_VFORK标志为 1 并且 fork 子进程成功的情况下，
// 通过让当前进程(父进程)在一个信号量上执行一次down()操作，以达到扣留父进程的目的。我们来
// 看看具体是怎样实现的。
// 首先，信号量sem是在函数开头时的560行定义的一个局部量(名曰DECLARE，实际上为之分配了空间)：
  if ((clone_flags & CLONE_VFORK) && (retval > 0)) 
// DECLARE_MUTEX_LOCKED 定义这个信号量中资源的数量为 0 。当资源数量为1时，第一个执行down()操作
// 的进程进入临界区，而使资源数量变成了 0，以后执行 down() 操作的进程便会因为资源为0而被拒之
// 门外进入睡眠，直到第一个进程归还资源离开临界区时才被唤醒。而现在这个信号量的资源从一开始
// 就是0，所以第一个对此执行down()操作的进程就会进入睡眠，一直要到某个进程往这个信号量中投
// 入资源，也就是执行一次up()操作时才会被唤醒。
//
// 那么，谁来投入资源呢？在“系统调用execve()”一节中读者将看到，子进程在通过execve()执
// 行一个新的可执行程序时会做这件事。此外，子进程在通过exit()退出系统时也会做这件事。这里还要
// 指出，这个信号量是do_fork()的一个局部变量，所以在父进程的系统空间堆栈中，而子进程在其
// task_struct结构中有指向这个信号量的指针(即 vfork_sem，见do_fork()的第554行和560行)。既然
// 父进程一直要睡眠到子进程使用这个信号量以后，信号量所在的空间就不会受到打扰。还应指出，
// CLONE_VM要与CLONE_VFORK结合使用，否则就会发生前述的问题，除非在用户程序中采取了特
// 殊的预防措施。
// 不管怎样，子进程的创建终于完成了，让我们祝福这新的生命！可是，如果子进程只具有与父进
// 程相同的可执行程序和数据，只是父进程的“影子”，那又有什么意义呢？子进程必须走自己的路，这
// 就是下一节“系统调用execve()”所要讲述的内容了。
    down(&sem);
  return retval;

bad_fork_cleanup_sighand:
  exit_sighand(p);
bad_fork_cleanup_fs:
  exit_fs(p); /* blocking */
bad_fork_cleanup_files:
  exit_files(p); /* blocking */
bad_fork_cleanup:
  put_exec_domain(p->exec_domain);
  if (p->binfmt && p->binfmt->module)
    __MOD_DEC_USE_COUNT(p->binfmt->module);
bad_fork_cleanup_count:
  atomic_dec(&p->user->processes);
  free_uid(p->user);
bad_fork_free:
  free_task_struct(p);
  goto fork_out;
}

// include/linux/sched.h
/*
 * cloning flags:
 */
#define CSIGNAL   0x000000ff  /* signal mask to be sent at exit */
#define CLONE_VM  0x00000100  /* set if VM shared between processes */
#define CLONE_FS  0x00000200  /* set if fs info shared between processes */
#define CLONE_FILES 0x00000400  /* set if open files shared between processes */
#define CLONE_SIGHAND 0x00000800  /* set if signal handlers and blocked signals shared */
#define CLONE_PID 0x00001000  /* set if pid shared */
#define CLONE_PTRACE  0x00002000  /* set if we want to let tracing continue on the child too */
#define CLONE_VFORK 0x00004000  /* set if the parent wants the child to wake it up on mm_release */
#define CLONE_PARENT  0x00008000  /* set if we want to have the same parent as the cloner */
#define CLONE_THREAD  0x00010000  /* Same thread group? */

#define CLONE_SIGNAL  (CLONE_SIGHAND | CLONE_THREAD)

// include/linux/sched.h
/*
 * Some day this will be a full-fledged user tracking system..
 */
struct user_struct {
  atomic_t __count; /* reference count */
  atomic_t processes; /* How many processes does this user have? */
  atomic_t files;   /* How many open files does this user have? */

  /* Hash table maintenance information */
  struct user_struct *next, **pprev;
  uid_t uid;
};

// include/linux/personality.h
/* Description of an execution domain - personality range supported,
 * lcall7 syscall handler, start up / shut down functions etc.
 * N.B. The name and lcall7 handler must be where they are since the
 * offset of the handler is hard coded in kernel/sys_call.S.
 */
struct exec_domain {
  const char *name;
  lcall7_func handler;
  unsigned char pers_low, pers_high;
  unsigned long * signal_map;
  unsigned long * signal_invmap;
  struct module * module;
  struct exec_domain *next;
};