Linux-fork-clone | 吴杭沉的博客

Linux

发布日期: 2020-01-09

作者: 吴杭沉

文章字数: 1.8k

阅读时长: 6 分

阅读次数:

在本文中，传统 UNIX fork 之后，我给出传统的 UNIX fork 在 Linux 内核中的变体 clone 系统调用的精彩。若要理解 fork 的原始意义，还是要看 Melvin Conway 提出 fork 思想的原始论文 A Multiprocessor System Design
该论文的核心在于 Conway 分离了进程process 和处理器processor 的概念：

一个进程不必特定于一个处理器上被处理。
一个处理器未必处理特定的进程。
系统中进程数量和处理器数量不需要相等。

fork为上述的核心思想提供了实现的手段。后来fork被引入到UNIX 系统，成了创建新进程几十年不变的通用操作。比较有意思的是，UNIX fork是通过著名的fork-exec序列而闻名于世的，而不是因为其提供的并行多处理手段而闻名于世，这可能是因为在线程概念出现以后，并行处理均由线程担当，也再没有人记起fork了吧。如果说一系列进程是完全可并行的，那么它们便没有资源是相互依赖的，这便是现代操作系统进程process抽象的基础。可见，基于进程抽象的现代操作系统本身就是一个可并行系统。
线程概念的出现，就是对 UNIX 进程抽象的资源如何共享重新解构再重构。我们看看在线程出现之前，fork提供的并行多处理是多么高效。最典型的例子就是 TCP 服务编程模型了：

void handle_request(int csd)
{
    // 读取请求
    ret = recv(csd, buf_req, len);
    ret = read(fd, buf_tosend, ret);
    ret = send(csd, buf_tosend, ret);
    close(csd);
}
void server(int sd)
{
    ...
    while (1) {
        csd = accept(sd, 10);
        if (fork() == 0) {
            close(sd);
            handle_request(csd); // 可并行处理
        }
    }
}

这几乎成了服务器编程范式，是理解和设计select/poll/epoll程序的前提，也是理解后来Apache Web Server以及Nginx的基础。

void handle_request(int csd)
{
    // 读取请求
    ret = recv(csd, buf_req, len);
    ret = read(fd, buf_tosend, ret);
    ret = send(csd, buf_tosend, ret);
    close(csd);
}
int main(int argc, char **argv)
{
    char *client_info = argv[1];
    int sd;
    sd = GetOrCreateSocket(client_info);
    handle_request(sd);
}

UNIX fork 有两个层面的含义：

创建新进程，fork-exec序列（而不是fork本身）竞争 Windows CreateProcess 或者 POSIX spawn。
并行多处理，fork作为多进程竞争多线程。

很明显，无论在哪个层面，fork均已落后于对手：

创建新进程，CreateProcess/spawn剔除了不必要的资源复制操作。
并行多处理，多线程共享资源替代了昂贵的 IPC。

作为多进程的优化或者说替代，多线程的本质和fork的原始意义看起来并无太大的分歧。唯一的区别似乎就是资源共享的深度不同。fork的原始意义将要在Linux内核task的设计中得到了延续和升华！Linux 内核的设计者似乎在很早以前就意识到了这一点，在很早的年代，Linux 内核就没有去设计一个表示进程的结构体，而只设计了一个 task_struct（以下简称 task），该结构体包含有让一个指令流能运行所需要的最少的东西！因此它并不包含特定于进程或者线程概念的字段。一个或者一组 task 对象到底是什么，关键看你怎么调配它！就像使用相同的文字，组合不同，或是诅咒，或是祝福。一个 task 对象只是一个原材料，它和其它 task 对象对资源的共享关系决定了它是什么。一组 task 对象按照下面的 ID 类型被标识为不同的实体：

enum pid_type
{
    PIDTYPE_PID,
    PIDTYPE_TGID,
    PIDTYPE_PGID,
    PIDTYPE_SID,
    PIDTYPE_MAX
};

关于上图更多的解释，参见下面的文章朴素的 UNIX 之-进程/线程模型
对应底层关于task 灵活的设计，必须给予应用程序调配它的接口以适应这种灵活。完成这种适配的是Linux的clone系统调用，该系统调用在很早的Linux内核（至少是 2.2 版本）中就已经存在了：

#define _GNU_SOURCE
#include <sched.h>
int clone(int (*fn)(void *), void *child_stack,
          int flags, void *arg, ...
          /* pid_t *ptid, void *newtls, pid_t *ctid */ );
/* For the prototype of the raw system call, see NOTES */

可见，参数众多，这里的flags参数就是让调用者控制如何和子进程共享资源的，拥有这种控制权是clone和fork最大的不同：注意到clone函数的声明依赖于一个宏：

#define _GNU_SOURCE

这意味着clone是非标准的。确实，它只是 Linux 的一个系统调用。之所以存在这个灵活的 clone 调用，完全得益于 Linux 内核底层对 task 灵活的设计。参见下面最简单 demo：

#include <pthread.h>
#include <stdio.h>
void *func(void *unused)
{
    printf("sub thread\n");
    return (void *)123;
}
int main(int argc, char **argv)
{
    pthread_t t1;
    void *p;
    pthread_create(&t1, NULL, *func, NULL);
    pthread_join(t1, &p);
    printf("main thread:%d\n", (int)p);
    return 0;
}

关于线程，重要的有两点，即创建和销毁。让我们来strace一下：
其中，clone系统调用的flags参数的含义大致可以表述如下：

黄色：指示都共享哪些资源，MM，FILES，FS 等
红色：实现 POSIX 线程的语义，比如共享进程 PID，信号传递这些。

clone之后，就创建了一个线程。线程执行func之后便退出了。问题是，线程是如何退出的呢？对于普通的 C 程序，我们知道 main 函数返回到了 C 库，而 C 库在 main 返回后会调用 exit 退出程序，而对于多线程程序，在编译代码的时候，我们显式链接了libpthread，那么类似C库的事情在多线程程序里就libpthread库代劳了。大致的pthread_create应该是这个样子：

void clone_func(Thread *thread)
{
    ret = thread->fn(...);
    exit(ret);
}
int pthread_create(..., fn, ...)
{
    thread = malloc(sizeof(&thread));
    thread->fn = fn;
    ret = clone(clone_func, &thread);
    return ERR_NO(ret);
}

我们通过上面的strace可以看出，线程退出使用exit系统调用，而主进程退出则使用exit_group系统调用，二者的区别更多的是 Posix 进程/线程的语义上的，严格来讲，
exit系统调用仅仅退出当前的task_struct，而exit_group则是退出当前task_struct所在进程的所有task_struct，对于多线程程序，它当然就是退出所有的线程了。
这就是 Linux 内核级线程的实现原理了。但是，clone系统调用远不是仅仅实现多线程这么单一，它还可以优化 UNIX fork 的另一个层面。按照传统UNIXfork在两个层面的效用，Linux clone的对应描述如下：