近来因为毕设需求，需要有一个简单的文件上传服务，结合 Nginx，最终通过 nginx-upload-module 实现。但是该模块开发者考虑到同时间同名文件上传碰撞，将文件名统一设置为一串经过计算得到的数值，交由后端服务对文件做改动。

本来不是啥大问题，只是网上教程都使用其他语言实现文件重命名，我实在不想因为这么一个简单的需求在毕设中引入其他后端语言，于是决定自写一个模块实现文件重命名功能，源码保存在 nginx-upload-rename-module 中。

毕设内容是基于 Nginx 实现流媒体点播服务器，打算自写一个支持 HLS 协议的模块，实现从 .mp4 到 .m3u8 的转码切分。正好写这个重命名模块，学习 Nginx 模块开发。

此次实验在本地机上进行，在服务器上部署基本一致。

❗ 请注意文末的提示！

思路

nginx-upload-module 的工作流程是将上传文件从 HTTP 报文中剥除，组合成文件，计算特定数值后保存到指定目录；其他文件信息则经过整合写入 HTTP 报文的请求体，交由后端处理。

我本打算直接调用它定义的变量，获取诸如文件名、文件类型等信息，直接完成文件重命名，但是可能是它变量定义时对标志位的设置，无法获取索引也没有记录入散列表，无法获得其值，就此作罢。

输出其 HTTP 报文的过程中，偶然明白了 nginx-upload-module 的 HTTP 报文传递到后端时的具体内容，于是决定对 HTTP 报文做处理，获取其特定字段，保存后用以处理文件。

编译

首先下载 Nginx 源码和两个模块：

1
2
3

wget https://nginx.org/download/nginx-1.20.2.tar.gz
git clone https://github.com/fdintino/nginx-upload-module.git
git clone https://github.com/xQmQ/nginx-upload-rename-module.git

解压缩 Nginx 源码后，有以下三个目录：

1
2
3
4

.
├── nginx-1.20.2
├── nginx-upload-module
└── nginx-upload-rename-module

进入nginx-1.20.2，准备编译。这里我直接将安装路径放在了当前目录：

自行安装 Nginx 源码编译时需要的依赖

1

./configure --prefix=$(pwd)/nginx --add-module=../nginx-upload-rename-module --add-module=../nginx-upload-module

经过检查后得到以下信息：

然后执行编译：

1

make

编译成功后安装：

1

make install

这样就得到了配置文件和二进制文件：

配置

首先将nginx-upload-rename-module/UploadSuccess目录复制入nginx/html中。这个目录里有上传成功后返回给前端的页面。

然后修改 Nginx 的配置文件conf/nginx.conf，在http{}中设置以下信息，监听的端口自定，我这里就直接监听 1080 端口。

注意配置upload_store时，指定的目录要存在，且有相应的权限，目录可以自定；client_max_body_size决定上传文件的大小；其他配置项可以看看 ngin-upload-module 的 README。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

server {
    listen 80;

    client_max_body_size 100m;
    
    # Upload form should be submitted to this location
    location /upload {
        # Pass altered request body to this location
        upload_pass /uploadSuccess;

        # Store files to this directory
        # The directory is hashed, subdirectories 0 1 2 3 4 5 6 7 8 9 should exist
        upload_store /tmp;

        # Allow uploaded files to be read only by user
        upload_store_access user:rw group:rw all:rw;

        # Set specified fields in request body
        upload_set_form_field $upload_field_name.name "$upload_file_name";
        upload_set_form_field $upload_field_name.content_type "$upload_content_type";
        upload_set_form_field $upload_field_name.path "$upload_tmp_path";

        # Inform backend about hash and size of a file
        upload_aggregate_form_field $upload_field_name.md5 "$upload_file_md5";
        upload_aggregate_form_field $upload_field_name.size "$upload_file_size";

        upload_pass_form_field "^submit$|^description$";

        upload_cleanup 400 404 499 500-505;
    }

    # Pass altered request body to a backend
    location /uploadSuccess {
        upload_files_rename on;
    }
}

启动

设置好后，进入sbin/，准备启动：

我没有写前端上传的页面，打算利用 Apifox 直接调用接口。

POST 请求，并插入待上传的文件，访问localhost:1080/upload。

我这里在本地机做实验。

可以看到返回了成功界面。

实际上进行上传并调用upload_pass后即会返回此页面，不代表文件重命名成功，但是一般情况下都是成功的。

也可以看到指定的目录下有了对应的文件：

而如果没有启动 nginx-upload-rename-module，一般来说文件名如下，一串数字所示：

提示

因为个人能力有限，模块可能会存在 bug，已经测试过多个不同名文件同时上传，没有什么问题。

但是正如 nginx-upload-module 开发者所说，存在文件碰撞的可能，所以他们决定让用户在后端程序（如 PHP）中移动和重命名文件。我没有条件测试同一上传时间的同名文件碰撞。

但是对于同文件名但不同内容的文件 A 和文件 B，先上传文件 A，再次上传文件 B 后，会删除 文件 A 保留文件 B，即没有设置同名文件碰撞处理，请知悉。

其次，由于模块开发过程中挂载方式的选择，upload_pass指定的location /uploadSuccess可能无法启动其他模块的功能，只能启动本模块（暂未测试）。

所以开发的模块只适用于简单的文件上传服务，请小心使用。

闲来无事，想把 WSL2 的 kernel 升级一下。GitHub 中微软官方发布的 WSL2 kernel 最新版本为5.10.74.3，但是 Microsoft Update Catalog 中一直没有相应版本的安装包（截止本文发布）

于是打算自己动手编译一下

编译环境

WSL2 下的 Arch Linux

编译内核

整体编译思路就是利用微软的编译配置文件来编译 Linux kernel，并在相应的 Windows 目录下替换现有的内核

这里放一下 GitHub 中的 WSL2-Linux-Kernel

下载源码

在 GitHub 下载相应版本的 releases

1

wget https://github.com/microsoft/WSL2-Linux-Kernel/archive/refs/tags/linux-msft-wsl-5.10.74.3.tar.gz

下载完成后解压缩并进入目录

1
2

tar zxvf linux-msft-wsl-5.10.74.3.tar.gz
cd WSL2-Linux-Kernel-linux-msft-wsl-5.10.74.3/

为确保内核树绝对干净，进入内核目录并执行make mrproper命令

1

make clean && make mrproper

安装编译工具

微软也在项目里告知了步骤，其中也包括编译工具

这个不能照葫芦画瓢直接复制下来，需要在 ArchWiki 中找一下 Arch Linux 中的包

build-essential、flex和bison都集成在 Arch Linux 的base-devel里了，其他两个也有相对应的包

1

sudo pacman -S base-devel openssl libelf pahole xmlto kmod inetutils bc

关于pahole：

在多次编译时，最终都会报错

1 2 3

BTF: .tmp_vmlinux.btf: pahole (pahole) is not available Failed to generate BTF for vmlinux Try to disable CONFIG_DEBUG_INFO_BTF

一种方法是在Microsoft/config-wsl中对CONFIG_DEBUG_INFO_BTF设置关闭

✨ 另一种方法是下载pahole，此方法取自 Stack Overflow，其他发行版遇到此问题也可以看一下

---

关于其余四个包：

由 ArchWiki 推荐

2022-02-08更新：

在最新推出的5.10.93.2版本中，官方修复了关于以上提到的BTF报错，针对 Ubuntu 给出依赖项dwarves

修改编译配置文件

打开Microsoft/config-wsl文件，把内核号修改了一下，改成自己的名字

开始编译

1

make KCONFIG_CONFIG=Microsoft/config-wsl -j

编译开始时会出现编译选项，全部按照默认就可以了

然后就可以等着编译完成了

可以看到编译完成的内核所在的路径为arch/x86/boot/bzImage

这就是编译好的 WSL2 的内核了

替换内核

WSL2 使用的内核是放在 Windows 目录下的C:\WINDOWS\System32\lxss\tools

只需要把编译好的bzImage复制到此路径下，并更名为kernel即可

可以使用文件管理器复制内核

1

explorer.exe .

关闭所有 WSL，并将bzImage复制到C:\WINDOWS\System32\lxss\tools下并更名为kernel

替换内核前需要将所有 WSL 关闭

启动 Arch Linux，并截图

🌈 可以看到内核已经替换为5.10.74.3版本了

此博客用于记录 CLion 搭建编译工具链的过程。WSL 的 arch Linux 通过 LxRunOffline 自定义安装

以下是相关信息：

• CLion：2021.2.1
• WSL2：Arch Linux on Windows 10

一般通过 Microsoft store 安装的 WSL，CLion 是可以直接发现的，但是自定义安装的发行版通常无法发现，这时候可以通过更改 CLion 的配置文件解决这个问题

WSL 的配置信息一般位于%HOMEPATH%\AppData\Roaming\JetBrains\XXXXX\options\wsl.distributions.xml中，XXXXX 对应于所使用的软件版本

比如我的 CLion 版本为 2.21.2.1 ，则对应路径为%HOMEPATH%\AppData\Roaming\JetBrains\CLion2021.2\options\wsl.distributions.xml

打开这个文件后，可以看到定义了很多已经在 Microsoft store 上发行的版本，接下来可以配置我们的自定义版本

比如我的 arch Linux 的路径为C:\WSL\Arch\Arch，在文件中进行配置

1
2
3
4
5
6

<descriptor>
  <id>ARCH</id>
  <microsoft-id>Arch</microsoft-id>
  <executable-path>C:\\WSL\\Arch\\Arch\\</executable-path>
  <presentable-name>Arch Linux</presentable-name>
</descriptor>

注意：配置文件中的路径应当用\\

内存管理

三种装入方式

逻辑地址：某一个进程中存放数据的地址，一般开头为 0

绝对地址：数据在内存中的地址，一般是起始地址 + 逻辑地址

程序员写好的程序，通过编译、链接和装入，实现最终的运行

编译：由编译程序将源代码编译成若干个目标模块（高级语言翻译为机器语言）

链接：由链接程序将目标模块和所需库函数链接在一起，形成一个完整的装入模块

装入：由装入程序将装入模块装入内存运行

在不适用存储器抽象的情况下，通过保存当前程序到磁盘，读入下一个程序到内存，来实现运行多个程序。在此时内存中只有一个程序，不会发生冲突

绝对装入：编译时，知道程序放到内存哪个地方，编译程序产生绝对地址的目标代码，将程序装入绝对地址，只适用于单道程序环境

静态重定位（可重定位装入）：编译、链接后的装入模块的地址都是从 0 开始，使用逻辑地址，根据内存情况装入到适当位置，在装入时对地址进行重定位，将逻辑地址转变为物理地址（在装入时一次完成）。在装入作业时，需要一次分配作业要求的全部内存空间，作业在运行期间不能移动，不能再申请内存空间

动态重定位（动态运行时装入）：编译、链接后的装入模块的地址都是从 0 开始，使用逻辑地址，根据内存情况装入到适当位置，调用一个基址寄存器记录起始地址，在程序真正运行时进行地址转换，运行程序在内存中发生移动

内存的离散分配管理

分页式存储管理

基本思想：把内存分为一个个大小相等的小分区，再按照分区大小把进程拆分成一个个小部分

物理块：内存中一个个大小相等的小分区，每个物理块有一个物理块号，物理块号从 0 开始

页：用户进程中按照物理块大小分割的一个个小部分，每个页有一个页号，页号从 0 开始

页大小一般为 2 的整数幂，例如 ；对应的，物理块大小也是 4KB

页大小具体看操作系统设置，这里的 4KB 用作举例

进程的最后一个页面可能没有物理块那么大，放入物理块后会产生内部碎片

操作系统以物理块为单位为每个进程分配内存空间，进程的每个页被放入一个物理块中，即进程的页号与内存的物理块号相对应，页面不一定被连续存放在内存中，可以放在不相邻的物理块中

逻辑地址到物理地址的转换

1. 算出页号

   

   以 32 位操作系统为例，逻辑地址长度为 32 位，则一个进程最大为 。第 0-11 位表示页内偏移量，也可以得出一个页的大小为 个内存单元，第 12-32 位用作表示页号，即一个进程中最多有 个页

   一个内存单元大小为 1B

   通过逻辑地址的第 12~32 位，可以计算出此地址对应的页号

2. 计算页号对应的内存中的起始地址

   操作系统会为每个进程维护一张页表，页表的每一个页表项记录的是页号到物理块号的转换

   

   一个页表项的大小需要根据页的大小来决定。一个页的大小为 4K 个内存单元，意味着表示起来用 20 位，也就是接近 3 字节

   页表中实际上不需要写出页号，页号是顺序记录下来的，可以通过页表始址 + 对应页号 M * 页表项大小，找到页表项在页表中的位置，从而获得物理块号

   M 号物理块在内存中的实际地址就是 M * 物理块大小

3. 算出页内地址（页内偏移量）

   根据逻辑地址的 0~11 位可以算出在物理块中的地址，也就是页内偏移量

   毕竟得到的物理块地址，实际上是一个物理块的起始地址

4. 物理地址=物理块起始地址 + 页内偏移量

页表寄存器与快表

基本地址变换机构：用于实现逻辑地址到物理地址转换的一组硬件机构

页表寄存器（PTR）：记录页表的内存起始地址和页表长度

进程未执行时，页表的始址和长度记录在 PCB 中；进程被调度后，始址和长度存放到页表寄存器中

快表，又称为联想寄存器（TLB）：是一种访问速度比内存快很多的高速缓冲存储器，用来存放当前访问的若干页表项

1. 逻辑地址计算页号和页内偏移量
2. 由页表寄存器获得页表长度
3. 页号 <= 页表长度，则未越界
4. 查看快表，是否命中，命中则直接获得物理块号
5. 快表未命中则由页表寄存器获得页表始址，找到内存中的页表，计算页号对应的物理块号（页表始址 + 页号 * 页表项长度），并存入快表
6. 根据物理块号 * 物理块大小 + 页内偏移量计算物理地址，找到内存中的目标页面

查看快表不需要访问内存，查看页表需要访问内存

快表命中，全程访存一次；快表未命中，全程访存两次

二级页表

对于现代计算机，大多数是 ​​​​ 内存，页表非常大。设页面大小为 4KB，一级页表的页表项有 ​ 至 ​​​​​ 个，再乘以页表项大小，就意味着每个进程需要极大的连续的内存空间用来存储页表

实际上一个进程不可能需要用到这么大的内存，划分多级页表后，外层页表记录内层页表，可以做到：

1. 页表可以离散存放在不同的物理块中
2. 只需要将用到的页表调入到内存，用不到的放在磁盘中
3. 进程不可能用到这么大的内存，外层页表可以忽略没有映射的内存页表

1. 转换逻辑地址得到一级页号、二级页号和页内偏移量
2. 通过页表寄存器找到页目录表始址，根据一级页号得到存放二级页表的物理块号 X
3. 由 X * 物理块大小，找到物理内存中存储二级页表的地址
4. 根据二级页号在二级页表中找到想要访问的物理块号 Y
5. 由 Y * 物理块大小，在物理内存中找到想要访问的物理块，根据页内偏移量找到物理地址

一些注意点：

1. 采用多级页表机制时，各级页表的大小不能超过一个页
2. 与一级页表和快表一样，访存次数看是否命中以及访问几次页表

分段式存储管理

进程中的地址空间按照程序自身的逻辑关系划分为若干个段，每个段一个段名，每段从 0 开始

以段为单位分配内存空间，每个段在内存中占据连续空间，但各段之间可以不相邻

1. 由逻辑地址计算得到段号和段内偏移量
2. 由段表寄存器获得段表长度
3. 段号 <= 段表长度，则未越界
4. 由段表寄存器获得段表始址，找到内存中的段表，计算段号对应的段表项（段表始址 + 段号 * 段表项长度）
5. 段内偏移量 <= 段长，则未越界
6. 根据段基址和段内偏移量计算物理地址，找到内存中的目标段

分页式与分段式的对比

页是信息的物理单位：分页的主要目的是为了实现离散分配，提高内存利用率。分页仅仅是系统管
理上的需要，完全是系统行为，对用户是不可见的

段是信息的逻辑单位：分段的主要目的是更好地满足用户需求。一个段通常包含着一组属于一个逻
辑模块的信息。分段对用户是可见的，用户编程时需要显式地给出段名

页的大小固定且由系统决定；段的长度却不固定，决定于用户编写的程序

分页的用户进程地址空间是一维的，程序员只需给出一个记忆符即可表示一个地址

分段的用户进程地址空间是二维的，程序员在标识一个地址时，既要给出段名，也要给出段内地址

段页式存储管理

1. 由逻辑地址计算得到段号、页号和页内偏移量
2. 由段表寄存器获得段表长度
3. 段号 <= 段表长度，则未越界
4. 由段表寄存器获得段表始址，找到内存中的段表，计算段号对应的段表项（段表始址 + 段号 * 段表项长度）
5. 页号 <= 页表长度，则未越界
6. 根据段表项的页表块号（也是一个物理块），找到独属于此段的页表（块号 * 物理块大小）
7. 根据页号得到物理块号 * 物理块大小 + 页内偏移量计算物理地址，找到内存中的目标页面

快表命中则访存一次，未命中则访存三次

内存紧张时如何解决？

当内存空间紧张时，有两种方式解决。一种是交换技术；一种是虚拟内存。这两种一般同时使用，以提高内存利用效率

交换技术

当内存空间紧张时，通过将内存中某些进程（阻塞态、低优先级等）暂时交换到外存中，但是保留 PCB 在内存中；将处于就绪态的进程从外存调入内存，分配 CPU 并运行

交换技术也就是处理机调度中的中级调度

1. 保存在外存什么位置？

   外存通常会划分为对换区和文件区。文件区是离散分配的（追求空间利用率），对换区是连续分配的（追求文件查找的 I/O 效率）。通常会将被交换的进程保存在对换区

2. 什么时候交换？

   当运行的进程频繁缺页，需要去外存调取时，说明内存吃紧。这时候可以发生交换

3. 交换哪些进程？

   优先换出阻塞态进程、低优先级进程。PCB 保存在内存中，不会换出

虚拟内存技术

离散式存储管理存在以下特性：

1. 一次性：作业必须一次性全部装入内存后才能开始运行。这会造成两个问题：
   • 作业很大时，不能全部装入内存，导致大作业无法运行
   • 当大量作业要求运行时，由于内存无法容纳所有作业，因此只有少量作业能运行，导致多道程序并发度下降
2. 驻留性：一旦作业被装入内存，就会一直驻留在内存中，直至作业运行结束。事实上，在一个时间段内，只需要访问作业的一小部分数据即可正常运行，这就导致了内存中会驻留大量的、暂时用不到的数据，浪费了宝贵的内存资源

虚拟内存技术在内存的离散式存储管理的基础上，做出改进。不会一次将作业全部装入内存，只会装入很快会用到的部分，其他部分留在外存；程序执行过程中，访问的信息不在内存中时，由操作系统将所需信息从外存调入内存，然后继续执行程序；如果内存空间不够用，会调出暂时不用的信息到外存

虚拟内存技术的主要特征：

1. 多次性：无需在作业运行时一次性全部装入内存，而是允许被分成多次调入内存
2. 对换性：在作业运行时无需一直驻留内存，而是允许作业在运行过程中，被换入或换出
3. 虚拟性：从逻辑上扩充了内存的大小，使用户看到的内存容量远大于实际容量

请求分页管理方式

1. 由于暂时用不到的信息会留在外存，所以页表需要记录当前准备使用的页面是否在内存中，需要有标志位来识别
2. 由于需要将暂时不用的信息换出内存，操作系统需要知道通过哪些指标来换出哪些页面；有些页面没有被修改过，则不用写回外存，可以直接覆盖使用；有些页面修改过，需要写回

状态位：是否已调入内存

访问字段：记录最近被访问过几次；或最近被访问的时间。供页面置换算法参考

修改位：调入内存后是否被修改

外存地址：页面在外存中的存放位置

缺页中断机制

当需要访问的页面不在内存时，产生一个缺页中断，然后由操作系统的缺页中断处理程序处理中断

此时缺页的进程阻塞，放入阻塞队列，调页完成后再将进程唤醒，放回就绪队列

• 如果内存中有空闲块，为进程分配一个空闲块，将所缺页面装入该块，并修改页表中相应的页表项
• 如果内存中没有空闲块，由页面置换算法选择一个页面淘汰，如果被淘汰的页面在内存中修改过，则需要写回外存，未修改的页面不需要写回外存

地址变换机构

补充：

1. 只有写指令才需要修改修改位。并且，一般来说只需修改快表中的数据，只有要将快表项删除时才需要写回内存中的慢表。这样可以减少访存次数
2. 和普通的中断处理一样，缺页中断处理依然需要保留 CPU 现场
3. 需要用某种页面置换算法来决定一个换出页面
4. 换入/换出页面都需要启动慢速的 I/O 操作，可见，如果换入/换出太频繁，会有很大的开销
5. 页面调入内存后，需要修改慢表，同时也需要将表项复制到快表中；所以在快表中出现的页一定在内存中

页面置换算法

缺页时未必发生页面置换，如果还有可用的空闲内存块，就不用进行页面置换

缺页率 = 缺页次数 / 页面访问次数

最佳置换算法（OPT）

每次选择淘汰的页面将是以后永不使用，或者在最长的时间内不再被访问的页面，这样可以保证最低的缺页率

最佳置换算法可以保证最低的缺页率，但实际上，只有在进程执行的过程中才能知道接下来会访问到的是哪个页面。操作系统无法提前预判页面访问序列。因此，最佳置换算法是无法实现的

先进先出置换算法（FIFO）

每次选择淘汰的页面是最早进入内存的页面

实现方法：把调入内存的页面根据调入的先后顺序排成一个队列，需要换出页面时选择对头页面即可，队列的最大长度取决于系统为进程分配了多少个内存块

最近最久未使用置换算法（LRU）

每次淘汰的页面是最近最久未使用的页面，需要专门的硬件支持，虽然算法性能好，但是实现困难，开销大

实现方法：赋予每个页面对应的页表项中，用访间字段记录该页面自上次被访问以来所经历的时间 t。当需要淘汰一个页面时，选择现有页面中 t 值最大的，即最近最久未使用的页面。

时钟置换算法（CLOCK）

简单的 CLOCK 算法实现方法：为每个页面设置一个访问位，再将内存中的页面都通过链接指针链接成一个循环队列。当某页被访问时，其访问位置为 1；当需要淘汰一个页面时，只需检查页的访问位。如果是 0，就选择该页换出；如果是 1，则将它置为 0，暂不换出，继续检查下一个页面，若第一轮扫描中所有页面都是 1，则将这些页面的访问位依次置为 0 后，再进行第二轮扫描（第二轮扫描中一定会有访问位为 0 的页面，因此简单的 CLOCK 算法选择一个淘汰页面最多会经过两轮扫描）

改进型的时钟置换算法

简单的时钟置换算法仅考虑到一个页面最近是否被访问过。事实上，如果被淘汰的页面没有被修改过，就不需要执行 I/O 操作写回外存。只有被淘汰的页面被修改过时，才需要写回外存
因此，除了考虑一个页面最近有没有被访问过之外，操作系统还应考虑页面有没有被修改过。在其他条件都相同时，应优先淘汰没有修改过的页面，避免 I/O 操作。这就是改进型的时钟置换算法的思想

修改位为 0，表示页面没有被修改过；修改位为 1， 表示页面被修改过

为方便讨论，用（访问位，修改位）的形式表示各页面状态。如（1, 1）表示一个页面近期被访问过，且被修改过

算法规则：将所有可能被置换的页面排成一个循环队列

1. 从当前位置开始扫描到第一个（0，0）的帧用于替换。本轮扫描不修改任何标志位

   第一优先级：最近没访问且没修改的页面

2. 若第一轮扫描失败，则重新扫描，查找第一个（0，1）的帧用于替换。本轮将所有扫描过的帧访问位设为 0

   第二优先级：最近没访问但修改过的页面

3. 若第二轮扫描失败，则重新扫描，查找第一个（0，0） 的帧用于替换。本轮扫描不修改任何标志位

   第三优先级：最近访问过但没修改的页面

4. 若第三轮扫描失败，则重新扫描，查找第一个（0，1）的帧用于替换

   第四优先级：最近访问过且没修改过的页面

由于第二轮已将所有帧的访问位设为 0，因此经过第三轮、第四轮扫描一定会有一个帧被选中，因此改进型 CLOCK 置换算法选择一个淘汰页面最多会进行四轮扫描

页面分配策略

驻留集

指请求分页存储管理中给进程分配的物理块的集合，在采用了虚拟存储技术的系统中，驻留集大小一般小于进程的总大小

例子：考虑一个极端情况，若某进程共有 100 个页面，则该进程的驻留集大小为 100 时进程可以全部放入内存，运行期间不可能再发生缺页。若驻留集大小为 1，则进程运行期间必定会极频繁地缺页

若驻留集太小，会导致缺页频繁，系统要花大量的时间来处理缺页，实际用于进程推进的时间很少；驻留集太大，又会导致多道程序并发度下降，资源利用率降低。所以应该选择一个合适的驻留集大小

页面分配、置换策略

固定分配：操作系统为每个进程分配一组固定数目的物理块，在进程运行期间不再改变。即，驻留集大小不变

可变分配：先为每个进程分配一定数目的物理块，在进程运行期间，可根据情况做适当的增加或减少。即，驻留集大小可变

局部置换：发生缺页时只能选进程自己的物理块进行置换

全局置换：可以将操作系统保留的空闲物理块分配给缺页进程，也可以将别的进程持有的物理块置换到外存，再分配给缺页进程

固定分配局部置换：系统为每个进程分配一定数量的物理块，在整个运行期间都不改变。若进程在运行中发生缺页，则只能从该进程在内存中的页面中选出一页换出，然后再调入需要的页面。

这种策略的缺点是：很难在刚开始就确定应为每个进程分配多少个物理块才算合理。( 采用这种策略的系统可以根据进程大小、优先级、或是根据程序员给出的参数来确定为一个进程分配的内存块数）

可变分配全局置换：刚开始会为每个进程分配一定数量的物理块。操作系统会保持一个空闲物理块队列。当某进程发生缺页时，从空闲物理块中取出一块分配给该进程；若已无空闲物理块，则可选择一个未锁定的页面换出外存，再将该物理块分配给缺页的进程。

采用这种策略时，只要某进程发生缺页，都将获得新的物理块，仅当空闲物理块用完时，系统才选择一个未锁定的页面调出。被选择调出的页可能是系统中任何一个进程中的页，因此这个被选中的进程拥有的物理块会减少，缺页率会增加

可变分配局部置换：刚开始会为每个进程分配一定数量的物理块。当某进程发生缺页时，只允许从该进程自己的物理块中选出一个进行换出外存。

如果进程在运行中频繁地缺页，系统会为该进程多分配几个物理块，直至该进程缺页率趋势适当程度；反之，如果进程在运行中缺页率特别低，则可适当减少分配给该进程的物理块

可变分配 全局 置换：只要缺页就给分配新物理块
可变分配 局部 置换：要根据发生缺页的频率来动态地增加或减少进程的物理块

一些问题

何时调入页面？

1. 预调页策略：根据局部性原理，一次调入若干个相邻的页面可能比一次调入一个页面更高效。但如果提前调入的页面中大多数都没被访问过，则又是低效的。因此可以预测不久之后可能访问到的页面，将它们预先调入内存，但目前预测成功率只有 50% 左右。故这种策略主要用于进程的首次调入，由程序员指出应该先调入哪些部分

   即运行前调入

2. 请求调页策略：进程在运行期间发现缺页时才将所缺页面调入内存。由这种策略调入的页面一定会被访问到，但由于每次只能调入一页，而每次调页都要磁盘 I/O 操作，因此 I/O 开销较大

   即运行时调入

何处调入页面？

1. 系统拥有足够的对换区空间：页面的调入、调出都是在内存与对换区之间进行，这样可以保证页面的调入、调出速度很快（因为对换区是连续分配方式）。在进程运行前，需将进程相关的数据从文件区复制到对换区
2. 系统缺少足够的对换区空间：凡是不会被修改的数据都直接从文件区调入，由于这些页面不会被修改，因此换出时不必写回磁盘，下次需要时再从文件区调入即可。对于可能被修改的部分，换出时需写回磁盘对换区，下次需要时再从对换区调入
3. UNIX 方式：运行之前进程有关的数据全部放在文件区，故未使用过的页面，都可从文件区调入。若被使用过的页面需要换出，则写回对换区，下次需要时从对换区调入

抖动（颠簸）现象

1. 刚刚换出的页面马上又要换入内存，刚刚换入的页面马上又要换出外存，这种频繁的页面调度行为称为抖动，或颠簸。产生抖动的主要原因是进程频繁访问的页面数目高于可用的物理块数（分配给进程的物理块不够）
2. 为进程分配的物理块太少，会使进程发生抖动现象。为进程分配的物理块太多，又会降低系统整体的并发度，降低某些资源的利用率

线程使用

线程模型

详情见【OS】进程与线程 | xStack 线程模型相关内容

Linux 线程库

Linux 上默认是 NPTL（Native POSIX Thread Library），查询相关信息

1
2
3
4
5
6

~ » neofetch
OS: Arch Linux on Windows 10 x86_64
Kernel: Linux 5.10.43.3-microsoft-standard-WSL2

~ » getconf GNU_LIBPTHREAD_VERSION
NPTL 2.33

创建与结束

1
2
3
4
5
6

#include <pthread.h>
int pthread_create(pthread_t* thread, const pthread_attr_t* attr, void* (*start_routine)(void*),
                   void* arg);

#include <bits/pthreadtypes.h>
typedef unsigned long int pthread_t;

thread：新线程的标识符

attr：设置线程属性，NULL表示默认属性

start_routine：线程将要执行的函数

art：线程执行函数的参数列表

成功时返回 0，失败时返回错误码

通过输出以下信息可以查询 Linux 中所有用户能创建的线程总数，当前机器最多创建 101244 个线程

1
2
3
4
5
6

~ » neofetch
OS: Arch Linux on Windows 10 x86_64
Kernel: Linux 5.10.43.3-microsoft-standard-WSL2

~ » cat /proc/sys/kernel/threads-max
101244

线程被创建好后，内核调度内核线程来执行start_routine函数指针所指向的工作函数。完成工作后调用退出函数

1
2

#include <pthread.h>
void pthread_exit(void* retval);

retval：通过此参数向线程回收者返回退出信息

1
2

#include <pthread.h>
int pthread_join(pthread_t thread, void** retval);

thread：线程标识符

retval：目标线程返回的退出信息

执行pthread_join()会一直阻塞，直到被回收的线程结束，成功时返回 0，失败返回错误码

1
2

#include <pthread.h>
int pthread_cancel(pthread_t thread);

thread：线程标识符

此函数异常终止一个线程，成功时返回 0，失败返回错误码。被终止的目标线程可以通过以下函数自主决定是否可以被取消以及取消方式

1
2
3

#include <pthread.h>
int pthread_setcancelstate(int state, int* oldstate);
int pthread_setcanceltype(int type, int* oldtype);

是否可以取消：state

PTHREAD_CANCEL_ENABLE：可以取消，创建线程时的默认状态

PTHREAD_CANCEL_DISABLE：不可取消

线程原来的取消状态：oldstate

取消方式：type

PTHREAD_CANCEL_ASYNCHRONOUS：线程可以随时取消，接收取消请求时立即行动

PTHREAD_CANCEL_DEFERRED：可以推迟取消，直到调用取消点函数

例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>

void*
thread(void* ptr)
{
  for (int i = 0; i < 3; i++) {
    sleep(1);
    printf("This is a pthread.\n");
  }

  pthread_exit(0);

  return 0;
}

int
main()
{
  pthread_t id;
  if (pthread_create(&id, NULL, thread, NULL)) {
    printf("Create pthread error!\n");
    return 1;
  }

  for (int i = 0; i < 3; i++) {
    printf("This is the main process.\n");
    sleep(1);
  }

  pthread_join(id, NULL);

  return 0;
}

线程同步

POSIX 信号量

1
2
3
4
5
6

#include <semaphore.h>
int sem_init(sem_t* sem, int pshared, unsigned int value);
int sem_destroy(sem_t* sem);
int sem_wait(sem_t* sem);
int sem_trywait(sem_t* sem);
int sem_post(sem_t* sem);

sem：被操作的信号量

pshared：取值为 0 表示为当前进程的局部信号量，否则可以在多个进程间共享

value：指定信号量初始值，0 或者更多

sem_init()用于初始化一个未命名的信号量

sem_destroy()用于销毁信号量

sem_wait()用于将信号量-1（原子操作），即 P 操作；当信号量为 0 时，阻塞

sem_trywait()用于非阻塞的 P 操作；当信号量为 0 时返回-1 并设置 errno

sem_post()用于将信号量 +1（原子操作），即 V 操作；当信号量大于 0 时，将唤醒其他等待该信号量的阻塞进程

以上成功时返回 0，失败返回-1 并设置 errno

互斥锁

1
2
3
4
5
6

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t* mutex, const pthread_mutexattr_t* mutexattr);
int pthread_mutex_destroy(pthread_mutex_t* mutex);
int pthread_mutex_lock(pthread_mutex_t* mutex);
int pthread_mutex_trylock(pthread_mutex_t* mutex);
int pthread_mutex_unlock(pthread_mutex_t* mutex);

mutex：被操作的互斥锁

mutexattr：初始化时互斥锁的属性；设置为NULL时使用默认属性

pthread_mutex_init()用于初始化互斥锁

pthread_mutex_destroy()用于销毁互斥锁

pthread_mutex_lock()用于加锁（原子操作）；当已上锁时阻塞

pthread_mutex_trylock()非阻塞的上锁操作；已上锁时返回错误码EBUSY

pthread_mutex_unlock()用于解锁（原子操作）；当其他线程等待这个互斥锁时将唤醒某一个线程

以上成功时返回 0，失败返回错误码

互斥锁通过pthread_mutexattr_t结构体来定义其属性，并通过函数操作来设置属性

1
2
3
4
5
6
7
8
9
10
11

#include <pthread.h>
// 初始化互斥锁对象属性
int pthread_mutexattr_init(pthread_mutexattr_t* attr);
// 销毁互斥锁对象属性
int pthread_mutexattr_destroy(pthread_mutexattr_t* attr);
// 获取和设置互斥锁的pshared属性
int pthread_mutexattr_getpshared(const pthread_mutexattr_t* attr, int* pshared);
int pthread_mutexattr_setpshared(pthread_mutexattr_t* attr, int pshared);
// 获取和设置互斥锁的type属性
int pthread_mutexattr_gettype(const pthread_mutexattr_t* attr, int* type);
int pthread_mutexattr_settype(pthread_mutexattr_t* attr, int type);

是否允许跨进程共享互斥锁：pshared

PTHREAD_PROCESS_SHARED：互斥锁可以跨进程共享

PTHREAD_PROCESS_PRIVATE：现有一线程用来初始化互斥锁，与此线程隶属于同一个进程的其他线程可以共享互斥锁，即不可以跨进程共享

指定互斥锁的类型：type

PTHREAD_MUTEX_NORMAL：普通锁，默认类型；请求锁的线程形成顺序等待队列；对已经加锁的锁再次加锁，将死锁；对已经解锁的锁再次解锁，将导致不可预知的错误

PTHREAD_MUTEX_ERRORCHECK：检错锁；对已经加锁的锁再次加锁，返回错误码EDEADLK；对已经解锁的锁再次解锁，返回错误码EPERM

PTHREAD_MUTEX_RECURSIVE：嵌套锁；对一个锁可以多次加锁，相应的解锁时也需要多次解锁

PTHREAD_MUTEX_DEFAULT：默认锁

条件变量

1
2
3
4
5
6

#include <pthread.h>
int pthread_cond_init(pthread_cond_t* cond, const pthread_condattr_t* cond_attr);
int pthread_cond_destroy(pthread_cond_t* cond);
int pthread_cond_broadcast(pthread_cond_t* cond);
int pthread_cond_signal(pthread_cond_t* cond);
int pthread_cond_wait(pthread_cond_t* cond, pthread_mutex_t* mutex);

cond：被操作的条件变量

cond_attr：初始化时条件变量的属性；设置为NULL时使用默认属性

pthread_cond_init()用于初始化条件变量

pthread_cond_destroy()用于销毁条件变量

pthread_cond_broadcast()用于以广播方式唤醒所有等待条件变量的线程

pthread_cond_signal()用于唤醒一个等待条件变量的线程

pthread_cond_wait()用于等待条件变量；使用前需要以mutex加锁以保证原子性

以上成功时返回 0，失败返回错误码

僵尸进程

僵尸态：子进程结束运行后，内核没有立即释放该进程的进程表表项，用以满足父进程后续对子进程退出信息的查询

在子进程结束之后、父进程读取退出状态之前（父进程正常运行），称之为僵尸态；父进程退出之后（下文）、子进程退出之前，称之为僵尸态

父进程结束或异常终止，子进程仍在运行时，改变其 PPID 为 1（init 进程），由 init 进程等待子进程结束

一般通过wait()和waitpid()处理僵尸进程

1
2
3
4

#include <sys/types.h>
#include <sys/wait.h>
pid_t wait(int* stat_loc);
pid_t waitpid(pid_t pid, int* stat_loc, int options);

wait()将父进程阻塞，直到任意一个子进程结束运行。返回结束运行的子进程的 PID，并保存退出状态信息到参数stat_loc指向的内存中

waitpid()通过参数pid指定等待的子进程，取值为-1 则表示如同wait()一样等待任意子进程结束；参数stat_loc保存退出状态信息；参数options指定控制行为，一般取值为WNOANG，表示非阻塞调用

相关参考

进程间通信

管道

父子进程通过管道传递数据，且管道只能用于有关联的两个进程之间。本质上是pipe()通过管道文件描述符fd[1]向内核缓冲区写入数据，fd[0]从内核缓冲区读出数据，为半双工方式。缓冲区大小有限，写满或者读空时，需要等待读出或者写入

管道容量的默认大小是 65536B，可以通过fcntl()修改容量

1
2

#include <unistd.h>
int pipe(int fd[2]);

通过构建两个管道实现双向通信；或者通过 socket 编程提供的sockpair()

1
2
3

#include <sys/types.h>
#include <sys/socket.h>
int socketpair(int domain, int type, int protocol, int fd[2]);

前三个参数与socket()的参数含义一致，但domain只能使用 UNIX 本地域协议族AF_UNIX；文件描述符fd是既可读又可写的

有名管道

保存在文件系统中

1
2
3

# mkfifo myPipe
# ls -l myPipe
prw-r--r--  1 z z    0  5月 23 12:17 myPipe

信号量

用户进程通过使用 OS 提供的一对原语来对信号量进行操作，实现进程同步与互斥

原语：一种特殊的程序段，执行时不可被中断，由关/开中断指令实现

一对原语：

1. wait(S)原语，可以理解为函数，信号量 S 是调入的参数，可以写作 P(S)，相当于进入临界区
2. signal(S)原语，可以写作 V(S)，相当于退出临界区

信号量可以看作变量（整数或者复杂的记录型变量），可以用信号量来表示系统中某种资源的数量，例如一台打印机的信号量初值为 1

可以看作一种计数器，用来为多个进程提供对共享数据对象的访问

❗ 通过semget()将某个信号量生成信号量标识符，通过semop()执行 P、V 操作，通过semctl()控制信号量的某些属性

semget()创建一个新的信号量集，或获得一个已存在的信号量集

1
2

#include <sys/sem.h>
int semget(key_t key, int num_sems, int sem_flags);

成功时返回一个正整数值，作为信号量集的标识符；错误时返回-1 并设置 errno

key：用来标识一个全局唯一的信号量集，它代表程序可能使用的某个资源，通过信号量通信的进程使用相同的key来 | 创建 | 获取 | 该信号量。通过semget()和key，由系统生成一个信号量标识符，程序通过信号量标识符来使用信号量

num_sems：指定要 | 创建 | 获取 | 的信号量集中信号量的数目。如果是创建信号量，则该值必须被指定，一般都是 1；如果是获取已经存在的信号量，则可以把它设置为 0

sem_flags：指定一组标志。作为参数的信号量不存在时，想要创建一个新的信号量，可以将sem_flags和值IPC_CREAT按位或操作；而IPC_CREAT | IPC_EXCL可以创建一个新的、唯一的信号量，如果信号量已存在，报错

下图为sem_flags可以的取值，一般直接设置为0666

例：

1
2

// 创建信号量
int sem_id = semget((key_t)1234, 1, 0666|IPC_CREAT);

semctl()控制信号量信息

1
2

#include <sys/sem.h>
int semctl(int sem_id, int sem_num, int command, ...);

sem_id：表示semget()返回的信号量集的标识符

sem_num：表示信号量集中信号量的编号，0 为第一个。一般来说都设置为 0

command：表示要执行的命令，第三个参数取值SETVAL（把信号量初始化为一个已知的值）或IPC_RMID（删除一个已经无需继续使用的信号量标识符）；第四个参数通常是一个union semum结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

union semun {
    int val;
    struct semid_ds* buf;
    unsigned short* array;
    struct seminfo* __buf;
};

struct seminfo {
    int semmap;
    int semmni;
    int semmns;
    int semmnu;
    int semmsl;
    int semopm;
    int semume;
    int semusz;
    int semvmx;
    int semasm;
};

一般需要利用semctl()初始化信号量，这是使用前必须做的

例：

1
2
3
4
5
6
7
8

// 创建信号量
int sem_id = semget((key_t)1234, 1, 0666|IPC_CREAT);

union semmun sem_union;
sem_union.val = 1;
if(semctl(sem_id, 0, SETVAL, sem_union) == -1) {
    return -1; // 初始化失败
}

semop()改变信号量的值，即 P、V 操作，实际上是对内核变量的操作

1
2

#include <sys/sem.h>
int semop(int sem_id, struct sembuf* sem_ops, size_t num_sem_ops);

sem_id：semget()返回的信号量集的标识符

sem_ops：指向sembuf结构体数组

1
2
3
4
5

struct sembuf {
    unsigned short int sem_num;
    short int sem_op;// 操作类型
    short int sem_flg;// IPC_NOWAIT 或 SEM_UNDO
};

sem_num：表示信号量集中信号量的编号，0 为第一个。一般来说，传入的单个信号量，此时设置为 0；如果使用信号量集，根据编号设置

sem_op：表示操作类型。一般用1表示 V 操作（即退出临界区）；用-1表示 P 操作（即进入临界区）

sem_flg：IPC_NOWAIT或SEM_UNDO。IPC_NOWAIT表示无论调用是否成功，立刻返回，类似于非阻塞 I/O；SEM_UNDO表示操作系统跟踪信号，进程未释放信号量而终止时，操作系统释放信号量

num_sem_ops：sem_ops中信号量的个数

例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// 创建信号量
int sem_id = semget((key_t)1234, 1, 0666|IPC_CREAT);

union semmun sem_union;
sem_union.val = 1;
if(semctl(sem_id, 0, SETVAL, sem_union) == -1) {
    return -1; // 初始化信号量失败
}

struct sembuf sem_b;
sem_b.sem_num = 0;
sem_b.sem_op = -1;// 此时表示P操作
sem_b.sem_flg = SEM_UNDO;
if(semop(sem_id, &sem_b, 1) == 1) {
    // 执行P操作，进入临界区
    // 在临界区中执行操作
}

// 准备退出临界区
sem_b.sem_op = 1; // 此时表示V操作
if(semop(sem_id, &sem_b, 1) != 1) {
    // 执行V操作，退出临界区
    printf("退出临界区失败");
    return -1;
}

if(semctl(sem_id, 0, IPC_RMID, sem_union) == -1) {
    return -1;// 删除信号量失败
}

共享内存

在通信进程的虚拟内存空间中，拿出一块虚拟地址空间，映射到相同的物理内存中

• 一般利用 | 信号量 | 记录锁 | 互斥量 | 来同步访问共享内存

❗ 通过shmget()申请一段新的共享内存，通过shmat()关联，shmdt分离；shmctl()控制共享内存的某些属性

shmget()创建一个新的共享内存，或获得一个已存在的共享内存

1
2

#include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg);

成功时返回一个正整数值，作为共享内存的标识符；错误时返回-1 并设置 errno

key：用来标识一个全局唯一的共享内存，通过shmget()和key，由系统生成一个共享内存标识符，程序通过共享内存标识符来使用共享内存

size：以 B 为单位指定需要共享的内存容量

shmflg：与信号量中semget()中的参数semflg类似，也是可以利用IPC_CREAT做按位或操作

例：

1
2
3

// 创建共享内存记录结构体shared_test
struct shared_test* ptr;
int sem_id = shmget((key_t)1234, sizeof(shared_test), 0666|IPC_CREAT);

shmat()在进程中关联新创建的共享内存；shmdt()在进程中分离共享内存

1
2
3

#include <sys/shm.h>
void* shmat(int shm_id, const void* shm_addr, int shmflg);
int shmdt(const void* shm_addr);

shm_id：shmget()中返回的共享内存标识符

shm_addr：指定共享内存关联到当前进程的地址，一般设置为 0，表示由系统决定

shmflg：一组标志位，一般设置为 0，配合shm_addr设置为 0，来由系统决定关联地址

shmat()返回指向共享内存所关联的地址的指针；失败返回-1。类似于malloc()申请动态内存

shmdt()由关联动态内存的指针，在本进程中分离动态内存（只是本进程不能使用，并不是删除动态内存）

例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// 创建共享内存记录结构体shared_test
struct shared_test* ptr;
int sem_id = shmget((key_t)1234, sizeof(shared_test), 0666|IPC_CREAT);

void* shm_ptr = shmat(shm_id, 0, 0);// 系统决定关联地址
if(shm_ptr == (void*)-1) {
    return -1;
}
ptr = (struct shared_test*)shm_ptr;
// 针对内存的读写操作
// 其他进程也是如此
if(shmdt(ptr) == -1) {
    return -1;// 分离共享内存失败
}

shmctl()控制共享内存的属性

1
2

#include <sys/shm.h>
int shmctl(int shm_id, int command, struct shmid_ds* buf);

shm_id：shmget()中返回的共享内存标识符

command：表示要执行的命令

IPC_STAT：复制共享内存的当前关联值到shmid_ds中

IPC_SET：当进程拥有权限时，设置shmid_ds中的属性到共享内存的关联值中

IPC_RMID：删除当前共享内存

buf：指向用于复制或更改属性的shmid_ds

例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// 创建共享内存记录结构体shared_test
struct shared_test* ptr;
int sem_id = shmget((key_t)1234, sizeof(shared_test), 0666|IPC_CREAT);

void* shm_ptr = shmat(shm_id, 0, 0);// 系统决定关联地址
if(shm_ptr == (void*)-1) {
    return -1;
}
ptr = (struct shared_test*)shm_ptr;
// 针对内存的读写操作
// 其他进程也是如此
if(shmdt(ptr) == -1) {
    return -1;// 分离共享内存失败
}

if(shmctl(shm_id, IPC_RMID, 0) == -1) {
    return -1;// 删除共享内存失败
}

❗：一般在操作共享内存时，可以搭配信号量实现读写的互斥访问；但是有的程序可以放弃使用信号量，让多个进程同时进行读操作，提高效率，这就是进程同步问题的读者-写者问题

消息队列

直接通信方式：发送进程利用发送原语将消息直接发送到接收进程的消息缓冲队列，由接收进程利用接收原语接收消息

间接通信方式：发送进程利用发送原语将消息发送到中间实体（信箱），接收进程利用接收原语将信箱中属于自己的消息接收；消息的消息头中包含了发送和接收进程的 ID 等内容，不用担心接收错误

• 消息队列可以独立于发送进程和接收进程而存在
• 接收程序可以选择接收消息队列中的特定类型的信息

❗ 通过msgget()创建一个消息队列；利用msgsnd()挂载消息到队列上，利用smgrcv()从队列上摘取消息；msgctl()控制消息队列的某些属性

msgget()创建一个消息队列，或者获取一个已有的消息队列

1
2

#include <sys/msg.h>
int msgget(key_t key, int msgflg);

成功时返回一个正整数值，作为消息队列的标识符；错误时返回-1 并设置 errno

key：用来标识一个全局唯一的消息队列，通过msgget()和key，由系统生成一个消息队列标识符，程序通过消息队列标识符来使用消息队列

msgflg：与信号量中semget()中的参数semflg类似，也是可以利用IPC_CREAT做按位或操作；当消息队列存在时，IPC_CREAT被忽略，返回标识符

例：

1
2

// 创建消息队列
int msg_id = msgget((key_t)1234, 0666|IPC_CREAT);

msgsnd()挂载消息到队列上，smgrcv()从队列上摘取消息

1
2
3
4
5
6
7
8
9

#include <sys/msg.h>
int msgsnd(int msg_id, const void* msg_ptr, size_t msg_sz, int msgflg);
int msgrcv(int msg_id, const void* msg_ptr, size_t msg_sz, long int msgtype,
           int msgflg);

struct msgbuf {
    long mtype;// 消息类型
    char mtext[512];// 消息数据
};

msg_id：msgget()中返回的消息队列标识符

msg_ptr：指向一个准备 | 发送 | 存储 | 的消息，消息必须被定义为msgbuf这种结构

msg_sz：表示消息数据的长度。如上所示则长度为 512；如设置为 0 则表示没有消息

msgflg：一组标志位，可以按位或

在msgsnd()中：默认为 0，消息队列满时将阻塞，直到成功；若设置为IPC_NOWAIT，表示为非阻塞方式，消息队列满时将立即返回并设置 errno

在msgrcv()中：设置为IPC_NOWAIT，表示非阻塞方式；设置为MSG_NOERROR，表示消息长度超过msg_sz时截断；设置为MSG_EXCEPT，且msgtype大于 0，表示接收消息队列中第一个非msgtype类型的消息

msgtype：指定接收何种类型的消息

等于 0：读取消息队列中的第一个消息

大于 0：读取消息队列中第一个类型为msgtype类型的消息（msgflg指定了MSG_EXECPT的情况下则不同）

小于 0：读取消息队列中第一个类型值比msgtype小的消息

两个系统调用成功时返回 0；失败则返回-1 并设置 errno

例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

struct msgbuf {
    long mtype;
    char mtext[512];
};

// 创建消息队列
int msg_id = msgget((key_t)1234, 0666|IPC_CREAT);

char* buffer = "Hello world";
struct msgbuf data;
data.mtype = 1;
strncpy(&data.mtext, buffer, strlen(buffer)+1);

if(msgsnd(msg_id, (void*)&data, 512, 0) == -1) {
    // 阻塞方式发送信息
    return -1;// 发送消息失败
}

if(msgrcv(msg_id,(void*)&data, 512, 0, 0) == -1) {
    // 接收消息队列中的第一个消息
    return -1; // 接收消息失败
}

msgctl()控制消息队列的某些属性

1
2

#include <sys/msg.h>
int msgctl(int msg_id, int command, struct msgid_ds* buf);

msg_id：msgget()中返回的消息队列标识符

command：表示要执行的命令

IPC_STAT：复制消息队列的当前关联值到msgid_ds中

IPC_SET：当进程拥有权限时，设置msgid_ds中的属性到消息队列的关联值中

IPC_RMID：删除当前消息队列

buf：指向用于复制或更改属性的msgid_ds

例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

struct msgbuf {
    long mtype;
    char mtext[512];
};

// 创建消息队列
int msg_id = msgget((key_t)1234, 0666|IPC_CREAT);

char* buffer = "Hello world";
struct msgbuf data;
data.mtype = 0;
strncpy(&data.mtext, buffer, strlen(buffer)+1);

if(msgsnd(msg_id, (void*)&data, 512, 0) == -1) { // 阻塞方式发送信息
    return -1;// 发送消息失败
}

if(msgrcv(msg_id,(void*)&data, 512, 0, 0) == -1) {
    return -1; // 接收消息失败
}

if(msgctl(msg_id, IPC_RMID, 0) == -1){
    return -1; // 删除消息队列失败
}

在进程间传递文件描述符

父进程打开的文件，通过fork()后将文件描述符复制到子进程中，但是子进程传递到父进程则不行

要点在于，传递文件描述符，并不是简单的将文件描述符的值复制给另一个进程，而是通过文件描述符指向相同的文件。进程有file_struct中的指针数组的索引做文件描述符，应当在进程间传递这样的结构

可以通过 UNIX 域 socket 在进程间传送，参考sockpair()