浅谈Linux内核创建新进程的全过程

进程描述

  • 进程描述符(task_struct)

用来描述进程的数据结构,可以理解为进程的属性。比如进程的状态、进程的标识(PID)等,都被封装在了进程描述符这个数据结构中,该数据结构被定义为task_struct

  • 进程控制块(PCB)

是操作系统核心中一种数据结构,主要表示进程状态。

  • 进程状态

  • fork()

fork()在父、子进程各返回一次。在父进程中返回子进程的 pid,在子进程中返回0。

fork一个子进程的代码

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

int main(int argc, char * argv[])
{
int pid;
/* fork another process */

pid = fork();
if (pid < 0)
{
  /* error occurred */
  fprintf(stderr,"Fork Failed!");
  exit(-1);
}
else if (pid == 0)
{
  /* child process */
  printf("This is Child Process!\n");
}
else
{
  /* parent process */
  printf("This is Parent Process!\n");
  /* parent will wait for the child to complete*/
  wait(NULL);
  printf("Child Complete!\n");
}
}

进程创建

1、大致流程

fork 通过0x80中断(系统调用)来陷入内核,由系统提供的相应系统调用来完成进程的创建。

fork.c
//fork
#ifdef __ARCH_WANT_SYS_FORK
SYSCALL_DEFINE0(fork)
{
#ifdef CONFIG_MMU
  return do_fork(SIGCHLD, 0, 0, NULL, NULL);
#else
  /* can not support in nommu mode */
  return -EINVAL;
#endif
}
#endif

//vfork
#ifdef __ARCH_WANT_SYS_VFORK
SYSCALL_DEFINE0(vfork)
{
  return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, 0,
      0, NULL, NULL);
}
#endif

//clone
#ifdef __ARCH_WANT_SYS_CLONE
#ifdef CONFIG_CLONE_BACKWARDS
SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
     int __user *, parent_tidptr,
     int, tls_val,
     int __user *, child_tidptr)
#elif defined(CONFIG_CLONE_BACKWARDS2)
SYSCALL_DEFINE5(clone, unsigned long, newsp, unsigned long, clone_flags,
     int __user *, parent_tidptr,
     int __user *, child_tidptr,
     int, tls_val)
#elif defined(CONFIG_CLONE_BACKWARDS3)
SYSCALL_DEFINE6(clone, unsigned long, clone_flags, unsigned long, newsp,
    int, stack_size,
    int __user *, parent_tidptr,
    int __user *, child_tidptr,
    int, tls_val)
#else
SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
     int __user *, parent_tidptr,
     int __user *, child_tidptr,
     int, tls_val)
#endif
{
  return do_fork(clone_flags, newsp, 0, parent_tidptr, child_tidptr);
}
#endif

通过看上边的代码,我们可以清楚的看到,不论是使用 fork 还是 vfork 来创建进程,最终都是通过 do_fork() 方法来实现的。接下来我们可以追踪到 do_fork()的代码:

long do_fork(unsigned long clone_flags,
     unsigned long stack_start,
     unsigned long stack_size,
     int __user *parent_tidptr,
     int __user *child_tidptr)
{
    //创建进程描述符指针
    struct task_struct *p;

    //……

    //复制进程描述符,copy_process()的返回值是一个 task_struct 指针。
    p = copy_process(clone_flags, stack_start, stack_size,
       child_tidptr, NULL, trace);

    if (!IS_ERR(p)) {
      struct completion vfork;
      struct pid *pid;

      trace_sched_process_fork(current, p);

      //得到新创建的进程描述符中的pid
      pid = get_task_pid(p, PIDTYPE_PID);
      nr = pid_vnr(pid);

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

      //如果调用的 vfork()方法,初始化 vfork 完成处理信息。
      if (clone_flags & CLONE_VFORK) {
        p->vfork_done = &vfork;
        init_completion(&vfork);
        get_task_struct(p);
      }

      //将子进程加入到调度器中,为其分配 CPU,准备执行
      wake_up_new_task(p);

      //fork 完成,子进程即将开始运行
      if (unlikely(trace))
        ptrace_event_pid(trace, pid);

      //如果是 vfork,将父进程加入至等待队列,等待子进程完成
      if (clone_flags & CLONE_VFORK) {
        if (!wait_for_vfork_done(p, &vfork))
          ptrace_event_pid(PTRACE_EVENT_VFORK_DONE, pid);
      }

      put_pid(pid);
    } else {
      nr = PTR_ERR(p);
    }
    return nr;
}

2、do_fork 流程

  • 调用 copy_process 为子进程复制出一份进程信息
  • 如果是 vfork 初始化完成处理信息
  • 调用 wake_up_new_task 将子进程加入调度器,为之分配 CPU
  • 如果是 vfork,父进程等待子进程完成 exec 替换自己的地址空间

3、copy_process 流程

追踪copy_process 代码(部分)

static struct task_struct *copy_process(unsigned long clone_flags,
          unsigned long stack_start,
          unsigned long stack_size,
          int __user *child_tidptr,
          struct pid *pid,
          int trace)
{
  int retval;

  //创建进程描述符指针
  struct task_struct *p;

  //……

  //复制当前的 task_struct
  p = dup_task_struct(current);

  //……

  //初始化互斥变量
  rt_mutex_init_task(p);

  //检查进程数是否超过限制,由操作系统定义
  if (atomic_read(&p->real_cred->user->processes) >=
      task_rlimit(p, RLIMIT_NPROC)) {
    if (p->real_cred->user != INIT_USER &&
      !capable(CAP_SYS_RESOURCE) && !capable(CAP_SYS_ADMIN))
      goto bad_fork_free;
  }

  //……

  //检查进程数是否超过 max_threads 由内存大小决定
  if (nr_threads >= max_threads)
    goto bad_fork_cleanup_count;

  //……

  //初始化自旋锁
  spin_lock_init(&p->alloc_lock);
  //初始化挂起信号
  init_sigpending(&p->pending);
  //初始化 CPU 定时器
  posix_cpu_timers_init(p);

  //……

  //初始化进程数据结构,并把进程状态设置为 TASK_RUNNING
  retval = sched_fork(clone_flags, p);

  //复制所有进程信息,包括文件系统、信号处理函数、信号、内存管理等
  if (retval)
    goto bad_fork_cleanup_policy;

  retval = perf_event_init_task(p);
  if (retval)
    goto bad_fork_cleanup_policy;
  retval = audit_alloc(p);
  if (retval)
    goto bad_fork_cleanup_perf;
  /* copy all the process information */
  shm_init_task(p);
  retval = copy_semundo(clone_flags, p);
  if (retval)
    goto bad_fork_cleanup_audit;
  retval = copy_files(clone_flags, p);
  if (retval)
    goto bad_fork_cleanup_semundo;
  retval = copy_fs(clone_flags, p);
  if (retval)
    goto bad_fork_cleanup_files;
  retval = copy_sighand(clone_flags, p);
  if (retval)
    goto bad_fork_cleanup_fs;
  retval = copy_signal(clone_flags, p);
  if (retval)
    goto bad_fork_cleanup_sighand;
  retval = copy_mm(clone_flags, p);
  if (retval)
    goto bad_fork_cleanup_signal;
  retval = copy_namespaces(clone_flags, p);
  if (retval)
    goto bad_fork_cleanup_mm;
  retval = copy_io(clone_flags, p);

  //初始化子进程内核栈
  retval = copy_thread(clone_flags, stack_start, stack_size, p);

  //为新进程分配新的 pid
  if (pid != &init_struct_pid) {
    retval = -ENOMEM;
    pid = alloc_pid(p->nsproxy->pid_ns_for_children);
    if (!pid)
      goto bad_fork_cleanup_io;
  }

  //设置子进程 pid
  p->pid = pid_nr(pid);

  //……

  //返回结构体 p
  return p;
  • 调用 dup_task_struct 复制当前的 task_struct
  • 检查进程数是否超过限制
  • 初始化自旋锁、挂起信号、CPU 定时器等
  • 调用 sched_fork 初始化进程数据结构,并把进程状态设置为 TASK_RUNNING
  • 复制所有进程信息,包括文件系统、信号处理函数、信号、内存管理等
  • 调用 copy_thread 初始化子进程内核栈
  • 为新进程分配并设置新的 pid

4、dup_task_struct 流程

static struct task_struct *dup_task_struct(struct task_struct *orig)
{
  struct task_struct *tsk;
  struct thread_info *ti;
  int node = tsk_fork_get_node(orig);
  int err;

  //分配一个 task_struct 节点
  tsk = alloc_task_struct_node(node);
  if (!tsk)
    return NULL;

  //分配一个 thread_info 节点,包含进程的内核栈,ti 为栈底
  ti = alloc_thread_info_node(tsk, node);
  if (!ti)
    goto free_tsk;

  //将栈底的值赋给新节点的栈
  tsk->stack = ti;

  //……

  return tsk;

}

调用alloc_task_struct_node分配一个 task_struct 节点
调用alloc_thread_info_node分配一个 thread_info 节点,其实是分配了一个thread_union联合体,将栈底返回给 ti

union thread_union {
  struct thread_info thread_info;
 unsigned long stack[THREAD_SIZE/sizeof(long)];
};

最后将栈底的值 ti 赋值给新节点的栈
最终执行完dup_task_struct之后,子进程除了tsk->stack指针不同之外,全部都一样!
5、sched_fork 流程

core.c

int sched_fork(unsigned long clone_flags, struct task_struct *p)
{
  unsigned long flags;
  int cpu = get_cpu();

  __sched_fork(clone_flags, p);

  //将子进程状态设置为 TASK_RUNNING
  p->state = TASK_RUNNING;

  //……

  //为子进程分配 CPU
  set_task_cpu(p, cpu);

  put_cpu();
  return 0;
}

我们可以看到sched_fork大致完成了两项重要工作,一是将子进程状态设置为 TASK_RUNNING,二是为其分配 CPU
6、copy_thread 流程

int copy_thread(unsigned long clone_flags, unsigned long sp,
  unsigned long arg, struct task_struct *p)
{
  //获取寄存器信息
  struct pt_regs *childregs = task_pt_regs(p);
  struct task_struct *tsk;
  int err;

  p->thread.sp = (unsigned long) childregs;
  p->thread.sp0 = (unsigned long) (childregs+1);
  memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));

  if (unlikely(p->flags & PF_KTHREAD)) {
    //内核线程
    memset(childregs, 0, sizeof(struct pt_regs));
    p->thread.ip = (unsigned long) ret_from_kernel_thread;
    task_user_gs(p) = __KERNEL_STACK_CANARY;
    childregs->ds = __USER_DS;
    childregs->es = __USER_DS;
    childregs->fs = __KERNEL_PERCPU;
    childregs->bx = sp; /* function */
    childregs->bp = arg;
    childregs->orig_ax = -1;
    childregs->cs = __KERNEL_CS | get_kernel_rpl();
    childregs->flags = X86_EFLAGS_IF | X86_EFLAGS_FIXED;
    p->thread.io_bitmap_ptr = NULL;
    return 0;
  }

  //将当前寄存器信息复制给子进程
  *childregs = *current_pt_regs();

  //子进程 eax 置 0,因此fork 在子进程返回0
  childregs->ax = 0;
  if (sp)
    childregs->sp = sp;

  //子进程ip 设置为ret_from_fork,因此子进程从ret_from_fork开始执行
  p->thread.ip = (unsigned long) ret_from_fork;

  //……

  return err;
}

copy_thread 这段代码为我们解释了两个相当重要的问题!
一是,为什么 fork 在子进程中返回0,原因是childregs->ax = 0;这段代码将子进程的 eax 赋值为0
二是,p->thread.ip = (unsigned long) ret_from_fork;将子进程的 ip 设置为 ret_form_fork 的首地址,因此子进程是从 ret_from_fork 开始执行的
总结

新进程的执行源于以下前提:

  • dup_task_struct中为其分配了新的堆栈
  • 调用了sched_fork,将其置为TASK_RUNNING
  • copy_thread中将父进程的寄存器上下文复制给子进程,保证了父子进程的堆栈信息是一致的
  • 将ret_from_fork的地址设置为eip寄存器的值

最终子进程从ret_from_fork开始执行。

以上就是针对Linux内核创建一个新进程的过程的详细分析,希望对大家的学习有所帮助。

(0)

相关推荐

  • Linux内核漏洞浅析

    与Windows相比,Linux被认为具有更好的安全性和其他扩展性能.这些特性使得Linux在操作系统领域异军突起,得到越来越多的重视.随着Linux应用量的增加,其安全性也逐渐受到了公众甚或黑客的关注.那么,Linux是否真的如其支持厂商们所宣称的那样安全呢?本期我们请到了启明星辰信息技术有限公司积极防御实验室工程师赵伟,对Linux进行专业的漏洞技术分析. Linux内核精短.稳定性高.可扩展性好.硬件需求低.免费.网络功能丰富.适用于多种cpu等特性,使之在操作系统领域异军突起.其独特的魅

  • 一张图看尽Linux内核运行原理

    众所周知的是,几乎整个互联网都运行在 Linux 上,从网络协议,到服务器,到你平常访问的绝大多数网站,都能看到它的身影.Linux 内核就是最复杂最流行的开源项目之一.如果你希望学习内核知识,在网上可以搜到无数的资料,但是 Linux 内核还是一个非常难弄明白的项目. 俗话说:一图胜千言,今天我们就为大家介绍一张完整的 Linux 内核运行原理图,通过这张图,你可以很方便地学习内核知识. 在 Linux 内核中,有许多层次.模块.功能调用和函数:要把其中的每一块儿都弄明白很不容易,不过 Mak

  • Linux内核模块和驱动的编写

    Linux内核是一个整体是结构,因此向内核添加任何东西,或者删除某些功能,都十分困难.为了解决这个问题引入了内核机制.从而可以动态的想内核中添加或者删除模块. 模块不被编译在内核中,因而控制了内核的大小.然而模块一旦被插入内核,他就和内核其他部分一样.这样一来就会曾家一部分系统开销.同时,如果模块出现问题,也许会带来系统的崩溃. 模块的实现机制: 启动时,由函数 void inti_modules() 来初始化模块,因为启动事很多时候没有模块.这个函数往往把内核自身当作一个虚模块. 如由系统需要

  • Linux内核启动参数详解

    1.环境: Ubuntu 16.04 Linux linuxidc 4.4.0-89-generic #112-Ubuntu SMP Mon Jul 31 19:38:41 UTC 2017 x86_64 x86_64 x86_64 GNU/Linux 2.查看当前linux内核的启动参数: cat /proc/cmdline 笔者的输出内容如下: BOOT_IMAGE=/boot/vmlinuz-4.4.0-89-generic root=UUID=bef418fa-4202-4513-b39

  • 解析Linux内核的基本的模块管理与时间管理操作

    内核模块管理 Linux设备驱动会以内核模块的形式出现,因此学会编写Linux内核模块编程是学习linux设备驱动的先决条件. Linux内核的整体结构非常庞大,其包含的组件非常多.我们把需要的功能都编译到linux内核,以模块方式扩展内核功能. 先来看下最简单的内核模块 #include <linux/init.h> #include <linux/module.h> static int __init hello_init(void) { printk(KERN_ALERT &

  • SYN Cookie在Linux内核中的实现

    概述 在目前以IPv4为支撑的网络协议上搭建的网络环境中,SYN Flood是一种非常危险而常见的DoS攻击方式.到目前为止,能够有效防范SYN Flood攻击的手段并不多,而SYN Cookie就是其中最著名的一种.SYN Cookie原理由D. J. Bernstain和 Eric Schenk发明.在很多操作系统上都有各种各样的实现.其中包括Linux.本文就分别介绍一下SYN Flood攻击和SYN Cookie的原理,更重要的是介绍Linux内核中实现SYN Cookie的方式.最后,

  • Linux内核中红黑树算法的实现详解

    一.简介 平衡二叉树(BalancedBinary Tree或Height-Balanced Tree) 又称AVL树.它或者是一棵空树,或者是具有下列性质的二叉树:它的左子树和右子树都是平衡二叉树,且左子树和右子树的深度之差的绝对值不超过1.若将二叉树上结点的平衡因子BF(BalanceFactor)定义为该结点的左子树的深度减去它的右子树的深度,则平衡二叉树上所有结点的平衡因子只可能是-1.0和1.(此段定义来自严蔚敏的<数据结构(C语言版)>) 红黑树 R-B Tree,全称是Red-B

  • Linux内核链表实现过程

    关于双链表实现,一般教科书上定义一个双向链表节点的方法如下: 复制代码 代码如下: struct list_node{stuct list_node *pre;stuct list_node *next;ElemType data; } 即一个链表节点包含:一个指向前向节点的指针.一个指向后续节点的指针,以及数据域共三部分.但查看linux内核代码中的list实现时,会发现其与教科书上的方法有很大的差别.来看看linux是如何实现双链表.双链表节点定义 复制代码 代码如下: struct lis

  • 浅谈Linux内核创建新进程的全过程

    进程描述 进程描述符(task_struct) 用来描述进程的数据结构,可以理解为进程的属性.比如进程的状态.进程的标识(PID)等,都被封装在了进程描述符这个数据结构中,该数据结构被定义为task_struct 进程控制块(PCB) 是操作系统核心中一种数据结构,主要表示进程状态. 进程状态 fork() fork()在父.子进程各返回一次.在父进程中返回子进程的 pid,在子进程中返回0. fork一个子进程的代码 #include <stdio.h> #include <stdli

  • 浅谈linux线程切换问题

    处理器总处于以下状态中的一种: 1.内核态,运行于进程上下文,内核代表进程运行于内核空间: 2.内核态,运行于中断上下文,内核代表硬件运行于内核空间: 3.用户态,运行于用户空间: 一个进程的上下文可以分为三个部分:用户级上下文.寄存器上下文以及系统级上下文. 用户级上下文:  正文.数据.用户堆栈以及共享存储区: 寄存器上下文:  通用寄存器.程序寄存器(IP).处理器状态寄存器(EFLAGS).栈指针(ESP): 系统级上下文:  进程控制块task_struct.内存管理信息(mm_str

  • 浅谈Linux进程间通信方式及优缺点

    1)管道 管道分为有名管道和无名管道 无名管道是一种半双工的通信方式,数据只能单向流动,而且只能在具有亲缘关系的进程间使用.进程的亲缘关系一般指的是父子关系.无明管道一般用于两个不同进程之间的通信.当一个进程创建了一个管道,并调用fork创建自己的一个子进程后,父进程关闭读管道端,子进程关闭写管道端,这样提供了两个进程之间数据流动的一种方式. 有名管道也是一种半双工的通信方式,但是它允许无亲缘关系进程间的通信. 2)信号量 信号量是一个计数器,可以用来控制多个线程对共享资源的访问.,它不是用于交

  • 浅谈Linux信号机制

    一.信号列表 root@ubuntu:# kill -l  1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP  6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM 16) SIGSTKFLT 17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20)

  • 浅谈Linux中ldconfig和ldd的用法

    ldd 查看程序依赖库 ldd 作用:用来查看程式运行所需的共享库,常用来解决程式因缺少某个库文件而不能运行的一些问题. 示例:查看test程序运行所依赖的库: /opt/app/todeav1/test$ldd test libstdc++.so.6 => /usr/lib64/libstdc++.so.6 (0x00000039a7e00000) libm.so.6 => /lib64/libm.so.6 (0x0000003996400000) libgcc_s.so.1 => /

  • 浅谈Linux文件目录介绍及文件颜色区别

    本文主要介绍的是关于Linux文件目录介绍及文件颜色区别的相关内容,具体如下. 文件颜色代表含义 蓝色表示目录: 绿色表示可执行文件: 红色表示压缩文件: 浅蓝色表示链接文件: 白色表示其他文件: 黄色是设备文件,包括block, char, fifo. 常见目录解释 Linux各种发行版的目录结构基本一致,各个目录简单介绍如下: 目录 描述 / 根目录 /bin 做为基础系统所需要的最基础的命令就是放在这里.比如 ls.cp.mkdir等命令:功能和/usr/bin类似,这个目录中的文件都是可

  • 浅谈Linux中的chattr与lsattr命令

    PS:有时候你发现用root权限都不能修改某个文件,大部分原因是曾经用chattr命令锁定该文件了.chattr命令的作用很大,其中一些功能是由Linux内核版本来支持的,不过现在生产绝大部分跑的linux系统都是2.6以上内核了.通过chattr命令修改属性能够提高系统的安全性,但是它并不适合所有的目录.chattr命令不能保护/./dev./tmp./var目录.lsattr命令是显示chattr命令设置的文件属性. 这两个命令是用来查看和改变文件.目录属性的,与chmod这个命令相比,ch

  • 浅谈linux几种定时函数的使用

    在程序开发过程中,我们时不时要用到一些定时器,通常如果时间精度要求不高,可以使用sleep,uslepp函数让进程睡眠一段时间来实现定时, 前者单位为秒(s),后者为微妙(us):但有时候我们又不想让进程睡眠阻塞在哪儿,我们需要进程正常执行,当到达规定的时间时再去执行相应的操作, 在linux下面我们一般使用alarm函数跟setitimer函数来实现定时功能: 下面对这两个函数进行详细分析: (1)alarm函数 alarm也称为闹钟函数,它可以在进程中设置一个定时器,当定时器指定的时间到时,

  • 浅谈linux下的串口通讯开发

    串行口是计算机一种常用的接口,具有连接线少,通讯简单,得到广泛的使用.常用的串口是RS-232-C接口(又称EIA RS-232-C)它是在1970年由美国电子工业协会(EIA)联合贝尔系统.调制解调器厂家及计算机终端生产厂家共同制定的用于串行通讯的标准.串口通讯指的是计算机依次以位(bit)为单位来传送数据,串行通讯使用的范围很广,在嵌入式系统开发过程中串口通讯也经常用到通讯方式之一. Linux对所有设备的访问是通过设备文件来进行的,串口也是这样,为了访问串口,只需打开其设备文件即可操作串口

  • 浅谈linux下的一些常用函数的总结(必看篇)

    1.exit()函数 exit(int n)  其实就是直接退出程序, 因为默认的标准程序入口为int main(int argc, char** argv),返回值是int型的. 一般在shell下面,运行一个程序,然后使用命令echo $?就能得到该程序的返回值,也就是退出值,在main()里面,你可以用return n,也能够直接用exit(n)来做.unix默认的习惯正确退出是返回0,错误返回非0. 重点:单独的进程是返回给操作系统的.如果是多进程,是返回给父进程的. 在父进程里面调用w

随机推荐