什么是系统调用？为什么程序访问硬件必须经过它

这是"操作系统系列教程"的第三篇。上一篇我们讲了内核，知道了它是操作系统的核心，运行在最高特权级，管理所有硬件资源。那么问题来了：应用程序运行在用户态，权限受限，它想读写文件、发送网络数据、申请内存，该怎么办？答案就是------系统调用。

一个你每天都在用、却从未察觉的机制

先看一段最简单的 C 语言代码：

#include <stdio.h>

int main() {
    printf("Hello, World!\n");
    return 0;
}

每个学编程的人，写的第一行代码几乎都是它。屏幕上打印出 Hello, World!，看起来理所当然。但你想过没有：

• printf 这个函数，是谁提供的？
• 它要把字符显示到屏幕上，需要操作显卡或终端设备，可应用程序凭什么能操作硬件？
• 如果每个程序都能直接操作硬件，那系统岂不是乱套了？

答案藏在 printf 的背后。printf 本身只是 C 标准库（如 glibc）提供的一个函数，它最终会调用内核提供的 write() 接口，把数据交给内核，由内核负责真正写到屏幕上。这个"应用程序请求内核帮忙做事"的过程，就是系统调用。

你每天都在用它，只是从未察觉。打开一个文件、发送一条微信消息、申请一块内存、创建一个进程，背后都是系统调用在默默工作。

这篇文章，我们就来把"系统调用"这件事讲清楚。

说明：本文涉及操作系统、C 语言、汇编语言和体系结构等相关知识，初学者如果遇到暂时看不懂的术语（如"寄存器""汇编指令"等），可以先跳过对应的细节，只需理解"应用程序通过系统调用请求内核服务"这一核心思想即可。后续文章会逐步展开这些知识点。

一、系统调用到底是什么？

1.1 从生活场景理解

我们先不谈技术，用一个生活场景来类比。

假设你去银行办业务。你不能直接冲进金库拿钱，也不能自己操作银行的内部系统。你必须：

1. 走到柜台窗口；
2. 告诉柜员你要办什么（取钱、存钱、转账）；
3. 柜员在内部系统中操作；
4. 柜员把结果（现金、回执）交给你。

在这个场景中：

银行场景	计算机系统
你（客户）	应用程序
柜台窗口	系统调用接口
柜员	内核
金库、内部系统	硬件资源
办业务的规定流程	系统调用规范

你不能直接进金库，就像应用程序不能直接操作硬件。你必须通过柜台，就像程序必须通过系统调用。

1.2 系统调用的定义

给出一个正式的定义：

系统调用（System Call）是操作系统内核提供给应用程序的编程接口，是应用程序请求内核服务、访问硬件资源的唯一合法途径。

这个定义里有三个关键点：

1. 内核提供：系统调用由内核实现，不是由应用程序或普通库提供。
2. 编程接口：它是一组函数，应用程序通过调用这些函数来请求服务。
3. 唯一合法途径：应用程序不能绕过系统调用直接访问硬件或内核数据。

1.3 系统调用在系统中的位置

#mermaid-svg-nKHZObqsrOeIE4Sb{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-nKHZObqsrOeIE4Sb .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-nKHZObqsrOeIE4Sb .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-nKHZObqsrOeIE4Sb .error-icon{fill:#552222;}#mermaid-svg-nKHZObqsrOeIE4Sb .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-nKHZObqsrOeIE4Sb .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-nKHZObqsrOeIE4Sb .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-nKHZObqsrOeIE4Sb .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-nKHZObqsrOeIE4Sb .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-nKHZObqsrOeIE4Sb .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-nKHZObqsrOeIE4Sb .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-nKHZObqsrOeIE4Sb .marker{fill:#333333;stroke:#333333;}#mermaid-svg-nKHZObqsrOeIE4Sb .marker.cross{stroke:#333333;}#mermaid-svg-nKHZObqsrOeIE4Sb svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-nKHZObqsrOeIE4Sb p{margin:0;}#mermaid-svg-nKHZObqsrOeIE4Sb .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-nKHZObqsrOeIE4Sb .cluster-label text{fill:#333;}#mermaid-svg-nKHZObqsrOeIE4Sb .cluster-label span{color:#333;}#mermaid-svg-nKHZObqsrOeIE4Sb .cluster-label span p{background-color:transparent;}#mermaid-svg-nKHZObqsrOeIE4Sb .label text,#mermaid-svg-nKHZObqsrOeIE4Sb span{fill:#333;color:#333;}#mermaid-svg-nKHZObqsrOeIE4Sb .node rect,#mermaid-svg-nKHZObqsrOeIE4Sb .node circle,#mermaid-svg-nKHZObqsrOeIE4Sb .node ellipse,#mermaid-svg-nKHZObqsrOeIE4Sb .node polygon,#mermaid-svg-nKHZObqsrOeIE4Sb .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-nKHZObqsrOeIE4Sb .rough-node .label text,#mermaid-svg-nKHZObqsrOeIE4Sb .node .label text,#mermaid-svg-nKHZObqsrOeIE4Sb .image-shape .label,#mermaid-svg-nKHZObqsrOeIE4Sb .icon-shape .label{text-anchor:middle;}#mermaid-svg-nKHZObqsrOeIE4Sb .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-nKHZObqsrOeIE4Sb .rough-node .label,#mermaid-svg-nKHZObqsrOeIE4Sb .node .label,#mermaid-svg-nKHZObqsrOeIE4Sb .image-shape .label,#mermaid-svg-nKHZObqsrOeIE4Sb .icon-shape .label{text-align:center;}#mermaid-svg-nKHZObqsrOeIE4Sb .node.clickable{cursor:pointer;}#mermaid-svg-nKHZObqsrOeIE4Sb .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-nKHZObqsrOeIE4Sb .arrowheadPath{fill:#333333;}#mermaid-svg-nKHZObqsrOeIE4Sb .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-nKHZObqsrOeIE4Sb .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-nKHZObqsrOeIE4Sb .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-nKHZObqsrOeIE4Sb .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-nKHZObqsrOeIE4Sb .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-nKHZObqsrOeIE4Sb .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-nKHZObqsrOeIE4Sb .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-nKHZObqsrOeIE4Sb .cluster text{fill:#333;}#mermaid-svg-nKHZObqsrOeIE4Sb .cluster span{color:#333;}#mermaid-svg-nKHZObqsrOeIE4Sb div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-nKHZObqsrOeIE4Sb .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-nKHZObqsrOeIE4Sb rect.text{fill:none;stroke-width:0;}#mermaid-svg-nKHZObqsrOeIE4Sb .icon-shape,#mermaid-svg-nKHZObqsrOeIE4Sb .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-nKHZObqsrOeIE4Sb .icon-shape p,#mermaid-svg-nKHZObqsrOeIE4Sb .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-nKHZObqsrOeIE4Sb .icon-shape .label rect,#mermaid-svg-nKHZObqsrOeIE4Sb .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-nKHZObqsrOeIE4Sb .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-nKHZObqsrOeIE4Sb .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-nKHZObqsrOeIE4Sb :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 内核空间
用户空间
调用 printf 等库函数
调用 write 等系统调用
应用程序
系统库

glibc / UCRT
系统调用接口
内核功能

进程·内存·文件·设备·网络
硬件层

CPU·内存·硬盘·网卡·外设

图 1：系统调用在系统中的位置。 应用程序通过系统库间接调用系统调用，系统调用是用户空间和内核空间之间的唯一桥梁。

从图 1 可以看出，应用程序并不是直接调用系统调用，而是通常先调用系统库（如 C 标准库）中的函数，这些库函数再封装系统调用。例如 printf 封装了 write，malloc 封装了 brk 或 mmap。

二、为什么必须有系统调用？

你可能会问：为什么应用程序不能直接操作硬件？为什么要多一层系统调用？

原因可以归结为四个词：保护、隔离、抽象、统一。

2.1 保护：防止程序破坏系统

如果应用程序可以直接操作硬件，会发生什么？

• 一个程序可以格式化整个硬盘；
• 一个程序可以修改另一个程序的内存；
• 一个程序可以关闭系统关键服务；
• 一个恶意程序可以窃取所有数据。

系统调用通过特权级机制防止这些问题。CPU 把运行状态分为用户态和内核态：

特性	用户态	内核态
权限	受限，不能执行特权指令	最高权限，可执行所有指令
硬件访问	不能直接访问	可直接访问
内存访问	只能访问自己的地址空间	可访问全部内存
典型代码	应用程序	内核、驱动

应用程序想读写文件、发送网络数据，必须通过系统调用"请求"内核，由内核在最高权限下代为执行。

图 2：系统调用的保护机制。 应用程序无法直接访问硬件，必须通过内核。

2.2 隔离：让程序互不干扰

现代操作系统同时运行多个程序。系统调用确保了：

• 一个进程不能非法访问另一个进程的内存；
• 一个进程不能随意占用另一个进程的资源；
• 一个进程的崩溃不会影响整个系统。

2.3 抽象：隐藏硬件复杂性

不同硬件的工作方式千差万别。机械硬盘和固态硬盘的读写方式不同，不同网卡的寄存器不同，不同显卡的驱动不同。

系统调用提供了统一的抽象接口。应用程序只需要调用 read()，不需要关心底层是机械硬盘还是固态硬盘，不需要知道网卡的型号。

2.4 统一：让程序可移植

因为系统调用提供了统一的接口，同一个程序可以在不同硬件上运行。只要操作系统提供了相同的系统调用，程序就不需要修改。

当然，不同操作系统的系统调用并不完全相同。Linux 和 Windows 的系统调用名称、参数、编号都不一样，这也是同一程序在不同系统上需要重新编译的原因之一。

三、系统调用的分类

系统调用数量众多，Linux 有三百多个，Windows 也有数百个。按照功能，可以归纳为以下几大类。
#mermaid-svg-wjBMA5FkQiWlTbuS{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-wjBMA5FkQiWlTbuS .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-wjBMA5FkQiWlTbuS .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-wjBMA5FkQiWlTbuS .error-icon{fill:#552222;}#mermaid-svg-wjBMA5FkQiWlTbuS .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-wjBMA5FkQiWlTbuS .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-wjBMA5FkQiWlTbuS .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-wjBMA5FkQiWlTbuS .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-wjBMA5FkQiWlTbuS .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-wjBMA5FkQiWlTbuS .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-wjBMA5FkQiWlTbuS .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-wjBMA5FkQiWlTbuS .marker{fill:#333333;stroke:#333333;}#mermaid-svg-wjBMA5FkQiWlTbuS .marker.cross{stroke:#333333;}#mermaid-svg-wjBMA5FkQiWlTbuS svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-wjBMA5FkQiWlTbuS p{margin:0;}#mermaid-svg-wjBMA5FkQiWlTbuS .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-wjBMA5FkQiWlTbuS .cluster-label text{fill:#333;}#mermaid-svg-wjBMA5FkQiWlTbuS .cluster-label span{color:#333;}#mermaid-svg-wjBMA5FkQiWlTbuS .cluster-label span p{background-color:transparent;}#mermaid-svg-wjBMA5FkQiWlTbuS .label text,#mermaid-svg-wjBMA5FkQiWlTbuS span{fill:#333;color:#333;}#mermaid-svg-wjBMA5FkQiWlTbuS .node rect,#mermaid-svg-wjBMA5FkQiWlTbuS .node circle,#mermaid-svg-wjBMA5FkQiWlTbuS .node ellipse,#mermaid-svg-wjBMA5FkQiWlTbuS .node polygon,#mermaid-svg-wjBMA5FkQiWlTbuS .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-wjBMA5FkQiWlTbuS .rough-node .label text,#mermaid-svg-wjBMA5FkQiWlTbuS .node .label text,#mermaid-svg-wjBMA5FkQiWlTbuS .image-shape .label,#mermaid-svg-wjBMA5FkQiWlTbuS .icon-shape .label{text-anchor:middle;}#mermaid-svg-wjBMA5FkQiWlTbuS .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-wjBMA5FkQiWlTbuS .rough-node .label,#mermaid-svg-wjBMA5FkQiWlTbuS .node .label,#mermaid-svg-wjBMA5FkQiWlTbuS .image-shape .label,#mermaid-svg-wjBMA5FkQiWlTbuS .icon-shape .label{text-align:center;}#mermaid-svg-wjBMA5FkQiWlTbuS .node.clickable{cursor:pointer;}#mermaid-svg-wjBMA5FkQiWlTbuS .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-wjBMA5FkQiWlTbuS .arrowheadPath{fill:#333333;}#mermaid-svg-wjBMA5FkQiWlTbuS .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-wjBMA5FkQiWlTbuS .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-wjBMA5FkQiWlTbuS .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-wjBMA5FkQiWlTbuS .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-wjBMA5FkQiWlTbuS .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-wjBMA5FkQiWlTbuS .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-wjBMA5FkQiWlTbuS .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-wjBMA5FkQiWlTbuS .cluster text{fill:#333;}#mermaid-svg-wjBMA5FkQiWlTbuS .cluster span{color:#333;}#mermaid-svg-wjBMA5FkQiWlTbuS div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-wjBMA5FkQiWlTbuS .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-wjBMA5FkQiWlTbuS rect.text{fill:none;stroke-width:0;}#mermaid-svg-wjBMA5FkQiWlTbuS .icon-shape,#mermaid-svg-wjBMA5FkQiWlTbuS .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-wjBMA5FkQiWlTbuS .icon-shape p,#mermaid-svg-wjBMA5FkQiWlTbuS .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-wjBMA5FkQiWlTbuS .icon-shape .label rect,#mermaid-svg-wjBMA5FkQiWlTbuS .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-wjBMA5FkQiWlTbuS .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-wjBMA5FkQiWlTbuS .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-wjBMA5FkQiWlTbuS :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 系统调用分类
进程管理
文件操作
内存管理
设备管理
网络通信
进程间通信
fork · exec · exit · wait
open · read · write · close
brk · mmap · munmap
ioctl · read · write
socket · bind · send · recv
pipe · shmget · msgget

图 3：系统调用的主要分类。 本系列后续文章会逐一深入讲解每一类。

3.1 进程管理

进程是程序的一次执行过程。相关系统调用包括：

系统调用	作用
fork()	创建一个新进程，新进程是当前进程的副本
exec()	用新程序替换当前进程的执行内容
exit()	终止当前进程
wait()	等待子进程结束
getpid()	获取当前进程的 ID

一个典型的"创建进程并执行新程序"的流程是：父进程调用 fork() 创建子进程，子进程调用 exec() 加载新程序，父进程调用 wait() 等待子进程结束。

3.2 文件操作

文件操作是应用程序最常用的系统调用。Linux 中有一句经典的话："一切皆文件"。

系统调用	作用
open()	打开文件，返回文件描述符
read()	从文件读取数据
write()	向文件写入数据
close()	关闭文件
lseek()	移动文件读写位置
stat()	获取文件属性
unlink()	删除文件

3.3 内存管理

系统调用	作用
brk()	调整数据段末尾，用于小内存分配
mmap()	把文件或设备映射到内存
munmap()	解除内存映射
mprotect()	修改内存保护属性

你在 C 语言中调用的 malloc()，底层就是通过 brk() 或 mmap() 向内核申请内存。

3.4 设备管理

系统调用	作用
ioctl()	对设备进行控制操作
read()	从设备读取数据
write()	向设备写入数据

3.5 网络通信

系统调用	作用
socket()	创建套接字
bind()	绑定地址和端口
listen()	监听连接
accept()	接受连接
connect()	发起连接
send()	发送数据
recv()	接收数据

3.6 进程间通信

系统调用	作用
pipe()	创建管道
shmget()	创建共享内存
msgget()	创建消息队列
semget()	创建信号量

四、系统调用的实现机制

系统调用看起来只是普通的函数调用，但它背后的机制远比想象中复杂。核心难点在于：如何从用户态安全地切换到内核态，执行完再安全地切回来？

4.1 用户态与内核态的切换

CPU 提供了特殊的指令来完成特权级切换。在 x86 架构上，传统方式是 int 0x80 软中断指令；现代 64 位系统使用 syscall 指令（AMD）或 sysenter 指令（Intel）。
内核 CPU 系统库 应用程序 内核 CPU 系统库 应用程序 #mermaid-svg-iTaGRMkJhNWcjGQj{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-iTaGRMkJhNWcjGQj .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-iTaGRMkJhNWcjGQj .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-iTaGRMkJhNWcjGQj .error-icon{fill:#552222;}#mermaid-svg-iTaGRMkJhNWcjGQj .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-iTaGRMkJhNWcjGQj .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-iTaGRMkJhNWcjGQj .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-iTaGRMkJhNWcjGQj .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-iTaGRMkJhNWcjGQj .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-iTaGRMkJhNWcjGQj .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-iTaGRMkJhNWcjGQj .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-iTaGRMkJhNWcjGQj .marker{fill:#333333;stroke:#333333;}#mermaid-svg-iTaGRMkJhNWcjGQj .marker.cross{stroke:#333333;}#mermaid-svg-iTaGRMkJhNWcjGQj svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-iTaGRMkJhNWcjGQj p{margin:0;}#mermaid-svg-iTaGRMkJhNWcjGQj .actor{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-iTaGRMkJhNWcjGQj text.actor>tspan{fill:black;stroke:none;}#mermaid-svg-iTaGRMkJhNWcjGQj .actor-line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-iTaGRMkJhNWcjGQj .innerArc{stroke-width:1.5;stroke-dasharray:none;}#mermaid-svg-iTaGRMkJhNWcjGQj .messageLine0{stroke-width:1.5;stroke-dasharray:none;stroke:#333;}#mermaid-svg-iTaGRMkJhNWcjGQj .messageLine1{stroke-width:1.5;stroke-dasharray:2,2;stroke:#333;}#mermaid-svg-iTaGRMkJhNWcjGQj #arrowhead path{fill:#333;stroke:#333;}#mermaid-svg-iTaGRMkJhNWcjGQj .sequenceNumber{fill:white;}#mermaid-svg-iTaGRMkJhNWcjGQj #sequencenumber{fill:#333;}#mermaid-svg-iTaGRMkJhNWcjGQj #crosshead path{fill:#333;stroke:#333;}#mermaid-svg-iTaGRMkJhNWcjGQj .messageText{fill:#333;stroke:none;}#mermaid-svg-iTaGRMkJhNWcjGQj .labelBox{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-iTaGRMkJhNWcjGQj .labelText,#mermaid-svg-iTaGRMkJhNWcjGQj .labelText>tspan{fill:black;stroke:none;}#mermaid-svg-iTaGRMkJhNWcjGQj .loopText,#mermaid-svg-iTaGRMkJhNWcjGQj .loopText>tspan{fill:black;stroke:none;}#mermaid-svg-iTaGRMkJhNWcjGQj .loopLine{stroke-width:2px;stroke-dasharray:2,2;stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-iTaGRMkJhNWcjGQj .note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-svg-iTaGRMkJhNWcjGQj .noteText,#mermaid-svg-iTaGRMkJhNWcjGQj .noteText>tspan{fill:black;stroke:none;}#mermaid-svg-iTaGRMkJhNWcjGQj .activation0{fill:#f4f4f4;stroke:#666;}#mermaid-svg-iTaGRMkJhNWcjGQj .activation1{fill:#f4f4f4;stroke:#666;}#mermaid-svg-iTaGRMkJhNWcjGQj .activation2{fill:#f4f4f4;stroke:#666;}#mermaid-svg-iTaGRMkJhNWcjGQj .actorPopupMenu{position:absolute;}#mermaid-svg-iTaGRMkJhNWcjGQj .actorPopupMenuPanel{position:absolute;fill:#ECECFF;box-shadow:0px 8px 16px 0px rgba(0,0,0,0.2);filter:drop-shadow(3px 5px 2px rgb(0 0 0 / 0.4));}#mermaid-svg-iTaGRMkJhNWcjGQj .actor-man line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-iTaGRMkJhNWcjGQj .actor-man circle,#mermaid-svg-iTaGRMkJhNWcjGQj line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;stroke-width:2px;}#mermaid-svg-iTaGRMkJhNWcjGQj :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 自动保存用户态上下文 特权级从 Ring 3 切换到 Ring 0 恢复用户态上下文 特权级从 Ring 0 切回 Ring 3 调用 write()把系统调用号放入寄存器执行 syscall 指令跳转到系统调用处理程序根据系统调用号查找处理函数执行特权操作执行 sysret 指令返回结果返回结果

图 4：系统调用的完整执行流程。 从用户态发起，经过 CPU 特权级切换，进入内核执行，最后返回用户态。

4.2 系统调用号

内核中维护着一张系统调用表（System Call Table），本质上是一个函数指针数组。每个系统调用有一个唯一的编号。

在 Linux x86-64 中，常见的系统调用号：

系统调用	编号
read	0
write	1
open	2
close	3
fork	57
execve	59
exit	60

当应用程序执行 syscall 指令时，会把系统调用号放入 rax 寄存器，把参数放入 rdi、rsi、rdx 等寄存器。内核根据 rax 中的编号，在系统调用表中找到对应的处理函数并执行。

4.3 上下文保存与恢复

从用户态切换到内核态时，CPU 和内核需要保存用户程序的执行状态，包括：

• 程序计数器（下一条指令的地址）；
• 寄存器内容；
• 栈指针；
• 标志寄存器。

这些信息保存在内核栈或进程的上下文结构中。当系统调用返回时，再恢复这些状态，用户程序从刚才中断的地方继续执行。

4.4 参数传递

系统调用的参数传递有多种方式：

1. 寄存器传参：参数较少时，直接放入寄存器。这是最快的方式。
2. 栈传参：参数较多时，把参数放入用户栈，把栈指针传给内核。
3. 内存传参：对于大块数据，传递指针，内核从用户空间拷贝数据。

Linux x86-64 使用寄存器传参，最多支持 6 个参数。超过 6 个参数时，需要使用栈或内存传递。

五、系统调用与库函数的关系

初学者最容易混淆的一点是：系统调用和库函数不是一回事。

图 5：库函数与系统调用的关系。 有些库函数封装了系统调用，有些则完全在用户态实现。

5.1 库函数封装系统调用

以 printf 为例：

printf("Hello\n")

它的执行过程是：

1. printf 把格式化后的字符串写入 C 标准库的缓冲区；
2. 缓冲区满或遇到换行时，调用 write() 系统调用；
3. write() 进入内核，把数据写到终端设备。

所以 printf 并不是系统调用，它是封装了 write 的库函数。

5.2 纯用户态库函数

有些库函数完全不涉及系统调用，例如：

• strlen()：计算字符串长度，纯用户态循环；
• memcpy()：内存复制，纯用户态操作；
• strcmp()：字符串比较，纯用户态操作。

这些函数不需要内核参与，执行速度很快。

5.3 对比表

对比项	库函数	系统调用
提供者	C 标准库、语言运行时	操作系统内核
运行状态	用户态	内核态
是否切换特权级	不一定	一定
执行开销	较小	较大
可移植性	跨平台较好	依赖操作系统
示例	printf、malloc、strlen	write、brk、open

六、一个完整的例子：从 printf 到屏幕显示

我们用一个完整的例子，把前面讲的知识串起来。假设你写了一段代码：

#include <stdio.h>

int main() {
    printf("Hello, OS!\n");
    return 0;
}

从这行代码到屏幕上出现 Hello, OS!，发生了什么？
终端设备 内核 glibc 应用程序 终端设备 内核 glibc 应用程序 #mermaid-svg-lVOdLMOQvjtldui9{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-lVOdLMOQvjtldui9 .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-lVOdLMOQvjtldui9 .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-lVOdLMOQvjtldui9 .error-icon{fill:#552222;}#mermaid-svg-lVOdLMOQvjtldui9 .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-lVOdLMOQvjtldui9 .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-lVOdLMOQvjtldui9 .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-lVOdLMOQvjtldui9 .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-lVOdLMOQvjtldui9 .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-lVOdLMOQvjtldui9 .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-lVOdLMOQvjtldui9 .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-lVOdLMOQvjtldui9 .marker{fill:#333333;stroke:#333333;}#mermaid-svg-lVOdLMOQvjtldui9 .marker.cross{stroke:#333333;}#mermaid-svg-lVOdLMOQvjtldui9 svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-lVOdLMOQvjtldui9 p{margin:0;}#mermaid-svg-lVOdLMOQvjtldui9 .actor{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-lVOdLMOQvjtldui9 text.actor>tspan{fill:black;stroke:none;}#mermaid-svg-lVOdLMOQvjtldui9 .actor-line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-lVOdLMOQvjtldui9 .innerArc{stroke-width:1.5;stroke-dasharray:none;}#mermaid-svg-lVOdLMOQvjtldui9 .messageLine0{stroke-width:1.5;stroke-dasharray:none;stroke:#333;}#mermaid-svg-lVOdLMOQvjtldui9 .messageLine1{stroke-width:1.5;stroke-dasharray:2,2;stroke:#333;}#mermaid-svg-lVOdLMOQvjtldui9 #arrowhead path{fill:#333;stroke:#333;}#mermaid-svg-lVOdLMOQvjtldui9 .sequenceNumber{fill:white;}#mermaid-svg-lVOdLMOQvjtldui9 #sequencenumber{fill:#333;}#mermaid-svg-lVOdLMOQvjtldui9 #crosshead path{fill:#333;stroke:#333;}#mermaid-svg-lVOdLMOQvjtldui9 .messageText{fill:#333;stroke:none;}#mermaid-svg-lVOdLMOQvjtldui9 .labelBox{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-lVOdLMOQvjtldui9 .labelText,#mermaid-svg-lVOdLMOQvjtldui9 .labelText>tspan{fill:black;stroke:none;}#mermaid-svg-lVOdLMOQvjtldui9 .loopText,#mermaid-svg-lVOdLMOQvjtldui9 .loopText>tspan{fill:black;stroke:none;}#mermaid-svg-lVOdLMOQvjtldui9 .loopLine{stroke-width:2px;stroke-dasharray:2,2;stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-lVOdLMOQvjtldui9 .note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-svg-lVOdLMOQvjtldui9 .noteText,#mermaid-svg-lVOdLMOQvjtldui9 .noteText>tspan{fill:black;stroke:none;}#mermaid-svg-lVOdLMOQvjtldui9 .activation0{fill:#f4f4f4;stroke:#666;}#mermaid-svg-lVOdLMOQvjtldui9 .activation1{fill:#f4f4f4;stroke:#666;}#mermaid-svg-lVOdLMOQvjtldui9 .activation2{fill:#f4f4f4;stroke:#666;}#mermaid-svg-lVOdLMOQvjtldui9 .actorPopupMenu{position:absolute;}#mermaid-svg-lVOdLMOQvjtldui9 .actorPopupMenuPanel{position:absolute;fill:#ECECFF;box-shadow:0px 8px 16px 0px rgba(0,0,0,0.2);filter:drop-shadow(3px 5px 2px rgb(0 0 0 / 0.4));}#mermaid-svg-lVOdLMOQvjtldui9 .actor-man line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-lVOdLMOQvjtldui9 .actor-man circle,#mermaid-svg-lVOdLMOQvjtldui9 line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;stroke-width:2px;}#mermaid-svg-lVOdLMOQvjtldui9 :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 遇到换行，触发刷新 从用户态切换到内核态 从内核态切换回用户态 调用 printf("Hello, OS!\n")格式化字符串写入缓冲区调用 write(1, buf, 10)根据 fd=1 找到终端设备调用设备驱动写入字符写入完成返回写入字节数返回结果

图 6：从 printf 到屏幕显示的完整流程。 应用程序调用库函数，库函数调用系统调用，内核操作硬件。

具体步骤：

1. 应用程序调用 printf：这是库函数，运行在用户态。
2. glibc 格式化字符串 ：把 "Hello, OS!\n" 放入内部缓冲区。
3. 遇到换行符触发刷新：标准输出是行缓冲的，遇到换行会立即刷新。
4. glibc 调用 write(1, buf, 10)：文件描述符 1 代表标准输出。
5. write 触发 syscall 指令：CPU 从用户态切换到内核态。
6. 内核根据系统调用号找到 sys_write 处理函数 ：系统调用号 1 对应 write。
7. 内核根据文件描述符 1 找到终端设备：调用对应的设备驱动。
8. 设备驱动把字符写入终端 ：屏幕上出现 Hello, OS!。
9. 内核返回结果，切换回用户态 ：printf 返回，程序继续执行。

七、系统调用的开销与优化

系统调用虽然强大，但并不是免费的。每次系统调用都涉及：

• 特权级切换：从 Ring 3 到 Ring 0，再切回来；
• 上下文保存与恢复：保存寄存器、栈指针等；
• 参数检查：内核需要验证参数的合法性；
• 数据拷贝：用户空间和内核空间之间的数据拷贝。

这些操作加起来，一次系统调用的开销大约在几百纳秒到几微秒之间。相比之下，一次普通的函数调用只需要几纳秒。

7.1 为什么系统调用开销大？

#mermaid-svg-056kLlcPfrQH404B{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-056kLlcPfrQH404B .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-056kLlcPfrQH404B .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-056kLlcPfrQH404B .error-icon{fill:#552222;}#mermaid-svg-056kLlcPfrQH404B .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-056kLlcPfrQH404B .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-056kLlcPfrQH404B .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-056kLlcPfrQH404B .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-056kLlcPfrQH404B .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-056kLlcPfrQH404B .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-056kLlcPfrQH404B .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-056kLlcPfrQH404B .marker{fill:#333333;stroke:#333333;}#mermaid-svg-056kLlcPfrQH404B .marker.cross{stroke:#333333;}#mermaid-svg-056kLlcPfrQH404B svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-056kLlcPfrQH404B p{margin:0;}#mermaid-svg-056kLlcPfrQH404B .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-056kLlcPfrQH404B .cluster-label text{fill:#333;}#mermaid-svg-056kLlcPfrQH404B .cluster-label span{color:#333;}#mermaid-svg-056kLlcPfrQH404B .cluster-label span p{background-color:transparent;}#mermaid-svg-056kLlcPfrQH404B .label text,#mermaid-svg-056kLlcPfrQH404B span{fill:#333;color:#333;}#mermaid-svg-056kLlcPfrQH404B .node rect,#mermaid-svg-056kLlcPfrQH404B .node circle,#mermaid-svg-056kLlcPfrQH404B .node ellipse,#mermaid-svg-056kLlcPfrQH404B .node polygon,#mermaid-svg-056kLlcPfrQH404B .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-056kLlcPfrQH404B .rough-node .label text,#mermaid-svg-056kLlcPfrQH404B .node .label text,#mermaid-svg-056kLlcPfrQH404B .image-shape .label,#mermaid-svg-056kLlcPfrQH404B .icon-shape .label{text-anchor:middle;}#mermaid-svg-056kLlcPfrQH404B .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-056kLlcPfrQH404B .rough-node .label,#mermaid-svg-056kLlcPfrQH404B .node .label,#mermaid-svg-056kLlcPfrQH404B .image-shape .label,#mermaid-svg-056kLlcPfrQH404B .icon-shape .label{text-align:center;}#mermaid-svg-056kLlcPfrQH404B .node.clickable{cursor:pointer;}#mermaid-svg-056kLlcPfrQH404B .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-056kLlcPfrQH404B .arrowheadPath{fill:#333333;}#mermaid-svg-056kLlcPfrQH404B .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-056kLlcPfrQH404B .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-056kLlcPfrQH404B .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-056kLlcPfrQH404B .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-056kLlcPfrQH404B .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-056kLlcPfrQH404B .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-056kLlcPfrQH404B .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-056kLlcPfrQH404B .cluster text{fill:#333;}#mermaid-svg-056kLlcPfrQH404B .cluster span{color:#333;}#mermaid-svg-056kLlcPfrQH404B div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-056kLlcPfrQH404B .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-056kLlcPfrQH404B rect.text{fill:none;stroke-width:0;}#mermaid-svg-056kLlcPfrQH404B .icon-shape,#mermaid-svg-056kLlcPfrQH404B .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-056kLlcPfrQH404B .icon-shape p,#mermaid-svg-056kLlcPfrQH404B .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-056kLlcPfrQH404B .icon-shape .label rect,#mermaid-svg-056kLlcPfrQH404B .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-056kLlcPfrQH404B .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-056kLlcPfrQH404B .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-056kLlcPfrQH404B :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 几纳秒
几百纳秒到几微秒
普通函数调用
完成
系统调用
保存上下文
特权级切换
参数检查
执行内核操作
数据拷贝
恢复上下文
特权级切换回

图 7：普通函数调用与系统调用的开销对比。 系统调用的开销主要来自特权级切换和上下文保存。

7.2 如何减少系统调用开销？

操作系统和应用程序都采取了多种优化手段：

1. 缓冲：标准库的缓冲区把多次小写入合并成一次大写入，减少系统调用次数。
2. 批量操作 ：如 readv()、writev() 一次读写多个缓冲区。
3. 内存映射 ：mmap() 把文件映射到内存，后续访问不需要系统调用。
4. 零拷贝 ：sendfile() 在内核中直接传输数据，避免用户空间和内核空间之间的拷贝。
5. vDSO ：把部分系统调用（如 gettimeofday）映射到用户空间，避免特权级切换。

八、不同操作系统的系统调用

8.1 Linux 系统调用

Linux 系统调用通过 syscall 指令触发，系统调用号在 unistd.h 中定义。Linux 的系统调用数量随着版本不断增加，目前有三百多个。

8.2 Windows 系统调用

Windows 的系统调用机制不同。Windows 应用程序通常不直接调用系统调用，而是调用 ntdll.dll 中的函数，再由 ntdll.dll 通过 syscall 指令进入内核。Windows 的系统调用号在不同版本之间可能变化，因此微软不鼓励直接使用系统调用。

8.3 国产操作系统的系统调用

国产操作系统大多基于 Linux 内核，因此系统调用与 Linux 基本一致。鸿蒙 HarmonyOS 采用微内核设计，系统调用接口与 Linux 不同，但基本思想一致：应用程序通过系统调用请求内核服务。

图 8：不同操作系统的系统调用路径。 虽然实现方式不同，但核心思想一致。

九、常见误区澄清

误区	真相
"printf 是系统调用"	printf 是库函数，它封装了 write 系统调用
"系统调用就是函数调用"	系统调用涉及特权级切换，开销远大于普通函数调用
"应用程序可以直接调用系统调用"	可以，但通常通过库函数间接调用。直接调用需要编写汇编代码
"所有操作系统的系统调用都一样"	Linux 和 Windows 的系统调用名称、编号、参数都不同
"系统调用越多越好"	系统调用开销大，应尽量减少调用次数，使用缓冲等优化手段
"malloc 是系统调用"	malloc 是库函数，底层通过 brk 或 mmap 系统调用申请内存