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

// // kernel/fork.c
static int get_pid(unsigned long flags)
{
  static int next_safe = PID_MAX;
  struct task_struct *p;

  if (flags & CLONE_PID)
    return current->pid;

  spin_lock(&lastpid_lock);
  if((++last_pid) & 0xffff8000) {
    last_pid = 300;   /* Skip daemons etc. */
    goto inside;
  }
  if(last_pid >= next_safe) {
inside:
    next_safe = PID_MAX;
    read_lock(&tasklist_lock);
  repeat:
    for_each_task(p) {
      if(p->pid == last_pid ||
         p->pgrp == last_pid  ||
         p->session == last_pid) {
        if(++last_pid >= next_safe) {
          if(last_pid & 0xffff8000)
            last_pid = 300;
          next_safe = PID_MAX;
        }
        goto repeat;
      }
      if(p->pid > last_pid && next_safe > p->pid)
        next_safe = p->pid;
      if(p->pgrp > last_pid && next_safe > p->pgrp)
        next_safe = p->pgrp;
      if(p->session > last_pid && next_safe > p->session)
        next_safe = p->session;
    }
    read_unlock(&tasklist_lock);
  }
  spin_unlock(&lastpid_lock);

  return last_pid;
}

// kernel/fork.c
static int copy_files(unsigned long clone_flags, struct task_struct * tsk)
{
  struct files_struct *oldf, *newf;
  struct file **old_fds, **new_fds;
  int open_files, nfds, size, i, error = 0;

  /*
   * A background process may not have any files ...
   */
// 读者可以在学习了 “文件系统” 一章以后再回过头来仔细阅读这段代码，我们在这里先作一些解释。
// 先看复制的方向。因为是当前进程在创建子进程，是从当前进程复制到子进程，所以把当前进程的
// task_struct 结构中的 files_struct 结构指针作为 oldf 。
  oldf = current->files;
  if (!oldf)
    goto out;

// 再看复制的条件。如果参数 clone_flags 中的CLONE_FILES标志位为1，就只是通过 atomic_inc()
// 递增当前进程的files_struct结构中的共享计数，表示这个数据结构现在多了一个“用户”，就返回了。
// 由于在此之前已通过数据结构赋值将当前进程的整个task_struct结构都复制给了子进程，结构中的指
// 针files自然也复制到了子进程的task_struct结构中，使子进程通过这个指针共享当前进程的
// files_struct 数据结构。
  if (clone_flags & CLONE_FILES) {
    atomic_inc(&oldf->count);
    goto out;
  }

  tsk->files = NULL;
  error = -ENOMEM;
// 否则，如果CLONE_FILES标志位为0，那就要复制了。首先通过kmem_cache_alloc() 为子进程分配一个
// files_struct 数据结构作为newf，然后从oldf把内容复制到newf。
  newf = kmem_cache_alloc(files_cachep, SLAB_KERNEL);
  if (!newf) 
    goto out;

  atomic_set(&newf->count, 1);

// 在files_struct数据结构
// 中有三个主要的“部件”。其一是个位图，名为close_on_exec_init；其二也是位图，名为open_fds_init；
// 其三则是 file 结构数组 fd_array[]。这七个部件都是固定大小的，如果打开的文件数量超过其容量，就
// 得通过expand_fdset()和expand_fd_array()在files_struct数据结构以外另行分配空间作为替换。
// 不管是采用files_struct数据结构内部的这三个部件或是采用外部的替换空间，指针close_on_exec、
// open_fds 和 fd 总是分别指向这二组信息。所以，如何复制取决于已打开文件的数量。
  newf->file_lock     = RW_LOCK_UNLOCKED;
  newf->next_fd     = 0;
  newf->max_fds     = NR_OPEN_DEFAULT;
  newf->max_fdset     = __FD_SETSIZE;
  newf->close_on_exec = &newf->close_on_exec_init;
  newf->open_fds      = &newf->open_fds_init;
  newf->fd      = &newf->fd_array[0];

  /* We don't yet have the oldf readlock, but even if the old
           fdset gets grown now, we'll only copy up to "size" fds */
  size = oldf->max_fdset;
  if (size > __FD_SETSIZE) {
    newf->max_fdset = 0;
    write_lock(&newf->file_lock);
    error = expand_fdset(newf, size);
    write_unlock(&newf->file_lock);
    if (error)
      goto out_release;
  }
  read_lock(&oldf->file_lock);

  open_files = count_open_files(oldf, size);

  /*
   * Check whether we need to allocate a larger fd array.
   * Note: we're not a clone task, so the open count won't
   * change.
   */
  nfds = NR_OPEN_DEFAULT;
  if (open_files > nfds) {
    read_unlock(&oldf->file_lock);
    newf->max_fds = 0;
    write_lock(&newf->file_lock);
    error = expand_fd_array(newf, open_files);
    write_unlock(&newf->file_lock);
    if (error) 
      goto out_release;
    nfds = newf->max_fds;
    read_lock(&oldf->file_lock);
  }

  old_fds = oldf->fd;
  new_fds = newf->fd;

  memcpy(newf->open_fds->fds_bits, oldf->open_fds->fds_bits, open_files/8);
  memcpy(newf->close_on_exec->fds_bits, oldf->close_on_exec->fds_bits, open_files/8);

  for (i = open_files; i != 0; i--) {
    struct file *f = *old_fds++;
    if (f)
      get_file(f);
    *new_fds++ = f;
  }
  read_unlock(&oldf->file_lock);

  /* compute the remainder to be cleared */
  size = (newf->max_fds - open_files) * sizeof(struct file *);

  /* This is long word aligned thus could use a optimized version */ 
  memset(new_fds, 0, size); 

  if (newf->max_fdset > open_files) {
    int left = (newf->max_fdset-open_files)/8;
    int start = open_files / (8 * sizeof(unsigned long));
    
    memset(&newf->open_fds->fds_bits[start], 0, left);
    memset(&newf->close_on_exec->fds_bits[start], 0, left);
  }

  tsk->files = newf;
  error = 0;
out:
  return error;

out_release:
  free_fdset (newf->close_on_exec, newf->max_fdset);
  free_fdset (newf->open_fds, newf->max_fdset);
  kmem_cache_free(files_cachep, newf);
  goto out;
}

// include/linux/fs_struct.h
struct fs_struct {
  atomic_t count;
  rwlock_t lock;
  int umask;
  struct dentry * root, * pwd, * altroot;
  struct vfsmount * rootmnt, * pwdmnt, * altrootmnt;
};

// ===============================================================================
// kernel/fork.c
static inline int copy_fs(unsigned long clone_flags, struct task_struct * tsk)
{
  if (clone_flags & CLONE_FS) {
    atomic_inc(&current->fs->count);
    return 0;
  }
  tsk->fs = __copy_fs_struct(current->fs);
  if (!tsk->fs)
    return -1;
  return 0;
}

static inline struct fs_struct *__copy_fs_struct(struct fs_struct *old)
{
  struct fs_struct *fs = kmem_cache_alloc(fs_cachep, GFP_KERNEL);
  /* We don't need to lock fs - think why ;-) */
  if (fs) {
    atomic_set(&fs->count, 1);
    fs->lock = RW_LOCK_UNLOCKED;
    fs->umask = old->umask;
    read_lock(&old->lock);
    fs->rootmnt = mntget(old->rootmnt);
    fs->root = dget(old->root);
    fs->pwdmnt = mntget(old->pwdmnt);
    fs->pwd = dget(old->pwd);
    if (old->altroot) {
      fs->altrootmnt = mntget(old->altrootmnt);
      fs->altroot = dget(old->altroot);
    } else {
      fs->altrootmnt = NULL;
      fs->altroot = NULL;
    } 
    read_unlock(&old->lock);
  }
  return fs;
}

// include/asm-i386/signal.h
struct sigaction {
  __sighandler_t sa_handler;
  unsigned long sa_flags;
  void (*sa_restorer)(void);
  sigset_t sa_mask;   /* mask last for extensibility */
};

struct k_sigaction {
  struct sigaction sa;
};

// ===============================================================================
// include/linux/sched.h
struct signal_struct {
  atomic_t    count;
  struct k_sigaction  action[_NSIG];
  spinlock_t    siglock;
};
// 其中的数组 action[] 确定了一个进程对各种信号(以信号的数值为下标)的反应和处理，子进程可
// 以通过复制或共享把它从父进程继承下来。

// ===============================================================================
static inline int copy_sighand(unsigned long clone_flags, struct task_struct * tsk)
{
  struct signal_struct *sig;

  if (clone_flags & CLONE_SIGHAND) {
    atomic_inc(&current->sig->count);
    return 0;
  }
  sig = kmem_cache_alloc(sigact_cachep, GFP_KERNEL);
  tsk->sig = sig;
  if (!sig)
    return -1;
  spin_lock_init(&sig->siglock);
  atomic_set(&sig->count, 1);
  memcpy(tsk->sig->action, current->sig->action, sizeof(tsk->sig->action));
  return 0;
}

// kernel/fork.c
static int copy_mm(unsigned long clone_flags, struct task_struct * tsk)
{
  struct mm_struct * mm, *oldmm;
  int retval;

  tsk->min_flt = tsk->maj_flt = 0;
  tsk->cmin_flt = tsk->cmaj_flt = 0;
  tsk->nswap = tsk->cnswap = 0;

  tsk->mm = NULL;
  tsk->active_mm = NULL;

  /*
   * Are we cloning a kernel thread?
   *
   * We need to steal a active VM for that..
   */
  oldmm = current->mm;
  if (!oldmm)
    return 0;

  if (clone_flags & CLONE_VM) {
    atomic_inc(&oldmm->mm_users);
    mm = oldmm;
    goto good_mm;
  }

  retval = -ENOMEM;
  mm = allocate_mm();
  if (!mm)
    goto fail_nomem;

  /* Copy the current MM stuff.. */
  memcpy(mm, oldmm, sizeof(*mm));
  if (!mm_init(mm))
    goto fail_nomem;

  down(&oldmm->mmap_sem);
  retval = dup_mmap(mm);
  up(&oldmm->mmap_sem);

  /*
   * Add it to the mmlist after the parent.
   *
   * Doing it this way means that we can order
   * the list, and fork() won't mess up the
   * ordering significantly.
   */
  spin_lock(&mmlist_lock);
  list_add(&mm->mmlist, &oldmm->mmlist);
  spin_unlock(&mmlist_lock);

  if (retval)
    goto free_pt;

  /*
   * child gets a private LDT (if there was an LDT in the parent)
   */
  copy_segments(tsk, mm);

  if (init_new_context(tsk,mm))
    goto free_pt;

good_mm:
  tsk->mm = mm;
  tsk->active_mm = mm;
  return 0;

free_pt:
  mmput(mm);
fail_nomem:
  return retval;
}

// kernel/fork.c
static inline int dup_mmap(struct mm_struct * mm)
{
  struct vm_area_struct * mpnt, *tmp, **pprev;
  int retval;

  flush_cache_mm(current->mm);
  mm->locked_vm = 0;
  mm->mmap = NULL;
  mm->mmap_avl = NULL;
  mm->mmap_cache = NULL;
  mm->map_count = 0;
  mm->cpu_vm_mask = 0;
  mm->swap_cnt = 0;
  mm->swap_address = 0;
  pprev = &mm->mmap;
// 这里通过140〜185行的for循环对同一用户空间中的各个区间进行复制。
  for (mpnt = current->mm->mmap ; mpnt ; mpnt = mpnt->vm_next) {
    struct file *file;

    retval = -ENOMEM;
    if(mpnt->vm_flags & VM_DONTCOPY)
      continue;
    tmp = kmem_cache_alloc(vm_area_cachep, SLAB_KERNEL);
    if (!tmp)
      goto fail_nomem;
    *tmp = *mpnt;
    tmp->vm_flags &= ~VM_LOCKED;
    tmp->vm_mm = mm;
    mm->map_count++;
    tmp->vm_next = NULL;
    file = tmp->vm_file;
// 对于通过mmap()映射到某个文件的区间，155〜169行是一些特殊的附加处理。
    if (file) {
      struct inode *inode = file->f_dentry->d_inode;
      get_file(file);
      if (tmp->vm_flags & VM_DENYWRITE)
        atomic_dec(&inode->i_writecount);
      
      /* insert tmp into the share list, just after mpnt */
      spin_lock(&inode->i_mapping->i_shared_lock);
      if((tmp->vm_next_share = mpnt->vm_next_share) != NULL)
        mpnt->vm_next_share->vm_pprev_share =
          &tmp->vm_next_share;
      mpnt->vm_next_share = tmp;
      tmp->vm_pprev_share = &mpnt->vm_next_share;
      spin_unlock(&inode->i_mapping->i_shared_lock);
    }

    /* Copy the pages, but defer checking for errors */
// 172行的copy_page_range()是关键所在，这个函数逐层处理页面目录项和页面表项，
// 其代码在mm/memory.c 中
    retval = copy_page_range(mm, current->mm, tmp);
    if (!retval && tmp->vm_ops && tmp->vm_ops->open)
      tmp->vm_ops->open(tmp);

    /*
     * Link in the new vma even if an error occurred,
     * so that exit_mmap() can clean up the mess.
     */
    *pprev = tmp;
    pprev = &tmp->vm_next;

    if (retval)
      goto fail_nomem;
  }
  retval = 0;
  if (mm->map_count >= AVL_MIN_MAP_COUNT)
    build_mmap_avl(mm);

fail_nomem:
  flush_tlb_mm(current->mm);
  return retval;
}

// mm/memory.c
/*
 * copy one vm_area from one task to the other. Assumes the page tables
 * already present in the new task to be cleared in the whole range
 * covered by this vma.
 *
 * 08Jan98 Merged into one routine from several inline routines to reduce
 *         variable count and make things faster. -jj
 */
int copy_page_range(struct mm_struct *dst, struct mm_struct *src,
      struct vm_area_struct *vma)
{
  pgd_t * src_pgd, * dst_pgd;
  unsigned long address = vma->vm_start;
  unsigned long end = vma->vm_end;
  unsigned long cow = (vma->vm_flags & (VM_SHARED | VM_MAYWRITE)) == VM_MAYWRITE;

  src_pgd = pgd_offset(src, address)-1;
  dst_pgd = pgd_offset(dst, address)-1;
  
  // 代码中163行的for循环是对页面目录项的循环，
  for (;;) {
    pmd_t * src_pmd, * dst_pmd;

    src_pgd++; dst_pgd++;
    
    /* copy_pmd_range */
    
    if (pgd_none(*src_pgd))
      goto skip_copy_pmd_range;
    if (pgd_bad(*src_pgd)) {
      pgd_ERROR(*src_pgd);
      pgd_clear(src_pgd);
skip_copy_pmd_range:
      address = (address + PGDIR_SIZE) & PGDIR_MASK;
      if (!address || (address >= end))
        goto out;
      continue;
    }
    if (pgd_none(*dst_pgd)) {
      if (!pmd_alloc(dst_pgd, 0))
        goto nomem;
    }
    
    src_pmd = pmd_offset(src_pgd, address);
    dst_pmd = pmd_offset(dst_pgd, address);

// 188行的do循环是对中间目录项的循环
    do {
      pte_t * src_pte, * dst_pte;
    
      /* copy_pte_range */
    
      if (pmd_none(*src_pmd))
        goto skip_copy_pte_range;
      if (pmd_bad(*src_pmd)) {
        pmd_ERROR(*src_pmd);
        pmd_clear(src_pmd);
skip_copy_pte_range:
        address = (address + PMD_SIZE) & PMD_MASK;
        if (address >= end)
          goto out;
        goto cont_copy_pmd_range;
      }
      if (pmd_none(*dst_pmd)) {
        if (!pte_alloc(dst_pmd, 0))
          goto nomem;
      }
      
      src_pte = pte_offset(src_pmd, address);
      dst_pte = pte_offset(dst_pmd, address);

// 211行的do循环则是对页面表项的循环。     
      do {
        pte_t pte = *src_pte;
        struct page *ptepage;
        
        /* copy_one_pte */

        if (pte_none(pte))
          goto cont_copy_pte_range_noset;
        if (!pte_present(pte)) {
          swap_duplicate(pte_to_swp_entry(pte));
          goto cont_copy_pte_range;
        }
        ptepage = pte_page(pte);
        if ((!VALID_PAGE(ptepage)) || 
            PageReserved(ptepage))
          goto cont_copy_pte_range;

        /* If it's a COW mapping, write protect it both in the parent and the child */
        if (cow) {
          ptep_set_wrprotect(src_pte);
          pte = *src_pte;
        }

        /* If it's a shared mapping, mark it clean in the child */
        if (vma->vm_flags & VM_SHARED)
          pte = pte_mkclean(pte);
        pte = pte_mkold(pte);
        get_page(ptepage);

cont_copy_pte_range:
        set_pte(dst_pte, pte);
cont_copy_pte_range_noset:
        address += PAGE_SIZE;
        if (address >= end)
          goto out;
        src_pte++;
        dst_pte++;
      } while ((unsigned long)src_pte & PTE_TABLE_MASK);
    
cont_copy_pmd_range:
      src_pmd++;
      dst_pmd++;
    } while ((unsigned long)src_pmd & PMD_TABLE_MASK);
  }
out:
  return 0;

nomem:
  return -ENOMEM;
}

// arch/i386/kernel/process.c
/*
 * we do not have to muck with descriptors here, that is
 * done in switch_mm() as needed.
 */
void copy_segments(struct task_struct *p, struct mm_struct *new_mm)
{
  struct mm_struct * old_mm;
  void *old_ldt, *ldt;

  ldt = NULL;
  old_mm = current->mm;
  if (old_mm && (old_ldt = old_mm->context.segments) != NULL) {
    /*
     * Completely new LDT, we initialize it from the parent:
     */
    ldt = vmalloc(LDT_ENTRIES*LDT_ENTRY_SIZE);
    if (!ldt)
      printk(KERN_WARNING "ldt allocation failed\n");
    else
      memcpy(ldt, old_ldt, LDT_ENTRIES*LDT_ENTRY_SIZE);
  }
  new_mm->context.segments = ldt;
}

// arch/i386/kernel/process.c
/*
 * Save a segment.
 */
#define savesegment(seg,value) \
  asm volatile("movl %%" #seg ",%0":"=m" (*(int *)&(value)))

int copy_thread(int nr, unsigned long clone_flags, unsigned long esp,
  unsigned long unused,
  struct task_struct * p, struct pt_regs * regs)
{
  struct pt_regs * childregs;

  childregs = ((struct pt_regs *) (THREAD_SIZE + (unsigned long) p)) - 1;
  struct_cpy(childregs, regs);
  childregs->eax = 0;
  childregs->esp = esp;

  p->thread.esp = (unsigned long) childregs;
  p->thread.esp0 = (unsigned long) (childregs+1);

  p->thread.eip = (unsigned long) ret_from_fork;

  savesegment(fs,p->thread.fs);
  savesegment(gs,p->thread.gs);

  unlazy_fpu(current);
  struct_cpy(&p->thread.i387, &current->thread.i387);

  return 0;
}

// include/asm-i386/semaphore.h
#define DECLARE_MUTEX(name) __DECLARE_SEMAPHORE_GENERIC(name,1)
#define DECLARE_MUTEX_LOCKED(name) __DECLARE_SEMAPHORE_GENERIC(name,0)

// arch/i386/kernel/process.c
/*
 * sys_execve() executes a new program.
 */
asmlinkage int sys_execve(struct pt_regs regs)
{
  int error;
  char * filename;

// 以前讲过，系统调用进入内核时，regs.ebx 中的内容为应用程序中调用相应库函数时的第一个参数。 
// 在本章第2节所举的例子中，这个参数为指向字符串 “/bin/echo" 的指针。现在，指针存放在
// regs.ebx 中，但字符串本身还在用户空间中，所以730行的 getname() 要把这个字符串从
// 用户空间拷贝到系统空间，在系统空间中建立起一个副本。让我们看看具体是怎么做的。
// 函数 getname() 的代码在 fs/namei.c 中
  filename = getname((char *) regs.ebx);
  error = PTR_ERR(filename);
  if (IS_ERR(filename))
    goto out;
// 在系统空间中建立起一份可执行文件的路径名副本以后，sys_execve()就调用do_execve()，以完
// 成其主体部分的工作。当然，完成以后还要通过 putname() 将所分配的物理页面释放。
// 函数 do_execvc() 的代码在 fs/exec.c 中
  error = do_execve(filename, (char **) regs.ecx, (char **) regs.edx, &regs);
  if (error == 0)
    current->ptrace &= ~PT_DTRACE;
  putname(filename);
out:
  return error;
}

// fs/namei.c
char * getname(const char * filename)
{
  char *tmp, *result;

  result = ERR_PTR(-ENOMEM);
  tmp = __getname();
  if (tmp)  {
    int retval = do_getname(filename, tmp);

    result = tmp;
    if (retval < 0) {
      putname(tmp);
      result = ERR_PTR(retval);
    }
  }
  return result;
}

// =================================================================
// include/linux/fs.h
#define __getname() kmem_cache_alloc(names_cachep, SLAB_KERNEL)

// fs/namei.c
/* In order to reduce some races, while at the same time doing additional
 * checking and hopefully speeding things up, we copy filenames to the
 * kernel data space before using them..
 *
 * POSIX.1 2.4: an empty pathname is invalid (ENOENT).
 */
static inline int do_getname(const char *filename, char *page)
{
  int retval;
  unsigned long len = PATH_MAX + 1;

  if ((unsigned long) filename >= TASK_SIZE) {
    if (!segment_eq(get_fs(), KERNEL_DS))
      return -EFAULT;
  } else if (TASK_SIZE - (unsigned long) filename < PAGE_SIZE)
    len = TASK_SIZE - (unsigned long) filename;

  retval = strncpy_from_user((char *)page, filename, len);
  if (retval > 0) {
    if (retval < len)
      return 0;
    return -ENAMETOOLONG;
  } else if (!retval)
    retval = -ENOENT;
  return retval;
}

// arch/i386/lib/usercopy.c
long strncpy_from_user(char *dst, const char *src, long count)
{
  long res = -EFAULT;
  if (access_ok(VERIFY_READ, src, 1))
    __do_strncpy_from_user(dst, src, count, res);
  return res;
}

#define __do_strncpy_from_user(dst,src,count,res)        \
do {                     \
  int __d0, __d1, __d2;              \
  __asm__ __volatile__(              \
    " testl %1,%1\n"             \
    " jz 2f\n"             \
    "0: lodsb\n"             \
    " stosb\n"             \
    " testb %%al,%%al\n"           \
    " jz 1f\n"             \
    " decl %1\n"             \
    " jnz 0b\n"            \
    "1: subl %1,%0\n"            \
    "2:\n"                 \
    ".section .fixup,\"ax\"\n"           \
    "3: movl %5,%0\n"            \
    " jmp 2b\n"            \
    ".previous\n"              \
    ".section __ex_table,\"a\"\n"          \
    " .align 4\n"            \
    " .long 0b,3b\n"             \
    ".previous"              \
    : "=d"(res), "=c"(count), "=&a" (__d0), "=&S" (__d1),    \
      "=&D" (__d2)               \
    : "i"(-EFAULT), "0"(count), "1"(count), "3"(src), "4"(dst) \
    : "memory");               \
} while (0)

// fs/exec.c
/*
 * sys_execve() executes a new program.
 */
int do_execve(char * filename, char ** argv, char ** envp, struct pt_regs * regs)
{
  struct linux_binprm bprm;
  struct file *file;
  int retval;
  int i;
// 显然，先要将给定的可执行程序文件找到并打开，open_exec()就是为此而调用的，其代码也在
// fs/exec.c 中，读者可结合“文件系统” 一章中有关打开文件操作的内容，特别是 path_walk() 
// 的代码自行阅读。
  file = open_exec(filename);

  retval = PTR_ERR(file);
  if (IS_ERR(file))
    return retval;

// 假定目标文件已经打开，下一步就要从文件中装入可执行程序了。内核中为可执行程序的装入定
// 义了一个数据结构 linux_binprm ，以便将运行一个可执行文件时所需的信息组织在一起，
// 这是在 include/linux/binfmts.h 定义的
  bprm.p = PAGE_SIZE*MAX_ARG_PAGES-sizeof(void *);
  memset(bprm.page, 0, MAX_ARG_PAGES*sizeof(bprm.page[0])); 
// 代码中的 linux_binprm 数据结构 bprm 是个局部量。函数 open_exec() 返回一个 file 结构指针，
// 代表着读入可执行文件的上下文，所以将其保存在数据结构 bprm 中。变量 bprm.sh_bang 的值说明
// 可执行文件的性质，当可执行文件是一个Shell过程(Shell Script，用 Shell 语言编写的命令文件，
// 由 shell 解释执行) 时置为 1。而现在还不知道，所以暂且将其置为 0，也就是先假定为二进制文件。
// 数据结构中的其他两个变量也暂时设置成 0。接着就处理可执行文件的参数和环境变量。
  bprm.file = file;
  bprm.filename = filename;
  bprm.sh_bang = 0;
  bprm.loader = 0;
  bprm.exec = 0;
// 与可执行文件路径名的处理办法一样，每个参数的最大长度也定为一个物理页面，所以 bprm 中有
// 一个页面指针数组，数组的大小为允许的最大参数个数 MAX_AGE_PAGES，目前这个常数定义为32。
// 前面已通过memset()将这个指针数组初始化成全0。现在将 bprm.p 设置成这些页面的总和减长一个
// 指针的大小，因为第 0 个参数也就是 argv[0] 是可执行程序本身的路径名。函数 count() 是在
// exec.c 中定义的，这里用它对字符串指针数组 argv[] 中参数的个数进行计数，而
// bprm.p/sizeof(void*)表示允许的最大值。同样，对作为参数传过来的环境变量也要通过 count() 
// 计数。注意这里的数组 argv[] 和 envp[] 是在用户空间而不在系统空间，所以计数的操作并不那么
// 简单。函数 count() 的代码在 fs/exec.c 中，它本身的代码很简单，但是引用的宏定义
// get_user() 却颇有些挑战性，值得一读。它也与第3章中介绍过的 __generic_copy_from_user() 
// 相似，我们把它留给读者作为练习。相关的代码在 include/asm-i386/uaccess.h 和 
// arch/i386/lib/getuser.S 中，调用的路径为
// [count() > getuser() > _get_user() > _get_user_4()] 。 如果 count() 失败，即返回负值，
// 则要对目标文件执行一次 allow_write_access()。这个函数是与 deny_write_access() 配对使用的，
// 目的在于防止其他进程(可能在另一个CPU上运行)在读入可执行文件期间通过内存映射改变它的内容
// (详见“文件系统”以及系统调用mmap())。与其配对的 deny_write_access() 是在打开可执行文件时在
// open_exec() 中调用的。
  if ((bprm.argc = count(argv, bprm.p / sizeof(void *))) < 0) {
    allow_write_access(file);
    fput(file);
    return bprm.argc;
  }

  if ((bprm.envc = count(envp, bprm.p / sizeof(void *))) < 0) {
    allow_write_access(file);
    fput(file);
    return bprm.envc;
  }

// 完成了对参数和环境变量的计数以后，do_execve()又调用prepare_binprm()，进一步做数据结构
// bprm的准备工作，从可执行文件读入开头的128个字节到 linux_binprm 结构 bprm 中的缓冲区。
// 当然，在读之前还要先检验当前进程是否有这个权力，以及该文件是否有可执行属性。如果可执行文件
// 具有"setuid”特性则要作相应的设置。这个函数的代码也在exec.c中。由于涉及文件操作的细节，我
// 们建议读者在学习了 “文件系统”以后再回过来自行阅读。此处先说明为什么只是先读128个字节。
// 这是因为，不管目标文件是elf格式还是a.out格式，或者别的格式，在开头128个字节中都包括了关
// 于可执行文件属性的必要而充分的信息。等一下读者就会看到这些信息的用途。
  retval = prepare_binprm(&bprm);
  if (retval < 0) 
    goto out; 
// 最后的准备工作就是把执行的参数，也就是argv[]，以及运行的环境，也就是envp[]，从用户空
// 间拷贝到数据结构bprm中。其中的第1个参数argv[0]就是可执行文件的路径名，已经在
// bprm.filename 中了，所以用copy_strings_kernel()从系统空间中拷贝，其他的就要用
// copy_strings()从用户空间拷贝。
  retval = copy_strings_kernel(1, &bprm.filename, &bprm);
  if (retval < 0) 
    goto out; 

  bprm.exec = bprm.p;
  retval = copy_strings(bprm.envc, envp, &bprm);
  if (retval < 0) 
    goto out; 

  retval = copy_strings(bprm.argc, argv, &bprm);
  if (retval < 0) 
    goto out; 
// 至此，所有的准备工作都己完成，所有必要的信息都已经搜集到了 linux_binprm 结构bprm中，
// 接下来就要装入并运行目标程序了 (exec.c) 。
//
// 显然，这里的关键是search_binary_handler()，在深入到这个函数内部之前，先介绍一个大概。内
// 核中有一个队列，叫 formats，挂在此队列中的成员是代表着各种可执行文件格式的“代理人”，每个
// 成员只认识并且处理一种特定格式的可执行文件的运行。在前面的准备阶段中，己经从可执行文件头
// 部读入了 128 个字节存放在bprm的缓冲区，而且运行所需的参数和环境变量也已经收集在bprm中。
// 现在就由formats队列中的成员逐个来认领，谁要是辨认到了它所代表的可执行文件格式，运行的事就
// 交给它。要是都不认识呢？那就根据文件头部的信息再找找看，是否有为此种格式设计，但是作为可
// 动态安装模块实现的“代理人”存在于文件系统中。如果有的话就把这模块安装进来并且将其挂入到
// formats队列中，然后让formats队列中的各个“代理人”再来试一次。
// 函数search_binary_handler()的代码也在exec.c中，其中有一段是专门针对alpha处理器的条件编
// 译，在下列的代码中跳过了这段条件编译语句：
  retval = search_binary_handler(&bprm,regs);
  if (retval >= 0)
    /* execve success */
    return retval;

out:
  /* Something went wrong, return the inode and free the argument pages*/
  allow_write_access(bprm.file);
  if (bprm.file)
    fput(bprm.file);

  for (i = 0 ; i < MAX_ARG_PAGES ; i++) {
    struct page * page = bprm.page[i];
    if (page)
      __free_page(page);
  }

  return retval;
}

// include/linux/binfmts.h
/*
 * This structure is used to hold the arguments that are used when loading binaries.
 */
struct linux_binprm{
  char buf[BINPRM_BUF_SIZE];
  struct page *page[MAX_ARG_PAGES];
  unsigned long p; /* current top of mem */
  int sh_bang;
  struct file * file;
  int e_uid, e_gid;
  kernel_cap_t cap_inheritable, cap_permitted, cap_effective;
  int argc, envc;
  char * filename;  /* Name of binary */
  unsigned long loader, exec;
};

// fs/exec.c
/*
 * cycle the list of binary formats handler, until one recognizes the image
 */
int search_binary_handler(struct linux_binprm *bprm,struct pt_regs *regs)
{
  int try,retval=0;
  struct linux_binfmt *fmt;
#ifdef __alpha__
  /* handle /sbin/loader.. */
  {
      struct exec * eh = (struct exec *) bprm->buf;

      if (!bprm->loader && eh->fh.f_magic == 0x183 &&
    (eh->fh.f_flags & 0x3000) == 0x3000)
      {
    char * dynloader[] = { "/sbin/loader" };
    struct file * file;
    unsigned long loader;

    allow_write_access(bprm->file);
    fput(bprm->file);
    bprm->file = NULL;

          loader = PAGE_SIZE*MAX_ARG_PAGES-sizeof(void *);

    file = open_exec(dynloader[0]);
    retval = PTR_ERR(file);
    if (IS_ERR(file))
      return retval;
    bprm->file = file;
    bprm->loader = loader;
    retval = prepare_binprm(bprm);
    if (retval<0)
      return retval;
    /* should call search_binary_handler recursively here,
       but it does not matter */
      }
  }
#endif
  for (try=0; try<2; try++) {
    read_lock(&binfmt_lock);
    for (fmt = formats ; fmt ; fmt = fmt->next) {
      int (*fn)(struct linux_binprm *, struct pt_regs *) = fmt->load_binary;
      if (!fn)
        continue;
      if (!try_inc_mod_count(fmt->module))
        continue;
      read_unlock(&binfmt_lock);
      retval = fn(bprm, regs);
      if (retval >= 0) {
        put_binfmt(fmt);
        allow_write_access(bprm->file);
        if (bprm->file)
          fput(bprm->file);
        bprm->file = NULL;
        current->did_exec = 1;
        return retval;
      }
      read_lock(&binfmt_lock);
      put_binfmt(fmt);
      if (retval != -ENOEXEC)
        break;
      if (!bprm->file) {
        read_unlock(&binfmt_lock);
        return retval;
      }
    }
    read_unlock(&binfmt_lock);
    if (retval != -ENOEXEC) {
      break;
#ifdef CONFIG_KMOD
    }else{
#define printable(c) (((c)=='\t') || ((c)=='\n') || (0x20<=(c) && (c)<=0x7e))
      char modname[20];
      if (printable(bprm->buf[0]) &&
          printable(bprm->buf[1]) &&
          printable(bprm->buf[2]) &&
          printable(bprm->buf[3]))
        break; /* -ENOEXEC */
      sprintf(modname, "binfmt-%04x", *(unsigned short *)(&bprm->buf[2]));
      request_module(modname);
#endif
    }
  }
  return retval;
}

// fs/binfmt_aout.c
static struct linux_binfmt aout_format = {
  NULL, THIS_MODULE, load_aout_binary, load_aout_library, aout_core_dump, PAGE_SIZE
};

/*
 * These are the functions used to load a.out style executables and shared
 * libraries.  There is no binary dependent code anywhere else.
 */
static int load_aout_binary(struct linux_binprm * bprm, struct pt_regs * regs)
{
  struct exec ex;
  unsigned long error;
  unsigned long fd_offset;
  unsigned long rlim;
  int retval;

// 首先是检查目标文件的格式，看看是否对上号。所有a.out格式可执行文件（二进制代码）的开头
// 都应该是一个exec数据结构，这是在include/asm-i386/a.out.h 中定义的：
  ex = *((struct exec *) bprm->buf);    /* exec-header */
  if ((N_MAGIC(ex) != ZMAGIC && N_MAGIC(ex) != OMAGIC &&
       N_MAGIC(ex) != QMAGIC && N_MAGIC(ex) != NMAGIC) ||
      N_TRSIZE(ex) || N_DRSIZE(ex) ||
      bprm->file->f_dentry->d_inode->i_size < ex.a_text+ex.a_data+N_SYMSIZE(ex)+N_TXTOFF(ex)) {
    return -ENOEXEC;
  }
// 各种a.out格式的文件因目标代码的特性不同，其正文的起始伟置也就不同。为此提供了一个宏操
// 作N_TXTOFF()，以便根据代码的特性取得正文在目标文件中的起始位置，这是在includc/linux/a.out.h
// 中定义的：
  fd_offset = N_TXTOFF(ex);

  /* Check initial limits. This avoids letting people circumvent
   * size limits imposed on them by creating programs with large
   * arrays in the data or bss.
   */
// 以前曾经讲过，每个进程的task_struct结构中有个数组rlim，规定了该进程使用各种资源的限制，
// 其中也包括对用于数据的内存空间的限制。所以，目标文件所确定的data和bss两个“段”的总和不
// 能超出这个限制。
  rlim = current->rlim[RLIMIT_DATA].rlim_cur;
  if (rlim >= RLIM_INFINITY)
    rlim = ~0;
  if (ex.a_data + ex.a_bss > rlim)
    return -ENOMEM;

  /* Flush all traces of the currently running executable */
// 顺利通过了这些检验就表示具备了执行该目标文件的条件，所以就到了 “与过去告别”的时候。
// 这种“告别过去”意味着放弃从父进程“继承”下来的全部用户空间，不管是通过复制还是通过共享
// 继承下来的。不过，下面读者会看到，这种告别也并非彻底的决裂。
// 函数 flush_old_exec() 的代码也在 exec.c 中
  retval = flush_old_exec(bprm);
  if (retval)
    return retval;

  /* OK, This is the point of no return */
#if !defined(__sparc__)
  set_personality(PER_LINUX);
#else
  set_personality(PER_SUNOS);
#if !defined(__sparc_v9__)
  memcpy(&current->thread.core_exec, &ex, sizeof(struct exec));
#endif
#endif

// 这里是对新的mm_struct数据结构中的一些变量进行初始化，为以后分配存储空间并读入可执行
// 代码的映象作好准备。目标代码的映象分成text、data 以及 bss 三段，mm_struct结构中为每个段都设
// 置了 start 和 end 两个指针。每段的起始地址定义于include/linux/a.out.h:
  current->mm->end_code = ex.a_text +
    (current->mm->start_code = N_TXTADDR(ex));
  current->mm->end_data = ex.a_data +
    (current->mm->start_data = N_DATADDR(ex));
  current->mm->brk = ex.a_bss +
    (current->mm->start_brk = N_BSSADDR(ex));

  current->mm->rss = 0;
  current->mm->mmap = NULL;
// 然后，通过compute_creds()确定进程在开始执行新的目标代码以后所具有的权限，这是根据bprm
// 中的内容和当前的权限确定的。其代码在 exec.c 中，读者可自行阅读。
  compute_creds(bprm);
  current->flags &= ~PF_FORKNOEXEC;
#ifdef __sparc__
  if (N_MAGIC(ex) == NMAGIC) {
    loff_t pos = fd_offset;
    /* Fuck me plenty... */
    /* <AOL></AOL> */
    error = do_brk(N_TXTADDR(ex), ex.a_text);
    bprm->file->f_op->read(bprm->file, (char *) N_TXTADDR(ex),
        ex.a_text, &pos);
    error = do_brk(N_DATADDR(ex), ex.a_data);
    bprm->file->f_op->read(bprm->file, (char *) N_DATADDR(ex),
        ex.a_data, &pos);
    goto beyond_if;
  }
#endif

// 前面讲过，a.out 格式目标代码中的 magic number 表示着代码的特性，或者说类型。当 magic number
// 为 OMAGIC 时，表示该文件中的可执行代码并非“纯代码”。对于这样的代码，先通过do_brk()为正文
// 段和数据段合在一起分配空间，然后就把这两部分从文件中读进来。函数do_brk()我们已经在笫2章中
// 介绍过，而从文件读入则在“文件系统”和“块设备驱动”两章中有详细叙述，读者可以参阅，这里
// 就不重复了。不过要指出，读入代码时是从文件中位移为32的地方开始，读入到进程用户空间中从地
// 址0开始的地方，读入的总长度为ex.a_text+ex.a_data。对于 i386 CPU 而言，
// flush_icache_range() 为一空语句。至于bss段，则无需从文件读入，只要分配空间就可以了，
// 所以放在后面再处理。对于 OMAGIC 类型的a.out可执行文件而言，装入程序的工作就基本完成了。
  if (N_MAGIC(ex) == OMAGIC) {
    unsigned long text_addr, map_size;
    loff_t pos;

    text_addr = N_TXTADDR(ex);

#if defined(__alpha__) || defined(__sparc__)
    pos = fd_offset;
    map_size = ex.a_text+ex.a_data + PAGE_SIZE - 1;
#else
    pos = 32;
    map_size = ex.a_text+ex.a_data;
#endif

    error = do_brk(text_addr & PAGE_MASK, map_size);
    if (error != (text_addr & PAGE_MASK)) {
      send_sig(SIGKILL, current, 0);
      return error;
    }

    error = bprm->file->f_op->read(bprm->file, (char *)text_addr,
        ex.a_text+ex.a_data, &pos);
    if (error < 0) {
      send_sig(SIGKILL, current, 0);
      return error;
    }
       
    flush_icache_range(text_addr, text_addr+ex.a_text+ex.a_data);
  } else {
// 在a.out格式的可执行文件中，除OMAGIC以外其他二种均为纯代码，也就是所谓的“可重入”代
// 码。此类代码中，不但其正文段的执行代码在运行时不会改变，其数据段的内容也不会在运行时改变。
// 凡是要在运行过程中改变内容的东西都在堆栈中（局部变量），要不然就在动态分配的缓冲区。所以，
// 内核干脆将可执行文件映射到子进程的用户空间中，这样连通常swap所需的盘上空间也省去了。在这
// 二种类型的可执行文件中，除NMGIC以外都要求正文段及数据段的长度与页面大小对齐，如发现没有
// 对齐就要通过printk()发出警告信息。但是，发出警告信息太频繁也不好，所以就设置了一个静态变量 
// error_time2，使警告信息之间的间隔不小于5秒。接下来的操作取决于具体的文件系统是否提供mmap、
// 就是将一个已打开文件映射到虚在空间的操作，以及正文段及数据段的长度是否与页面大小对齐。如
// 果不满足映射的条件，就分配空间并且将正文段和数据段一起读入至进程的用户空间。这次是从文件
// 中位移为fd_offset ，即N_TXTOFF（ex）的地方开始，读入到由文件的头部所指定的地址
// N_TXTADDR（ex），长度为两段的总和。如果满足映射的条件，那就更好了，那就通过do_mmap()分别
// 将文件中的正文段和数据段映射到进程的用户空间中，映射的地址则与装入的地址一致。
// 调用mmap()之前无需分配空间， 那已经包含在mmap()之中了。
// 至此，正文段和数据段都已经装入就绪了，接下来就是bss段和堆栈段了(fs/binfmt_aout.c)
    static unsigned long error_time, error_time2;
    if ((ex.a_text & 0xfff || ex.a_data & 0xfff) &&
        (N_MAGIC(ex) != NMAGIC) && (jiffies-error_time2) > 5*HZ)
    {
      printk(KERN_NOTICE "executable not page aligned\n");
      error_time2 = jiffies;
    }

    if ((fd_offset & ~PAGE_MASK) != 0 &&
        (jiffies-error_time) > 5*HZ)
    {
      printk(KERN_WARNING 
             "fd_offset is not page aligned. Please convert program: %s\n",
             bprm->file->f_dentry->d_name.name);
      error_time = jiffies;
    }

    if (!bprm->file->f_op->mmap||((fd_offset & ~PAGE_MASK) != 0)) {
      loff_t pos = fd_offset;
      do_brk(N_TXTADDR(ex), ex.a_text+ex.a_data);
      bprm->file->f_op->read(bprm->file,(char *)N_TXTADDR(ex),
          ex.a_text+ex.a_data, &pos);
      flush_icache_range((unsigned long) N_TXTADDR(ex),
             (unsigned long) N_TXTADDR(ex) +
             ex.a_text+ex.a_data);
      goto beyond_if;
    }

    down(&current->mm->mmap_sem);
    error = do_mmap(bprm->file, N_TXTADDR(ex), ex.a_text,
      PROT_READ | PROT_EXEC,
      MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE,
      fd_offset);
    up(&current->mm->mmap_sem);

    if (error != N_TXTADDR(ex)) {
      send_sig(SIGKILL, current, 0);
      return error;
    }

    down(&current->mm->mmap_sem);
    error = do_mmap(bprm->file, N_DATADDR(ex), ex.a_data,
        PROT_READ | PROT_WRITE | PROT_EXEC,
        MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE,
        fd_offset + ex.a_text);
    up(&current->mm->mmap_sem);
    if (error != N_DATADDR(ex)) {
      send_sig(SIGKILL, current, 0);
      return error;
    }
  }
beyond_if:
  set_binfmt(&aout_format);

  set_brk(current->mm->start_brk, current->mm->brk);
// 接着，还要在用户空间的堆栈区顶部为进程建立起一个虚存区间，并将执行参数以及环境变量所
// 占的物理页面与此虚存区间建立起映射。这是由setup_arg_pages()完成的，其代码在exec.c中：
//
// 进程的用户空间中地址最高处为堆栈区，这里的常数STACK_TOP就是TASK_SIZE，也就是3GB
// (0xC0000 0000)。堆栈区的顶部为一个数组，数组中的每一个元素都是一个页面。数组的大小为
// MAX_ARG_PAGES，而实际映射的页面数量则取决于这些执行参数和环境变量的数量。
// 然后，在这些页面的下方，就是过程的用户空间堆栈了。另一方面，大家知道任何用户程序的入
// 口都是main()，而main有两个参数argc和argv[]。其中参数argv[]是字符指针数组，
// argc则为数组的大小。 但是实际上还有个隐藏着的字符指针数组envp[]用来传递环境变量，
// 只是不在用户程序的“视野”之内而已。所以，用户空间堆栈中从一开始就要设置好三项数据，
// 即envp[]、argv[] 以及argc。
  retval = setup_arg_pages(bprm); 
  if (retval < 0) { 
    /* Someone check-me: is this error path enough? */ 
    send_sig(SIGKILL, current, 0); 
    return retval;
  }

// 此外，还要将保存着的(字符串形式的)参数和环境变量复制到用户空间的顶端。这都是由
// create_aout_tables() 完成的，其代码也在同一文件(binfmt.aout.c)中
//
// 读者应该能看明白，这是在堆栈的顶端构筑envp[]、argv[]和argc。请读者注意看一下这段代码中
// 的228至234行(以及237至243行)，然后回答一个问题：为什么是get_user(c, ptt)，后不是
// get_user(&c， ptt)? 以前我们曾经讲过，get_user()是一段颇具挑战性的代码，
// 并建议读者自行阅读。现在简单地介绍一下，看看你是否读懂了。
// 这是在include/asm-i386/uaccess.h 中定义的一个宏定义
  current->mm->start_stack =
    (unsigned long) create_aout_tables((char *) bprm->p, bprm);
#ifdef __alpha__
  regs->gp = ex.a_gpvalue;
#endif

// 这里只剩下最后一个关键性的操作了，那就是start_thread()。这是个宏操作，定义于
// include/asm-i386/process.h 中
//
// 读者对这里的regs指针已经很熟悉，它指向保留在当前进程系统空间堆栈中的各个寄存器副本。
// 当进程从系统调用返回时，这些数值就会被“恢复”到CPU的各个寄存器中。所以，那时候的堆栈指
// 针将是current->mm->start_stack；而返回地址，也就是EIP的内容，则将是ex.a_entry。
// 显然，这正是我们所需要的。
  start_thread(regs, ex.a_entry, current->mm->start_stack);
  if (current->ptrace & PT_PTRACED)
    send_sig(SIGTRAP, current, 0);
  return 0;
// 至此，可执行代码的装入和投运已经完成。而 do_execve() 在调用了 search_binary_handler()
//  以后也就结束了。当CPU从系统调用返回到用户空间时，就会从由 ex.a_entry 确定的地址开始执行。
}

// include/asm-i386/a.out.h
struct exec
{
  unsigned long a_info;   /* Use macros N_MAGIC, etc for access */
  unsigned a_text;    /* length of text, in bytes */
  unsigned a_data;    /* length of data, in bytes */
  unsigned a_bss;   /* length of uninitialized data area for file, in bytes */
  unsigned a_syms;    /* length of symbol table data in file, in bytes */
  unsigned a_entry;   /* start address */
  unsigned a_trsize;    /* length of relocation info for text, in bytes */
  unsigned a_drsize;    /* length of relocation info for data, in bytes */
};

#define N_TRSIZE(a) ((a).a_trsize)
#define N_DRSIZE(a) ((a).a_drsize)
#define N_SYMSIZE(a)  ((a).a_syms)

// fs/exec.c
int flush_old_exec(struct linux_binprm * bprm)
{
  char * name;
  int i, ch, retval;
  struct signal_struct * oldsig;

  /*
   * Make sure we have a private signal table
   */
  oldsig = current->sig;
// 首先是进程的信号(软中断)处理表。我们讲过，一个进程的信号处理表就好像一个系统中的中断向量表，
// 虽然运用的层次不同，其概念是相似的。当子进程被创建出来时，父进程的信号处理表可以己经复制过来，
// 但也有可能只是把父进程的信号处理表指针复制了过来，而通过这指针来共享父进程的信号处理表。现在，
// 子进程最终要“自立门户” 了，所以要看一下，如果还在共享父进程的信号处理表的话，就要把它复制过来。
// 正因为这样，make_private_signals() 的代码与do_fork()中调用的 copy_sighand()基本相同。
  retval = make_private_signals();
  if (retval) goto flush_failed;

  /* 
   * Release all of the old mmap stuff
   */
// 同样，子进程的用户空间可能是父进程用户空间的复制品，也可能只是通过一个指针来共享父进
// 程的用户空间，这一点只要检查一下对用户空间、也就是current->mm的共享计数就可清楚。当共享
// 计数为 1 时，表明对此空间的使用是独占的，也就是说这是从父进程复制过来的，那就要先释放
// mm_struct 数据结构以下的所有 vm_area_struct 数据结构(但是不包括mm_struct结构本身)，并且将页
// 面表中的表项都设置成0。具体地这是由exit_mmap()完成的，其代码在mm/mmap.c中，读者可自行
// 阅读。在调用exit_mmap()之前还调用了一个函数mm_release()，对此我们将在稍后加以讨论，因为在
// 后面也调用了这个函数。至于flush_cache_mm() 和 flush_tlb_mm()，那只是使高速缓存与内存相一致，
// 不在我们现在关心之列，而且前者对i386处理器而言根本就是空语句。这里倒是要问一句，在父进程
// fork()子进程的时候，辛辛苦苦地复制了代及用户空间的所有数据结构，难道目的就在于稍后在执行
// execve()时又辛辛苦苦把它们全部释放？既有今日，何必当初？是的，这确实不合理。这就是在有了
// fork()系统调用以后又增加了一个vfork()系统调用(从BSD Unix开始)的原因。让我们回顾一下
// sys_fork() 与 sys_vfork() 在调用 do_fork() 时的不同。
//
// 可见，sys_vfork() 在调用 do_fork()时比 sys_fork()多了两个标志位，一个是 CLONE_VFORK，另
// 一个是CLONE_VM。当CLONE_VM标志位为1时，内核并不将父进程的用户空间(数据结构)复制
// 给子进程，向只是将指向mm_struct数据结构的指针复制给子进程，让子进程通过这个指针来共享父
// 进程的用户空间。这样，创建了进程时可以免去复制用户空间的麻烦。向当子进程调用execve()时就
// 可以跳过释放用户空间这一步，直接就为子进程分配新的用户空间。但是，这样一来省事是省事了，
// 却可能带来新的问题。以前讲过，fork()以后，execve()之前，子进程虽然有它自己的一整套代表用户
// 空间的数据结构，但是最终在物理上还是与父进程共用相同的页面。不过，由于子进程有其独立的页
// 面目录与页面表，可以在子进程的页面表里把对所有页面的访问权限都设置成“只读”。这样，当子进
// 程企图改变某个页面的内容时，就会因权限不符而导致页面异常"，在页面异常的处理程序中为子进程
// 复制所需的物理页面，这就叫"copy_on_write”。相比之下，如果子进程与父进程共享用户空间，也就
// 是共享包括页面表在内的所有数据结构，那就无法实施"copy_on_write”了。此时子进程所写入的内容
// 就真正进入了父进程的空间中。我们知道，当一个进程在用户空间运行时，其堆栈也在用户空间。这
// 意味着在这种情况下子进程可以改变父进程的堆栈，反过来父进程也可以改变子进程的堆栈！因为这
// 个原因，vfork()的使用是很危险的，在子进程尚未放弃对父进程用户空间的共享之前，绝不能让两个
// 进程都进入系统空间运行。所以，在sys_vfork()调用do_fork()时结合使用了另一个标志位
// CLONE_VFORK。当这个标志位为1时，父进程在创建了子进程以后就进入睡眠状态，等候子进程通
// 过execve()执行另一个目标程序，或者通过exit()寿终正寝。在这两种情况下子进程都会释放其共享的
// 用户空间，使父进程可以安全地继续运行。即便如此，也还是有危险，子进程绝对不能从调用vfork()
// 的那个函数中返回，否则还是可能破坏父进程的返回地址。所以，vfork()实际上是建立在子进程在创
// 建以后立即就会调用execve()这个前提之上的。
// 那么，怎样使父进程进入睡眠而等待子进程调用execve()或exit()呢？当然可以有不同的实现。读
// 者已经在do_fork()的代码中看到了内核让父进程在一个0资源的“信号量”上执行一次down()操作而
// 进入睡眠的安排，这里的mm_release()则让子进程在此信号量上执行1次up()操作将父进程唤醒。
// 函数 mm_release()的代码在 fork.c 中
  retval = exec_mmap();
  if (retval) goto mmap_failed;

// 从exec_mmap()返回到flush_old_exec()时，子进程从父进程继承的用户空间已经释放，其用户空
// 间变成了一个独立的“空壳”，也就是一个大小为0的独立的用户空间。这时候的进程已经是“义无反
// 顾” 了，回不到原来的用户空间中去了(见代码中的注解)。前面讲过，当前进程(子进程)原来可能
// 是通过指针共享父进程的信号处理表的，而现在有了自己的独立的信号处理表，所以也要递减父进程
// 信号处理表的共享计数，并且如果递减后为0就要将其所占的空间释放，这就是
// release_old_signals() 所做的事情。
  /* This is the point of no return */
  release_old_signals(oldsig);

  current->sas_ss_sp = current->sas_ss_size = 0;

  if (current->euid == current->uid && current->egid == current->gid)
    current->dumpable = 1;
// 此外，进程的task_struct结构中有一个字符数组用来保存进程所执行的程序名，
// 所以还要把bprm->filename的目标程序路径名中的最后一段抄过去。
  name = bprm->filename;
  for (i=0; (ch = *(name++)) != '\0';) {
    if (ch == '/')
      i = 0;
    else
      if (i < 15)
        current->comm[i++] = ch;
  }
  current->comm[i] = '\0';
// 接着的flush_thread()只是处理与 debug和i387协处理器有关的内容，不是我们所关心的。
  flush_thread();
// 如果“当前进程”原来只是一个线程，那么它的task_struct结构通过结构中的队列头thread_group
// 挂入由其父进程为首的“线程组”队列。现在，它已经在通过execve()升级为进程，放弃了对父进程
// 用户空间的共享，所以就要通过de_thread()从这个线程组中脱离出来。这个函数的代码在fs/exec.c中
  de_thread(current);

  if (bprm->e_uid != current->euid || bprm->e_gid != current->egid || 
      permission(bprm->file->f_dentry->d_inode,MAY_READ))
    current->dumpable = 0;

  /* An exec changes our domain. We are no longer part of the thread
     group */
     
  current->self_exec_id++;
// 前面说过，进程的信号处理表就好像是个中断向量表。但是，这里还有个重要的不同，就是中断
// 向量表中的表项要么指向一个服务程序，要么就没有；而信号处理式中则还可以有对各种信号预设的 
// (default)响应，并不定非要指向一个服务程序。当把信号处理表从父进程复制过来时，其中每个
// 表项的值有三种可能：一种可能是SIG_IGN，表示不理睬；第二种是SIG_DFL，表示采取预设的响应
// 方式(例如收到SIGQUIT就exit())：笫二种就是指向一个用户空间的子程行。可是，现在整个用户空
// 间都已经放弃了，怎么还能让信号处理表的表项指向用户空间的子程序呢？所以还得检查一遍，将指
// 向服务程序的表项改成SIG_DFL。这是由flush_signal_handler()完成的，代码在kernel/signal.c 中
  flush_signal_handlers(current);
// 最后，是对原有已打开文件的处理，这是由flush_old_files()完成的。进程的task_struct结构中有
// 个指向一个file_struct结构的指针“files"，所指向的数据结构中保存着己打开文件的信息。在
// file_struct 结构中有个位图close_on_exec，里面存储着表示哪些文件在执行一个新目标程序时应予
// 关闭的信息。 而flush_old_files()要做的就是根据这个位图的指示将这型文件关闭，并且将此位图
// 清成全0。其代码在 exec.c 中
  flush_old_files(current->files);

  return 0;

mmap_failed:
flush_failed:
  spin_lock_irq(&current->sigmask_lock);
  if (current->sig != oldsig)
    kfree(current->sig);
  current->sig = oldsig;
  spin_unlock_irq(&current->sigmask_lock);
  return retval;
}

// fs/binfmt_script.c
struct linux_binfmt script_format = {
  NULL, THIS_MODULE, load_script, NULL, NULL, 0
};

static int load_script(struct linux_binprm *bprm,struct pt_regs *regs)
{
  char *cp, *i_name, *i_arg;
  struct file *file;
  char interp[BINPRM_BUF_SIZE];
  int retval;

  if ((bprm->buf[0] != '#') || (bprm->buf[1] != '!') || (bprm->sh_bang)) 
    return -ENOEXEC;
  /*
   * This section does the #! interpretation.
   * Sorta complicated, but hopefully it will work.  -TYT
   */

  bprm->sh_bang++;
  allow_write_access(bprm->file);
  fput(bprm->file);
  bprm->file = NULL;

  bprm->buf[BINPRM_BUF_SIZE - 1] = '\0';
  if ((cp = strchr(bprm->buf, '\n')) == NULL)
    cp = bprm->buf+BINPRM_BUF_SIZE-1;
  *cp = '\0';
  while (cp > bprm->buf) {
    cp--;
    if ((*cp == ' ') || (*cp == '\t'))
      *cp = '\0';
    else
      break;
  }
  for (cp = bprm->buf+2; (*cp == ' ') || (*cp == '\t'); cp++);
  if (*cp == '\0') 
    return -ENOEXEC; /* No interpreter name found */
  i_name = cp;
  i_arg = 0;
  for ( ; *cp && (*cp != ' ') && (*cp != '\t'); cp++)
    /* nothing */ ;
  while ((*cp == ' ') || (*cp == '\t'))
    *cp++ = '\0';
  if (*cp)
    i_arg = cp;
  strcpy (interp, i_name);
// 得到了解释程序的路径名以后，问题就转化成了对解释程序的装入，而script文件本身则转化成了
// 解释程序的运行参数。虽然script文件本身并不是二进制格式的可执行文件，解释程序的映象却是一个
// 二进制的可执行文件。
  /*
   * OK, we've parsed out the interpreter name and
   * (optional) argument.
   * Splice in (1) the interpreter's name for argv[0]
   *           (2) (optional) argument to interpreter
   *           (3) filename of shell script (replace argv[0])
   *
   * This is done in reverse order, because of how the
   * user environment and arguments are stored.
   */
  remove_arg_zero(bprm);
  retval = copy_strings_kernel(1, &bprm->filename, bprm);
  if (retval < 0) return retval; 
  bprm->argc++;
  if (i_arg) {
    retval = copy_strings_kernel(1, &i_arg, bprm);
    if (retval < 0) return retval; 
    bprm->argc++;
  }
  retval = copy_strings_kernel(1, &i_name, bprm);
  if (retval) return retval; 
  bprm->argc++;
  /*
   * OK, now restart the process with the interpreter's dentry.
   */
  file = open_exec(interp);
  if (IS_ERR(file))
    return PTR_ERR(file);

  bprm->file = file;
  retval = prepare_binprm(bprm);
  if (retval < 0)
    return retval;
  return search_binary_handler(bprm,regs);
// 可见，Script文件的使用在装入运行的过程中引入了递归性，load_script() 最后又调用 
// search_binary_handler()不管递归有多深，显终执行的一定是个二进制可执行文件，例如
// /bin/sh、 /usr/bin/perl 等解释程序。在递归的过程中，逐层的可执行文件路径名形成
// 一个参数堆栈，传递给最终的解释程序。
}