Linux Kernel: Program Exzecution

copy_strings(argc, argv, bprm):
  while (argc-- > 0):
    char __user *str;
    // str 代表 argv 中的一项
    get_user(str, argv+argc);
    len = strnlen_user(str, bprm->p)

    // 调整 bprm->p, 给 str 留出空间, 可以看到, argv[1] 对应的 bprm->p 比
    // argv[0] 的更大, 而后面 copy 到 bprm->page 时使用 bprm->p 做为
    // offset, 所以 argv[0] 将位于 bprm->page 的高地址, 而最终 bprm->page
    // 会被通过映射页表的方式 "平移" 到 stack 顶端, 所以 argv[1] 指向的地
    // 址最终会在 argv[0] 之上
    bprm->p -= len;
    pos = bprm->p;

    // 将对应的 argv 复制到合适的 bprm->page[i] 的合适的位置 (根据 bprm->p)
    offset = pos % PAGE_SIZE;
    i = pos/PAGE_SIZE;
    page = bprm->page[i];
    // 按需要分配新的 page 并用 kmap 映射, 以便后面复制到这个 page
    if (!page):
      page = alloc_page(GFP_HIGHUSER);
      bprm->page[i] = page;
    if (page != kmapped_page):
      if (kmapped_page):
        kunmap(kmapped_page);
      kmapped_page = page;
      kaddr = kmap(kmapped_page);
    copy_from_user(kaddr+offset, str, bytes_to_copy);

load_elf_binary(bprm, regs):
  // 动态链接的 elf 程序会指定 interpreter, 则程序的入口不再是 elf 本身的
  // e_entry, 而是 interpreter 的 e_entry
  loc->elf_ex = *((struct elfhdr *) bprm->buf);

  // 看 elf 中是否包含 PT_INTERP section (.interp)
  for (i = 0; i < loc->elf_ex.e_phnum; i++):
    if (elf_ppnt->p_type == PT_INTERP):
      // 读取 interp 的名字 (例如 /lib/ld-linux.so.2) 保存在
      // elf_interpreter 中
      elf_interpreter = (char *) kmalloc(elf_ppnt->p_filesz, GFP_KERNEL);
      kernel_read(bprm->file, elf_ppnt->p_offset,elf_interpreter, elf_ppnt->p_filesz);
      // 打开 interpreter 文件
      interpreter = open_exec(elf_interpreter);
      kernel_read(interpreter, 0, bprm->buf, BINPRM_BUF_SIZE);

  // 杀死其它线程, 按照 man 2 execve 的说法:
  // All threads other than
  // the calling thread are destroyed during an execve().
  flush_old_exec(bprm);
    de_thread(current);
      zap_other_threads(current);
        for (t = next_thread(p); t != p; t = next_thread(t)):
          sigaddset(&t->pending.signal, SIGKILL);
          signal_wake_up(t, 1);
  // 选择 mmap layout, 参考 [[file:memory.org::*get_unmapped_area][get_unmapped_area]]
  arch_pick_mmap_layout(current->mm);
  // 将保存着 argv 和 envp 的 bprm->page "平移" 到最终的用户地址空间中
  setup_arg_pages(bprm, STACK_TOP, executable_stack);

  // 这个值后面会被设置为 regs->esp, 从而成为新进程的栈顶
  current->mm->start_stack = bprm->p;

  // 把 elf 中所有为 PT_LOAD 的 segment 通过 mmap 映射进来, PT_LOAD 的
  // segment 主要包括: text, init, rodata, data, bss 等 section
  for(i = 0, elf_ppnt = elf_phdata; i < loc->elf_ex.e_phnum; i++, elf_ppnt++):
    if (elf_ppnt->p_type != PT_LOAD): continue;
    // 设置 mmap 的 prot 和 flags
    if (elf_ppnt->p_flags & PF_R) elf_prot |= PROT_READ;
    if (elf_ppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
    if (elf_ppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;

    elf_flags = MAP_PRIVATE|MAP_DENYWRITE|MAP_EXECUTABLE;
    // 需要 mmap 到的地址, 编译时由链接器脚本 (ld script) 指定, 写入在
    // elf 文件中
    vaddr = elf_ppnt->p_vaddr;
    // mmap
    elf_map(bprm->file, load_bias + vaddr, elf_ppnt, elf_prot, elf_flags);

  // 动态编译的 elf 程序指定了 interpreter, 所以其入口不再是 e_entry, 而
  // 是 interpreter 对应的 e_entry
  if (elf_interpreter):
    elf_entry = load_elf_interp(&loc->interp_elf_ex,interpreter,&interp_load_addr);
  else:
    // 静态编译的程序, 直接使用 e_entry 做为入口, e_entry 在 x86_32 下一
    // 般固定为 0x80482c0, 对应于 crt1.o 中的 __start 函数, 由 ld script
    // 指定        
    elf_entry = loc->elf_ex.e_entry;

  create_elf_tables(bprm, &loc->elf_ex,
                    (interpreter_type == INTERPRETER_AOUT),load_addr, interp_load_addr);
  current->mm->end_code = end_code;
  current->mm->start_code = start_code;
  current->mm->start_data = start_data;
  current->mm->end_data = end_data;
  current->mm->start_stack = bprm->p;

  // do_execve 返回到 user mode 的最后一步: 设置 regs->{eip,esp, ...} 以
  // 便从 syscall 返回后能执行 elf 程序
  start_thread(regs, elf_entry, bprm->p);
    regs->xds = __USER_DS;
    regs->xes = __USER_DS;
    regs->xss = __USER_DS;
    regs->xcs = __USER_CS;
    regs->eip = elf_entry;
    regs->esp = bprm->p;

setup_arg_pages(bprm,stack_top):
  // stack_top 的值为 STACK_TOP 为 3G, 下面两行代码将 bprm->p "平移" 到了
  // 3G 以下对应的位置. 实际上在新版本的 kernel 中, 这里的 stack_top 传进
  // 来之前已经随机过了, 实际的值是 STACK_TOP - random_offset (参考
  // randomize_stack_top)
  stack_base = stack_top - MAX_ARG_PAGES * PAGE_SIZE;
  bprm->p += stack_base;

  mm->arg_start = bprm->p;
  arg_size = stack_top - (PAGE_MASK & (unsigned long) mm->arg_start);

  mpnt = kmem_cache_alloc(vm_area_cachep, SLAB_KERNEL);
  mpnt->vm_mm = current->mm;

  // 这个 vma 对应 args+stack, 但初始大小只包括 args 的部分 (argv, envp),
  // 但这并没有问题, 因为 vma 的 VM_GROWSDOWN flag 保证访问 stack 时并不
  // 会出错
  mpnt->vm_end = stack_top;
  mpnt->vm_start = mpnt->vm_end - arg_size;
  mpnt->vm_flags = VM_STACK_FLAGS;
  mpnt->vm_flags |= mm->def_flags;
  mpnt->vm_page_prot = protection_map[mpnt->vm_flags & 0x7];
  insert_vm_struct(mm, mpnt)

  // 将 bprm->page 映射到前面的 vma 中
  for (i = 0 ; i < MAX_ARG_PAGES ; i++):
    struct page *page = bprm->page[i];
      if (page):
        bprm->page[i] = NULL;
        install_arg_page(mpnt, page, stack_base);
    stack_base += PAGE_SIZE;

create_elf_tables:
  int argc = bprm->argc;
  // bprm->p 是栈底
  sp = (elf_addr_t __user *)bprm->p;
  // argc
  __put_user(argc, sp++)

  argv = sp;
  // +1 是因为 argv[] 最后一个元素是 NULL
  envp = argv + argc + 1;

  // 填充 argv[]
  p = current->mm->arg_start;
  while (argc-- > 0):
    size_t len;
    __put_user((elf_addr_t)p, argv++);
    // strnlen_user 与 libc 中的 strnlen 并不一样: strnlen_user 返回的长
    // 度是包括结尾的 NULL 的
    len = strnlen_user((void __user *)p);
    p += len;
  // finally, argv
  __put_user(0, argv)
  // 填充 envp[]
  while (envc-- > 0):
    size_t len;
    __put_user((elf_addr_t)p, envp++);
    len = strnlen_user((void __user *)p, PAGE_SIZE*MAX_ARG_PAGES);
    p += len;
  // finally, envp
  __put_user(0, envp)

load_elf_interp(interpreter):
  kernel_read(interpreter,interp_elf_ex->e_phoff,(char *)elf_phdata,size);
  for (i=0; i<interp_elf_ex->e_phnum; i++, eppnt++):
    if (eppnt->p_type == PT_LOAD) {
      int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
      int elf_prot = 0;
      unsigned long vaddr = 0;
      unsigned long k, map_addr;

      if (eppnt->p_flags & PF_R) elf_prot =  PROT_READ;
      if (eppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
      if (eppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
      vaddr = eppnt->p_vaddr;

      map_addr = elf_map(interpreter, load_addr + vaddr, eppnt, elf_prot, elf_type);

      // 第一个被 mmap 必定是 .text?
      if (!load_addr_set && interp_elf_ex->e_type == ET_DYN):
          load_addr = map_addr - ELF_PAGESTART(vaddr);
          load_addr_set = 1;

      load_addr = map_addr - ELF_PAGESTART(vaddr);

  return ((unsigned long) interp_elf_ex->e_entry) + load_addr;