[系统运维] Linux系统调用 - 进程管理初探（中）

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 系统运维 -> Linux系统调用 - 进程管理初探（中） -> 正文阅读

[系统运维]Linux系统调用 - 进程管理初探（中）

??本文对Linux系统调用的机制进行了大致分析，并以此为基础对Linux进程管理（多进程调用、进程同步等）进行初步探索。在研究进程fork()函数的过程中，笔者产生了很多问题，也通过查阅资料、动手实验等方式对这些问题有了一定的研究和理解。本文将按照笔者对问题研究的历程入手，对Linux进程管理的部分基本过程和背后机理进行阐述。

在本文中，你将看到：

系统调用（system call）的流程
POSIX基本进程管理函数——fork() / vfork() / clone() / wait() / waitpid() …
fork() 和 vfork()的区别、发展
vfork()等待机制（Completion 进程同步机制）
fork clone vfork的内核实现机理
wait()函数等待机制（详解）

进程状态码

本文是系列第二篇，关于系统调用请见：Linux系统调用 - 进程管理初探（上）

文章目录

- Linux 进程管理

Linux 进程管理

进程管理函数

fork()

#include <unistd.h>
/* Clone the calling process, creating an exact copy.
   Return -1 for errors, 0 to the new process,
   and the process ID of the new process to the old process.  */
extern __pid_t fork (void) __THROWNL;

头文件注释中已经写得很清楚了，fork()函数会将调用它的进程复制出一个完全一样的新进程。

如果函数成功执行，它将在两个进程中分别返回，返回值如下：

父进程：返回fork出的子进程的pid
子进程：返回0

如果函数执行失败，它会返回 -1.

这样的返回值可以帮助程序编写者分清哪个是父进程，哪个是新生成的子进程，从而对两个进程执行不同的动作。

另外，在资源共享方面，它也有自己的特点：

复制进程地址空间。在早期的Linux版本中，fork函数将一个进程的所有内存资源（包括栈、堆、代码段、数据段等）完整复制一份，这对系统性能有极大的影响。后来，fork的地址空间管理采用了写时复制 (copy-on-write)技术，子进程仅复制父进程的页表，当读取时，它们从同一个物理页中读取；如果需要写入，则内存管理器会将这个内存页复制一份。在两个进程看来，它们的内存空间都是私有的，但是在操作系统的角度，这大大降低了fork的时间和空间开销。
共享打开的文件。fork时，父进程的文件描述符表被复制给了子进程，他们将共享打开的文件描述符。当然，所有对共享资源的使用都会受到锁的限制，以防止产生并发错误。

在并发方面，父进程和子进程非阻塞同时运行，运行的次序先后由CPU调度决定。

vfork()

#include <unistd.h>
/* Clone the calling process, but without copying the whole address space.
   The calling process is suspended until the new process exits or is
   replaced by a call to `execve'.  Return -1 for errors, 0 to the new process,
   and the process ID of the new process to the old process.  */
extern __pid_t vfork (void) __THROW;

同样，我们可以在头文件中读出很多信息。从功能上，vfork很像fork，但是在具体实现细节上，它们也存在着许多差异。

vfork的返回值与fork相同，不再赘述。

在资源共享方面：

vfork子进程完全共享父进程的地址空间。它不需要复制页表，子进程对内存资源（包括栈（局部变量）、数据段（全局变量））的修改，在父进程中同样生效。
同样，子进程与父进程共享打开的文件描述符资源。

在并发方面：

由于父进程与子进程共享所有内存空间，为了避免竞争，父进程被阻塞，等待子进程运行完成。只有子进程退出（必须是exit(),否则会引发段错误）

clone()

#ifdef __USE_GNU
#include <sched.h>
/* Clone current process.  */
extern int clone (int (*__fn) (void *__arg), void *__child_stack,
		  		  int __flags, void *__arg, ...) __THROW;

clone()函数作为glibc封装函数（wrapper function）的原型被定义，为创建子进程提供更精细化的选项。如果是C语言程序，需要定义C特性宏以开启此函数声明：

#define _GNU_SOURCE
#include <sched.h>

参数说明：

fn : 函数指针，类型见上，指定clone后子进程要执行的函数，函数返回后，子进程会退出（使用exit系统调用）
__child_stack：子进程的栈，供子进程独立使用。在使用clone函数前，需要使用mmap函数申请一块内存空间传入函数，如果该参数为空指针，函数会返回错误。
__arg：传递给子进程函数的指针。

__flags：clone 相关的控制选项，这提供了精细化的子进程创建功能：

/*
 * 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_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_NEWNS	0x00020000	/* New mount namespace group */
#define CLONE_SYSVSEM	0x00040000	/* share system V SEM_UNDO semantics */
#define CLONE_SETTLS	0x00080000	/* create a new TLS for the child */
#define CLONE_PARENT_SETTID	0x00100000	/* set the TID in the parent */
#define CLONE_CHILD_CLEARTID	0x00200000	/* clear the TID in the child */
#define CLONE_DETACHED		0x00400000	/* Unused, ignored */
#define CLONE_UNTRACED		0x00800000	/* set if the tracing process can't force CLONE_PTRACE on this clone */
#define CLONE_CHILD_SETTID	0x01000000	/* set the TID in the child */
#define CLONE_NEWCGROUP		0x02000000	/* New cgroup namespace */
#define CLONE_NEWUTS		0x04000000	/* New utsname namespace */
#define CLONE_NEWIPC		0x08000000	/* New ipc namespace */
#define CLONE_NEWUSER		0x10000000	/* New user namespace */
#define CLONE_NEWPID		0x20000000	/* New pid namespace */
#define CLONE_NEWNET		0x40000000	/* New network namespace */
#define CLONE_IO		0x80000000	/* Clone io context */

具体可以参考注释，下面仅介绍几个常用的选项：

CLONE_VM: 两进程共享虚拟内存空间 (Virtual Memory)；如果选中，则不启用写时复制，两进程完全共享内存空间；反之，复制页表，两进程私有内存空间。
CLONE_FILES: 两进程共享相同的文件描述符表。
CLONE_SIGHAND: 两进程共享信号处理例程表，即，它们对到来的信号使用同样处理程序。另外，如果一个程序调用sigaction修改对某一个信号的处理例程，那么所有共享这个表的进程都会受到影响；反之使用复制，则不然
CLONE_VFORK: 在子进程结束或者调用exec函数加载程序后唤醒父进程。此处的唤醒不同于发出信号SIGCHLD，我们在后面将会讨论到；
CLONE_PARENT: 生成的进程的父进程与原进程相同。两进程成为兄弟进程，而不是父子进程
CLONE_THREAD: 为了支持POSIX线程标准而增加，两线程属于一个线程组(thread group)，并且父进程为同一个（类似CLONE_PARENT），同属于一个线程组的所有线程，getpid()返回值相同

wait()

#include <wait.h>
/* Wait for a child to die.  When one does, put its status in *STAT_LOC
   and return its process ID.  For errors, return (pid_t) -1. */
extern __pid_t wait (int *__stat_loc);

wait函数用于等到一个子进程的状态变化（一般是运行结束）。这个状态变化可以是：

Terminated：进程运行结束，关闭
Stopped：进程被一个信号停止执行（不是结束），比如信号SIGSTOP/SIGTSTP/SIGTTIN等
Resumed：进程被信号终止，如SIGKILL等

任何一个子进程的变化都可以导致父进程被唤醒，具体见waitpid。

如果一个子进程已经发生状态变化，则函数会立刻返回；否则将会等到子进程的状态变化，或是自身收到终止信号（SIGKILL等）

wait包含一个参数__stat_loc，当被唤醒时，子进程的返回状态信息会传回这个变量。

waitpid()

#include <wait.h>
/* Wait for a child matching PID to die.
   If PID is greater than 0, match any process whose process ID is PID.
   If PID is (pid_t) -1, match any process.
   If PID is (pid_t) 0, match any process with the
   same process group as the current process.
   If PID is less than -1, match any process whose
   process group is the absolute value of PID.
   If the WNOHANG bit is set in OPTIONS, and that child
   is not already dead, return (pid_t) 0.  If successful,
   return PID and store the dead child's status in STAT_LOC.
   Return (pid_t) -1 for errors.  If the WUNTRACED bit is
   set in OPTIONS, return status for stopped children; otherwise don't.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
extern __pid_t waitpid (__pid_t __pid, int *__stat_loc, int __options);

waitpid函数的功能与wait相同，只是提供了更加精细的选项。事实上，wait调用了waitpid的一个特殊情况：waitpid(-1, __stat_loc, 0)

参数解释如下：

__PID: 指定等待的PID
- PID>0: 匹配PID指定的进程
- PID=-1: 匹配所有进程（子进程）
- PID=0: 匹配所有属于当前进程组的进程
- PID<-1: 匹配所有进程组为-PID的进程
__stat_loc: 同wait
__options:
- WNOHANG: 进程不挂起，直接采集信息并返回，如果没有子进程退出，则返回0。这个选项可以用来统计子进程信息，同时父进程不至于阻塞
- WUNTRACED: 如果一个子进程停止__TASK_STOPPED，函数也返回

根据上面的条件就可看出，wait函数只是waitpid函数的一个特例。

fork & vfork

??fork和vfork这两个函数在功能上极为相似，都是生成一个调用进程的副本。但它们也有非常多的区别。本节我们将联系运行机理等，从两函数的功能对比展开研究。

空间管理

??上一节已经说过，早期fork会直接复制整个调用进程的内存空间，即使很大概率被fork出的新函数会直接执行exec系统调用，执行一个新的程序，将fork辛苦复制的所有内存空间全部刷新。事实上，Linux所有的进程都是由init(系统启动的第一个用户态进程，PID始终为1)进程通过fork类系统调用创建的，命令行中程序的启动也是通过它完成，exec函数族的使用频率非常高。如果对每一个进程都通过完全复制内存空间的方式创建，那将导致非常大的无用开销。
??因此，内存管理单元 (Memory Management Unit, MMU) 引入的copy-on-write写时复制技术被使用到fork上。fork仅复制进程的页表，并对页表属性做标记。在读取页数据时，两个页表映射到相同的物理页中，节约了空间。当其中一个进程需要进行写入，MMU才会将该页复制。在这些进程的视角下，它们的虚拟内存空间都是私有的，不会被别的进程修改。所以，fork函数只能在支持MMU的架构上使用。
??即使如此，fork函数依然具有一定的开销，特别是在子进程立即执行exec系统调用的情况下。这时候vfork可以以相对较小的开销完成同样的功能。它将调用进程（Caller process）的内存空间直接共享给子进程，甚至不需要复制页表。这不仅节约了大量的时间开销，也减少了部分空间开销。另外，由于不需要写时复制，它允许在没有MMU的平台上运行。为了避免资源竞争，vfork会将父进程阻塞，直到子进程运行完成（或被信号终止），才会继续运行。

vfork等待机制

??在此期间，父进程状态被设置为TASK_KILLABLE，这个状态是TASK_WAKEKILL和TASK_UNINTERRUPTIBLE的合并。进程不能被除终止信号外的任何信号打扰，将一直等到子进程运行完成。但是如果收到TASK_KILL，它仍会被唤醒并结束，这是它有别于单独TASK_UNINTERRUPTIBLE的地方。
??进程初始化一个活动后，将会等待这个活动的结束。Linux通过Completion接口来完成这个操作，它是一种相对信号量更轻量的进程间同步机制。vfork内部调用wait_for_task_killable内核函数，将自己的状态更新，并等待子进程的结束。Completion等待的主例程如下：

do_wait_for_common(struct completion *x,
		   long (*action)(long), long timeout, int state)
{
	if (!x->done) {
		DECLARE_WAITQUEUE(wait, current);
		__add_wait_queue_entry_tail_exclusive(&x->wait, &wait);
		do {
			if (signal_pending_state(state, current)) {		// 检查任务状态
				timeout = -ERESTARTSYS;
				break;
			}
			__set_current_state(state);
			spin_unlock_irq(&x->wait.lock);
			timeout = action(timeout);						// 执行计时器等待
			spin_lock_irq(&x->wait.lock);
		} while (!x->done && timeout);
		__remove_wait_queue(&x->wait, &wait);
		if (!x->done)
			return timeout;
	}
	if (x->done != UINT_MAX)
		x->done--;
	return timeout ?: 1;
}

它通过定时检查目标活动状态实现等待，当目标活动被挂起，则退出等待循环并返回。

发展

实际上，用到vfork的场景并不是很多，在fork采用写时复制后，vfork一般只在上面提到的那个场景中使用。POSIX 2008标准移除了vfork函数，vfork+exec函数组合的功能通过posix_spawn替代。

wait函数机理

wait4 进入等待

wait函数调用wait4系统调用，对应内核函数为do_wait。当检测到一个函数含有正在等待的目标活动，则将进程加入等待队列waitqueue。

static long do_wait(struct wait_opts *wo)
{
	struct task_struct *tsk;
	int retval;
	trace_sched_process_wait(wo->wo_pid);
	init_waitqueue_func_entry(&wo->child_wait, child_wait_callback);
	wo->child_wait.private = current;
	add_wait_queue(&current->signal->wait_chldexit, &wo->child_wait);	// core
repeat:
    ......		// wait for matching task
}

wake_up 唤醒

当子进程运行结束，它会调用do_notify_parent函数通知父进程，

/*
 * Let a parent know about the death of a child.
 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
 *
 * Returns true if our parent ignored us and so we've switched to
 * self-reaping.
 */
bool do_notify_parent(struct task_struct *tsk, int sig);

这个函数包含两个功能：

发出一个SIGCHLD信号，将自身退出的相关信息发送给父进程
执行__wake_up_parent函数，它将在等待队列中找出正在等待的父进程，并将其加入调度序列中，即唤醒父进程。

进程状态码

上面的几节中，我们已经看到过一些进程状态码。进程状态码被存放在PCB中，标志了当前进程的运行状态。下面是一个附录，列出了主要的进程状态，并对一些状态进行了解释：

/*
 * Task state bitmask. NOTE! These bits are also
 * encoded in fs/proc/array.c: get_task_state().
 *
 * We have two separate sets of flags: task->state
 * is about runnability, while task->exit_state are
 * about the task exiting. Confusing, but this way
 * modifying one set can't modify the other one by
 * mistake.
 */
/* Used in tsk->state: */
#define TASK_RUNNING			0x0000
#define TASK_INTERRUPTIBLE		0x0001
#define TASK_UNINTERRUPTIBLE		0x0002
#define __TASK_STOPPED			0x0004
#define __TASK_TRACED			0x0008
/* Used in tsk->exit_state: */
#define EXIT_DEAD			0x0010
#define EXIT_ZOMBIE			0x0020
#define EXIT_TRACE			(EXIT_ZOMBIE | EXIT_DEAD)
/* Used in tsk->state again: */
#define TASK_PARKED			0x0040
#define TASK_DEAD			0x0080
#define TASK_WAKEKILL			0x0100
#define TASK_WAKING			0x0200
#define TASK_NOLOAD			0x0400
#define TASK_NEW			0x0800
#define TASK_STATE_MAX			0x1000
/* Convenience macros for the sake of set_current_state: */
#define TASK_KILLABLE			(TASK_WAKEKILL | TASK_UNINTERRUPTIBLE)
#define TASK_STOPPED			(TASK_WAKEKILL | __TASK_STOPPED)
#define TASK_TRACED			(TASK_WAKEKILL | __TASK_TRACED)

TASK_RUNNING: 该状态是教科书中正在占用CPU的RUNNING运行状态，和进入等待队列的READY就绪状态。
TASK_INTERRUPTIBLE: 进程进入睡眠状态，当进程需要等待一些条件满足，或等待低速设备的任务完成时，会被移出调度序列而放入睡眠序列，这些进程将等待条件满足或者信号到来时被唤醒。
TASK_UNINTERRUPTIBLE: 进程同样进入睡眠状态，但是不会被信号唤醒。当一个进程需要等待硬件的一个“原子操作”时，如果被其他的信号量唤醒，则会导致不可控的结果。进入这个状态的进程不会被任何信号中断，甚至SIGKILL也不行
TASK_KILLABLE: 是两个状态的结合（见上），进程不可被除了SIGKILL外的信号打断。
__TASK_STOPPED: 进程被SIGSTOP、SIGTSTP等信号中断后进入这个状态，常见于ptrace进程跟踪，如调试器等。

下一篇中，我们将一起探索Linux信号相关的机制。

入睡眠序列，这些进程将等待条件满足或者信号到来时被唤醒。

TASK_UNINTERRUPTIBLE: 进程同样进入睡眠状态，但是不会被信号唤醒。当一个进程需要等待硬件的一个“原子操作”时，如果被其他的信号量唤醒，则会导致不可控的结果。进入这个状态的进程不会被任何信号中断，甚至SIGKILL也不行
TASK_KILLABLE: 是两个状态的结合（见上），进程不可被除了SIGKILL外的信号打断。
__TASK_STOPPED: 进程被SIGSTOP、SIGTSTP等信号中断后进入这个状态，常见于ptrace进程跟踪，如调试器等。

下一篇中，我们将一起探索Linux信号相关的机制。