我们来深入学习 setns 系统调用

1. 函数介绍

Linux 命名空间 (Namespaces) 是 Linux 内核的一个强大特性，它提供了隔离机制。通过命名空间，可以将一组进程及其资源（如网络接口、挂载点、进程 ID 等）与系统上的其他进程隔离开来，仿佛它们运行在独立的系统中一样。这是实现 容器 (Containers) 技术（如 Docker, LXC）的核心基础之一。

Linux 支持多种类型的命名空间，每种隔离不同类型的系统资源：

• Mount (mnt): 隔离文件系统挂载点。
• PID (pid): 隔离进程 ID 空间。
• Network (net): 隔离网络设备、IP 地址、端口等。
• Interprocess Communication (ipc): 隔离 System V IPC 和 POSIX 消息队列。
• UTS (uts): 隔离主机名和域名 (nodename/domainname)。
• User (user): 隔离用户和组 ID。
• Cgroup (cgroup): 隔离控制组 (cgroups) 的视图。

setns (Set Namespace) 系统调用的作用是：将调用它的进程，加入到一个已经存在的命名空间中。

想象一下，你手里有一把钥匙，这把钥匙可以打开一扇通往某个“隔离房间”的门。setns 就像是你使用这把钥匙（文件描述符）进入那个特定的“隔离房间”（命名空间）的过程。一旦进入，你就能看到并使用那个房间里的东西（资源），就像你属于那个房间一样。

简单来说，setns 让一个正在运行的进程可以“穿越”到另一个隔离的环境（命名空间）中去。

重要提示：

1. 需要权限：加入某些类型的命名空间（尤其是 User 命名空间）可能需要特殊权限或遵循复杂的规则。
2. 文件描述符：setns 不是直接通过命名空间的名字或 ID 来操作，而是通过一个指向该命名空间的文件描述符。这个文件描述符通常是通过打开 /proc/[pid]/ns/ 目录下的特殊符号链接文件获得的。
3. 部分加入：一个进程可以同时属于多个不同类型的命名空间。setns 每次只加入一个指定类型的命名空间。

2. 函数原型

// 标准 C 库通常不提供直接包装，需要通过 syscall 调用
#include <sched.h>       // 包含 CLONE_* 常量，定义了命名空间类型
#include <sys/syscall.h> // 包含系统调用号 SYS_setns
#include <unistd.h>      // 包含 syscall 函数

long syscall(SYS_setns, int fd, int nstype);

3. 功能

将调用进程加入由文件描述符 fd 指向的命名空间。如果 nstype 不为 0，还会检查该命名空间的类型是否与 nstype 指定的类型匹配。

4. 参数

• fd:
  • int 类型。
  • 一个指向命名空间的文件描述符。这个文件描述符通常是通过打开 /proc/[pid]/ns/[namespace_name] 文件（例如 /proc/self/ns/net）获得的。[pid] 可以是目标进程的 PID，也可以是 self（代表调用进程自身）。
• nstype:
  • int 类型。
  • 指定要加入的命名空间的类型。这是一个检查机制。有效的值是 <sched.h> 中定义的 CLONE_NEW* 常量，例如：
    • CLONE_NEWIPC
    • CLONE_NEWNET
    • CLONE_NEWNS (Mount)
    • CLONE_NEWPID
    • CLONE_NEWUSER
    • CLONE_NEWUTS
    • CLONE_NEWCGROUP
  • 如果 nstype 设置为 0，则不进行类型检查。

5. 返回值

• 成功: 返回 0。
• 失败: 返回 -1，并设置全局变量 errno 来指示具体的错误原因。

6. 错误码 (errno)

• EBADF: fd 不是一个有效的文件描述符。
• EINVAL: fd 是有效的，但它不指向一个命名空间文件，或者 nstype 指定的类型与文件描述符指向的命名空间类型不匹配。
• ENOMEM: 内核内存不足，无法完成操作。
• EPERM: 调用者没有权限加入该命名空间。例如，尝试加入一个 User 命名空间可能受到严格限制。

7. 相似函数或关联函数

• unshare: 允许调用进程脱离当前的某个命名空间，并加入一个新创建的、空的同类型命名空间。
• clone: 创建新进程时，可以通过传递 CLONE_NEW* 标志，使新进程在新的命名空间中启动。
• /proc/[pid]/ns/: 这个目录包含了进程所处的各种命名空间的符号链接文件。通过打开这些文件可以获得命名空间的文件描述符。
• nsenter: 命令行工具，可以在指定的命名空间中执行命令，它在底层使用了 setns。

8. 示例代码

由于命名空间涉及系统级隔离，创建和操作它们通常需要 root 权限或对 /proc 文件系统的访问。下面的示例将展示如何使用 setns 加入一个 Mount 命名空间。

警告：此示例需要 root 权限，并且会创建挂载点。请在测试环境中运行。

#define _GNU_SOURCE // 启用 GNU 扩展
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sched.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <sys/mount.h> // 包含 mount 函数
#include <sys/wait.h>  // 包含 waitpid

// 简单的子进程函数，用于在新命名空间中执行
int child_func(void* arg) {
    printf("Child process (PID: %d) started.\n", getpid());

    // 在子进程中挂载一个 tmpfs 到 /tmp/my_test_mount
    // 这个挂载操作只在子进程的 Mount Namespace 中可见
    const char* mount_point = "/tmp/my_test_mount";
    if (mkdir(mount_point, 0755) == -1 && errno != EEXIST) {
        perror("mkdir (child)");
        return 1;
    }

    if (mount("tmpfs", mount_point, "tmpfs", 0, NULL) == -1) {
        perror("mount (child)");
        return 1;
    }

    printf("Child process: Mounted tmpfs on %s\n", mount_point);

    // 在挂载点创建一个文件
    char file_path[256];
    snprintf(file_path, sizeof(file_path), "%s/test_file.txt", mount_point);
    FILE *f = fopen(file_path, "w");
    if (f) {
        fprintf(f, "Hello from child process in its own mount namespace!\n");
        fclose(f);
        printf("Child process: Created file %s\n", file_path);
    } else {
        perror("fopen (child)");
    }

    printf("Child process: Sleeping for 30 seconds. Check /tmp/my_test_mount from parent and child.\n");
    printf("Child process: You can run 'ls /tmp/my_test_mount' in another terminal as root.\n");
    sleep(30); // 睡眠，让我们有时间从外部观察

    // 清理 (可选，因为退出时会自动清理)
    // umount(mount_point);
    // rmdir(mount_point);

    printf("Child process exiting.\n");
    return 0;
}

int main() {
    pid_t child_pid;
    int parent_ns_fd, child_ns_fd;
    char ns_path[256];
    const int STACK_SIZE = 1024 * 1024; // 1MB 栈
    char *child_stack = malloc(STACK_SIZE);
    if (!child_stack) {
        perror("malloc");
        exit(EXIT_FAILURE);
    }

    printf("--- Demonstrating setns with Mount Namespace ---\n");
    printf("Main process PID: %d\n", getpid());

    // 1. 获取父进程当前的 Mount Namespace 文件描述符
    snprintf(ns_path, sizeof(ns_path), "/proc/self/ns/mnt");
    parent_ns_fd = open(ns_path, O_RDONLY);
    if (parent_ns_fd == -1) {
        perror("open parent namespace");
        free(child_stack);
        exit(EXIT_FAILURE);
    }
    printf("Opened parent's mount namespace fd: %d\n", parent_ns_fd);

    // 2. 使用 clone 创建一个新进程，并让它拥有自己的 Mount Namespace
    // CLONE_NEWNS: 创建新的 Mount Namespace
    child_pid = clone(child_func, child_stack + STACK_SIZE,
                      CLONE_NEWNS | SIGCHLD, NULL);
    if (child_pid == -1) {
        perror("clone");
        close(parent_ns_fd);
        free(child_stack);
        exit(EXIT_FAILURE);
    }
    printf("Created child process with new mount namespace. PID: %d\n", child_pid);

    // 等待一小会儿，让子进程完成挂载
    sleep(2);

    // 3. 获取子进程的 Mount Namespace 文件描述符
    snprintf(ns_path, sizeof(ns_path), "/proc/%d/ns/mnt", child_pid);
    child_ns_fd = open(ns_path, O_RDONLY);
    if (child_ns_fd == -1) {
        perror("open child namespace");
        close(parent_ns_fd);
        // 杀死子进程
        kill(child_pid, SIGKILL);
        waitpid(child_pid, NULL, 0);
        free(child_stack);
        exit(EXIT_FAILURE);
    }
    printf("Opened child's mount namespace fd: %d\n", child_ns_fd);

    // 4. 在父进程中，检查 /tmp/my_test_mount 是否存在
    // (它应该不存在，因为父进程在不同的 Mount Namespace)
    if (access("/tmp/my_test_mount", F_OK) == 0) {
         printf("Parent process: /tmp/my_test_mount EXISTS in parent namespace (unexpected!).\n");
    } else {
         printf("Parent process: /tmp/my_test_mount does NOT exist in parent namespace (as expected).\n");
    }

    // 5. 现在，使用 setns 将父进程加入到子进程的 Mount Namespace
    printf("\n--- Calling setns to join child's mount namespace ---\n");
    if (syscall(SYS_setns, child_ns_fd, CLONE_NEWNS) == -1) {
        perror("setns");
        printf("Failed to join child's namespace. Do you have root privileges?\n");
        close(parent_ns_fd);
        close(child_ns_fd);
        kill(child_pid, SIGKILL);
        waitpid(child_pid, NULL, 0);
        free(child_stack);
        exit(EXIT_FAILURE);
    }
    printf("Parent process successfully joined child's mount namespace.\n");

    // 6. 再次检查 /tmp/my_test_mount
    // (现在它应该存在了，因为父进程已经加入了子进程的命名空间)
    if (access("/tmp/my_test_mount", F_OK) == 0) {
         printf("Parent process (after setns): /tmp/my_test_mount NOW EXISTS in current namespace.\n");
         printf("Parent process (after setns): You can now see the file created by the child.\n");
         // 尝试读取子进程创建的文件
         char file_path[256];
         snprintf(file_path, sizeof(file_path), "%s/test_file.txt", "/tmp/my_test_mount");
         FILE *f = fopen(file_path, "r");
         if (f) {
             char buffer[256];
             if (fgets(buffer, sizeof(buffer), f)) {
                 printf("Parent process (after setns): Read from file: %s", buffer);
             }
             fclose(f);
         } else {
             perror("fopen (parent after setns)");
         }
    } else {
         printf("Parent process (after setns): /tmp/my_test_mount STILL does not exist (unexpected!).\n");
    }

    // 7. 清理和等待
    printf("\n--- Cleaning up ---\n");
    close(parent_ns_fd);
    close(child_ns_fd);

    // 等待子进程结束
    int status;
    waitpid(child_pid, &status, 0);
    if (WIFEXITED(status)) {
        printf("Child process exited with status %d.\n", WEXITSTATUS(status));
    } else {
        printf("Child process did not exit normally.\n");
    }

    free(child_stack);
    printf("Main process finished.\n");

    return 0;
}

使用 nsenter 命令行工具的对比示例:

nsenter 是一个非常方便的命令行工具，它封装了 setns 的功能，允许你在指定的命名空间中运行命令。

# 1. 启动一个长时间运行的进程 (例如 sleep) 并让它进入新的 PID 命名空间
# (通常与 unshare 一起使用)
unshare -p -f --mount-proc sleep 300 &
UNSHARE_PID=$!

# 等待一下让 unshare 启动
sleep 1

# 2. 查看这个新进程的 PID 命名空间 inode
ls -li /proc/1/ns/pid /proc/$UNSHARE_PID/ns/pid

# 3. 使用 nsenter 进入这个进程的 PID 和 Mount 命名空间，并运行 ps
# 这会显示在那个命名空间内部看到的进程
nsenter -t $UNSHARE_PID -p -m ps aux

# 4. 清理
kill $UNSHARE_PID

编译和运行:

# 假设代码保存在 setns_example.c 中
# 需要 root 权限来运行涉及 mount 和 setns 的操作

# 编译
gcc -o setns_example setns_example.c

# 运行 (必须使用 sudo)
sudo ./setns_example

预期输出 (片段):

--- Demonstrating setns with Mount Namespace ---
Main process PID: 12345
Opened parent's mount namespace fd: 3
Created child process with new mount namespace. PID: 12346
Child process (PID: 12346) started.
Child process: Mounted tmpfs on /tmp/my_test_mount
Child process: Created file /tmp/my_test_mount/test_file.txt
Child process: Sleeping for 30 seconds. Check /tmp/my_test_mount from parent and child.
Opened child's mount namespace fd: 4
Parent process: /tmp/my_test_mount does NOT exist in parent namespace (as expected).

--- Calling setns to join child's mount namespace ---
Parent process successfully joined child's mount namespace.
Parent process (after setns): /tmp/my_test_mount NOW EXISTS in current namespace.
Parent process (after setns): You can now see the file created by the child.
Parent process (after setns): Read from file: Hello from child process in its own mount namespace!

--- Cleaning up ---
Child process exited with status 0.
Main process finished.

总结:
setns 是一个强大的系统调用，是 Linux 容器技术的基石之一。它允许进程动态地加入到已存在的命名空间中，从而获得该命名空间的视图和资源访问权限。对于 Linux 编程新手来说，理解命名空间的概念是第一步，setns 则是实现命名空间操作的关键工具。直接使用它进行编程比较复杂，通常在容器运行时（如 runc）或高级系统管理脚本中会用到。日常开发中，使用 nsenter 或容器管理工具（如 docker exec）是更常见的与命名空间交互的方式。

 setns 系统调用及示例 – LinuxGuide setns setns,setns-系统调用及示例LinuxGuide

setns系统调用及示例-CSDN博客

awk分析Nginx日志

以下是一个基于 Nginx 访问日志的 AWK 逻辑组合实战示例，模拟实际工作中“多条件筛选异常请求并统计”的场景，包含基础逻辑组合、高级统计及输出格式化。

场景背景

假设我们有一份 Nginx 访问日志 access.log，格式如下（简化版，字段含义对应）：

$1: 客户端IP  $4: 访问时间  $6: 请求方法  $7: 请求路径  $9: 状态码  $10: 响应大小（字节）  

示例日志内容：

192.168.1.1 - - [10/Oct/2023:10:00:00 +0800] "GET /index.html HTTP/1.1" 200 1500  
10.0.0.2 - - [10/Oct/2023:10:01:30 +0800] "POST /login HTTP/1.1" 500 0  
192.168.1.3 - - [10/Oct/2023:10:02:15 +0800] "GET /api/data HTTP/1.1" 404 100  
10.0.0.2 - - [10/Oct/2023:10:03:00 +0800] "POST /login HTTP/1.1" 500 0  
192.168.1.1 - - [10/Oct/2023:10:05:00 +0800] "GET /largefile.zip HTTP/1.1" 200 10485760  

需求目标

用 AWK 逻辑组合实现：

1. 筛选两类“异常请求”：
   • 条件A：状态码为 500（服务器错误）且请求方法为 POST 的请求（可能是接口故障）。
   • 条件B：状态码为 200（正常）但响应大小 > 10MB（10485760 字节）的 GET 请求（可能是大文件滥用）。
2. 分别统计两类异常的出现次数，并按 IP 分组统计。
3. 输出格式化报告，包含总次数和 Top IP。

实现代码

#!/usr/bin/awk -f  
# 处理 Nginx 日志，筛选并统计异常请求  

# 字段对应（根据实际日志格式调整）  
# $1: IP  $6: 请求方法（如"GET"）  $9: 状态码  $10: 响应大小  

# 逻辑组合筛选异常请求，并统计  
{  
  # 条件A：500错误 + POST请求（提取方法时去除引号，如"POST→POST）  
  if ($9 == 500 && substr($6, 2, length($6)-2) == "POST") {  
    typeA_total++                     # 总次数+1  
    typeA_ip[$1]++                    # 按IP统计  
  }  
  # 条件B：200正常 + GET请求 + 响应大小>10MB（10485760字节）  
  else if ($9 == 200 && substr($6, 2, length($6)-2) == "GET" && $10 > 10485760) {  
    typeB_total++                     # 总次数+1  
    typeB_ip[$1]++                    # 按IP统计  
  }  
}  

# 输出报告（END块汇总结果）  
END {  
  print "===== 异常请求统计报告 ====="  
  # 输出类型A统计  
  print "\n1. 服务器错误（500+POST）："  
  print "   总次数：", typeA_total  
  print "   主要IP分布："  
  for (ip in typeA_ip) {  
    printf "      %-15s 出现 %d 次\n", ip, typeA_ip[ip]  
  }  

  # 输出类型B统计  
  print "\n2. 大文件请求（200+GET+>10MB）："  
  print "   总次数：", typeB_total  
  print "   主要IP分布："  
  for (ip in typeB_ip) {  
    printf "      %-15s 出现 %d 次\n", ip, typeB_ip[ip]  
  }  
}  

执行与输出

1. 保存脚本为 log_analysis.awk，添加执行权限：chmod +x log_analysis.awk
2. 执行：./log_analysis.awk access.log
3. 输出结果：

===== 异常请求统计报告 =====  

1. 服务器错误（500+POST）：  
   总次数： 2  
   主要IP分布：  
      10.0.0.2        出现 2 次  

2. 大文件请求（200+GET+>10MB）：  
   总次数： 1  
   主要IP分布：  
      192.168.1.1     出现 1 次  

逻辑组合解析

1. 多条件“与”组合：
   • 条件A用 $9 == 500 && 方法==POST，确保同时满足“状态码500”和“POST请求”。
   • 条件B用 $9 == 200 && 方法==GET && 大小>10MB，三重条件筛选大文件请求。
2. 字符串处理与逻辑结合：
   • 用 substr($6, 2, length($6)-2) 提取请求方法（去除日志中方法外的引号，如 "POST→POST），避免因引号导致匹配失败。
3. 分支逻辑（if-else）：
   • 用 else if 区分两类异常，避免重复统计（同一行不会同时属于A和B）。
4. 数组统计：
   • 用关联数组 typeA_ip[$1]++ 按IP分组，实现“多维度统计”（既算总数，又看IP分布）。

实际价值

此示例可直接用于生产环境的日志监控：

• 快速定位接口故障（500+POST）的频发IP，排查是否为恶意请求；
• 识别大文件滥用（200+GET+大尺寸）的IP，限制其带宽或访问权限；
• 通过逻辑组合灵活扩展规则（如添加时间范围 $4 ~ /10:00:00/ 筛选特定时段异常）。

awk逻辑组合专题：从基础到实战

一、专题提纲

AWK 逻辑组合专题：从基础到实战

一、专题提纲

1. 什么是 AWK 逻辑组合？
2. 基础逻辑运算符与优先级
3. 模式（Pattern）的逻辑组合方式
4. 高级逻辑组合技巧
5. 典型工作场景实战

二、核心知识点（基础篇）

1. 逻辑组合的本质

AWK 的逻辑组合是通过运算符将多个条件（模式）关联，实现“多条件筛选”或“分支处理”。核心目标：精准定位需要处理的行，并按规则执行对应动作。

2. 基础逻辑运算符

3. 模式组合的 3 种基础方式

（1）单个模式块内的多条件组合（同一动作）

用逻辑运算符将多个条件写在同一个模式中，匹配后执行同一动作。

# 示例：筛选“年龄>20 且 性别为male”的行，打印姓名  
awk '$2 > 20 && $3 == "male" {print $1}' student.txt  

（2）多个模式块（不同条件对应不同动作）

对不同条件设置独立的 模式 {动作} 块，各自匹配并执行对应操作（类似 if-else if）。

# 示例：按分数区间输出评价  
awk '
  $2 >= 90 {print $1, "→ 优秀"}      # 条件1：90分以上  
  $2 >= 60 && $2 < 90 {print $1, "→ 及格"}  # 条件2：60-89分  
  $2 < 60 {print $1, "→ 不及格"}     # 条件3：60分以下  
' scores.txt  

（3）范围模式（连续区间匹配）

用 , 分隔两个模式，表示“从第一个模式成立的行开始，到第二个模式成立的行结束”的所有行（包含边界）。

# 示例：提取日志中“[START]”到“[END]”之间的所有行  
awk '/\[START\]/, /\[END\]/ {print}' app.log  

4. 优先级与括号的重要性

• 优先级顺序：!（非） > &&（与） > ||（或）。
• 复杂逻辑必须用 () 明确分组，避免歧义。# 错误写法（&& 优先级高于 ||，实际等价于 $1=="a" || ($2=="b" && $3>100)） awk '$1 == "a" || $2 == "b" && $3 > 100 {print}' data.txt # 正确写法（用括号明确“a或b”的组合） awk '($1 == "a" || $2 == "b") && $3 > 100 {print}' data.txt

三、高级应用技巧

1. 逻辑与正则的混合组合

将逻辑运算符与正则表达式结合，实现更灵活的匹配。

# 示例：筛选“包含error且来自192.168网段，或包含warn且状态码为500”的日志行  
awk '(/error/ && $1 ~ /^192\.168\./) || (/warn/ && $9 == 500) {print}' access.log  

（~ 表示“匹配正则”，$1 ~ /^192\.168\./ 即第1字段为192.168网段IP）

2. 条件嵌套（动作块内的逻辑组合）

在动作块（{}）中用 if-else 嵌套逻辑，实现“先筛选行，再细分处理”。

# 示例：先筛选分数>80的行，再按科目细分统计  
awk '$3 > 80 {  # 外层：只处理分数>80的行  
  if ($2 == "math") math++;    # 内层：按科目累加  
  else if ($2 == "english") english++;  
}' scores.txt  
END {print "数学优秀:", math; print "英语优秀:", english}  

3. 短路求值与效率优化

AWK 支持逻辑运算的“短路特性”：

• A && B：若 A 为假，直接跳过 B（无需计算）。
• A || B：若 A 为真，直接跳过 B（无需计算）。
  可利用此特性优化复杂逻辑的执行效率。

# 示例：先判断行是否包含“POST”请求（快速筛选），再判断状态码（复杂判断）  
awk '/POST/ && $9 == 500 {print "POST请求500错误:", $7}' access.log  

4. 结合数组的多条件统计

用逻辑组合定义数组的键，实现按“多维度条件”统计。

# 示例：统计“不同IP+不同状态码”的出现次数  
awk '{  
  # 键为“IP:状态码”，仅统计GET请求且状态码非200的记录  
  if ($6 == "\"GET" && $9 != 200) {  
    key = $1 ":" $9;  
    count[key]++  
  }  
} END {for (k in count) print k, count[k]}' access.log  

四、典型工作场景实战

1. 日志分析：错误分类与统计

场景：从 Nginx 日志中统计“404错误（来自移动端）”和“500错误（来自PC端）”的数量。

# Nginx日志格式（简化）：$1=IP，$12=设备类型，$9=状态码  
awk '  
  # 条件1：404错误且设备为移动端  
  $9 == 404 && $12 ~ /Mobile/ {count_404_mobile++}  
  # 条件2：500错误且设备为PC端  
  $9 == 500 && $12 ~ /PC/ {count_500_pc++}  
END {  
  print "移动端404次数:", count_404_mobile;  
  print "PC端500次数:", count_500_pc  
}' access.log  

2. 数据清洗：多条件过滤无效数据

场景：处理用户数据（user.txt，格式：姓名 年龄 注册时间），筛选“年龄>18、注册时间在2023年之后”的有效用户。

awk '  
  # 年龄>18 且 注册时间（$3）以2023/2024开头（假设格式YYYY-MM-DD）  
  $2 > 18 && ($3 ~ /^2023/ || $3 ~ /^2024/) {print}  
' user.txt > valid_users.txt  

3. 系统配置分析：用户权限筛选

场景：从 /etc/passwd 中筛选“可登录（shell非/sbin/nologin）且家目录在/home下”的用户。

awk -F ':' '  
  # 分隔符为:，$7=shell，$6=家目录  
  $7 != "/sbin/nologin" && $6 ~ /^\/home/ {print $1, $6}  
' /etc/passwd  

4. 报表生成：多维度数据汇总

场景：从销售数据（sales.csv，格式：日期,产品,销售额）中，统计“产品A在2023年10月销售额>1000”的日期。

awk -F ',' '  
  NR > 1 && $2 == "A" && $1 ~ /^2023-10/ && $3 > 1000 {  
    print $1, "销售额:", $3  
  }  
' sales.csv > report.txt  

五、总结

• 基础核心：掌握 &&/||/! 的用法，明确优先级，善用括号。
• 高级技巧：结合正则、数组、条件嵌套，利用短路特性优化效率。
• 实战关键：根据场景选择“单模式多条件”或“多模式块”，优先用逻辑组合减少代码量。

通过多练习日志分析、数据清洗等场景，可快速掌握逻辑组合的精髓，提升 AWK 处理复杂文本的效率。

AWK的逻辑组合（多条件判断、分支处理等）凭借其轻量、高效的文本处理能力，在除日志分析外的多个领域都有广泛应用。以下是几个典型典型领域及具体场景，结合逻辑组合的用法说明：

一、数据清洗与格式转换

核心需求：从非结构化/半结构化数据中提取有效信息，按规则过滤、转换格式。
逻辑组合应用：用多条件判断筛选符合要求的记录，或按不同格式规则分支处理。

示例：处理 CSV 格式的用户数据

假设有 users.csv（格式：姓名,年龄,性别,注册日期），需：

1. 保留“年龄>18 且 注册日期在2023年后”的有效用户；
2. 对“男性”用户添加标签 [M]，对“女性”用户添加标签 [F]。

# 用逻辑组合筛选+分支处理
awk -F ',' '
  NR == 1 {print "姓名,标签,年龄,注册日期"}  # 保留表头
  NR > 1 {
    # 条件1：年龄>18 且 注册日期以2023/2024开头（多条件与）
    if ($2 > 18 && ($4 ~ /^2023/ || $4 ~ /^2024/)) {
      # 条件2：按性别分支处理（逻辑或+分支）
      if ($3 == "男") tag = "[M]";
      else if ($3 == "女") tag = "[F]";
      else tag = "[未知]";
      print $1 "," tag "," $2 "," $4;  # 输出转换后的数据
    }
  }
' users.csv > cleaned_users.csv

二、系统配置与监控

核心需求：分析系统配置文件、监控系统状态，提取关键信息或判断异常。
逻辑组合应用：结合正则匹配与条件判断，筛选特定配置项或异常状态。

示例：分析 /etc/passwd 识别特殊用户

需求：找出“可登录（shell 非 /sbin/nologin）且 家目录不在 /home 下”的特权用户。

# 多条件组合筛选系统用户
awk -F ':' '
  # 条件：shell不是nologin，且家目录不以/home开头（逻辑与+非）
  $7 != "/sbin/nologin" && !($6 ~ /^\/home/) {
    print "特权用户:", $1, "家目录:", $6, "shell:", $7
  }
' /etc/passwd

三、报表生成与统计分析

核心需求：从原始数据中按多维度统计（如分类计数、求和、平均值），生成结构化报表。
逻辑组合应用：用条件分组统计，结合数组存储多维度结果。

示例：销售数据多维度统计

假设有 sales.txt（格式：地区,产品,销售额），需统计：

1. “华东地区”的“手机”和“电脑”销售额总和；
2. 其他地区“电脑”销售额超 10000 的记录数。

# 多条件分组统计
awk -F ',' '
  NR > 1 {
    # 条件1：华东地区的手机或电脑（逻辑与+或）
    if ($1 == "华东" && ($2 == "手机" || $2 == "电脑")) {
      east_total += $3;
    }
    # 条件2：非华东地区且电脑销售额>10000（逻辑与+非）
    else if ($1 != "华东" && $2 == "电脑" && $3 > 10000) {
      other_high_count++;
    }
  }
END {
  print "华东地区手机+电脑总销售额:", east_total;
  print "其他地区电脑销售额超10000的记录数:", other_high_count;
}
' sales.txt

四、文本内容提取与过滤

核心需求：从文档、代码、配置文件中提取符合特定规则的内容（如提取URL、过滤敏感词）。
逻辑组合应用：用正则+条件判断精准定位目标内容。

示例：从HTML中提取有效链接

需求：从网页源码中提取“以 https 开头且 域名包含 example”的链接。

# 正则+逻辑组合提取链接
awk '
  # 匹配<a>标签中的href，且链接符合https+example条件（正则+逻辑与）
  /<a[^>]+href="[^"]+"/ {
    # 提取href值（简化处理）
    if (match($0, /href="([^"]+)"/, arr)) {
      url = arr[1];
      # 条件：以https开头且包含example（逻辑与）
      if (url ~ /^https/ && url ~ /example/) {
        print url;
      }
    }
  }
' page.html

五、数据库与数据交互辅助

核心需求：处理数据库导出的文本（如SQL结果、CSV备份），进行格式转换或校验。
逻辑组合应用：用多条件校验数据合法性，或按数据库格式规则转换。

示例：校验MySQL导出的用户表数据

假设有 users.sql（导出格式：INSERT INTO ... (id,name,email) VALUES (1,'a','a@x.com');），需校验：

1. id 为数字且 >0；
2. email 包含 @ 且 域名不为 test.com。

# 多条件校验数据合法性
awk '
  /INSERT INTO.*users/ {  # 匹配用户表插入语句
    # 提取id、email（简化正则）
    if (match($0, /VALUES \(([0-9]+),[^,]+,'\''([^'\'']+)'\'')/, arr)) {
      id = arr[1];
      email = arr[2];
      # 条件1：id>0 且 email含@ 且 域名不是test.com（多条件与）
      if (id > 0 && email ~ /@/ && !(email ~ /@test\.com$/)) {
        valid++;
      } else {
        invalid++;
        print "无效记录:", $0;
      }
    }
  }
END {
  print "有效记录数:", valid, "无效记录数:", invalid;
}
' users.sql

总结

AWK 逻辑组合的核心价值在于**“用简洁的语法实现多条件驱动的文本处理”**，其应用场景覆盖：

• 数据处理（清洗、转换、统计）；
• 系统管理（配置分析、状态监控）；
• 内容提取（文档、代码、网页）；
• 数据校验（数据库、文件格式）。

只要涉及“按规则筛选/处理文本”的场景，AWK 的逻辑组合都能大幅提升效率，尤其适合中小规模数据的快速处理（无需编写复杂脚本或依赖数据库）。

AWK 的主流版本是 GNU AWK（gawk），它是 AWK 语言的最主要实现，也是目前更新最活跃的版本。以下是其最新版本及主要升级内容：

AWK 的主流版本是 GNU AWK（gawk），它是 AWK 语言的最主要实现，也是目前更新最活跃的版本。以下是其最新版本及主要升级内容：

一、最新稳定版本

截至 2024 年，GNU AWK 的最新稳定版本是 gawk 5.3.0（2023 年 10 月发布）。

• 官方网站：https://www.gnu.org/software/gawk/
• 版本迭代规律：通常每年更新 1-2 个小版本，主要以 bug 修复和功能增强为主。

二、主要版本升级内容（5.x 系列）

1. gawk 5.3.0（2023 年 10 月）

• 正则表达式增强：支持 Unicode 15.0 标准，改进了对多字节字符的匹配精度。
• 性能优化：提升了大型数组遍历和字符串操作的效率，尤其在处理 GB 级文本时速度提升约 10%。
• 新增函数：strtonum() 函数支持更多进制转换（如二进制 0b 前缀、十六进制 0x 前缀）。
• 兼容性修复：解决了与最新 Linux 内核版本的兼容性问题，修复了部分边缘场景的内存泄漏。

2. gawk 5.2.0（2022 年 12 月）

• 安全增强：新增 --sandbox 模式，限制脚本对文件系统的写入和命令执行，防止恶意脚本攻击。
• 调试功能：改进了 --debug 选项，支持更详细的语法解析日志，便于复杂脚本的调试。
• 数组功能：支持对数组使用 delete 命令时返回删除的元素数量（n = delete arr）。
• 国际化：增强了对非英语 locales 的支持，strftime() 函数可正确处理多语言日期格式。

3. gawk 5.1.0（2021 年 5 月）

• 主要特性更新：
  • 引入 命名捕获组（正则表达式中支持 (?<name>...) 语法，可通过 arr["name"] 访问捕获内容）。
  • 新增 @load 指令，支持动态加载扩展模块（如 JSON 解析、数学函数扩展）。
  • 改进 FPAT 变量（字段模式），更灵活地定义非分隔符的字段格式（适合处理不规则 CSV）。
• 性能优化：优化了正则表达式引擎，复杂模式匹配速度提升约 15%。

三、5.x 系列与旧版本（4.x）的核心差异

1. 正则功能：5.x 支持命名捕获组、Unicode 更高版本标准，正则表达式能力更接近现代编程语言。
2. 安全性：新增沙箱模式，适合在多用户环境中运行不可信的 awk 脚本。
3. 扩展性：支持动态加载模块，可扩展功能（如处理 JSON、XML 等格式）。
4. 性能：数组操作和字符串处理效率显著提升，更适合大数据量场景。

四、升级方法

1. 源码编译（推荐，获取最新版本）：wget https://ftp.gnu.org/gnu/gawk/gawk-5.3.0.tar.gz tar -zxvf gawk-5.3.0.tar.gz cd gawk-5.3.0 ./configure && make && sudo make install
2. 包管理器安装（适用于主流 Linux 发行版，版本可能滞后）：
   • Ubuntu/Debian：sudo apt update && sudo apt install gawk
   • CentOS/RHEL：sudo yum install gawk
   • macOS（Homebrew）：brew install gawk
3. 验证版本：gawk --version # 输出 "GNU Awk 5.3.0" 即表示升级成功

五、使用建议

• 对于日常文本处理（如日志分析、数据清洗），gawk 5.x 的新特性（如命名捕获组、沙箱模式）能显著提升效率和安全性。
• 若脚本需要兼容旧系统（如 CentOS 7 自带 gawk 4.0.2），需注意避免使用 5.x 独有的特性（如命名捕获组）。
• 官方文档（info gawk 或在线手册）是学习新特性的最佳资源，尤其推荐关注正则增强和扩展模块部分。

通过升级到最新版本，可充分利用 AWK 在文本处理中的现代特性，适应更复杂的场景需求。

截至 2024 年，GNU AWK 的最新稳定版本是 gawk 5.3.0（2023 年 10 月发布）。

• 官方网站：https://www.gnu.org/software/gawk/
• 版本迭代规律：通常每年更新 1-2 个小版本，主要以 bug 修复和功能增强为主。

二、主要版本升级内容（5.x 系列）

1. gawk 5.3.0（2023 年 10 月）

• 正则表达式增强：支持 Unicode 15.0 标准，改进了对多字节字符的匹配精度。
• 性能优化：提升了大型数组遍历和字符串操作的效率，尤其在处理 GB 级文本时速度提升约 10%。
• 新增函数：strtonum() 函数支持更多进制转换（如二进制 0b 前缀、十六进制 0x 前缀）。
• 兼容性修复：解决了与最新 Linux 内核版本的兼容性问题，修复了部分边缘场景的内存泄漏。

2. gawk 5.2.0（2022 年 12 月）

• 安全增强：新增 --sandbox 模式，限制脚本对文件系统的写入和命令执行，防止恶意脚本攻击。
• 调试功能：改进了 --debug 选项，支持更详细的语法解析日志，便于复杂脚本的调试。
• 数组功能：支持对数组使用 delete 命令时返回删除的元素数量（n = delete arr）。
• 国际化：增强了对非英语 locales 的支持，strftime() 函数可正确处理多语言日期格式。

3. gawk 5.1.0（2021 年 5 月）

• 主要特性更新：
  • 引入 命名捕获组（正则表达式中支持 (?<name>...) 语法，可通过 arr["name"] 访问捕获内容）。
  • 新增 @load 指令，支持动态加载扩展模块（如 JSON 解析、数学函数扩展）。
  • 改进 FPAT 变量（字段模式），更灵活地定义非分隔符的字段格式（适合处理不规则 CSV）。
• 性能优化：优化了正则表达式引擎，复杂模式匹配速度提升约 15%。

三、5.x 系列与旧版本（4.x）的核心差异

1. 正则功能：5.x 支持命名捕获组、Unicode 更高版本标准，正则表达式能力更接近现代编程语言。
2. 安全性：新增沙箱模式，适合在多用户环境中运行不可信的 awk 脚本。
3. 扩展性：支持动态加载模块，可扩展功能（如处理 JSON、XML 等格式）。
4. 性能：数组操作和字符串处理效率显著提升，更适合大数据量场景。

四、升级方法

1. 源码编译（推荐，获取最新版本）：wget https://ftp.gnu.org/gnu/gawk/gawk-5.3.0.tar.gz tar -zxvf gawk-5.3.0.tar.gz cd gawk-5.3.0 ./configure && make && sudo make install
2. 包管理器安装（适用于主流 Linux 发行版，版本可能滞后）：
   • Ubuntu/Debian：sudo apt update && sudo apt install gawk
   • CentOS/RHEL：sudo yum install gawk
   • macOS（Homebrew）：brew install gawk
3. 验证版本：gawk --version # 输出 "GNU Awk 5.3.0" 即表示升级成功

五、使用建议

• 对于日常文本处理（如日志分析、数据清洗），gawk 5.x 的新特性（如命名捕获组、沙箱模式）能显著提升效率和安全性。
• 若脚本需要兼容旧系统（如 CentOS 7 自带 gawk 4.0.2），需注意避免使用 5.x 独有的特性（如命名捕获组）。
• 官方文档（info gawk 或在线手册）是学习新特性的最佳资源，尤其推荐关注正则增强和扩展模块部分。

通过升级到最新版本，可充分利用 AWK 在文本处理中的现代特性，适应更复杂的场景需求。

ls与du统计占用空间大小的区别

ls 命令显示的文件大小是通过读取文件系统的元数据（metadata）获取的，具体来说是读取文件的 inode 信息 中的大小字段。以下是详细解释：

一、获取文件大小的底层原理

1. 文件系统存储元数据
   每个文件在 Linux 系统中都对应一个 inode（索引节点），其中记录了文件的关键属性：
   • 文件大小（字节数）
   • 创建/修改/访问时间
   • 权限、所有者
   • 数据块在磁盘上的存储位置等

ls 命令通过系统调用（如 stat() 或 lstat()）读取这些元数据，从而获取文件大小。
(https://www.calcguide.tech/2025/08/20/ls%e4%b8%8edu%e7%bb%9f%e8%ae%a1%e5%8d%a0%e7%94%a8%e7%a9%ba%e9%97%b4%e5%a4%a7%e5%b0%8f%e7%9a%84%e5%8c%ba%e5%88%ab/)

2. ls 命令的实现逻辑
   当执行 ls -l 或 ls -s 时，ls 会：
   • 遍历目标目录下的所有文件/目录
   • 对每个文件调用 stat() 系统调用，获取 inode 中的 st_size 字段（文件大小，单位字节）
   • 根据用户指定的格式（如 -h 显示人类可读单位，-k 显示 KB 等）转换并展示大小

二、不同 ls 选项的文件大小显示

ls 提供多种选项控制文件大小的显示方式，本质都是对 st_size 字段的转换：

三、特殊情况说明

1. 目录的大小
   ls -l 显示的目录大小通常是固定值（如 4096 字节），这是目录本身的 inode 元数据占用的磁盘块大小，而非目录内所有文件的总大小。
   若要查看目录内所有文件的总大小，需用 du -sh 目录名。
2. 符号链接（软链接）
   ls -l 显示的是软链接本身的大小（通常是链接目标路径的字符串长度），而非目标文件的大小。
   若要查看目标文件大小，需用 ls -lL 链接名（-L 跟随链接）。
3. 稀疏文件（Sparse File）
   稀疏文件的 ls 显示大小（st_size）可能远大于实际磁盘占用（如虚拟机镜像文件），因为其未写入数据的区域不占用磁盘空间。

四、验证：手动查看文件大小元数据

可以通过 stat 命令直接查看文件的元数据，对比 ls 的结果：

# 查看文件的元数据
stat example.txt

# 输出中与大小相关的字段：
# Size: 1024        （文件逻辑大小，同 ls 显示的字节数）
# Blocks: 8         （实际占用磁盘块数，同 ls -s 显示的值）

总结：ls 的文件大小来自文件系统的 inode 元数据，通过系统调用读取后转换为用户指定的格式，不同选项仅影响显示单位，不改变原始大小值。

sigaltstack 函数详解

1. 函数介绍

sigaltstack 系统调用及示例，sigaltstack是Linux系统调用，用于设置和获取信号处理程序的备用栈（alternate signal stack）。当进程收到信号时，内核通常在当前栈上执行信号处理程序。使用 sigaltstack 可以为信号处理程序指定一个独立的栈空间，这对于处理栈溢出等异常情况特别有用。

2. 函数原型

#include <signal.h>
int sigaltstack(const stack_t *ss, stack_t *oss);

3. 功能

sigaltstack 允许进程为信号处理程序设置一个备用的栈空间。当信号被递送到使用备用栈的信号处理程序时，内核会切换到备用栈执行信号处理程序，执行完毕后再切换回原来的栈。

4. 参数

• *const stack_t ss: 指向新栈设置的指针（NULL表示不改变当前设置）
• *stack_t oss: 指向存储旧栈设置的指针（NULL表示不获取旧设置）

5. 返回值

• 成功: 返回0
• 失败: 返回-1，并设置errno

6. 相似函数，或关联函数

• signal/sigaction: 设置信号处理程序
• sigprocmask: 设置信号屏蔽字
• setjmp/longjmp: 非局部跳转
• getcontext/setcontext: 上下文操作

7. 示例代码

示例1：基础sigaltstack使用

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>

/**
 * 信号栈结构体
 */
typedef struct {
    void *stack_ptr;
    size_t stack_size;
    int is_active;
} signal_stack_t;

/**
 * 显示当前信号栈信息
 */
void show_signal_stack_info() {
    stack_t current_stack;
    
    if (sigaltstack(NULL, &current_stack) == 0) {
        printf("=== 当前信号栈信息 ===\n");
        printf("栈指针: %p\n", current_stack.ss_sp);
        printf("栈大小: %zu 字节\n", current_stack.ss_size);
        printf("栈标志: ");
        if (current_stack.ss_flags & SS_ONSTACK) {
            printf("SS_ONSTACK (正在使用中)\n");
        } else if (current_stack.ss_flags & SS_DISABLE) {
            printf("SS_DISABLE (已禁用)\n");
        } else {
            printf("SS_ENABLED (已启用)\n");
        }
        printf("\n");
    } else {
        printf("获取信号栈信息失败: %s\n", strerror(errno));
    }
}

/**
 * 信号处理程序
 */
void signal_handler(int sig) {
    stack_t current_stack;
    
    printf("信号处理程序执行中 (信号: %d)\n", sig);
    
    // 检查当前是否在备用栈上
    if (sigaltstack(NULL, &current_stack) == 0) {
        if (current_stack.ss_flags & SS_ONSTACK) {
            printf("  ✓ 正在备用栈上执行\n");
        } else {
            printf("  ✗ 在主栈上执行\n");
        }
    }
    
    printf("  当前栈指针: %p\n", &sig);
    printf("  信号处理完成\n\n");
}

/**
 * 演示基础sigaltstack使用方法
 */
int demo_sigaltstack_basic() {
    stack_t new_stack, old_stack;
    char *stack_buffer;
    struct sigaction sa;
    
    printf("=== 基础sigaltstack使用示例 ===\n");
    
    // 显示原始信号栈信息
    printf("1. 原始信号栈信息:\n");
    show_signal_stack_info();
    
    // 分配备用栈空间
    size_t stack_size = SIGSTKSZ;  // 系统推荐的栈大小
    stack_buffer = malloc(stack_size);
    if (!stack_buffer) {
        perror("分配栈空间失败");
        return -1;
    }
    
    printf("2. 分配备用栈空间:\n");
    printf("   栈大小: %zu 字节\n", stack_size);
    printf("   栈地址: %p\n", (void*)stack_buffer);
    
    // 设置备用栈
    new_stack.ss_sp = stack_buffer;
    new_stack.ss_size = stack_size;
    new_stack.ss_flags = 0;  // 启用栈
    
    printf("3. 设置备用信号栈:\n");
    if (sigaltstack(&new_stack, &old_stack) == 0) {
        printf("   ✓ 备用栈设置成功\n");
        show_signal_stack_info();
    } else {
        printf("   ✗ 备用栈设置失败: %s\n", strerror(errno));
        free(stack_buffer);
        return -1;
    }
    
    // 设置使用备用栈的信号处理程序
    printf("4. 设置信号处理程序:\n");
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = signal_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_ONSTACK;  // 使用备用栈
    
    if (sigaction(SIGUSR1, &sa, NULL) == 0) {
        printf("   ✓ 信号处理程序设置成功 (使用备用栈)\n");
    } else {
        printf("   ✗ 信号处理程序设置失败: %s\n", strerror(errno));
        free(stack_buffer);
        return -1;
    }
    
    // 发送信号测试
    printf("5. 发送测试信号:\n");
    if (kill(getpid(), SIGUSR1) == 0) {
        printf("   ✓ 信号发送成功\n");
        sleep(1);  // 等待信号处理完成
    } else {
        printf("   ✗ 信号发送失败: %s\n", strerror(errno));
    }
    
    // 禁用备用栈
    printf("6. 禁用备用栈:\n");
    stack_t disable_stack;
    disable_stack.ss_flags = SS_DISABLE;
    
    if (sigaltstack(&disable_stack, NULL) == 0) {
        printf("   ✓ 备用栈禁用成功\n");
        show_signal_stack_info();
    } else {
        printf("   ✗ 备用栈禁用失败: %s\n", strerror(errno));
    }
    
    // 清理资源
    free(stack_buffer);
    
    return 0;
}

int main() {
    return demo_sigaltstack_basic();
}

示例2：栈溢出保护演示

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <setjmp.h>

/**
 * 栈溢出保护结构
 */
typedef struct {
    stack_t alt_stack;
    char *stack_buffer;
    sigjmp_buf jump_buffer;
    int overflow_detected;
} stack_protection_t;

/**
 * 栈溢出信号处理程序
 */
void stack_overflow_handler(int sig) {
    printf("⚠ 检测到栈溢出异常 (信号: %d)\n", sig);
    
    // 检查是否在备用栈上
    stack_t current_stack;
    if (sigaltstack(NULL, &current_stack) == 0) {
        if (current_stack.ss_flags & SS_ONSTACK) {
            printf("  ✓ 在备用栈上安全处理异常\n");
        } else {
            printf("  ✗ 不在备用栈上 (异常情况)\n");
        }
    }
    
    // 恢复到安全状态
    printf("  跳转到安全恢复点...\n");
    siglongjmp(((stack_protection_t*)NULL)->jump_buffer, 1);
}

/**
 * 递归函数（可能导致栈溢出）
 */
void recursive_function(int depth) {
    char buffer[1024];  // 消耗栈空间
    
    // 填充缓冲区以确保栈使用
    memset(buffer, depth & 0xFF, sizeof(buffer));
    
    printf("递归深度: %d, 栈地址: %p\n", depth, (void*)&buffer);
    
    // 深度递归可能导致栈溢出
    if (depth < 1000) {  // 限制递归深度
        recursive_function(depth + 1);
    }
}

/**
 * 安全的递归执行
 */
int safe_recursive_execution(stack_protection_t *protection) {
    struct sigaction sa;
    int result;
    
    printf("=== 栈溢出保护演示 ===\n");
    
    // 设置信号处理程序
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = stack_overflow_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_ONSTACK;
    
    if (sigaction(SIGSEGV, &sa, NULL) != 0) {
        printf("设置SIGSEGV处理程序失败: %s\n", strerror(errno));
        return -1;
    }
    
    if (sigaction(SIGBUS, &sa, NULL) != 0) {
        printf("设置SIGBUS处理程序失败: %s\n", strerror(errno));
        return -1;
    }
    
    // 设置跳转点
    result = sigsetjmp(protection->jump_buffer, 1);
    if (result == 0) {
        printf("开始安全递归执行...\n");
        
        // 执行可能引起栈溢出的操作
        recursive_function(0);
        
        printf("递归执行正常完成\n");
        return 0;
    } else {
        printf("✓ 从栈溢出异常中成功恢复\n");
        return 1;
    }
}

/**
 * 演示栈溢出保护
 */
int demo_stack_overflow_protection() {
    stack_protection_t protection = {0};
    size_t stack_size = SIGSTKSZ * 2;  // 更大的备用栈
    
    printf("=== 栈溢出保护演示 ===\n");
    
    // 分配备用栈
    protection.stack_buffer = malloc(stack_size);
    if (!protection.stack_buffer) {
        perror("分配备用栈失败");
        return -1;
    }
    
    printf("分配备用栈: %zu 字节\n", stack_size);
    
    // 设置备用栈
    protection.alt_stack.ss_sp = protection.stack_buffer;
    protection.alt_stack.ss_size = stack_size;
    protection.alt_stack.ss_flags = 0;
    
    if (sigaltstack(&protection.alt_stack, NULL) != 0) {
        printf("设置备用栈失败: %s\n", strerror(errno));
        free(protection.stack_buffer);
        return -1;
    }
    
    printf("备用栈设置成功\n");
    show_signal_stack_info();
    
    // 执行安全递归
    int result = safe_recursive_execution(&protection);
    
    // 清理资源
    free(protection.stack_buffer);
    
    return result;
}

// 辅助函数声明
void show_signal_stack_info();

int main() {
    return demo_stack_overflow_protection();
}

示例3：多信号处理程序管理

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>

/**
 * 多栈管理器
 */
typedef struct {
    stack_t stack1;
    stack_t stack2;
    char *buffer1;
    char *buffer2;
    int current_stack;
} multi_stack_manager_t;

/**
 * 信号处理程序1（使用栈1）
 */
void signal_handler_1(int sig) {
    printf("信号处理程序1执行 (信号: %d)\n", sig);
    
    stack_t current_stack;
    if (sigaltstack(NULL, &current_stack) == 0) {
        if (current_stack.ss_flags & SS_ONSTACK) {
            printf("  使用备用栈1执行\n");
        }
    }
    
    printf("  处理程序1完成\n");
}

/**
 * 信号处理程序2（使用栈2）
 */
void signal_handler_2(int sig) {
    printf("信号处理程序2执行 (信号: %d)\n", sig);
    
    stack_t current_stack;
    if (sigaltstack(NULL, &current_stack) == 0) {
        if (current_stack.ss_flags & SS_ONSTACK) {
            printf("  使用备用栈2执行\n");
        }
    }
    
    printf("  处理程序2完成\n");
}

/**
 * 初始化多栈管理器
 */
int init_multi_stack_manager(multi_stack_manager_t *manager) {
    size_t stack_size = SIGSTKSZ;
    
    printf("=== 多栈管理器初始化 ===\n");
    
    // 分配两个栈空间
    manager->buffer1 = malloc(stack_size);
    manager->buffer2 = malloc(stack_size);
    
    if (!manager->buffer1 || !manager->buffer2) {
        printf("分配栈空间失败\n");
        if (manager->buffer1) free(manager->buffer1);
        if (manager->buffer2) free(manager->buffer2);
        return -1;
    }
    
    printf("栈1地址: %p, 大小: %zu\n", (void*)manager->buffer1, stack_size);
    printf("栈2地址: %p, 大小: %zu\n", (void*)manager->buffer2, stack_size);
    
    // 初始化栈结构
    manager->stack1.ss_sp = manager->buffer1;
    manager->stack1.ss_size = stack_size;
    manager->stack1.ss_flags = 0;
    
    manager->stack2.ss_sp = manager->buffer2;
    manager->stack2.ss_size = stack_size;
    manager->stack2.ss_flags = 0;
    
    manager->current_stack = 0;
    
    return 0;
}

/**
 * 切换备用栈
 */
int switch_alternate_stack(multi_stack_manager_t *manager, int stack_id) {
    stack_t *target_stack = (stack_id == 1) ? &manager->stack1 : &manager->stack2;
    
    printf("切换到备用栈 %d\n", stack_id);
    
    if (sigaltstack(target_stack, NULL) == 0) {
        printf("✓ 成功切换到备用栈 %d\n", stack_id);
        manager->current_stack = stack_id;
        return 0;
    } else {
        printf("✗ 切换备用栈 %d 失败: %s\n", stack_id, strerror(errno));
        return -1;
    }
}

/**
 * 演示多信号处理程序
 */
int demo_multi_signal_handlers() {
    multi_stack_manager_t manager = {0};
    struct sigaction sa1, sa2;
    
    printf("=== 多信号处理程序演示 ===\n");
    
    // 初始化多栈管理器
    if (init_multi_stack_manager(&manager) != 0) {
        printf("初始化多栈管理器失败\n");
        return -1;
    }
    
    // 设置信号处理程序1（使用栈1）
    printf("\n设置信号处理程序1:\n");
    switch_alternate_stack(&manager, 1);
    
    memset(&sa1, 0, sizeof(sa1));
    sa1.sa_handler = signal_handler_1;
    sigemptyset(&sa1.sa_mask);
    sa1.sa_flags = SA_ONSTACK;
    
    if (sigaction(SIGUSR1, &sa1, NULL) == 0) {
        printf("✓ 信号处理程序1设置成功\n");
    } else {
        printf("✗ 信号处理程序1设置失败: %s\n", strerror(errno));
    }
    
    // 设置信号处理程序2（使用栈2）
    printf("\n设置信号处理程序2:\n");
    switch_alternate_stack(&manager, 2);
    
    memset(&sa2, 0, sizeof(sa2));
    sa2.sa_handler = signal_handler_2;
    sigemptyset(&sa2.sa_mask);
    sa2.sa_flags = SA_ONSTACK;
    
    if (sigaction(SIGUSR2, &sa2, NULL) == 0) {
        printf("✓ 信号处理程序2设置成功\n");
    } else {
        printf("✗ 信号处理程序2设置失败: %s\n", strerror(errno));
    }
    
    // 测试信号处理
    printf("\n测试信号处理:\n");
    
    // 发送SIGUSR1
    printf("发送SIGUSR1信号:\n");
    switch_alternate_stack(&manager, 1);
    if (kill(getpid(), SIGUSR1) == 0) {
        printf("✓ SIGUSR1发送成功\n");
        sleep(1);
    }
    
    // 发送SIGUSR2
    printf("发送SIGUSR2信号:\n");
    switch_alternate_stack(&manager, 2);
    if (kill(getpid(), SIGUSR2) == 0) {
        printf("✓ SIGUSR2发送成功\n");
        sleep(1);
    }
    
    // 清理资源
    free(manager.buffer1);
    free(manager.buffer2);
    
    return 0;
}

int main() {
    return demo_multi_signal_handlers();
}

示例4：线程安全的信号栈管理

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>

/**
 * 线程信号栈管理器
 */
typedef struct {
    stack_t signal_stack;
    char *stack_buffer;
    pthread_t thread_id;
    int thread_num;
} thread_stack_manager_t;

/**
 * 线程信号处理程序
 */
void thread_signal_handler(int sig) {
    pthread_t current_thread = pthread_self();
    
    printf("线程 %lu 收到信号 %d\n", (unsigned long)current_thread, sig);
    
    stack_t current_stack;
    if (sigaltstack(NULL, &current_stack) == 0) {
        if (current_stack.ss_flags & SS_ONSTACK) {
            printf("  线程 %lu 在备用栈上处理信号\n", (unsigned long)current_thread);
        } else {
            printf("  线程 %lu 在主栈上处理信号\n", (unsigned long)current_thread);
        }
    }
    
    printf("  线程 %lu 信号处理完成\n", (unsigned long)current_thread);
}

/**
 * 初始化线程栈管理器
 */
int init_thread_stack_manager(thread_stack_manager_t *manager, int thread_num) {
    size_t stack_size = SIGSTKSZ;
    
    manager->thread_num = thread_num;
    manager->thread_id = pthread_self();
    
    // 分配栈空间
    manager->stack_buffer = malloc(stack_size);
    if (!manager->stack_buffer) {
        printf("线程 %d: 分配栈空间失败\n", thread_num);
        return -1;
    }
    
    // 初始化栈结构
    manager->signal_stack.ss_sp = manager->stack_buffer;
    manager->signal_stack.ss_size = stack_size;
    manager->signal_stack.ss_flags = 0;
    
    printf("线程 %d: 分配备用栈 %p, 大小 %zu\n", 
           thread_num, (void*)manager->stack_buffer, stack_size);
    
    return 0;
}

/**
 * 线程工作函数
 */
void* thread_worker(void *arg) {
    thread_stack_manager_t *manager = (thread_stack_manager_t*)arg;
    struct sigaction sa;
    sigset_t set;
    
    printf("工作线程 %d 启动 (ID: %lu)\n", 
           manager->thread_num, (unsigned long)manager->thread_id);
    
    // 设置备用栈
    if (sigaltstack(&manager->signal_stack, NULL) != 0) {
        printf("线程 %d: 设置备用栈失败: %s\n", 
               manager->thread_num, strerror(errno));
        return NULL;
    }
    
    printf("线程 %d: 备用栈设置成功\n", manager->thread_num);
    
    // 设置信号处理程序
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = thread_signal_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_ONSTACK;
    
    if (sigaction(SIGUSR1, &sa, NULL) != 0) {
        printf("线程 %d: 设置信号处理程序失败: %s\n", 
               manager->thread_num, strerror(errno));
        return NULL;
    }
    
    printf("线程 %d: 信号处理程序设置成功\n", manager->thread_num);
    
    // 阻塞SIGUSR1以便测试
    sigemptyset(&set);
    sigaddset(&set, SIGUSR1);
    pthread_sigmask(SIG_BLOCK, &set, NULL);
    
    // 执行工作
    for (int i = 0; i < 5; i++) {
        printf("线程 %d: 工作中... (%d/5)\n", manager->thread_num, i + 1);
        sleep(2);
    }
    
    // 解除阻塞并等待信号
    printf("线程 %d: 等待信号...\n", manager->thread_num);
    pthread_sigmask(SIG_UNBLOCK, &set, NULL);
    
    // 等待一段时间让信号处理完成
    sleep(2);
    
    printf("线程 %d: 工作完成\n", manager->thread_num);
    return NULL;
}

/**
 * 演示线程安全的信号栈管理
 */
int demo_thread_safe_signal_stacks() {
    const int num_threads = 3;
    pthread_t threads[num_threads];
    thread_stack_manager_t managers[num_threads];
    sigset_t set;
    
    printf("=== 线程安全的信号栈管理演示 ===\n");
    
    // 阻塞SIGUSR1信号
    sigemptyset(&set);
    sigaddset(&set, SIGUSR1);
    pthread_sigmask(SIG_BLOCK, &set, NULL);
    
    // 创建工作线程
    printf("创建 %d 个工作线程:\n", num_threads);
    
    for (int i = 0; i < num_threads; i++) {
        if (init_thread_stack_manager(&managers[i], i + 1) != 0) {
            printf("初始化线程 %d 失败\n", i + 1);
            // 清理已分配的资源
            for (int j = 0; j < i; j++) {
                free(managers[j].stack_buffer);
            }
            return -1;
        }
        
        if (pthread_create(&threads[i], NULL, thread_worker, &managers[i]) != 0) {
            printf("创建线程 %d 失败\n", i + 1);
            free(managers[i].stack_buffer);
            // 清理已分配的资源
            for (int j = 0; j < i; j++) {
                free(managers[j].stack_buffer);
            }
            return -1;
        }
        
        managers[i].thread_id = threads[i];
        printf("创建线程 %d: ID=%lu\n", i + 1, (unsigned long)threads[i]);
    }
    
    // 等待线程启动
    sleep(1);
    
    // 向所有线程发送信号
    printf("\n向所有线程发送SIGUSR1信号:\n");
    pthread_sigmask(SIG_UNBLOCK, &set, NULL);
    
    for (int i = 0; i < num_threads; i++) {
        // 注意：实际应用中需要更精确的线程信号发送方法
        if (kill(getpid(), SIGUSR1) == 0) {
            printf("向线程 %d 发送信号成功\n", i + 1);
        } else {
            printf("向线程 %d 发送信号失败: %s\n", i + 1, strerror(errno));
        }
        sleep(1);  // 间隔发送
    }
    
    // 等待所有线程完成
    printf("\n等待所有线程完成:\n");
    for (int i = 0; i < num_threads; i++) {
        void *result;
        pthread_join(threads[i], &result);
        printf("线程 %d 已完成\n", i + 1);
        
        // 清理资源
        free(managers[i].stack_buffer);
    }
    
    return 0;
}

int main() {
    return demo_thread_safe_signal_stacks();
}

示例5：信号栈监控和调试

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/resource.h>

/**
 * 信号栈监控器
 */
typedef struct {
    stack_t original_stack;
    stack_t current_stack;
    int stack_switch_count;
    size_t total_stack_size;
    time_t last_switch_time;
} stack_monitor_t;

/**
 * 详细的栈信息显示
 */
void show_detailed_stack_info(const char *context) {
    stack_t stack_info;
    
    printf("=== %s ===\n", context);
    
    if (sigaltstack(NULL, &stack_info) == 0) {
        printf("栈指针: %p\n", stack_info.ss_sp);
        printf("栈大小: %zu 字节\n", stack_info.ss_size);
        printf("栈标志: 0x%x\n", stack_info.ss_flags);
        
        if (stack_info.ss_flags & SS_ONSTACK) {
            printf("状态: 正在使用备用栈\n");
        } else if (stack_info.ss_flags & SS_DISABLE) {
            printf("状态: 备用栈已禁用\n");
        } else {
            printf("状态: 备用栈已启用但未使用\n");
        }
        
        // 计算栈使用情况（简化版）
        void *current_sp;
        asm volatile("mov %%rsp, %0" : "=r"(current_sp));
        printf("当前栈指针: %p\n", current_sp);
        
        if (stack_info.ss_sp) {
            ptrdiff_t distance = (char*)current_sp - (char*)stack_info.ss_sp;
            printf("距离栈底: %td 字节\n", distance);
            
            if (distance > 0 && (size_t)distance < stack_info.ss_size) {
                double usage = (double)distance / stack_info.ss_size * 100;
                printf("栈使用率: %.1f%%\n", usage);
            }
        }
    } else {
        printf("获取栈信息失败: %s\n", strerror(errno));
    }
    
    printf("\n");
}

/**
 * 信号处理程序（带监控）
 */
void monitored_signal_handler(int sig) {
    static int call_count = 0;
    call_count++;
    
    printf("监控信号处理程序执行 (第 %d 次, 信号: %d)\n", call_count, sig);
    
    show_detailed_stack_info("信号处理程序中的栈状态");
    
    // 模拟一些栈使用
    char local_buffer[512];
    memset(local_buffer, call_count & 0xFF, sizeof(local_buffer));
    
    printf("  处理程序使用了 %zu 字节本地缓冲区\n", sizeof(local_buffer));
    printf("  处理程序执行完成\n\n");
}

/**
 * 栈使用压力测试
 */
void stack_pressure_test(int depth) {
    char buffer[1024];  // 每层消耗1KB栈空间
    
    // 填充缓冲区
    memset(buffer, depth & 0xFF, sizeof(buffer));
    
    if (depth < 50) {  // 限制递归深度
        printf("递归深度: %d, 使用栈空间: %d KB\n", depth, depth);
        stack_pressure_test(depth + 1);
    } else {
        printf("达到最大递归深度: %d\n", depth);
    }
}

/**
 * 演示信号栈监控和调试
 */
int demo_stack_monitoring() {
    stack_t alt_stack, old_stack;
    char *stack_buffer;
    struct sigaction sa;
    struct rlimit rl;
    
    printf("=== 信号栈监控和调试演示 ===\n");
    
    // 显示系统栈限制
    printf("1. 系统栈限制信息:\n");
    if (getrlimit(RLIMIT_STACK, &rl) == 0) {
        printf("   主栈大小限制: %ld 字节", rl.rlim_cur);
        if (rl.rlim_cur == RLIM_INFINITY) {
            printf(" (无限制)");
        }
        printf("\n");
        printf("   最大栈大小: %ld 字节", rl.rlim_max);
        if (rl.rlim_max == RLIM_INFINITY) {
            printf(" (无限制)");
        }
        printf("\n");
    }
    
    // 显示初始栈状态
    show_detailed_stack_info("初始栈状态");
    
    // 分配备用栈
    size_t stack_size = SIGSTKSZ * 4;  // 4倍标准大小
    stack_buffer = malloc(stack_size);
    if (!stack_buffer) {
        perror("分配备用栈失败");
        return -1;
    }
    
    printf("2. 分配备用栈:\n");
    printf("   请求大小: %zu 字节 (%.1f KB)\n", stack_size, stack_size / 1024.0);
    printf("   分配地址: %p\n", (void*)stack_buffer);
    
    // 设置备用栈
    alt_stack.ss_sp = stack_buffer;
    alt_stack.ss_size = stack_size;
    alt_stack.ss_flags = 0;
    
    printf("3. 设置备用栈:\n");
    if (sigaltstack(&alt_stack, &old_stack) == 0) {
        printf("   ✓ 备用栈设置成功\n");
        show_detailed_stack_info("设置备用栈后");
    } else {
        printf("   ✗ 备用栈设置失败: %s\n", strerror(errno));
        free(stack_buffer);
        return -1;
    }
    
    // 设置监控信号处理程序
    printf("4. 设置监控信号处理程序:\n");
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = monitored_signal_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_ONSTACK;
    
    if (sigaction(SIGUSR1, &sa, NULL) == 0) {
        printf("   ✓ 监控信号处理程序设置成功\n");
    } else {
        printf("   ✗ 监控信号处理程序设置失败: %s\n", strerror(errno));
        free(stack_buffer);
        return -1;
    }
    
    // 发送多个信号进行测试
    printf("5. 发送测试信号:\n");
    for (int i = 1; i <= 3; i++) {
        printf("   发送第 %d 个信号:\n", i);
        if (kill(getpid(), SIGUSR1) == 0) {
            printf("     ✓ 信号发送成功\n");
            sleep(1);  // 等待处理完成
        } else {
            printf("     ✗ 信号发送失败: %s\n", strerror(errno));
        }
    }
    
    // 栈压力测试
    printf("6. 栈压力测试:\n");
    printf("   开始递归栈使用测试...\n");
    stack_pressure_test(0);
    printf("   栈压力测试完成\n");
    
    show_detailed_stack_info("压力测试后栈状态");
    
    // 禁用备用栈
    printf("7. 禁用备用栈:\n");
    stack_t disable_stack;
    disable_stack.ss_flags = SS_DISABLE;
    
    if (sigaltstack(&disable_stack, NULL) == 0) {
        printf("   ✓ 备用栈禁用成功\n");
        show_detailed_stack_info("禁用备用栈后");
    } else {
        printf("   ✗ 备用栈禁用失败: %s\n", strerror(errno));
    }
    
    // 清理资源
    free(stack_buffer);
    
    printf("=== 监控演示完成 ===\n");
    return 0;
}

int main() {
    return demo_stack_monitoring();
}

sigaltstack 使用注意事项

系统要求：

1. 内核版本: 支持信号备用栈的Linux内核
2. 权限要求: 通常不需要特殊权限
3. 架构支持: 支持所有主流架构

栈大小考虑：

1. 最小大小: 至少MINSIGSTKSZ字节
2. 推荐大小: 使用SIGSTKSZ或更大
3. 动态分配: 建议在堆上分配栈空间

错误处理：

1. ENOMEM: 内存不足
2. EINVAL: 参数无效
3. EPERM: 权限不足

安全考虑：

1. 栈溢出保护: 备用栈可以防止主栈溢出
2. 信号安全: 确保信号处理程序的安全执行
3. 资源管理: 及时释放分配的栈空间

最佳实践：

1. 适当大小: 根据信号处理程序的需求分配栈大小
2. 错误检查: 始终检查sigaltstack的返回值
3. 资源清理: 程序结束时释放栈空间
4. 线程安全: 多线程环境中每个线程需要独立的栈
5. 监控调试: 监控栈使用情况以便调试

信号栈标志说明

SS_ONSTACK：

• 含义: 当前正在使用备用栈执行信号处理程序
• 用途: 检查信号处理程序是否在备用栈上执行

SS_DISABLE：

• 含义: 备用栈被禁用
• 用途: 禁用备用栈功能

SS_ENABLED：

• 含义: 备用栈已启用但未使用
• 用途: 正常状态，可以使用备用栈

相关常量

SIGSTKSZ：

• 含义: 系统推荐的信号栈大小
• 典型值: 8KB或更大

MINSIGSTKSZ：

• 含义: 信号栈的最小大小
• 典型值: 2KB

常见使用场景

1. 栈溢出保护：

// 为可能引起栈溢出的程序设置备用栈
stack_t alt_stack;
alt_stack.ss_sp = malloc(SIGSTKSZ);
alt_stack.ss_size = SIGSTKSZ;
alt_stack.ss_flags = 0;
sigaltstack(&alt_stack, NULL);

2. 信号处理程序：

// 为信号处理程序设置独立的执行环境
struct sigaction sa;
sa.sa_handler = signal_handler;
sa.sa_flags = SA_ONSTACK;
sigaction(SIGSEGV, &sa, NULL);

3. 多线程应用：

// 每个线程设置独立的信号栈
void* thread_function(void *arg) {
    stack_t thread_stack;
    thread_stack.ss_sp = malloc(SIGSTKSZ);
    thread_stack.ss_size = SIGSTKSZ;
    thread_stack.ss_flags = 0;
    sigaltstack(&thread_stack, NULL);
    // 线程工作...
}

总结

sigaltstack 是Linux系统中重要的信号处理机制，提供了：

1. 栈隔离: 为信号处理程序提供独立的执行环境
2. 异常处理: 防止栈溢出等异常情况
3. 安全执行: 确保信号处理程序的安全执行
4. 灵活配置: 支持动态栈管理和配置

通过合理使用 sigaltstack，可以构建更加健壮和安全的信号处理系统。在实际应用中，需要注意栈大小、错误处理和资源管理等关键问题。

我们来深入学习 sethostname 系统调用及示例

我们来深入学习 sethostname 系统调用及示例

1. 函数介绍

在 Linux 系统（以及大多数 Unix-like 系统）中，每台计算机都有一个唯一的标识符，叫做 主机名 (hostname)。这个主机名用于在网络中识别这台机器。例如，当你在命令行输入 hostname 时，它会显示当前机器的主机名。

sethostname 系统调用的作用就是设置这台运行着 Linux 内核的计算机的 主机名。这是一个系统级别的设置，会影响整个机器，而不仅仅是调用它的那个进程。

简单来说，sethostname 就是让你用程序来给你的 Linux 电脑“改名字”。

重要提示：
1. 需要权限：修改主机名是一个特权操作，通常只有 root 用户（超级用户）才有权限执行 sethostname。普通用户尝试调用它会失败。
2. 影响范围：主机名是系统全局的属性。一旦通过 sethostname 修改，系统中所有查询主机名的地方（如 gethostname, uname 命令）都会返回新的名字。
3. 持久性：通过 sethostname 设置的主机名是临时的。它只在当前的系统运行会话（直到关机或重启）中有效。系统重启后，主机会从配置文件（如 /etc/hostname）中读取并恢复原来的主机名。

2. 函数原型

#include <unistd.h>      // 包含系统调用声明
#include <sys/utsname.h> // 有时也需要，包含主机名长度常量

int sethostname(const char *name, size_t len);

3. 功能

设置内核维护的主机名。这个主机名可以通过 gethostname 系统调用或 uname 系统调用来查询。

4. 参数

• name:
  • const char * 类型。
  • 一个指向以 null 结尾的字符串的指针，该字符串包含了新的主机名。
• len:
  • size_t 类型。
  • 指定 name 字符串中实际包含的字符数（不包括末尾的 null 终止符 \0）。通常使用 strlen(name) 来获取这个长度。

5. 返回值

• 成功: 返回 0。
• 失败: 返回 -1，并设置全局变量 errno 来指示具体的错误原因。

6. 错误码 (errno)

• EFAULT: name 指向了调用进程无法访问的内存地址。
• EINVAL: len 超过了系统允许的最大主机名长度（通常是 MAXHOSTNAMELEN，在 <sys/utsname.h> 或 <limits.h> 中定义，常见值是 64 或 256）。
• EPERM: 调用进程没有权限（不是 root 用户）来更改主机名。

7. 相似函数或关联函数

• gethostname: 用于获取当前的主机名。
• uname: 系统调用，可以获取包括主机名在内的系统信息（系统名、版本、机器类型等）。对应的命令行工具也叫 uname。
• hostname: 命令行工具，用于显示或设置系统的主机名。它在底层就是调用 sethostname 和 gethostname。
• /etc/hostname: 在许多 Linux 发行版中，系统启动时会从这个文件读取主机名并使用 sethostname 设置。

8. 示例代码

下面的示例演示了如何使用 sethostname 来修改主机名，以及如何使用 gethostname 来查询它。

#define _GNU_SOURCE // 启用 GNU 扩展
#include <stdio.h>
#include <unistd.h>
#include <sys/utsname.h> // 包含 gethostname, uname, MAXHOSTNAMELEN
#include <string.h>
#include <errno.h>
#include <stdlib.h>

#define HOST_NAME_BUFFER_SIZE MAXHOSTNAMELEN // 通常定义在 <sys/utsname.h> 或 <limits.h>

void print_current_hostname(const char* context) {
    char hostname[HOST_NAME_BUFFER_SIZE];
    if (gethostname(hostname, sizeof(hostname)) == 0) {
        printf("[%s] Current hostname is: '%s'\n", context, hostname);
    } else {
        perror("gethostname");
    }
}

int main(int argc, char *argv[]) {
    char new_hostname[HOST_NAME_BUFFER_SIZE];
    struct utsname uname_info; // 用于 uname 系统调用

    printf("--- Demonstrating sethostname ---\n");

    // 1. 显示当前主机名
    print_current_hostname("Initial");

    // 2. 使用 uname 系统调用获取更详细的系统信息
    if (uname(&uname_info) == 0) {
        printf("[uname] System name: %s\n", uname_info.sysname);
        printf("[uname] Node name (hostname): %s\n", uname_info.nodename);
        printf("[uname] Release: %s\n", uname_info.release);
        printf("[uname] Version: %s\n", uname_info.version);
        printf("[uname] Machine: %s\n", uname_info.machine);
    } else {
        perror("uname");
    }

    // 3. 检查命令行参数
    if (argc != 2) {
        printf("Usage: %s <new_hostname>\n", argv[0]);
        printf("Note: You need to run this program as root to change the hostname.\n");
        exit(EXIT_FAILURE);
    }

    strncpy(new_hostname, argv[1], sizeof(new_hostname) - 1);
    new_hostname[sizeof(new_hostname) - 1] = '\0'; // 确保 null 终止

    printf("\nAttempting to change hostname to: '%s'\n", new_hostname);

    // 4. 调用 sethostname
    // 注意：这需要 root 权限
    if (sethostname(new_hostname, strlen(new_hostname)) == -1) {
        perror("sethostname");
        if (errno == EPERM) {
            printf("Error: Permission denied. You must run this program as root (e.g., using sudo).\n");
        }
        exit(EXIT_FAILURE);
    }

    printf("sethostname('%s') succeeded.\n", new_hostname);

    // 5. 再次显示主机名以验证更改
    print_current_hostname("After sethostname");

    // 6. 再次使用 uname 验证
    if (uname(&uname_info) == 0) {
        printf("[uname after change] Node name (hostname): %s\n", uname_info.nodename);
    }

    printf("\n--- Important Notes ---\n");
    printf("1. The hostname change is TEMPORARY and only lasts until the system is rebooted.\n");
    printf("2. To make the change persistent, you need to update configuration files like /etc/hostname.\n");
    printf("3. You need ROOT privileges to call sethostname.\n");

    return 0;
}

编译和运行:

# 假设代码保存在 sethostname_example.c 中
gcc -o sethostname_example sethostname_example.c

# 1. 不带参数运行 (会报错)
./sethostname_example

# 2. 带一个参数运行，但没有 root 权限 (会失败)
./sethostname_example MyNewTempHostname

# 3. 带一个参数运行，并使用 sudo 获取 root 权限 (应该成功)
# 注意：请将 MyNewTempHostname 替换为你想要的主机名
sudo ./sethostname_example MyNewTempHostname

# 4. 验证更改
hostname
uname -n

预期输出 (使用 sudo 运行):

# 假设原始主机名是 'old-hostname'
$ sudo ./sethostname_example NewTempName
--- Demonstrating sethostname ---
[Initial] Current hostname is: 'old-hostname'
[uname] System name: Linux
[uname] Node name (hostname): old-hostname
[uname] Release: 5.4.0-XX-generic
[uname] Version: #XX-Ubuntu SMP ...
[uname] Machine: x86_64

Attempting to change hostname to: 'NewTempName'
sethostname('NewTempName') succeeded.
[After sethostname] Current hostname is: 'NewTempName'
[uname after change] Node name (hostname): NewTempName

--- Important Notes ---
1. The hostname change is TEMPORARY and only lasts until the system is rebooted.
2. To make the change persistent, you need to update configuration files like /etc/hostname.
3. You need ROOT privileges to call sethostname.

# 验证命令
$ hostname
NewTempName
$ uname -n
NewTempName

重启后:
如果你重启系统，主机会名会恢复到 /etc/hostname 文件中配置的名称。

总结:
sethostname 是一个用于修改系统全局主机名的系统调用。它需要 root 权限，并且修改是临时的。理解它有助于你编写需要动态管理主机名的系统管理工具。在日常使用中，hostname 命令是更常见的设置主机名的方式。

我们来深入学习 setfsgid 和 setfsuid 这两个系统调用。
(https://www.calcguide.tech/2025/08/19/setfsuid%e7%b3%bb%e7%bb%9f%e8%b0%83%e7%94%a8%e5%8f%8a%e7%a4%ba%e4%be%8b/)

1. 函数介绍

在 Linux 系统中，每个进程都有一套与之相关的用户 ID (UID) 和组 ID (GID)，比如：

• 真实用户 ID (Real UID): 登录系统的用户 ID。
• 有效用户 ID (Effective UID): 决定进程当前拥有哪些权限，用于权限检查。
• 保存的设置用户 ID (Saved Set-UID): 用于在有效 UID 和真实 UID 之间切换。

通常，文件访问权限检查是基于进程的 有效 UID 和 有效 GID 进行的。

但是，Linux 提供了两个特殊的系统调用：setfsuid 和 setfsgid。

• setfsuid (Set File System UID): 用来设置或修改进程的 File System UID (文件系统用户 ID)。
• setfsgid (Set File System GID): 用来设置或修改进程的 File System GID (文件系统组 ID)。

关键点：
这两个 ID 只用于文件系统的权限检查！它们不影响其他任何权限检查（比如信号发送权限、进程调度优先级等）。当内核执行文件访问权限检查时，它会使用 文件系统 UID/GID 而不是 有效 UID/GID。

默认情况下：
当一个进程启动时，它的 文件系统 UID/GID 会被自动设置为与 有效 UID/GID 相同。

为什么需要它们？（主要场景）
一个经典的例子是 NFS (Network File System) 服务器：
1. NFS 服务器进程通常以 root 权限运行，因此它的 有效 UID 是 0 (root)。
2. 但是，当它代表一个非 root 用户（比如 UID 1000）访问 NFS 文件系统上的文件时，它需要进行权限检查，仿佛是 UID 1000 在访问。
3. 如果只使用 setuid/seteuid 来切换有效 UID，会影响服务器进程的其他权限（比如绑定到特权端口）。
4. 所以，NFS 服务器可以调用 setfsuid(1000)，这样在进行文件权限检查时，内核会看到 UID 是 1000，但进程的其他权限（如有效 UID 仍然是 root）保持不变。

简单来说：
setfsuid 和 setfsgid 允许进程在进行文件访问权限检查时，“伪装”成另一个用户或组，而不会影响进程的其他特权。

2. 函数原型

#include <sys/fsuid.h> // 包含函数声明 (在某些系统上可能在 unistd.h 或其他地方)

// 设置文件系统用户 ID
int setfsuid(uid_t fsuid);

// 设置文件系统组 ID
int setfsgid(gid_t fsgid);

3. 功能

分别设置调用进程的文件系统用户 ID (FS-UID) 和文件系统组 ID (FS-GID)，仅用于文件系统的访问权限检查。

4. 参数

• fsuid:
  • uid_t 类型。
  • 指定要设置的新文件系统用户 ID。
• fsgid:
  • gid_t 类型。
  • 指定要设置的新文件系统组 ID。

5. 返回值

这两个函数的返回值比较特殊：

• 总是返回调用者之前的 文件系统 UID (setfsuid) 或 文件系统 GID (setfsgid)。
• 无论调用成功与否！

这与其他大多数系统调用不同（它们通常成功返回 0 或文件描述符，失败返回 -1）。这种设计意味着你无法仅通过返回值判断调用是否成功。

那么如何判断是否成功呢？
通常的做法是：
1. 先调用 setfsuid/setfsgid。
2. 然后立即再次调用 setfsuid/setfsgid，传入同一个 ID。
3. 如果两次返回的旧 ID 相同，说明第一次调用成功了；如果不同，则说明第一次调用失败。

调用失败的情况：
调用通常会成功，但在某些安全模型下或传入无效 ID 时可能会失败。不过，失败的具体条件比较复杂，实践中很少遇到。

6. 相似函数或关联函数

• setuid / seteuid / setreuid / setresuid: 用于设置进程的真实、有效、保存的用户 ID。这些会影响所有权限检查，而不仅仅是文件系统权限。
• setgid / setegid / setregid / setresgid: 用于设置进程的组 ID。
• getuid / geteuid / getgid / getegid: 获取进程的真实和有效 UID/GID。
• capset / capget: 用于设置和获取进程的能力 (capabilities)，这是 Linux 中更细粒度的权限控制机制，可以作为 setuid/setfsuid 的现代替代方案。
• 文件系统权限检查: 内核在 open, read, write, stat 等系统调用时执行的检查。

7. 示例代码

由于 setfsuid/setfsgid 的使用场景比较特殊（主要是像 NFS 这样的服务器程序），编写一个完全展示其效果的用户态程序比较困难，因为它需要特定的文件系统环境和权限设置。下面的示例将演示如何调用它们，并尝试解释其行为。

#define _GNU_SOURCE // 启用 GNU 扩展以使用 getresuid 等
#include <stdio.h>
#include <unistd.h>
#include <sys/fsuid.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>

int main() {
    uid_t ruid, euid, suid;
    gid_t rgid, egid, sgid;
    uid_t old_fsuid, new_fsuid;
    gid_t old_fsgid, new_fsgid;

    printf("--- Demonstrating setfsuid and setfsgid ---\n");

    // 1. 获取当前进程的各种 ID
    if (getresuid(&ruid, &euid, &suid) == -1 ||
        getresgid(&rgid, &egid, &sgid) == -1) {
        perror("getresuid/getresgid");
        exit(EXIT_FAILURE);
    }

    printf("Initial IDs:\n");
    printf("  Real UID:      %d\n", ruid);
    printf("  Effective UID: %d\n", euid);
    printf("  Saved UID:     %d\n", suid);
    printf("  Real GID:      %d\n", rgid);
    printf("  Effective GID: %d\n", egid);
    printf("  Saved GID:     %d\n", sgid);
    printf("  (By default, FS-UID and FS-GID equal Effective UID/GID)\n");

    // 2. 演示 setfsuid
    printf("\n--- Testing setfsuid ---\n");
    // 获取当前 FS-UID (通过调用 setfsuid 并传入当前 EUID)
    old_fsuid = setfsuid(euid);
    printf("  Current FS-UID (queried): %d\n", old_fsuid);

    // 尝试将 FS-UID 设置为一个不同的值，例如 euid + 1 (如果存在)
    // 注意：这只是演示，实际是否有效取决于系统中是否存在该 UID
    // 并且权限检查仍然基于文件系统权限
    new_fsuid = (euid == 0) ? 1 : euid - 1; // 简单地选择一个不同的 UID
    printf("  Attempting to set FS-UID to: %d\n", new_fsuid);

    uid_t result1 = setfsuid(new_fsuid);
    printf("  setfsuid(%d) returned: %d (should be the old FS-UID: %d)\n", new_fsuid, result1, old_fsuid);

    // 验证是否设置成功：再次调用 setfsuid 获取当前值
    uid_t result2 = setfsuid(new_fsuid);
    printf("  Verifying: setfsuid(%d) again returned: %d\n", new_fsuid, result2);
    if (result1 == result2) {
        printf("  -> FS-UID was successfully set to %d.\n", new_fsuid);
    } else {
        printf("  -> FS-UID setting might have failed.\n");
    }

    // 3. 演示 setfsgid (逻辑同上)
    printf("\n--- Testing setfsgid ---\n");
    old_fsgid = setfsgid(egid);
    printf("  Current FS-GID (queried): %d\n", old_fsgid);

    new_fsgid = (egid == 0) ? 1 : egid - 1; // 选择一个不同的 GID
    printf("  Attempting to set FS-GID to: %d\n", new_fsgid);

    gid_t result3 = setfsgid(new_fsgid);
    printf("  setfsgid(%d) returned: %d (should be the old FS-GID: %d)\n", new_fsgid, result3, old_fsgid);

    gid_t result4 = setfsgid(new_fsgid);
    printf("  Verifying: setfsgid(%d) again returned: %d\n", new_fsgid, result4);
    if (result3 == result4) {
        printf("  -> FS-GID was successfully set to %d.\n", new_fsgid);
    } else {
        printf("  -> FS-GID setting might have failed.\n");
    }

    // 4. 尝试一个实际的文件操作来“感受” FS-UID/GID 的影响
    // 注意：这个例子的权限检查结果可能不会明显变化，
    // 因为我们没有真正切换到一个权限不同的用户上下文，
    // 也没有访问一个严格基于 FS-UID/GID 权限的特殊文件系统。
    printf("\n--- Attempting file operation to observe behavior ---\n");
    const char *test_file = "test_fsuid_file.txt";
    int fd;

    // 创建一个测试文件
    fd = open(test_file, O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd != -1) {
        write(fd, "test", 4);
        close(fd);
        printf("  Created test file '%s'.\n", test_file);
    } else {
        perror("  Creating test file");
    }

    // 尝试读取文件 (应该成功，因为我们没有真正改变有效权限)
    fd = open(test_file, O_RDONLY);
    if (fd != -1) {
        printf("  Successfully opened '%s' for reading (as expected).\n", test_file);
        close(fd);
    } else {
        perror("  Opening test file for reading");
    }

    // 清理测试文件
    if (unlink(test_file) == -1) {
        perror("  Deleting test file");
    } else {
        printf("  Deleted test file '%s'.\n", test_file);
    }

    printf("\n--- Important Notes ---\n");
    printf("1. setfsuid/setfsgid primarily affect filesystem permission checks.\n");
    printf("2. They do not change effective UID/GID for other operations.\n");
    printf("3. Their main use is in system daemons like NFS servers.\n");
    printf("4. The return value is the OLD fsid, success is verified by calling again.\n");

    return 0;
}

编译和运行:

# 假设代码保存在 fsuid_fsgid_example.c 中
gcc -o fsuid_fsgid_example fsuid_fsgid_example.c

# 运行程序 (普通用户权限即可)
./fsuid_fsgid_example

# 你也可以用 sudo 运行，看看 root 权限下的行为
# sudo ./fsuid_fsgid_example

预期输出 (作为普通用户运行):

--- Demonstrating setfsuid and setfsgid ---
Initial IDs:
  Real UID:      1000
  Effective UID: 1000
  Saved UID:     1000
  Real GID:      1000
  Effective GID: 1000
  Saved GID:     1000
  (By default, FS-UID and FS-GID equal Effective UID/GID)

--- Testing setfsuid ---
  Current FS-UID (queried): 1000
  Attempting to set FS-UID to: 999
  setfsuid(999) returned: 1000 (should be the old FS-UID: 1000)
  Verifying: setfsuid(999) again returned: 999
  -> FS-UID was successfully set to 999.

--- Testing setfsgid ---
  Current FS-GID (queried): 1000
  Attempting to set FS-GID to: 999
  setfsgid(999) returned: 1000 (should be the old FS-GID: 1000)
  Verifying: setfsgid(999) again returned: 999
  -> FS-GID was successfully set to 999.

--- Attempting file operation to observe behavior ---
  Created test file 'test_fsuid_file.txt'.
  Successfully opened 'test_fsuid_file.txt' for reading (as expected).
  Deleted test file 'test_fsuid_file.txt'.

--- Important Notes ---
1. setfsuid/setfsgid primarily affect filesystem permission checks.
2. They do not change effective UID/GID for other operations.
3. Their main use is in system daemons like NFS servers.
4. The return value is the OLD fsid, success is verified by calling again.

总结:
对于 Linux 编程新手，setfsuid 和 setfsgid 是比较特殊的系统调用。它们不是日常编程中会频繁使用的。理解它们有助于理解 Linux 权限模型的细节，特别是文件系统权限检查是如何与进程的其他权限分离的。在编写需要代表不同用户执行文件操作的系统服务（如文件服务器）时，它们会很有用。在常规应用程序开发中，使用标准的 setuid/seteuid 或现代的 capabilities 通常更合适。

我们来深入学习 setfsgid 和 setfsuid 这两个系统调用

1. 函数介绍

在 Linux 系统中，每个进程都有一套与之相关的用户 ID (UID) 和组 ID (GID)，比如：

• 真实用户 ID (Real UID): 登录系统的用户 ID。
• 有效用户 ID (Effective UID): 决定进程当前拥有哪些权限，用于权限检查。
• 保存的设置用户 ID (Saved Set-UID): 用于在有效 UID 和真实 UID 之间切换。

通常，文件访问权限检查是基于进程的 有效 UID 和 有效 GID 进行的。

但是，Linux 提供了两个特殊的系统调用：setfsuid 和 setfsgid。

• setfsuid (Set File System UID): 用来设置或修改进程的 File System UID (文件系统用户 ID)。
• setfsgid (Set File System GID): 用来设置或修改进程的 File System GID (文件系统组 ID)。

关键点：
这两个 ID 只用于文件系统的权限检查！它们不影响其他任何权限检查（比如信号发送权限、进程调度优先级等）。当内核执行文件访问权限检查时，它会使用 文件系统 UID/GID 而不是 有效 UID/GID。

默认情况下：
当一个进程启动时，它的 文件系统 UID/GID 会被自动设置为与 有效 UID/GID 相同。

为什么需要它们？（主要场景）
一个经典的例子是 NFS (Network File System) 服务器：

1. NFS 服务器进程通常以 root 权限运行，因此它的 有效 UID 是 0 (root)。
2. 但是，当它代表一个非 root 用户（比如 UID 1000）访问 NFS 文件系统上的文件时，它需要进行权限检查，仿佛是 UID 1000 在访问。
3. 如果只使用 setuid/seteuid 来切换有效 UID，会影响服务器进程的其他权限（比如绑定到特权端口）。
4. 所以，NFS 服务器可以调用 setfsuid(1000)，这样在进行文件权限检查时，内核会看到 UID 是 1000，但进程的其他权限（如有效 UID 仍然是 root）保持不变。

简单来说：
setfsuid 和 setfsgid 允许进程在进行文件访问权限检查时，“伪装”成另一个用户或组，而不会影响进程的其他特权。

2. 函数原型

#include <sys/fsuid.h> // 包含函数声明 (在某些系统上可能在 unistd.h 或其他地方)

// 设置文件系统用户 ID
int setfsuid(uid_t fsuid);

// 设置文件系统组 ID
int setfsgid(gid_t fsgid);

3. 功能

分别设置调用进程的文件系统用户 ID (FS-UID) 和文件系统组 ID (FS-GID)，仅用于文件系统的访问权限检查。

4. 参数

• fsuid:
  • uid_t 类型。
  • 指定要设置的新文件系统用户 ID。
• fsgid:
  • gid_t 类型。
  • 指定要设置的新文件系统组 ID。

5. 返回值

这两个函数的返回值比较特殊：

• 总是返回调用者之前的 文件系统 UID (setfsuid) 或 文件系统 GID (setfsgid)。
• 无论调用成功与否！

这与其他大多数系统调用不同（它们通常成功返回 0 或文件描述符，失败返回 -1）。这种设计意味着你无法仅通过返回值判断调用是否成功。

那么如何判断是否成功呢？
通常的做法是：

1. 先调用 setfsuid/setfsgid。
2. 然后立即再次调用 setfsuid/setfsgid，传入同一个 ID。
3. 如果两次返回的旧 ID 相同，说明第一次调用成功了；如果不同，则说明第一次调用失败。

调用失败的情况：
调用通常会成功，但在某些安全模型下或传入无效 ID 时可能会失败。不过，失败的具体条件比较复杂，实践中很少遇到。

6. 相似函数或关联函数

• setuid / seteuid / setreuid / setresuid: 用于设置进程的真实、有效、保存的用户 ID。这些会影响所有权限检查，而不仅仅是文件系统权限。
• setgid / setegid / setregid / setresgid: 用于设置进程的组 ID。
• getuid / geteuid / getgid / getegid: 获取进程的真实和有效 UID/GID。
• capset / capget: 用于设置和获取进程的能力 (capabilities)，这是 Linux 中更细粒度的权限控制机制，可以作为 setuid/setfsuid 的现代替代方案。
• 文件系统权限检查: 内核在 open, read, write, stat 等系统调用时执行的检查。

7. 示例代码

由于 setfsuid/setfsgid 的使用场景比较特殊（主要是像 NFS 这样的服务器程序），编写一个完全展示其效果的用户态程序比较困难，因为它需要特定的文件系统环境和权限设置。下面的示例将演示如何调用它们，并尝试解释其行为。

#define _GNU_SOURCE // 启用 GNU 扩展以使用 getresuid 等
#include <stdio.h>
#include <unistd.h>
#include <sys/fsuid.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>

int main() {
    uid_t ruid, euid, suid;
    gid_t rgid, egid, sgid;
    uid_t old_fsuid, new_fsuid;
    gid_t old_fsgid, new_fsgid;

    printf("--- Demonstrating setfsuid and setfsgid ---\n");

    // 1. 获取当前进程的各种 ID
    if (getresuid(&ruid, &euid, &suid) == -1 ||
        getresgid(&rgid, &egid, &sgid) == -1) {
        perror("getresuid/getresgid");
        exit(EXIT_FAILURE);
    }

    printf("Initial IDs:\n");
    printf("  Real UID:      %d\n", ruid);
    printf("  Effective UID: %d\n", euid);
    printf("  Saved UID:     %d\n", suid);
    printf("  Real GID:      %d\n", rgid);
    printf("  Effective GID: %d\n", egid);
    printf("  Saved GID:     %d\n", sgid);
    printf("  (By default, FS-UID and FS-GID equal Effective UID/GID)\n");

    // 2. 演示 setfsuid
    printf("\n--- Testing setfsuid ---\n");
    // 获取当前 FS-UID (通过调用 setfsuid 并传入当前 EUID)
    old_fsuid = setfsuid(euid);
    printf("  Current FS-UID (queried): %d\n", old_fsuid);

    // 尝试将 FS-UID 设置为一个不同的值，例如 euid + 1 (如果存在)
    // 注意：这只是演示，实际是否有效取决于系统中是否存在该 UID
    // 并且权限检查仍然基于文件系统权限
    new_fsuid = (euid == 0) ? 1 : euid - 1; // 简单地选择一个不同的 UID
    printf("  Attempting to set FS-UID to: %d\n", new_fsuid);

    uid_t result1 = setfsuid(new_fsuid);
    printf("  setfsuid(%d) returned: %d (should be the old FS-UID: %d)\n", new_fsuid, result1, old_fsuid);

    // 验证是否设置成功：再次调用 setfsuid 获取当前值
    uid_t result2 = setfsuid(new_fsuid);
    printf("  Verifying: setfsuid(%d) again returned: %d\n", new_fsuid, result2);
    if (result1 == result2) {
        printf("  -> FS-UID was successfully set to %d.\n", new_fsuid);
    } else {
        printf("  -> FS-UID setting might have failed.\n");
    }

    // 3. 演示 setfsgid (逻辑同上)
    printf("\n--- Testing setfsgid ---\n");
    old_fsgid = setfsgid(egid);
    printf("  Current FS-GID (queried): %d\n", old_fsgid);

    new_fsgid = (egid == 0) ? 1 : egid - 1; // 选择一个不同的 GID
    printf("  Attempting to set FS-GID to: %d\n", new_fsgid);

    gid_t result3 = setfsgid(new_fsgid);
    printf("  setfsgid(%d) returned: %d (should be the old FS-GID: %d)\n", new_fsgid, result3, old_fsgid);

    gid_t result4 = setfsgid(new_fsgid);
    printf("  Verifying: setfsgid(%d) again returned: %d\n", new_fsgid, result4);
    if (result3 == result4) {
        printf("  -> FS-GID was successfully set to %d.\n", new_fsgid);
    } else {
        printf("  -> FS-GID setting might have failed.\n");
    }

    // 4. 尝试一个实际的文件操作来“感受” FS-UID/GID 的影响
    // 注意：这个例子的权限检查结果可能不会明显变化，
    // 因为我们没有真正切换到一个权限不同的用户上下文，
    // 也没有访问一个严格基于 FS-UID/GID 权限的特殊文件系统。
    printf("\n--- Attempting file operation to observe behavior ---\n");
    const char *test_file = "test_fsuid_file.txt";
    int fd;

    // 创建一个测试文件
    fd = open(test_file, O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd != -1) {
        write(fd, "test", 4);
        close(fd);
        printf("  Created test file '%s'.\n", test_file);
    } else {
        perror("  Creating test file");
    }

    // 尝试读取文件 (应该成功，因为我们没有真正改变有效权限)
    fd = open(test_file, O_RDONLY);
    if (fd != -1) {
        printf("  Successfully opened '%s' for reading (as expected).\n", test_file);
        close(fd);
    } else {
        perror("  Opening test file for reading");
    }

    // 清理测试文件
    if (unlink(test_file) == -1) {
        perror("  Deleting test file");
    } else {
        printf("  Deleted test file '%s'.\n", test_file);
    }

    printf("\n--- Important Notes ---\n");
    printf("1. setfsuid/setfsgid primarily affect filesystem permission checks.\n");
    printf("2. They do not change effective UID/GID for other operations.\n");
    printf("3. Their main use is in system daemons like NFS servers.\n");
    printf("4. The return value is the OLD fsid, success is verified by calling again.\n");

    return 0;
}

编译和运行:

# 假设代码保存在 fsuid_fsgid_example.c 中
gcc -o fsuid_fsgid_example fsuid_fsgid_example.c

# 运行程序 (普通用户权限即可)
./fsuid_fsgid_example

# 你也可以用 sudo 运行，看看 root 权限下的行为
# sudo ./fsuid_fsgid_example

预期输出 (作为普通用户运行):

--- Demonstrating setfsuid and setfsgid ---
Initial IDs:
  Real UID:      1000
  Effective UID: 1000
  Saved UID:     1000
  Real GID:      1000
  Effective GID: 1000
  Saved GID:     1000
  (By default, FS-UID and FS-GID equal Effective UID/GID)

--- Testing setfsuid ---
  Current FS-UID (queried): 1000
  Attempting to set FS-UID to: 999
  setfsuid(999) returned: 1000 (should be the old FS-UID: 1000)
  Verifying: setfsuid(999) again returned: 999
  -> FS-UID was successfully set to 999.

--- Testing setfsgid ---
  Current FS-GID (queried): 1000
  Attempting to set FS-GID to: 999
  setfsgid(999) returned: 1000 (should be the old FS-GID: 1000)
  Verifying: setfsgid(999) again returned: 999
  -> FS-GID was successfully set to 999.

--- Attempting file operation to observe behavior ---
  Created test file 'test_fsuid_file.txt'.
  Successfully opened 'test_fsuid_file.txt' for reading (as expected).
  Deleted test file 'test_fsuid_file.txt'.

--- Important Notes ---
1. setfsuid/setfsgid primarily affect filesystem permission checks.
2. They do not change effective UID/GID for other operations.
3. Their main use is in system daemons like NFS servers.
4. The return value is the OLD fsid, success is verified by calling again.

总结:
对于 Linux 编程新手，setfsuid 和 setfsgid 是比较特殊的系统调用。它们不是日常编程中会频繁使用的。理解它们有助于理解 Linux 权限模型的细节，特别是文件系统权限检查是如何与进程的其他权限分离的。在编写需要代表不同用户执行文件操作的系统服务（如文件服务器）时，它们会很有用。在常规应用程序开发中，使用标准的 setuid/seteuid 或现代的 capabilities 通常更合适。

sendmmsg 函数详解

1. 函数介绍

sendmmsg 是Linux 2.6.39引入的高效批量发送消息系统调用。它是 sendmsg 的批量版本，允许应用程序在单次系统调用中发送多个消息，显著减少了系统调用开销，特别适用于高吞吐量的网络服务器和实时应用。

2. 函数原型

#define _GNU_SOURCE
#include <sys/socket.h>
int sendmmsg(int sockfd, struct mmsghdr *msgvec, unsigned int vlen,
             int flags);

3. 功能

sendmmsg 允许向套接字批量发送多个消息，每个消息可以包含数据和控制信息。它支持分散缓冲区发送、地址信息指定、控制数据发送等功能，是构建高性能网络应用的关键工具。

4. 参数

• int sockfd: 套接字文件描述符
• *struct mmsghdr msgvec: 消息向量数组，描述多个发送消息
• unsigned int vlen: 消息向量数组的长度（最大可发送的消息数）
• int flags: 发送标志，与sendmsg相同

5. 返回值

• 成功: 返回实际发送的消息数量
• 失败: 返回-1，并设置errno

6. 相似函数，或关联函数

• sendmsg: 单消息发送函数
• send: 基本发送函数
• recvmmsg: 对应的批量接收函数
• writev: 分散缓冲区写入函数

7. 示例代码

示例1：基础sendmmsg使用

#define _GNU_SOURCE
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

/**
 * 演示sendmmsg的基础使用方法
 */
int demo_sendmmsg_basic() {
    int server_fd, client_fd;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_len = sizeof(client_addr);
    struct mmsghdr msgvec[3];
    struct iovec iov[3][1];
    char *messages[3] = {
        "First message from sendmmsg",
        "Second message from sendmmsg", 
        "Third message from sendmmsg"
    };
    int messages_sent;
    
    printf("=== sendmmsg 基础使用示例 ===\n");
    
    // 创建TCP服务器套接字
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd == -1) {
        perror("创建服务器套接字失败");
        return -1;
    }
    
    // 设置服务器地址
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(8080);
    
    // 绑定套接字
    if (bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        perror("绑定套接字失败");
        close(server_fd);
        return -1;
    }
    
    // 监听连接
    if (listen(server_fd, 1) == -1) {
        perror("监听失败");
        close(server_fd);
        return -1;
    }
    
    printf("服务器监听在端口 8080\n");
    
    // 启动客户端连接
    if (fork() == 0) {
        // 客户端代码
        sleep(1);  // 等待服务器启动
        client_fd = socket(AF_INET, SOCK_STREAM, 0);
        struct sockaddr_in serv_addr;
        
        memset(&serv_addr, 0, sizeof(serv_addr));
        serv_addr.sin_family = AF_INET;
        serv_addr.sin_port = htons(8080);
        serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
        
        if (connect(client_fd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == 0) {
            printf("客户端连接成功\n");
            
            // 接收服务器发送的消息
            char buffer[256];
            for (int i = 0; i < 3; i++) {
                ssize_t bytes = recv(client_fd, buffer, sizeof(buffer) - 1, 0);
                if (bytes > 0) {
                    buffer[bytes] = '\0';
                    printf("客户端接收到消息 %d: %s\n", i + 1, buffer);
                }
            }
        }
        
        close(client_fd);
        exit(0);
    }
    
    // 接受客户端连接
    client_fd = accept(server_fd, (struct sockaddr*)&client_addr, &client_len);
    if (client_fd == -1) {
        perror("接受连接失败");
        close(server_fd);
        return -1;
    }
    
    printf("客户端连接来自: %s:%d\n", 
           inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
    
    // 准备批量发送消息结构
    memset(msgvec, 0, sizeof(msgvec));
    
    for (int i = 0; i < 3; i++) {
        // 设置每个消息的缓冲区
        iov[i][0].iov_base = messages[i];
        iov[i][0].iov_len = strlen(messages[i]);
        
        // 设置消息头
        msgvec[i].msg_hdr.msg_iov = iov[i];
        msgvec[i].msg_hdr.msg_iovlen = 1;
        msgvec[i].msg_hdr.msg_name = NULL;  // TCP不需要目标地址
        msgvec[i].msg_hdr.msg_namelen = 0;
    }
    
    printf("准备批量发送3个消息...\n");
    
    // 批量发送消息
    messages_sent = sendmmsg(client_fd, msgvec, 3, 0);
    
    if (messages_sent == -1) {
        perror("sendmmsg 失败");
        close(client_fd);
        close(server_fd);
        return -1;
    }
    
    printf("成功发送 %d 个消息:\n", messages_sent);
    
    // 显示发送结果
    for (int i = 0; i < messages_sent; i++) {
        printf("  消息 %d: 发送了 %u 字节\n", i + 1, msgvec[i].msg_len);
    }
    
    close(client_fd);
    close(server_fd);
    
    // 等待客户端结束
    int status;
    wait(&status);
    
    return 0;
}

int main() {
    return demo_sendmmsg_basic();
}

示例2：UDP批量发送

#define _GNU_SOURCE
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <time.h>

/**
 * 演示UDP批量发送消息
 */
int demo_udp_batch_send() {
    int client_fd;
    struct sockaddr_in server_addr;
    struct mmsghdr msgvec[5];
    struct iovec iov[5][2];  // 每个消息使用2个缓冲区
    char *message_parts[5][2] = {
        {"UDP ", "Message 1"},
        {"UDP ", "Message 2"},
        {"UDP ", "Message 3"},
        {"UDP ", "Message 4"},
        {"UDP ", "Message 5"}
    };
    int messages_sent;
    
    printf("=== UDP批量发送示例 ===\n");
    
    // 创建UDP客户端套接字
    client_fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (client_fd == -1) {
        perror("创建UDP套接字失败");
        return -1;
    }
    
    // 设置服务器地址
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8081);
    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    
    printf("UDP客户端准备向 127.0.0.1:8081 发送消息\n");
    
    // 准备批量发送结构（使用分散缓冲区）
    memset(msgvec, 0, sizeof(msgvec));
    
    for (int i = 0; i < 5; i++) {
        // 设置分散缓冲区
        iov[i][0].iov_base = message_parts[i][0];
        iov[i][0].iov_len = strlen(message_parts[i][0]);
        iov[i][1].iov_base = message_parts[i][1];
        iov[i][1].iov_len = strlen(message_parts[i][1]);
        
        // 设置消息头
        msgvec[i].msg_hdr.msg_iov = iov[i];
        msgvec[i].msg_hdr.msg_iovlen = 2;
        msgvec[i].msg_hdr.msg_name = &server_addr;
        msgvec[i].msg_hdr.msg_namelen = sizeof(server_addr);
    }
    
    printf("准备发送5个UDP消息（每个消息使用分散缓冲区）...\n");
    
    // 批量发送UDP消息
    messages_sent = sendmmsg(client_fd, msgvec, 5, 0);
    
    if (messages_sent == -1) {
        perror("sendmmsg 失败");
        close(client_fd);
        return -1;
    }
    
    printf("成功发送 %d 个UDP消息:\n", messages_sent);
    
    // 显示发送统计
    size_t total_bytes = 0;
    for (int i = 0; i < messages_sent; i++) {
        printf("  消息 %d: %u 字节\n", i + 1, msgvec[i].msg_len);
        total_bytes += msgvec[i].msg_len;
    }
    
    printf("总发送字节数: %zu\n", total_bytes);
    
    close(client_fd);
    
    return 0;
}

/**
 * UDP服务器用于接收批量消息
 */
int udp_server_receive() {
    int server_fd;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_len = sizeof(client_addr);
    char buffer[256];
    ssize_t bytes_received;
    int message_count = 0;
    
    server_fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (server_fd == -1) {
        perror("创建UDP服务器套接字失败");
        return -1;
    }
    
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(8081);
    
    if (bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        perror("绑定UDP套接字失败");
        close(server_fd);
        return -1;
    }
    
    printf("UDP服务器监听在端口 8081\n");
    printf("等待接收消息（10秒超时）...\n");
    
    // 设置接收超时
    struct timeval timeout;
    timeout.tv_sec = 10;
    timeout.tv_usec = 0;
    setsockopt(server_fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
    
    // 接收消息
    while (message_count < 10) {
        bytes_received = recvfrom(server_fd, buffer, sizeof(buffer) - 1, 0,
                                 (struct sockaddr*)&client_addr, &client_len);
        if (bytes_received == -1) {
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                printf("接收超时\n");
                break;
            }
            perror("接收消息失败");
            break;
        }
        
        buffer[bytes_received] = '\0';
        printf("接收到消息 %d: %s (来自 %s:%d)\n", 
               ++message_count, buffer,
               inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
    }
    
    close(server_fd);
    return 0;
}

int main() {
    // 启动UDP服务器
    if (fork() == 0) {
        sleep(1);  // 等待客户端准备
        return udp_server_receive();
    }
    
    // 执行UDP批量发送
    sleep(1);
    int result = demo_udp_batch_send();
    
    // 等待服务器结束
    int status;
    wait(&status);
    
    return result;
}

示例3：高性能网络服务器

#define _GNU_SOURCE
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <poll.h>
#include <time.h>

/**
 * 高性能服务器结构
 */
typedef struct {
    int server_fd;
    int port;
    struct pollfd *clients;
    int max_clients;
    int client_count;
    unsigned long messages_sent;
    unsigned long bytes_sent;
} high_perf_server_t;

/**
 * 初始化高性能服务器
 */
int server_init(high_perf_server_t *server, int port, int max_clients) {
    struct sockaddr_in server_addr;
    
    memset(server, 0, sizeof(high_perf_server_t));
    server->port = port;
    server->max_clients = max_clients;
    server->client_count = 0;
    server->messages_sent = 0;
    server->bytes_sent = 0;
    
    // 分配客户端数组
    server->clients = calloc(max_clients + 1, sizeof(struct pollfd));
    if (!server->clients) {
        perror("分配客户端数组失败");
        return -1;
    }
    
    // 创建服务器套接字
    server->server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server->server_fd == -1) {
        perror("创建服务器套接字失败");
        free(server->clients);
        return -1;
    }
    
    // 设置套接字选项
    int opt = 1;
    if (setsockopt(server->server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) == -1) {
        perror("设置套接字选项失败");
        close(server->server_fd);
        free(server->clients);
        return -1;
    }
    
    // 设置服务器地址
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(port);
    
    // 绑定套接字
    if (bind(server->server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        perror("绑定套接字失败");
        close(server->server_fd);
        free(server->clients);
        return -1;
    }
    
    // 监听连接
    if (listen(server->server_fd, 10) == -1) {
        perror("监听失败");
        close(server->server_fd);
        free(server->clients);
        return -1;
    }
    
    // 设置服务器套接字为poll监听
    server->clients[0].fd = server->server_fd;
    server->clients[0].events = POLLIN;
    
    printf("高性能服务器初始化完成，监听端口 %d\n", port);
    return 0;
}

/**
 * 接受新客户端连接
 */
int server_accept_client(high_perf_server_t *server) {
    struct sockaddr_in client_addr;
    socklen_t client_len = sizeof(client_addr);
    int client_fd;
    
    client_fd = accept(server->server_fd, (struct sockaddr*)&client_addr, &client_len);
    if (client_fd == -1) {
        perror("接受连接失败");
        return -1;
    }
    
    if (server->client_count >= server->max_clients) {
        printf("客户端数量已达上限，拒绝连接\n");
        close(client_fd);
        return -1;
    }
    
    // 添加到客户端数组
    int index = server->client_count + 1;
    server->clients[index].fd = client_fd;
    server->clients[index].events = POLLOUT;  // 准备发送数据
    server->client_count++;
    
    printf("新客户端连接: %s:%d (fd=%d)\n", 
           inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port), client_fd);
    
    return 0;
}

/**
 * 使用sendmmsg向客户端批量发送消息
 */
int server_send_batch_messages(high_perf_server_t *server, int client_index) {
    int client_fd = server->clients[client_index].fd;
    const int BATCH_SIZE = 8;  // 每次批量发送8个消息
    struct mmsghdr msgvec[BATCH_SIZE];
    struct iovec iov[BATCH_SIZE][1];
    char messages[BATCH_SIZE][128];
    int messages_to_send = 0;
    
    // 准备批量发送消息
    memset(msgvec, 0, sizeof(msgvec));
    
    for (int i = 0; i < BATCH_SIZE; i++) {
        // 构造消息内容
        snprintf(messages[i], sizeof(messages[i]), 
                "Server Message %lu: Batch %d, Index %d", 
                server->messages_sent + i + 1, 
                (int)(server->messages_sent / BATCH_SIZE) + 1, i + 1);
        
        // 设置缓冲区
        iov[i][0].iov_base = messages[i];
        iov[i][0].iov_len = strlen(messages[i]);
        
        // 设置消息头
        msgvec[i].msg_hdr.msg_iov = iov[i];
        msgvec[i].msg_hdr.msg_iovlen = 1;
        msgvec[i].msg_hdr.msg_name = NULL;
        msgvec[i].msg_hdr.msg_namelen = 0;
        
        messages_to_send++;
    }
    
    // 批量发送消息
    int messages_sent = sendmmsg(client_fd, msgvec, messages_to_send, MSG_NOSIGNAL);
    
    if (messages_sent == -1) {
        if (errno == EPIPE || errno == ECONNRESET) {
            printf("客户端 %d 连接断开\n", client_fd);
            return -1;
        }
        perror("sendmmsg 失败");
        return -1;
    }
    
    // 更新统计信息
    server->messages_sent += messages_sent;
    for (int i = 0; i < messages_sent; i++) {
        server->bytes_sent += msgvec[i].msg_len;
    }
    
    printf("向客户端 %d 批量发送 %d 个消息\n", client_fd, messages_sent);
    
    return 0;
}

/**
 * 运行服务器主循环
 */
int server_run(high_perf_server_t *server) {
    printf("服务器开始运行，等待客户端连接...\n");
    
    time_t start_time = time(NULL);
    
    while (difftime(time(NULL), start_time) < 30) {  // 运行30秒
        // 使用poll等待事件
        int nfds = server->client_count + 1;
        int activity = poll(server->clients, nfds, 1000);  // 1秒超时
        
        if (activity == -1) {
            if (errno == EINTR) continue;  // 被信号中断
            perror("poll 失败");
            break;
        }
        
        if (activity == 0) {
            // 超时，继续循环
            continue;
        }
        
        // 检查服务器套接字（新连接）
        if (server->clients[0].revents & POLLIN) {
            server_accept_client(server);
            activity--;
        }
        
        // 检查客户端套接字（准备发送数据）
        for (int i = 1; i <= server->client_count && activity > 0; i++) {
            if (server->clients[i].revents & POLLOUT) {
                if (server_send_batch_messages(server, i) == -1) {
                    // 客户端断开连接，移除客户端
                    close(server->clients[i].fd);
                    // 将最后一个客户端移到当前位置
                    if (i < server->client_count) {
                        server->clients[i] = server->clients[server->client_count];
                    }
                    server->client_count--;
                    i--;  // 重新检查当前位置
                }
                activity--;
            }
        }
    }
    
    return 0;
}

/**
 * 清理服务器资源
 */
void server_cleanup(high_perf_server_t *server) {
    // 关闭所有客户端连接
    for (int i = 1; i <= server->client_count; i++) {
        close(server->clients[i].fd);
    }
    
    // 关闭服务器套接字
    if (server->server_fd != -1) {
        close(server->server_fd);
    }
    
    // 释放内存
    if (server->clients) {
        free(server->clients);
    }
    
    printf("服务器资源清理完成\n");
    printf("统计信息:\n");
    printf("  总发送消息数: %lu\n", server->messages_sent);
    printf("  总发送字节数: %lu\n", server->bytes_sent);
    if (server->messages_sent > 0) {
        printf("  平均消息大小: %.2f 字节\n", 
               (double)server->bytes_sent / server->messages_sent);
    }
}

/**
 * 演示高性能网络服务器
 */
int demo_high_performance_server() {
    high_perf_server_t server;
    
    printf("=== 高性能网络服务器示例 ===\n");
    
    // 初始化服务器
    if (server_init(&server, 8082, 10) != 0) {
        return -1;
    }
    
    // 启动测试客户端
    if (fork() == 0) {
        sleep(2);  // 等待服务器启动
        
        // 创建多个并发客户端
        for (int i = 0; i < 3; i++) {
            if (fork() == 0) {
                int client_sock = socket(AF_INET, SOCK_STREAM, 0);
                struct sockaddr_in serv_addr;
                
                memset(&serv_addr, 0, sizeof(serv_addr));
                serv_addr.sin_family = AF_INET;
                serv_addr.sin_port = htons(8082);
                serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
                
                if (connect(client_sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == 0) {
                    printf("客户端 %d 连接成功\n", i + 1);
                    
                    // 接收服务器发送的消息
                    char buffer[256];
                    for (int msg = 0; msg < 20; msg++) {
                        ssize_t bytes = recv(client_sock, buffer, sizeof(buffer) - 1, 0);
                        if (bytes > 0) {
                            buffer[bytes] = '\0';
                            printf("客户端 %d 接收消息: %s\n", i + 1, buffer);
                        } else if (bytes == 0) {
                            printf("客户端 %d 连接关闭\n", i + 1);
                            break;
                        }
                    }
                }
                
                close(client_sock);
                exit(0);
            }
        }
        
        // 等待所有客户端完成
        for (int i = 0; i < 3; i++) {
            int status;
            wait(&status);
        }
        
        exit(0);
    }
    
    // 运行服务器
    server_run(&server);
    
    // 清理资源
    server_cleanup(&server);
    
    // 等待测试客户端结束
    int status;
    wait(&status);
    
    return 0;
}

int main() {
    return demo_high_performance_server();
}

示例4：实时数据流发送

#define _GNU_SOURCE
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <signal.h>

/**
 * 实时数据流结构
 */
typedef struct {
    int sockfd;
    struct sockaddr_in dest_addr;
    unsigned long packets_sent;
    unsigned long bytes_sent;
    time_t start_time;
    volatile int running;
} data_stream_t;

// 全局变量用于信号处理
static data_stream_t *g_stream = NULL;

/**
 * 信号处理函数
 */
void signal_handler(int sig) {
    if (g_stream) {
        g_stream->running = 0;
        printf("\n收到信号 %d，准备停止数据流...\n", sig);
    }
}

/**
 * 初始化数据流发送器
 */
int stream_init(data_stream_t *stream, const char *dest_ip, int dest_port) {
    memset(stream, 0, sizeof(data_stream_t));
    stream->start_time = time(NULL);
    stream->running = 1;
    
    // 设置全局指针用于信号处理
    g_stream = stream;
    
    // 注册信号处理
    signal(SIGINT, signal_handler);
    signal(SIGTERM, signal_handler);
    
    // 创建UDP套接字
    stream->sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (stream->sockfd == -1) {
        perror("创建UDP套接字失败");
        return -1;
    }
    
    // 设置目标地址
    memset(&stream->dest_addr, 0, sizeof(stream->dest_addr));
    stream->dest_addr.sin_family = AF_INET;
    stream->dest_addr.sin_port = htons(dest_port);
    stream->dest_addr.sin_addr.s_addr = inet_addr(dest_ip);
    
    printf("数据流发送器初始化完成\n");
    printf("目标地址: %s:%d\n", dest_ip, dest_port);
    
    return 0;
}

/**
 * 发送实时数据包批次
 */
int stream_send_batch(data_stream_t *stream) {
    const int BATCH_SIZE = 16;  // 每次发送16个数据包
    struct mmsghdr msgvec[BATCH_SIZE];
    struct iovec iov[BATCH_SIZE][1];
    char packets[BATCH_SIZE][256];
    struct timespec ts;
    
    // 准备批量发送结构
    memset(msgvec, 0, sizeof(msgvec));
    
    clock_gettime(CLOCK_REALTIME, &ts);
    
    for (int i = 0; i < BATCH_SIZE; i++) {
        // 构造实时数据包
        snprintf(packets[i], sizeof(packets[i]), 
                "REALTIME_DATA:%lu.%09ld:Packet_%lu:Value_%d", 
                ts.tv_sec, ts.tv_nsec,
                stream->packets_sent + i + 1,
                rand() % 1000);
        
        // 设置缓冲区
        iov[i][0].iov_base = packets[i];
        iov[i][0].iov_len = strlen(packets[i]);
        
        // 设置消息头
        msgvec[i].msg_hdr.msg_iov = iov[i];
        msgvec[i].msg_hdr.msg_iovlen = 1;
        msgvec[i].msg_hdr.msg_name = &stream->dest_addr;
        msgvec[i].msg_hdr.msg_namelen = sizeof(stream->dest_addr);
    }
    
    // 批量发送数据包
    int packets_sent = sendmmsg(stream->sockfd, msgvec, BATCH_SIZE, 0);
    
    if (packets_sent == -1) {
        perror("sendmmsg 发送数据包失败");
        return -1;
    }
    
    // 更新统计信息
    stream->packets_sent += packets_sent;
    for (int i = 0; i < packets_sent; i++) {
        stream->bytes_sent += msgvec[i].msg_len;
    }
    
    return packets_sent;
}

/**
 * 显示实时统计信息
 */
void stream_show_stats(data_stream_t *stream) {
    time_t current_time = time(NULL);
    double uptime = difftime(current_time, stream->start_time);
    
    if (uptime > 0) {
        double packets_per_sec = stream->packets_sent / uptime;
        double bytes_per_sec = stream->bytes_sent / uptime;
        
        printf("\r运行时间: %.0fs | 数据包: %lu | 字节: %lu | "
               "速率: %.0f包/s %.2fMB/s",
               uptime, stream->packets_sent, stream->bytes_sent,
               packets_per_sec, bytes_per_sec / (1024 * 1024));
        fflush(stdout);
    }
}

/**
 * 运行数据流发送器
 */
int stream_run(data_stream_t *stream) {
    printf("数据流发送器开始运行，按 Ctrl+C 停止\n");
    
    time_t last_stats_time = time(NULL);
    int batch_count = 0;
    
    while (stream->running) {
        int result = stream_send_batch(stream);
        if (result == -1) {
            break;
        }
        
        batch_count++;
        
        // 定期显示统计信息
        time_t current_time = time(NULL);
        if (current_time - last_stats_time >= 1) {
            stream_show_stats(stream);
            last_stats_time = current_time;
        }
        
        // 控制发送速率（每秒约1000个数据包）
        if (batch_count % 64 == 0) {
            usleep(10000);  // 10ms延迟
        }
    }
    
    printf("\n数据流发送器停止\n");
    return 0;
}

/**
 * 演示实时数据流发送
 */
int demo_real_time_data_stream() {
    data_stream_t stream;
    
    printf("=== 实时数据流发送示例 ===\n");
    
    // 初始化数据流发送器
    if (stream_init(&stream, "127.0.0.1", 8083) != 0) {
        return -1;
    }
    
    // 启动数据接收器
    if (fork() == 0) {
        int server_fd;
        struct sockaddr_in server_addr, client_addr;
        socklen_t client_len = sizeof(client_addr);
        char buffer[512];
        ssize_t bytes_received;
        int packet_count = 0;
        
        server_fd = socket(AF_INET, SOCK_DGRAM, 0);
        if (server_fd == -1) {
            perror("创建接收器套接字失败");
            exit(1);
        }
        
        memset(&server_addr, 0, sizeof(server_addr));
        server_addr.sin_family = AF_INET;
        server_addr.sin_addr.s_addr = INADDR_ANY;
        server_addr.sin_port = htons(8083);
        
        if (bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
            perror("绑定接收器套接字失败");
            close(server_fd);
            exit(1);
        }
        
        printf("数据接收器启动，监听端口 8083\n");
        
        // 设置接收超时
        struct timeval timeout;
        timeout.tv_sec = 30;
        timeout.tv_usec = 0;
        setsockopt(server_fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
        
        // 接收数据包
        while (packet_count < 1000) {
            bytes_received = recvfrom(server_fd, buffer, sizeof(buffer) - 1, 0,
                                     (struct sockaddr*)&client_addr, &client_len);
            if (bytes_received == -1) {
                if (errno == EAGAIN || errno == EWOULDBLOCK) {
                    printf("接收超时\n");
                    break;
                }
                perror("接收数据包失败");
                break;
            }
            
            buffer[bytes_received] = '\0';
            packet_count++;
            
            if (packet_count % 100 == 0) {
                printf("接收器: 接收到 %d 个数据包\n", packet_count);
            }
        }
        
        printf("接收器: 总共接收到 %d 个数据包\n", packet_count);
        close(server_fd);
        exit(0);
    }
    
    // 运行数据流发送器
    srand(time(NULL));
    stream_run(&stream);
    
    // 显示最终统计
    printf("\n\n最终统计:\n");
    printf("  总发送数据包: %lu\n", stream.packets_sent);
    printf("  总发送字节数: %lu\n", stream.bytes_sent);
    printf("  平均包大小: %.2f 字节\n", 
           stream.packets_sent > 0 ? (double)stream.bytes_sent / stream.packets_sent : 0);
    
    // 清理资源
    close(stream.sockfd);
    
    // 等待接收器结束
    int status;
    wait(&status);
    
    return 0;
}

int main() {
    return demo_real_time_data_stream();
}

示例5：性能对比测试

#define _GNU_SOURCE
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <sys/time.h>

/**
 * 性能测试结构
 */
typedef struct {
    const char *name;
    unsigned long messages_sent;
    unsigned long bytes_sent;
    struct timeval start_time;
    struct timeval end_time;
} perf_test_t;

/**
 * 使用传统sendmsg进行测试
 */
int test_sendmsg_performance(int sockfd, struct sockaddr_in *dest_addr, 
                            int message_count, const char *message) {
    struct msghdr msg;
    struct iovec iov[1];
    int sent_count = 0;
    
    // 准备发送结构
    memset(&msg, 0, sizeof(msg));
    iov[0].iov_base = (void*)message;
    iov[0].iov_len = strlen(message);
    
    msg.msg_iov = iov;
    msg.msg_iovlen = 1;
    msg.msg_name = dest_addr;
    msg.msg_namelen = sizeof(*dest_addr);
    
    // 逐个发送消息
    while (sent_count < message_count) {
        if (sendmsg(sockfd, &msg, 0) == -1) {
            if (errno != EAGAIN && errno != EWOULDBLOCK) {
                perror("sendmsg 失败");
                break;
            }
        } else {
            sent_count++;
        }
    }
    
    return sent_count;
}

/**
 * 使用sendmmsg进行测试
 */
int test_sendmmsg_performance(int sockfd, struct sockaddr_in *dest_addr, 
                             int message_count, const char *message) {
    const int BATCH_SIZE = 32;
    struct mmsghdr msgvec[BATCH_SIZE];
    struct iovec iov[BATCH_SIZE][1];
    char *messages[BATCH_SIZE];
    int total_sent = 0;
    int messages_sent;
    
    // 准备批量发送结构
    memset(msgvec, 0, sizeof(msgvec));
    
    for (int i = 0; i < BATCH_SIZE; i++) {
        messages[i] = strdup(message);
        if (!messages[i]) {
            perror("分配消息缓冲区失败");
            return total_sent;
        }
        
        iov[i][0].iov_base = messages[i];
        iov[i][0].iov_len = strlen(message);
        
        msgvec[i].msg_hdr.msg_iov = iov[i];
        msgvec[i].msg_hdr.msg_iovlen = 1;
        msgvec[i].msg_hdr.msg_name = dest_addr;
        msgvec[i].msg_hdr.msg_namelen = sizeof(*dest_addr);
    }
    
    // 批量发送消息
    while (total_sent < message_count) {
        int to_send = (message_count - total_sent < BATCH_SIZE) ? 
                     message_count - total_sent : BATCH_SIZE;
        
        messages_sent = sendmmsg(sockfd, msgvec, to_send, 0);
        
        if (messages_sent == -1) {
            if (errno != EAGAIN && errno != EWOULDBLOCK) {
                perror("sendmmsg 失败");
                break;
            }
        } else {
            total_sent += messages_sent;
        }
    }
    
    // 释放内存
    for (int i = 0; i < BATCH_SIZE; i++) {
        free(messages[i]);
    }
    
    return total_sent;
}

/**
 * UDP性能测试服务器
 */
int perf_test_server(int port) {
    int server_fd;
    struct sockaddr_in server_addr;
    
    server_fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (server_fd == -1) {
        perror("创建UDP服务器套接字失败");
        return -1;
    }
    
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(port);
    
    if (bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        perror("绑定服务器套接字失败");
        close(server_fd);
        return -1;
    }
    
    printf("性能测试服务器启动，监听端口 %d\n", port);
    return server_fd;
}

/**
 * 演示性能对比测试
 */
int demo_performance_comparison() {
    int server_fd, client_fd;
    struct sockaddr_in server_addr, dest_addr;
    const int SERVER_PORT = 8084;
    const int MESSAGE_COUNT = 10000;
    const char *test_message = "Performance test message for sendmmsg vs sendmsg comparison";
    perf_test_t tests[2];
    
    printf("=== sendmmsg vs sendmsg 性能对比测试 ===\n");
    
    // 初始化测试结构
    tests[0].name = "sendmsg";
    tests[0].messages_sent = 0;
    tests[0].bytes_sent = 0;
    
    tests[1].name = "sendmmsg";
    tests[1].messages_sent = 0;
    tests[1].bytes_sent = 0;
    
    // 启动服务器
    server_fd = perf_test_server(SERVER_PORT);
    if (server_fd == -1) {
        return -1;
    }
    
    // 创建客户端套接字
    client_fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (client_fd == -1) {
        perror("创建客户端套接字失败");
        close(server_fd);
        return -1;
    }
    
    // 设置目标地址
    memset(&dest_addr, 0, sizeof(dest_addr));
    dest_addr.sin_family = AF_INET;
    dest_addr.sin_port = htons(SERVER_PORT);
    dest_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    
    // 启动服务器接收线程
    if (fork() == 0) {
        char buffer[512];
        int received_count = 0;
        
        printf("服务器开始接收测试消息...\n");
        
        // 设置接收超时
        struct timeval timeout;
        timeout.tv_sec = 30;
        timeout.tv_usec = 0;
        setsockopt(server_fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
        
        while (received_count < MESSAGE_COUNT * 2) {  // 两次测试
            ssize_t bytes = recv(server_fd, buffer, sizeof(buffer) - 1, 0);
            if (bytes > 0) {
                received_count++;
                if (received_count % 1000 == 0) {
                    printf("服务器已接收 %d 个消息\n", received_count);
                }
            } else if (bytes == -1) {
                if (errno == EAGAIN || errno == EWOULDBLOCK) {
                    printf("服务器接收超时\n");
                    break;
                }
            }
        }
        
        printf("服务器接收完成，总共接收 %d 个消息\n", received_count);
        close(server_fd);
        exit(0);
    }
    
    // 等待服务器启动
    sleep(1);
    
    // 测试1: 使用sendmsg
    printf("\n测试1: 使用传统sendmsg发送 %d 个消息...\n", MESSAGE_COUNT);
    gettimeofday(&tests[0].start_time, NULL);
    
    tests[0].messages_sent = test_sendmsg_performance(client_fd, &dest_addr, 
                                                     MESSAGE_COUNT, test_message);
    tests[0].bytes_sent = tests[0].messages_sent * strlen(test_message);
    
    gettimeofday(&tests[0].end_time, NULL);
    
    printf("sendmsg测试完成: 发送 %lu 个消息\n", tests[0].messages_sent);
    
    // 短暂休息
    sleep(1);
    
    // 测试2: 使用sendmmsg
    printf("\n测试2: 使用sendmmsg发送 %d 个消息...\n", MESSAGE_COUNT);
    gettimeofday(&tests[1].start_time, NULL);
    
    tests[1].messages_sent = test_sendmmsg_performance(client_fd, &dest_addr, 
                                                      MESSAGE_COUNT, test_message);
    tests[1].bytes_sent = tests[1].messages_sent * strlen(test_message);
    
    gettimeofday(&tests[1].end_time, NULL);
    
    printf("sendmmsg测试完成: 发送 %lu 个消息\n", tests[1].messages_sent);
    
    // 计算并显示结果
    printf("\n=== 性能测试结果 ===\n");
    
    for (int i = 0; i < 2; i++) {
        double elapsed_time = (tests[i].end_time.tv_sec - tests[i].start_time.tv_sec) +
                             (tests[i].end_time.tv_usec - tests[i].start_time.tv_usec) / 1000000.0;
        
        double messages_per_sec = tests[i].messages_sent / elapsed_time;
        double bytes_per_sec = tests[i].bytes_sent / elapsed_time;
        
        printf("%s 测试:\n", tests[i].name);
        printf("  发送消息数: %lu\n", tests[i].messages_sent);
        printf("  发送字节数: %lu\n", tests[i].bytes_sent);
        printf("  耗时: %.3f 秒\n", elapsed_time);
        printf("  吞吐量: %.0f 消息/秒 (%.2f MB/s)\n", 
               messages_per_sec, bytes_per_sec / (1024 * 1024));
        printf("  平均延迟: %.3f 微秒/消息\n", 
               (elapsed_time * 1000000) / tests[i].messages_sent);
        printf("\n");
    }
    
    // 计算性能提升
    double sendmsg_time = (tests[0].end_time.tv_sec - tests[0].start_time.tv_sec) +
                         (tests[0].end_time.tv_usec - tests[0].start_time.tv_usec) / 1000000.0;
    double sendmmsg_time = (tests[1].end_time.tv_sec - tests[1].start_time.tv_sec) +
                          (tests[1].end_time.tv_usec - tests[1].start_time.tv_usec) / 1000000.0;
    
    if (sendmsg_time > 0 && sendmmsg_time > 0) {
        double improvement = (sendmsg_time - sendmmsg_time) / sendmsg_time * 100;
        printf("性能提升: %.1f%%\n", improvement);
    }
    
    close(client_fd);
    
    // 等待服务器结束
    int status;
    wait(&status);
    
    return 0;
}

int main() {
    return demo_performance_comparison();
}

sendmmsg 标志参数详解

常用标志：

• MSG_CONFIRM: 提供路径确认反馈
• MSG_DONTROUTE: 不使用网关路由
• MSG_DONTWAIT: 非阻塞操作
• MSG_EOR: 发送记录结束标记
• MSG_MORE: 还有更多数据要发送
• MSG_NOSIGNAL: 发送时不产生SIGPIPE信号
• MSG_OOB: 发送带外数据

高级标志：

• MSG_PROXY: SOCKS代理相关
• MSG_TRYHARD: 尽力发送（已废弃）

使用注意事项

系统要求：

1. 内核版本: 需要Linux 2.6.39或更高版本
2. glibc版本: 需要支持sendmmsg的glibc版本
3. 编译选项: 需要定义_GNU_SOURCE

性能优化：

1. 批量大小: 根据应用需求选择合适的批量大小
2. 缓冲区管理: 合理分配缓冲区避免内存浪费
3. 错误处理: 妥善处理部分发送的情况

错误处理：

1. 部分发送: 处理实际发送消息数少于请求的情况
2. 连接状态: 检查连接是否正常
3. 资源清理: 及时关闭套接字和释放内存

安全考虑：

1. 缓冲区溢出: 确保消息缓冲区大小正确
2. 输入验证: 验证发送的数据内容
3. 权限检查: 确保有适当的网络访问权限

sendmmsg 优势

1. 性能优势：

• 减少系统调用: 单次调用发送多个消息
• 降低上下文切换: 减少用户态和内核态切换
• 提高吞吐量: 特别适用于小消息高频发送场景

2. 功能优势：

• 完整功能: 支持sendmsg的所有功能
• 分散缓冲区: 每个消息可使用多个缓冲区
• 控制信息: 支持发送辅助控制数据

3. 应用场景：

• 高并发服务器: Web服务器、游戏服务器
• 实时系统: 音视频流传输、传感器数据采集
• 消息队列: 批量消息处理系统
• 网络协议: 实现自定义网络协议

总结

sendmmsg 是构建高性能网络应用的重要工具，它提供了：

• 批量消息发送能力，显著减少系统调用开销
• 与sendmsg相同的完整功能集
• 更好的性能和可扩展性
• 适用于高吞吐量的实时应用

通过合理使用 sendmmsg，可以大幅提升网络应用的性能，特别是在需要发送大量小消息的场景中效果显著。在实际应用中，需要注意批量大小的选择、错误处理和系统兼容性等问题。

sigaltstack 函数详解

1. 函数介绍

sigaltstack 是Linux系统调用，用于设置和获取信号处理程序的备用栈（alternate signal stack）。当进程收到信号时，内核通常在当前栈上执行信号处理程序。使用 sigaltstack 可以为信号处理程序指定一个独立的栈空间，这对于处理栈溢出等异常情况特别有用。

2. 函数原型

#include <signal.h>
int sigaltstack(const stack_t *ss, stack_t *oss);

3. 功能

sigaltstack 允许进程为信号处理程序设置一个备用的栈空间。当信号被递送到使用备用栈的信号处理程序时，内核会切换到备用栈执行信号处理程序，执行完毕后再切换回原来的栈。

4. 参数

• *const stack_t ss: 指向新栈设置的指针（NULL表示不改变当前设置）
• *stack_t oss: 指向存储旧栈设置的指针（NULL表示不获取旧设置）

5. 返回值

• 成功: 返回0
• 失败: 返回-1，并设置errno

6. 相似函数，或关联函数

• signal/sigaction: 设置信号处理程序
• sigprocmask: 设置信号屏蔽字
• setjmp/longjmp: 非局部跳转
• getcontext/setcontext: 上下文操作

7. 示例代码

示例1：基础sigaltstack使用

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>

/**
 * 信号栈结构体
 */
typedef struct {
    void *stack_ptr;
    size_t stack_size;
    int is_active;
} signal_stack_t;

/**
 * 显示当前信号栈信息
 */
void show_signal_stack_info() {
    stack_t current_stack;
    
    if (sigaltstack(NULL, &current_stack) == 0) {
        printf("=== 当前信号栈信息 ===\n");
        printf("栈指针: %p\n", current_stack.ss_sp);
        printf("栈大小: %zu 字节\n", current_stack.ss_size);
        printf("栈标志: ");
        if (current_stack.ss_flags & SS_ONSTACK) {
            printf("SS_ONSTACK (正在使用中)\n");
        } else if (current_stack.ss_flags & SS_DISABLE) {
            printf("SS_DISABLE (已禁用)\n");
        } else {
            printf("SS_ENABLED (已启用)\n");
        }
        printf("\n");
    } else {
        printf("获取信号栈信息失败: %s\n", strerror(errno));
    }
}

/**
 * 信号处理程序
 */
void signal_handler(int sig) {
    stack_t current_stack;
    
    printf("信号处理程序执行中 (信号: %d)\n", sig);
    
    // 检查当前是否在备用栈上
    if (sigaltstack(NULL, &current_stack) == 0) {
        if (current_stack.ss_flags & SS_ONSTACK) {
            printf("  ✓ 正在备用栈上执行\n");
        } else {
            printf("  ✗ 在主栈上执行\n");
        }
    }
    
    printf("  当前栈指针: %p\n", &sig);
    printf("  信号处理完成\n\n");
}

/**
 * 演示基础sigaltstack使用方法
 */
int demo_sigaltstack_basic() {
    stack_t new_stack, old_stack;
    char *stack_buffer;
    struct sigaction sa;
    
    printf("=== 基础sigaltstack使用示例 ===\n");
    
    // 显示原始信号栈信息
    printf("1. 原始信号栈信息:\n");
    show_signal_stack_info();
    
    // 分配备用栈空间
    size_t stack_size = SIGSTKSZ;  // 系统推荐的栈大小
    stack_buffer = malloc(stack_size);
    if (!stack_buffer) {
        perror("分配栈空间失败");
        return -1;
    }
    
    printf("2. 分配备用栈空间:\n");
    printf("   栈大小: %zu 字节\n", stack_size);
    printf("   栈地址: %p\n", (void*)stack_buffer);
    
    // 设置备用栈
    new_stack.ss_sp = stack_buffer;
    new_stack.ss_size = stack_size;
    new_stack.ss_flags = 0;  // 启用栈
    
    printf("3. 设置备用信号栈:\n");
    if (sigaltstack(&new_stack, &old_stack) == 0) {
        printf("   ✓ 备用栈设置成功\n");
        show_signal_stack_info();
    } else {
        printf("   ✗ 备用栈设置失败: %s\n", strerror(errno));
        free(stack_buffer);
        return -1;
    }
    
    // 设置使用备用栈的信号处理程序
    printf("4. 设置信号处理程序:\n");
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = signal_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_ONSTACK;  // 使用备用栈
    
    if (sigaction(SIGUSR1, &sa, NULL) == 0) {
        printf("   ✓ 信号处理程序设置成功 (使用备用栈)\n");
    } else {
        printf("   ✗ 信号处理程序设置失败: %s\n", strerror(errno));
        free(stack_buffer);
        return -1;
    }
    
    // 发送信号测试
    printf("5. 发送测试信号:\n");
    if (kill(getpid(), SIGUSR1) == 0) {
        printf("   ✓ 信号发送成功\n");
        sleep(1);  // 等待信号处理完成
    } else {
        printf("   ✗ 信号发送失败: %s\n", strerror(errno));
    }
    
    // 禁用备用栈
    printf("6. 禁用备用栈:\n");
    stack_t disable_stack;
    disable_stack.ss_flags = SS_DISABLE;
    
    if (sigaltstack(&disable_stack, NULL) == 0) {
        printf("   ✓ 备用栈禁用成功\n");
        show_signal_stack_info();
    } else {
        printf("   ✗ 备用栈禁用失败: %s\n", strerror(errno));
    }
    
    // 清理资源
    free(stack_buffer);
    
    return 0;
}

int main() {
    return demo_sigaltstack_basic();
}

示例2：栈溢出保护演示

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <setjmp.h>

/**
 * 栈溢出保护结构
 */
typedef struct {
    stack_t alt_stack;
    char *stack_buffer;
    sigjmp_buf jump_buffer;
    int overflow_detected;
} stack_protection_t;

/**
 * 栈溢出信号处理程序
 */
void stack_overflow_handler(int sig) {
    printf("⚠ 检测到栈溢出异常 (信号: %d)\n", sig);
    
    // 检查是否在备用栈上
    stack_t current_stack;
    if (sigaltstack(NULL, &current_stack) == 0) {
        if (current_stack.ss_flags & SS_ONSTACK) {
            printf("  ✓ 在备用栈上安全处理异常\n");
        } else {
            printf("  ✗ 不在备用栈上 (异常情况)\n");
        }
    }
    
    // 恢复到安全状态
    printf("  跳转到安全恢复点...\n");
    siglongjmp(((stack_protection_t*)NULL)->jump_buffer, 1);
}

/**
 * 递归函数（可能导致栈溢出）
 */
void recursive_function(int depth) {
    char buffer[1024];  // 消耗栈空间
    
    // 填充缓冲区以确保栈使用
    memset(buffer, depth & 0xFF, sizeof(buffer));
    
    printf("递归深度: %d, 栈地址: %p\n", depth, (void*)&buffer);
    
    // 深度递归可能导致栈溢出
    if (depth < 1000) {  // 限制递归深度
        recursive_function(depth + 1);
    }
}

/**
 * 安全的递归执行
 */
int safe_recursive_execution(stack_protection_t *protection) {
    struct sigaction sa;
    int result;
    
    printf("=== 栈溢出保护演示 ===\n");
    
    // 设置信号处理程序
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = stack_overflow_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_ONSTACK;
    
    if (sigaction(SIGSEGV, &sa, NULL) != 0) {
        printf("设置SIGSEGV处理程序失败: %s\n", strerror(errno));
        return -1;
    }
    
    if (sigaction(SIGBUS, &sa, NULL) != 0) {
        printf("设置SIGBUS处理程序失败: %s\n", strerror(errno));
        return -1;
    }
    
    // 设置跳转点
    result = sigsetjmp(protection->jump_buffer, 1);
    if (result == 0) {
        printf("开始安全递归执行...\n");
        
        // 执行可能引起栈溢出的操作
        recursive_function(0);
        
        printf("递归执行正常完成\n");
        return 0;
    } else {
        printf("✓ 从栈溢出异常中成功恢复\n");
        return 1;
    }
}

/**
 * 演示栈溢出保护
 */
int demo_stack_overflow_protection() {
    stack_protection_t protection = {0};
    size_t stack_size = SIGSTKSZ * 2;  // 更大的备用栈
    
    printf("=== 栈溢出保护演示 ===\n");
    
    // 分配备用栈
    protection.stack_buffer = malloc(stack_size);
    if (!protection.stack_buffer) {
        perror("分配备用栈失败");
        return -1;
    }
    
    printf("分配备用栈: %zu 字节\n", stack_size);
    
    // 设置备用栈
    protection.alt_stack.ss_sp = protection.stack_buffer;
    protection.alt_stack.ss_size = stack_size;
    protection.alt_stack.ss_flags = 0;
    
    if (sigaltstack(&protection.alt_stack, NULL) != 0) {
        printf("设置备用栈失败: %s\n", strerror(errno));
        free(protection.stack_buffer);
        return -1;
    }
    
    printf("备用栈设置成功\n");
    show_signal_stack_info();
    
    // 执行安全递归
    int result = safe_recursive_execution(&protection);
    
    // 清理资源
    free(protection.stack_buffer);
    
    return result;
}

// 辅助函数声明
void show_signal_stack_info();

int main() {
    return demo_stack_overflow_protection();
}

示例3：多信号处理程序管理

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>

/**
 * 多栈管理器
 */
typedef struct {
    stack_t stack1;
    stack_t stack2;
    char *buffer1;
    char *buffer2;
    int current_stack;
} multi_stack_manager_t;

/**
 * 信号处理程序1（使用栈1）
 */
void signal_handler_1(int sig) {
    printf("信号处理程序1执行 (信号: %d)\n", sig);
    
    stack_t current_stack;
    if (sigaltstack(NULL, &current_stack) == 0) {
        if (current_stack.ss_flags & SS_ONSTACK) {
            printf("  使用备用栈1执行\n");
        }
    }
    
    printf("  处理程序1完成\n");
}

/**
 * 信号处理程序2（使用栈2）
 */
void signal_handler_2(int sig) {
    printf("信号处理程序2执行 (信号: %d)\n", sig);
    
    stack_t current_stack;
    if (sigaltstack(NULL, &current_stack) == 0) {
        if (current_stack.ss_flags & SS_ONSTACK) {
            printf("  使用备用栈2执行\n");
        }
    }
    
    printf("  处理程序2完成\n");
}

/**
 * 初始化多栈管理器
 */
int init_multi_stack_manager(multi_stack_manager_t *manager) {
    size_t stack_size = SIGSTKSZ;
    
    printf("=== 多栈管理器初始化 ===\n");
    
    // 分配两个栈空间
    manager->buffer1 = malloc(stack_size);
    manager->buffer2 = malloc(stack_size);
    
    if (!manager->buffer1 || !manager->buffer2) {
        printf("分配栈空间失败\n");
        if (manager->buffer1) free(manager->buffer1);
        if (manager->buffer2) free(manager->buffer2);
        return -1;
    }
    
    printf("栈1地址: %p, 大小: %zu\n", (void*)manager->buffer1, stack_size);
    printf("栈2地址: %p, 大小: %zu\n", (void*)manager->buffer2, stack_size);
    
    // 初始化栈结构
    manager->stack1.ss_sp = manager->buffer1;
    manager->stack1.ss_size = stack_size;
    manager->stack1.ss_flags = 0;
    
    manager->stack2.ss_sp = manager->buffer2;
    manager->stack2.ss_size = stack_size;
    manager->stack2.ss_flags = 0;
    
    manager->current_stack = 0;
    
    return 0;
}

/**
 * 切换备用栈
 */
int switch_alternate_stack(multi_stack_manager_t *manager, int stack_id) {
    stack_t *target_stack = (stack_id == 1) ? &manager->stack1 : &manager->stack2;
    
    printf("切换到备用栈 %d\n", stack_id);
    
    if (sigaltstack(target_stack, NULL) == 0) {
        printf("✓ 成功切换到备用栈 %d\n", stack_id);
        manager->current_stack = stack_id;
        return 0;
    } else {
        printf("✗ 切换备用栈 %d 失败: %s\n", stack_id, strerror(errno));
        return -1;
    }
}

/**
 * 演示多信号处理程序
 */
int demo_multi_signal_handlers() {
    multi_stack_manager_t manager = {0};
    struct sigaction sa1, sa2;
    
    printf("=== 多信号处理程序演示 ===\n");
    
    // 初始化多栈管理器
    if (init_multi_stack_manager(&manager) != 0) {
        printf("初始化多栈管理器失败\n");
        return -1;
    }
    
    // 设置信号处理程序1（使用栈1）
    printf("\n设置信号处理程序1:\n");
    switch_alternate_stack(&manager, 1);
    
    memset(&sa1, 0, sizeof(sa1));
    sa1.sa_handler = signal_handler_1;
    sigemptyset(&sa1.sa_mask);
    sa1.sa_flags = SA_ONSTACK;
    
    if (sigaction(SIGUSR1, &sa1, NULL) == 0) {
        printf("✓ 信号处理程序1设置成功\n");
    } else {
        printf("✗ 信号处理程序1设置失败: %s\n", strerror(errno));
    }
    
    // 设置信号处理程序2（使用栈2）
    printf("\n设置信号处理程序2:\n");
    switch_alternate_stack(&manager, 2);
    
    memset(&sa2, 0, sizeof(sa2));
    sa2.sa_handler = signal_handler_2;
    sigemptyset(&sa2.sa_mask);
    sa2.sa_flags = SA_ONSTACK;
    
    if (sigaction(SIGUSR2, &sa2, NULL) == 0) {
        printf("✓ 信号处理程序2设置成功\n");
    } else {
        printf("✗ 信号处理程序2设置失败: %s\n", strerror(errno));
    }
    
    // 测试信号处理
    printf("\n测试信号处理:\n");
    
    // 发送SIGUSR1
    printf("发送SIGUSR1信号:\n");
    switch_alternate_stack(&manager, 1);
    if (kill(getpid(), SIGUSR1) == 0) {
        printf("✓ SIGUSR1发送成功\n");
        sleep(1);
    }
    
    // 发送SIGUSR2
    printf("发送SIGUSR2信号:\n");
    switch_alternate_stack(&manager, 2);
    if (kill(getpid(), SIGUSR2) == 0) {
        printf("✓ SIGUSR2发送成功\n");
        sleep(1);
    }
    
    // 清理资源
    free(manager.buffer1);
    free(manager.buffer2);
    
    return 0;
}

int main() {
    return demo_multi_signal_handlers();
}

示例4：线程安全的信号栈管理

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>

/**
 * 线程信号栈管理器
 */
typedef struct {
    stack_t signal_stack;
    char *stack_buffer;
    pthread_t thread_id;
    int thread_num;
} thread_stack_manager_t;

/**
 * 线程信号处理程序
 */
void thread_signal_handler(int sig) {
    pthread_t current_thread = pthread_self();
    
    printf("线程 %lu 收到信号 %d\n", (unsigned long)current_thread, sig);
    
    stack_t current_stack;
    if (sigaltstack(NULL, &current_stack) == 0) {
        if (current_stack.ss_flags & SS_ONSTACK) {
            printf("  线程 %lu 在备用栈上处理信号\n", (unsigned long)current_thread);
        } else {
            printf("  线程 %lu 在主栈上处理信号\n", (unsigned long)current_thread);
        }
    }
    
    printf("  线程 %lu 信号处理完成\n", (unsigned long)current_thread);
}

/**
 * 初始化线程栈管理器
 */
int init_thread_stack_manager(thread_stack_manager_t *manager, int thread_num) {
    size_t stack_size = SIGSTKSZ;
    
    manager->thread_num = thread_num;
    manager->thread_id = pthread_self();
    
    // 分配栈空间
    manager->stack_buffer = malloc(stack_size);
    if (!manager->stack_buffer) {
        printf("线程 %d: 分配栈空间失败\n", thread_num);
        return -1;
    }
    
    // 初始化栈结构
    manager->signal_stack.ss_sp = manager->stack_buffer;
    manager->signal_stack.ss_size = stack_size;
    manager->signal_stack.ss_flags = 0;
    
    printf("线程 %d: 分配备用栈 %p, 大小 %zu\n", 
           thread_num, (void*)manager->stack_buffer, stack_size);
    
    return 0;
}

/**
 * 线程工作函数
 */
void* thread_worker(void *arg) {
    thread_stack_manager_t *manager = (thread_stack_manager_t*)arg;
    struct sigaction sa;
    sigset_t set;
    
    printf("工作线程 %d 启动 (ID: %lu)\n", 
           manager->thread_num, (unsigned long)manager->thread_id);
    
    // 设置备用栈
    if (sigaltstack(&manager->signal_stack, NULL) != 0) {
        printf("线程 %d: 设置备用栈失败: %s\n", 
               manager->thread_num, strerror(errno));
        return NULL;
    }
    
    printf("线程 %d: 备用栈设置成功\n", manager->thread_num);
    
    // 设置信号处理程序
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = thread_signal_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_ONSTACK;
    
    if (sigaction(SIGUSR1, &sa, NULL) != 0) {
        printf("线程 %d: 设置信号处理程序失败: %s\n", 
               manager->thread_num, strerror(errno));
        return NULL;
    }
    
    printf("线程 %d: 信号处理程序设置成功\n", manager->thread_num);
    
    // 阻塞SIGUSR1以便测试
    sigemptyset(&set);
    sigaddset(&set, SIGUSR1);
    pthread_sigmask(SIG_BLOCK, &set, NULL);
    
    // 执行工作
    for (int i = 0; i < 5; i++) {
        printf("线程 %d: 工作中... (%d/5)\n", manager->thread_num, i + 1);
        sleep(2);
    }
    
    // 解除阻塞并等待信号
    printf("线程 %d: 等待信号...\n", manager->thread_num);
    pthread_sigmask(SIG_UNBLOCK, &set, NULL);
    
    // 等待一段时间让信号处理完成
    sleep(2);
    
    printf("线程 %d: 工作完成\n", manager->thread_num);
    return NULL;
}

/**
 * 演示线程安全的信号栈管理
 */
int demo_thread_safe_signal_stacks() {
    const int num_threads = 3;
    pthread_t threads[num_threads];
    thread_stack_manager_t managers[num_threads];
    sigset_t set;
    
    printf("=== 线程安全的信号栈管理演示 ===\n");
    
    // 阻塞SIGUSR1信号
    sigemptyset(&set);
    sigaddset(&set, SIGUSR1);
    pthread_sigmask(SIG_BLOCK, &set, NULL);
    
    // 创建工作线程
    printf("创建 %d 个工作线程:\n", num_threads);
    
    for (int i = 0; i < num_threads; i++) {
        if (init_thread_stack_manager(&managers[i], i + 1) != 0) {
            printf("初始化线程 %d 失败\n", i + 1);
            // 清理已分配的资源
            for (int j = 0; j < i; j++) {
                free(managers[j].stack_buffer);
            }
            return -1;
        }
        
        if (pthread_create(&threads[i], NULL, thread_worker, &managers[i]) != 0) {
            printf("创建线程 %d 失败\n", i + 1);
            free(managers[i].stack_buffer);
            // 清理已分配的资源
            for (int j = 0; j < i; j++) {
                free(managers[j].stack_buffer);
            }
            return -1;
        }
        
        managers[i].thread_id = threads[i];
        printf("创建线程 %d: ID=%lu\n", i + 1, (unsigned long)threads[i]);
    }
    
    // 等待线程启动
    sleep(1);
    
    // 向所有线程发送信号
    printf("\n向所有线程发送SIGUSR1信号:\n");
    pthread_sigmask(SIG_UNBLOCK, &set, NULL);
    
    for (int i = 0; i < num_threads; i++) {
        // 注意：实际应用中需要更精确的线程信号发送方法
        if (kill(getpid(), SIGUSR1) == 0) {
            printf("向线程 %d 发送信号成功\n", i + 1);
        } else {
            printf("向线程 %d 发送信号失败: %s\n", i + 1, strerror(errno));
        }
        sleep(1);  // 间隔发送
    }
    
    // 等待所有线程完成
    printf("\n等待所有线程完成:\n");
    for (int i = 0; i < num_threads; i++) {
        void *result;
        pthread_join(threads[i], &result);
        printf("线程 %d 已完成\n", i + 1);
        
        // 清理资源
        free(managers[i].stack_buffer);
    }
    
    return 0;
}

int main() {
    return demo_thread_safe_signal_stacks();
}

示例5：信号栈监控和调试

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/resource.h>

/**
 * 信号栈监控器
 */
typedef struct {
    stack_t original_stack;
    stack_t current_stack;
    int stack_switch_count;
    size_t total_stack_size;
    time_t last_switch_time;
} stack_monitor_t;

/**
 * 详细的栈信息显示
 */
void show_detailed_stack_info(const char *context) {
    stack_t stack_info;
    
    printf("=== %s ===\n", context);
    
    if (sigaltstack(NULL, &stack_info) == 0) {
        printf("栈指针: %p\n", stack_info.ss_sp);
        printf("栈大小: %zu 字节\n", stack_info.ss_size);
        printf("栈标志: 0x%x\n", stack_info.ss_flags);
        
        if (stack_info.ss_flags & SS_ONSTACK) {
            printf("状态: 正在使用备用栈\n");
        } else if (stack_info.ss_flags & SS_DISABLE) {
            printf("状态: 备用栈已禁用\n");
        } else {
            printf("状态: 备用栈已启用但未使用\n");
        }
        
        // 计算栈使用情况（简化版）
        void *current_sp;
        asm volatile("mov %%rsp, %0" : "=r"(current_sp));
        printf("当前栈指针: %p\n", current_sp);
        
        if (stack_info.ss_sp) {
            ptrdiff_t distance = (char*)current_sp - (char*)stack_info.ss_sp;
            printf("距离栈底: %td 字节\n", distance);
            
            if (distance > 0 && (size_t)distance < stack_info.ss_size) {
                double usage = (double)distance / stack_info.ss_size * 100;
                printf("栈使用率: %.1f%%\n", usage);
            }
        }
    } else {
        printf("获取栈信息失败: %s\n", strerror(errno));
    }
    
    printf("\n");
}

/**
 * 信号处理程序（带监控）
 */
void monitored_signal_handler(int sig) {
    static int call_count = 0;
    call_count++;
    
    printf("监控信号处理程序执行 (第 %d 次, 信号: %d)\n", call_count, sig);
    
    show_detailed_stack_info("信号处理程序中的栈状态");
    
    // 模拟一些栈使用
    char local_buffer[512];
    memset(local_buffer, call_count & 0xFF, sizeof(local_buffer));
    
    printf("  处理程序使用了 %zu 字节本地缓冲区\n", sizeof(local_buffer));
    printf("  处理程序执行完成\n\n");
}

/**
 * 栈使用压力测试
 */
void stack_pressure_test(int depth) {
    char buffer[1024];  // 每层消耗1KB栈空间
    
    // 填充缓冲区
    memset(buffer, depth & 0xFF, sizeof(buffer));
    
    if (depth < 50) {  // 限制递归深度
        printf("递归深度: %d, 使用栈空间: %d KB\n", depth, depth);
        stack_pressure_test(depth + 1);
    } else {
        printf("达到最大递归深度: %d\n", depth);
    }
}

/**
 * 演示信号栈监控和调试
 */
int demo_stack_monitoring() {
    stack_t alt_stack, old_stack;
    char *stack_buffer;
    struct sigaction sa;
    struct rlimit rl;
    
    printf("=== 信号栈监控和调试演示 ===\n");
    
    // 显示系统栈限制
    printf("1. 系统栈限制信息:\n");
    if (getrlimit(RLIMIT_STACK, &rl) == 0) {
        printf("   主栈大小限制: %ld 字节", rl.rlim_cur);
        if (rl.rlim_cur == RLIM_INFINITY) {
            printf(" (无限制)");
        }
        printf("\n");
        printf("   最大栈大小: %ld 字节", rl.rlim_max);
        if (rl.rlim_max == RLIM_INFINITY) {
            printf(" (无限制)");
        }
        printf("\n");
    }
    
    // 显示初始栈状态
    show_detailed_stack_info("初始栈状态");
    
    // 分配备用栈
    size_t stack_size = SIGSTKSZ * 4;  // 4倍标准大小
    stack_buffer = malloc(stack_size);
    if (!stack_buffer) {
        perror("分配备用栈失败");
        return -1;
    }
    
    printf("2. 分配备用栈:\n");
    printf("   请求大小: %zu 字节 (%.1f KB)\n", stack_size, stack_size / 1024.0);
    printf("   分配地址: %p\n", (void*)stack_buffer);
    
    // 设置备用栈
    alt_stack.ss_sp = stack_buffer;
    alt_stack.ss_size = stack_size;
    alt_stack.ss_flags = 0;
    
    printf("3. 设置备用栈:\n");
    if (sigaltstack(&alt_stack, &old_stack) == 0) {
        printf("   ✓ 备用栈设置成功\n");
        show_detailed_stack_info("设置备用栈后");
    } else {
        printf("   ✗ 备用栈设置失败: %s\n", strerror(errno));
        free(stack_buffer);
        return -1;
    }
    
    // 设置监控信号处理程序
    printf("4. 设置监控信号处理程序:\n");
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = monitored_signal_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_ONSTACK;
    
    if (sigaction(SIGUSR1, &sa, NULL) == 0) {
        printf("   ✓ 监控信号处理程序设置成功\n");
    } else {
        printf("   ✗ 监控信号处理程序设置失败: %s\n", strerror(errno));
        free(stack_buffer);
        return -1;
    }
    
    // 发送多个信号进行测试
    printf("5. 发送测试信号:\n");
    for (int i = 1; i <= 3; i++) {
        printf("   发送第 %d 个信号:\n", i);
        if (kill(getpid(), SIGUSR1) == 0) {
            printf("     ✓ 信号发送成功\n");
            sleep(1);  // 等待处理完成
        } else {
            printf("     ✗ 信号发送失败: %s\n", strerror(errno));
        }
    }
    
    // 栈压力测试
    printf("6. 栈压力测试:\n");
    printf("   开始递归栈使用测试...\n");
    stack_pressure_test(0);
    printf("   栈压力测试完成\n");
    
    show_detailed_stack_info("压力测试后栈状态");
    
    // 禁用备用栈
    printf("7. 禁用备用栈:\n");
    stack_t disable_stack;
    disable_stack.ss_flags = SS_DISABLE;
    
    if (sigaltstack(&disable_stack, NULL) == 0) {
        printf("   ✓ 备用栈禁用成功\n");
        show_detailed_stack_info("禁用备用栈后");
    } else {
        printf("   ✗ 备用栈禁用失败: %s\n", strerror(errno));
    }
    
    // 清理资源
    free(stack_buffer);
    
    printf("=== 监控演示完成 ===\n");
    return 0;
}

int main() {
    return demo_stack_monitoring();
}

sigaltstack 使用注意事项

系统要求：

1. 内核版本: 支持信号备用栈的Linux内核
2. 权限要求: 通常不需要特殊权限
3. 架构支持: 支持所有主流架构

栈大小考虑：

1. 最小大小: 至少MINSIGSTKSZ字节
2. 推荐大小: 使用SIGSTKSZ或更大
3. 动态分配: 建议在堆上分配栈空间

错误处理：

1. ENOMEM: 内存不足
2. EINVAL: 参数无效
3. EPERM: 权限不足

安全考虑：

1. 栈溢出保护: 备用栈可以防止主栈溢出
2. 信号安全: 确保信号处理程序的安全执行
3. 资源管理: 及时释放分配的栈空间

最佳实践：

1. 适当大小: 根据信号处理程序的需求分配栈大小
2. 错误检查: 始终检查sigaltstack的返回值
3. 资源清理: 程序结束时释放栈空间
4. 线程安全: 多线程环境中每个线程需要独立的栈
5. 监控调试: 监控栈使用情况以便调试

信号栈标志说明

SS_ONSTACK：

• 含义: 当前正在使用备用栈执行信号处理程序
• 用途: 检查信号处理程序是否在备用栈上执行

SS_DISABLE：

• 含义: 备用栈被禁用
• 用途: 禁用备用栈功能

SS_ENABLED：

• 含义: 备用栈已启用但未使用
• 用途: 正常状态，可以使用备用栈

相关常量

SIGSTKSZ：

• 含义: 系统推荐的信号栈大小
• 典型值: 8KB或更大

MINSIGSTKSZ：

• 含义: 信号栈的最小大小
• 典型值: 2KB

常见使用场景

1. 栈溢出保护：

// 为可能引起栈溢出的程序设置备用栈
stack_t alt_stack;
alt_stack.ss_sp = malloc(SIGSTKSZ);
alt_stack.ss_size = SIGSTKSZ;
alt_stack.ss_flags = 0;
sigaltstack(&alt_stack, NULL);

2. 信号处理程序：

// 为信号处理程序设置独立的执行环境
struct sigaction sa;
sa.sa_handler = signal_handler;
sa.sa_flags = SA_ONSTACK;
sigaction(SIGSEGV, &sa, NULL);

3. 多线程应用：

// 每个线程设置独立的信号栈
void* thread_function(void *arg) {
    stack_t thread_stack;
    thread_stack.ss_sp = malloc(SIGSTKSZ);
    thread_stack.ss_size = SIGSTKSZ;
    thread_stack.ss_flags = 0;
    sigaltstack(&thread_stack, NULL);
    // 线程工作...
}

总结

sigaltstack 是Linux系统中重要的信号处理机制，提供了：

1. 栈隔离: 为信号处理程序提供独立的执行环境
2. 异常处理: 防止栈溢出等异常情况
3. 安全执行: 确保信号处理程序的安全执行
4. 灵活配置: 支持动态栈管理和配置

通过合理使用 sigaltstack，可以构建更加健壮和安全的信号处理系统。在实际应用中，需要注意栈大小、错误处理和资源管理等关键问题。

getcwd – 获取当前工作目录

getcwd – 获取当前工作目录

函数介绍

getcwd系统调用用于获取进程当前的工作目录路径。它返回一个以null结尾的字符串，表示当前目录的绝对路径名。

函数原型

#include <unistd.h>

char *getcwd(char *buf, size_t size);

功能

获取进程当前工作目录的绝对路径名。

参数

• char *buf: 指向存储路径名的缓冲区
• size_t size: 缓冲区大小（字节）

返回值

• 成功时返回指向缓冲区的指针（buf）
• 失败时返回NULL，并设置errno：
  • EINVAL: size参数为0且buf非NULL
  • ERANGE: 缓冲区太小
  • ENOMEM: 内存不足

相似函数

• chdir(): 改变当前工作目录
• fchdir(): 通过文件描述符改变当前工作目录

示例代码

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <limits.h>

int main() {
    char buffer[PATH_MAX];
    char *result;
    
    printf("=== Getcwd函数示例 ===\n");
    
    // 示例1: 基本的获取当前目录操作
    printf("\n示例1: 基本的获取当前目录操作\n");
    
    // 方法1: 使用预分配的缓冲区
    result = getcwd(buffer, sizeof(buffer));
    if (result != NULL) {
        printf("当前工作目录: %s\n", buffer);
    } else {
        perror("获取当前目录失败");
    }
    
    // 方法2: 让系统分配内存（buf为NULL，size为0）
    char *dynamic_buffer = getcwd(NULL, 0);
    if (dynamic_buffer != NULL) {
        printf("动态分配的当前目录: %s\n", dynamic_buffer);
        free(dynamic_buffer);  // 需要手动释放内存
    } else {
        perror("动态获取当前目录失败");
    }
    
    // 示例2: 缓冲区大小处理
    printf("\n示例2: 缓冲区大小处理\n");
    
    // 测试不同大小的缓冲区
    size_t sizes[] = {10, 50, 100, PATH_MAX};
    for (int i = 0; i < 4; i++) {
        char small_buffer[1000];  // 足够大的缓冲区
        printf("尝试使用大小为 %zu 的缓冲区: ", sizes[i]);
        
        result = getcwd(small_buffer, sizes[i]);
        if (result != NULL) {
            printf("成功，目录长度: %zu 字节\n", strlen(small_buffer));
        } else {
            if (errno == ERANGE) {
                printf("失败 - 缓冲区太小\n");
            } else {
                printf("失败 - %s\n", strerror(errno));
            }
        }
    }
    
    // 示例3: 创建测试目录并切换
    printf("\n示例3: 目录切换演示\n");
    
    // 保存原始目录
    char original_dir[PATH_MAX];
    if (getcwd(original_dir, sizeof(original_dir)) == NULL) {
        perror("保存原始目录失败");
        exit(EXIT_FAILURE);
    }
    printf("原始目录: %s\n", original_dir);
    
    // 创建测试目录
    const char *test_dir = "test_getcwd_dir";
    if (mkdir(test_dir, 0755) == -1 && errno != EEXIST) {
        perror("创建测试目录失败");
    } else {
        printf("创建测试目录: %s\n", test_dir);
        
        // 切换到测试目录
        if (chdir(test_dir) == -1) {
            perror("切换目录失败");
        } else {
            printf("切换到测试目录\n");
            
            // 获取当前目录
            result = getcwd(buffer, sizeof(buffer));
            if (result != NULL) {
                printf("切换后当前目录: %s\n", buffer);
                
                // 验证是否正确切换
                if (strstr(buffer, test_dir) != NULL) {
                    printf("目录切换验证成功\n");
                }
            }
            
            // 在测试目录中创建子目录
            const char *sub_dir = "sub_directory";
            if (mkdir(sub_dir, 0755) == -1 && errno != EEXIST) {
                perror("创建子目录失败");
            } else {
                printf("创建子目录: %s\n", sub_dir);
                
                // 切换到子目录
                if (chdir(sub_dir) == -1) {
                    perror("切换到子目录失败");
                } else {
                    printf("切换到子目录\n");
                    
                    result = getcwd(buffer, sizeof(buffer));
                    if (result != NULL) {
                        printf("子目录路径: %s\n", buffer);
                    }
                }
            }
        }
        
        // 返回原始目录
        if (chdir(original_dir) == -1) {
            perror("返回原始目录失败");
        } else {
            printf("返回原始目录\n");
            result = getcwd(buffer, sizeof(buffer));
            if (result != NULL) {
                printf("确认当前目录: %s\n", buffer);
            }
        }
    }
    
    // 示例4: 错误处理演示
    printf("\n示例4: 错误处理演示\n");
    
    // 测试缓冲区太小的情况
    char tiny_buffer[5];
    result = getcwd(tiny_buffer, sizeof(tiny_buffer));
    if (result == NULL) {
        if (errno == ERANGE) {
            printf("缓冲区太小错误处理正确: %s\n", strerror(errno));
        } else {
            printf("其他错误: %s\n", strerror(errno));
        }
    }
    
    // 测试无效参数
    result = getcwd(buffer, 0);
    if (result == NULL) {
        if (errno == EINVAL) {
            printf("无效参数处理正确: %s\n", strerror(errno));
        }
    }
    
    // 示例5: 实际应用场景
    printf("\n示例5: 实际应用场景\n");
    
    // 场景1: 程序配置文件定位
    printf("场景1: 程序配置文件定位\n");
    result = getcwd(buffer, sizeof(buffer));
    if (result != NULL) {
        char config_path[PATH_MAX * 2];
        snprintf(config_path, sizeof(config_path), "%s/.myapp/config", buffer);
        printf("配置文件路径: %s\n", config_path);
        
        // 检查配置文件是否存在
        if (access(config_path, F_OK) == 0) {
            printf("配置文件存在\n");
        } else {
            printf("配置文件不存在，将创建默认配置\n");
        }
    }
    
    // 场景2: 相对路径转换为绝对路径
    printf("场景2: 相对路径处理\n");
    const char *relative_paths[] = {"./file.txt", "../parent_dir", "subdir/file"};
    
    for (int i = 0; i < 3; i++) {
        result = getcwd(buffer, sizeof(buffer));
        if (result != NULL) {
            char absolute_path[PATH_MAX * 2];
            snprintf(absolute_path, sizeof(absolute_path), "%s/%s", buffer, relative_paths[i]);
            printf("  %s -> %s\n", relative_paths[i], absolute_path);
        }
    }
    
    // 场景3: 目录操作安全检查
    printf("场景3: 目录操作安全检查\n");
    char current_dir[PATH_MAX];
    char previous_dir[PATH_MAX];
    
    // 保存当前目录
    if (getcwd(current_dir, sizeof(current_dir)) != NULL) {
        printf("当前工作目录: %s\n", current_dir);
        
        // 执行一些目录操作
        // ... 目录操作代码 ...
        
        // 检查目录是否发生变化
        if (getcwd(previous_dir, sizeof(previous_dir)) != NULL) {
            if (strcmp(current_dir, previous_dir) != 0) {
                printf("警告: 工作目录已改变\n");
                printf("原目录: %s\n", current_dir);
                printf("现目录: %s\n", previous_dir);
            } else {
                printf("工作目录保持不变\n");
            }
        }
    }
    
    // 场景4: 日志记录中的目录信息
    printf("场景4: 日志记录\n");
    time_t current_time = time(NULL);
    result = getcwd(buffer, sizeof(buffer));
    if (result != NULL) {
        printf("[%s] INFO: 程序在目录 '%s' 中启动\n", 
               ctime(&current_time), buffer);
    }
    
    // 示例6: 跨平台兼容性考虑
    printf("\n示例6: 跨平台兼容性\n");
    
    // 获取系统路径限制
    long path_max = pathconf(".", _PC_PATH_MAX);
    if (path_max == -1) {
        path_max = PATH_MAX;
        printf("使用默认PATH_MAX: %ld\n", path_max);
    } else {
        printf("系统PATH_MAX: %ld\n", path_max);
    }
    
    // 使用动态分配确保足够空间
    char *safe_buffer = getcwd(NULL, 0);
    if (safe_buffer != NULL) {
        printf("动态分配确保安全: %s\n", safe_buffer);
        printf("路径长度: %zu 字节\n", strlen(safe_buffer));
        free(safe_buffer);
    }
    
    // 示例7: 性能对比测试
    printf("\n示例7: 性能对比测试\n");
    
    // 测试预分配缓冲区的性能
    clock_t start = clock();
    for (int i = 0; i < 10000; i++) {
        getcwd(buffer, sizeof(buffer));
    }
    clock_t preallocated_time = clock() - start;
    
    // 测试动态分配的性能
    start = clock();
    for (int i = 0; i < 10000; i++) {
        char *temp = getcwd(NULL, 0);
        if (temp != NULL) {
            free(temp);
        }
    }
    clock_t dynamic_time = clock() - start;
    
    printf("预分配缓冲区 10000 次调用耗时: %f 秒\n", 
           ((double)preallocated_time) / CLOCKS_PER_SEC);
    printf("动态分配 10000 次调用耗时: %f 秒\n", 
           ((double)dynamic_time) / CLOCKS_PER_SEC);
    printf("预分配方式通常更快\n");
    
    // 清理测试目录
    printf("\n清理测试资源...\n");
    if (access(test_dir, F_OK) == 0) {
        if (rmdir(test_dir) == -1) {
            printf("删除测试目录失败: %s\n", strerror(errno));
        } else {
            printf("删除测试目录完成\n");
        }
    }
    
    return 0;
}

getgroups – 获取进程的补充组列表

1. 函数介绍

getgroups – 获取进程的补充组列表

getgroups 是一个 Linux 系统调用，用于获取当前进程所属的补充组（supplementary groups）列表。除了进程的主要组 ID（由 getgid() 返回）之外，进程还可以属于多个补充组，这些组决定了进程对文件和资源的额外访问权限。

补充组机制是 Unix/Linux 系统中实现灵活访问控制的重要组成部分，允许用户同时属于多个组以获得相应的权限。

2. 函数原型

#include <unistd.h>
#include <sys/types.h>

int getgroups(int size, gid_t list[]);

3. 功能

获取当前进程所属的补充组 ID 列表。补充组是除了主要组之外，进程还属于的其他组。

4. 参数

• int size: 指定 list 数组的大小（元素个数）
  • 如果为 0：函数返回补充组的数量，不填充 list 数组
  • 如果大于 0：将补充组 ID 填充到 list 数组中
• gid_t list[]: 指向存储组 ID 的数组
  • 如果 size 为 0：可以为 NULL
  • 如果 size 大于 0：必须指向有效的数组

5. 返回值

• 成功时：
  • 如果 size 为 0：返回补充组的数量
  • 如果 size 大于 0：返回实际填充到数组中的组 ID 数量
• 失败时返回 -1，并设置 errno

6. 常见 errno 错误码

• EINVAL: size 参数小于补充组的实际数量（缓冲区不足）
• EFAULT: list 指针指向无效内存地址
• EPERM: 在某些安全限制下可能返回（较少见）

7. 相似函数，或关联函数

• setgroups(): 设置进程的补充组列表
• initgroups(): 根据用户信息初始化补充组列表
• getgid(): 获取进程的真实组 ID
• getegid(): 获取进程的有效组 ID
• getuid(), geteuid(): 获取用户 ID 相关函数
• setgid(), setegid(): 设置组 ID
• getgrouplist(): 获取用户的所有组（包括主要组）
• /etc/group: 系统组信息文件
• /etc/passwd: 用户主要组信息文件

8. 示例代码

示例1：基本使用 – 获取补充组列表

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <grp.h>
#include <errno.h>
#include <string.h>

int main() {
    int group_count;
    gid_t *group_list;
    long max_groups;
    
    printf("=== 获取进程补充组列表 ===\n");
    
    // 首先获取补充组数量
    group_count = getgroups(0, NULL);
    if (group_count == -1) {
        perror("获取补充组数量失败");
        exit(EXIT_FAILURE);
    }
    
    printf("补充组数量: %d\n", group_count);
    
    if (group_count == 0) {
        printf("当前进程没有补充组\n");
        return 0;
    }
    
    // 获取系统支持的最大组数
    max_groups = sysconf(_SC_NGROUPS_MAX);
    if (max_groups == -1) {
        max_groups = 65536;  // 设置一个较大的默认值
    }
    
    printf("系统最大支持组数: %ld\n", max_groups);
    
    // 确保不会超出系统限制
    if (group_count > max_groups) {
        printf("警告: 补充组数量超出系统限制\n");
        group_count = max_groups;
    }
    
    // 分配内存存储组列表
    group_list = malloc(group_count * sizeof(gid_t));
    if (group_list == NULL) {
        perror("内存分配失败");
        exit(EXIT_FAILURE);
    }
    
    // 获取补充组列表
    int result = getgroups(group_count, group_list);
    if (result == -1) {
        perror("获取补充组列表失败");
        free(group_list);
        exit(EXIT_FAILURE);
    }
    
    printf("成功获取 %d 个补充组:\n", result);
    printf("%-8s %-10s %s\n", "序号", "组ID", "组名");
    printf("%-8s %-10s %s\n", "----", "----", "----");
    
    // 显示每个组的信息
    for (int i = 0; i < result; i++) {
        printf("%-8d %-10d ", i + 1, group_list[i]);
        
        // 尝试获取组名
        struct group *grp = getgrgid(group_list[i]);
        if (grp != NULL) {
            printf("%s", grp->gr_name);
        } else {
            printf("(未知)");
        }
        printf("\n");
    }
    
    // 显示主要组信息进行对比
    gid_t primary_gid = getgid();
    printf("\n主要组信息:\n");
    printf("  组ID: %d\n", primary_gid);
    
    struct group *primary_grp = getgrgid(primary_gid);
    if (primary_grp != NULL) {
        printf("  组名: %s\n", primary_grp->gr_name);
    }
    
    // 检查主要组是否在补充组列表中
    int found_in_supplementary = 0;
    for (int i = 0; i < result; i++) {
        if (group_list[i] == primary_gid) {
            found_in_supplementary = 1;
            break;
        }
    }
    
    printf("主要组是否在补充组中: %s\n", 
           found_in_supplementary ? "是" : "否");
    
    free(group_list);
    return 0;
}

示例2：错误处理和边界情况

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <grp.h>
#include <errno.h>
#include <string.h>

void demonstrate_error_handling() {
    int result;
    gid_t small_buffer[2];  // 故意使用小缓冲区
    
    printf("=== 错误处理演示 ===\n");
    
    // 获取实际补充组数量
    int actual_count = getgroups(0, NULL);
    if (actual_count == -1) {
        perror("获取补充组数量失败");
        return;
    }
    
    printf("实际补充组数量: %d\n", actual_count);
    
    if (actual_count > 0) {
        // 使用过小的缓冲区，应该返回错误
        printf("使用过小缓冲区测试 (大小: 2):\n");
        result = getgroups(2, small_buffer);
        
        if (result == -1) {
            if (errno == EINVAL) {
                printf("  错误处理正确: 缓冲区不足 (EINVAL)\n");
            } else {
                printf("  其他错误: %s\n", strerror(errno));
            }
        } else {
            printf("  意外成功，返回数量: %d\n", result);
        }
        
        // 使用 NULL 指针但 size > 0
        printf("使用 NULL 指针测试:\n");
        result = getgroups(10, NULL);
        if (result == -1) {
            if (errno == EFAULT) {
                printf("  错误处理正确: 无效指针 (EFAULT)\n");
            } else {
                printf("  其他错误: %s\n", strerror(errno));
            }
        }
    }
}

void demonstrate_empty_groups() {
    printf("\n=== 空组列表演示 ===\n");
    
    // 获取补充组数量
    int count = getgroups(0, NULL);
    if (count == -1) {
        perror("获取组数量失败");
        return;
    }
    
    printf("当前进程补充组数量: %d\n", count);
    
    if (count == 0) {
        printf("进程没有补充组权限\n");
        printf("这可能表示:\n");
        printf("  1. 进程以最小权限运行\n");
        printf("  2. 用户不属于任何补充组\n");
        printf("  3. 在容器或受限环境中运行\n");
    }
}

int main() {
    demonstrate_error_handling();
    demonstrate_empty_groups();
    return 0;
}

示例3：完整的组权限分析工具

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <grp.h>
#include <pwd.h>
#include <string.h>

typedef struct {
    gid_t gid;
    char group_name[256];
    int is_primary;
    int is_effective;
    int is_supplementary;
} group_info_t;

int compare_gids(const void *a, const void *b) {
    gid_t gid_a = ((group_info_t*)a)->gid;
    gid_t gid_b = ((group_info_t*)b)->gid;
    return (gid_a > gid_b) - (gid_a < gid_b);
}

void analyze_process_groups() {
    gid_t primary_gid, effective_gid;
    int sup_count;
    gid_t *sup_groups = NULL;
    group_info_t *all_groups = NULL;
    int total_groups = 0;
    
    printf("=== 进程组权限完整分析 ===\n");
    
    // 获取基本信息
    primary_gid = getgid();
    effective_gid = getegid();
    
    printf("进程基本信息:\n");
    printf("  真实用户 ID: %d\n", getuid());
    printf("  有效用户 ID: %d\n", geteuid());
    printf("  真实组 ID: %d\n", primary_gid);
    printf("  有效组 ID: %d\n", effective_gid);
    
    // 获取用户信息
    struct passwd *pwd = getpwuid(getuid());
    if (pwd != NULL) {
        printf("  用户名: %s\n", pwd->pw_name);
    }
    
    // 获取补充组
    sup_count = getgroups(0, NULL);
    if (sup_count > 0) {
        sup_groups = malloc(sup_count * sizeof(gid_t));
        if (sup_groups == NULL) {
            perror("内存分配失败");
            return;
        }
        
        if (getgroups(sup_count, sup_groups) == -1) {
            perror("获取补充组失败");
            free(sup_groups);
            return;
        }
    }
    
    // 创建完整的组信息列表
    total_groups = 2 + sup_count;  // primary + effective + supplementary
    all_groups = malloc(total_groups * sizeof(group_info_t));
    if (all_groups == NULL) {
        perror("内存分配失败");
        if (sup_groups) free(sup_groups);
        return;
    }
    
    int index = 0;
    
    // 添加主要组
    all_groups[index].gid = primary_gid;
    all_groups[index].is_primary = 1;
    all_groups[index].is_effective = (primary_gid == effective_gid);
    all_groups[index].is_supplementary = 0;
    struct group *grp = getgrgid(primary_gid);
    if (grp != NULL) {
        strncpy(all_groups[index].group_name, grp->gr_name, sizeof(all_groups[index].group_name) - 1);
    } else {
        snprintf(all_groups[index].group_name, sizeof(all_groups[index].group_name), "group_%d", primary_gid);
    }
    index++;
    
    // 添加有效组（如果不同于主要组）
    if (effective_gid != primary_gid) {
        all_groups[index].gid = effective_gid;
        all_groups[index].is_primary = 0;
        all_groups[index].is_effective = 1;
        all_groups[index].is_supplementary = 0;
        struct group *grp = getgrgid(effective_gid);
        if (grp != NULL) {
            strncpy(all_groups[index].group_name, grp->gr_name, sizeof(all_groups[index].group_name) - 1);
        } else {
            snprintf(all_groups[index].group_name, sizeof(all_groups[index].group_name), "group_%d", effective_gid);
        }
        index++;
    }
    
    // 添加补充组
    for (int i = 0; i < sup_count; i++) {
        // 检查是否已存在
        int exists = 0;
        for (int j = 0; j < index; j++) {
            if (all_groups[j].gid == sup_groups[i]) {
                all_groups[j].is_supplementary = 1;
                exists = 1;
                break;
            }
        }
        
        if (!exists) {
            all_groups[index].gid = sup_groups[i];
            all_groups[index].is_primary = 0;
            all_groups[index].is_effective = (sup_groups[i] == effective_gid);
            all_groups[index].is_supplementary = 1;
            struct group *grp = getgrgid(sup_groups[i]);
            if (grp != NULL) {
                strncpy(all_groups[index].group_name, grp->gr_name, sizeof(all_groups[index].group_name) - 1);
            } else {
                snprintf(all_groups[index].group_name, sizeof(all_groups[index].group_name), "group_%d", sup_groups[i]);
            }
            index++;
        }
    }
    
    total_groups = index;
    
    // 按组 ID 排序
    qsort(all_groups, total_groups, sizeof(group_info_t), compare_gids);
    
    // 显示结果
    printf("\n完整的组权限信息:\n");
    printf("%-8s %-10s %-12s %-12s %-15s %s\n", 
           "序号", "组ID", "主要组", "有效组", "补充组", "组名");
    printf("%-8s %-10s %-12s %-12s %-15s %s\n", 
           "----", "----", "----", "----", "----", "----");
    
    for (int i = 0; i < total_groups; i++) {
        printf("%-8d %-10d %-12s %-12s %-15s %s\n",
               i + 1,
               all_groups[i].gid,
               all_groups[i].is_primary ? "是" : "否",
               all_groups[i].is_effective ? "是" : "否",
               all_groups[i].is_supplementary ? "是" : "否",
               all_groups[i].group_name);
    }
    
    // 统计信息
    printf("\n统计信息:\n");
    printf("  总组数: %d\n", total_groups);
    
    int primary_count = 0, effective_count = 0, supplementary_count = 0;
    for (int i = 0; i < total_groups; i++) {
        if (all_groups[i].is_primary) primary_count++;
        if (all_groups[i].is_effective) effective_count++;
        if (all_groups[i].is_supplementary) supplementary_count++;
    }
    
    printf("  主要组: %d\n", primary_count);
    printf("  有效组: %d\n", effective_count);
    printf("  补充组: %d\n", supplementary_count);
    
    // 特殊权限检查
    printf("\n特殊权限检查:\n");
    int has_root_group = 0;
    int has_admin_group = 0;
    
    for (int i = 0; i < total_groups; i++) {
        if (all_groups[i].gid == 0) {
            has_root_group = 1;
        }
        // 检查常见的管理员组
        if (strcmp(all_groups[i].group_name, "wheel") == 0 ||
            strcmp(all_groups[i].group_name, "sudo") == 0 ||
            strcmp(all_groups[i].group_name, "adm") == 0) {
            has_admin_group = 1;
        }
    }
    
    printf("  Root 组权限: %s\n", has_root_group ? "是" : "否");
    printf("  管理员组权限: %s\n", has_admin_group ? "是" : "否");
    
    // 清理内存
    if (sup_groups) free(sup_groups);
    if (all_groups) free(all_groups);
}

int main() {
    analyze_process_groups();
    return 0;
}

示例4：组权限验证和安全检查

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <grp.h>

// 检查进程是否属于指定组
int is_process_member_of_group(gid_t target_gid) {
    // 首先检查主要组和有效组
    if (getgid() == target_gid || getegid() == target_gid) {
        return 1;
    }
    
    // 检查补充组
    int sup_count = getgroups(0, NULL);
    if (sup_count <= 0) {
        return 0;
    }
    
    gid_t *sup_groups = malloc(sup_count * sizeof(gid_t));
    if (sup_groups == NULL) {
        return 0;
    }
    
    if (getgroups(sup_count, sup_groups) == -1) {
        free(sup_groups);
        return 0;
    }
    
    for (int i = 0; i < sup_count; i++) {
        if (sup_groups[i] == target_gid) {
            free(sup_groups);
            return 1;
        }
    }
    
    free(sup_groups);
    return 0;
}

// 获取特定组的权限级别
typedef enum {
    NO_ACCESS = 0,
    SUPPLEMENTARY_ACCESS = 1,
    PRIMARY_ACCESS = 2,
    EFFECTIVE_ACCESS = 3,
    ROOT_ACCESS = 4
} access_level_t;

access_level_t get_group_access_level(gid_t target_gid) {
    if (target_gid == 0 && (getgid() == 0 || getegid() == 0)) {
        return ROOT_ACCESS;
    }
    
    if (getegid() == target_gid) {
        return EFFECTIVE_ACCESS;
    }
    
    if (getgid() == target_gid) {
        return PRIMARY_ACCESS;
    }
    
    // 检查补充组
    int sup_count = getgroups(0, NULL);
    if (sup_count > 0) {
        gid_t *sup_groups = malloc(sup_count * sizeof(gid_t));
        if (sup_groups != NULL) {
            if (getgroups(sup_count, sup_groups) != -1) {
                for (int i = 0; i < sup_count; i++) {
                    if (sup_groups[i] == target_gid) {
                        free(sup_groups);
                        return SUPPLEMENTARY_ACCESS;
                    }
                }
            }
            free(sup_groups);
        }
    }
    
    return NO_ACCESS;
}

void check_common_groups() {
    printf("=== 常见组权限检查 ===\n");
    
    // 检查一些常见的系统组
    struct {
        const char *name;
        gid_t gid;
    } common_groups[] = {
        {"root", 0},
        {"wheel", 0},  // 需要查找实际 GID
        {"sudo", 0},
        {"adm", 0},
        {"disk", 0}
    };
    
    // 获取这些组的实际 GID
    for (int i = 0; i < sizeof(common_groups)/sizeof(common_groups[0]); i++) {
        struct group *grp = getgrnam(common_groups[i].name);
        if (grp != NULL) {
            common_groups[i].gid = grp->gr_gid;
        }
    }
    
    printf("%-12s %-8s %-15s %s\n", "组名", "组ID", "访问级别", "成员状态");
    printf("%-12s %-8s %-15s %s\n", "----", "----", "----", "----");
    
    for (int i = 0; i < sizeof(common_groups)/sizeof(common_groups[0]); i++) {
        if (common_groups[i].gid != 0) {
            access_level_t level = get_group_access_level(common_groups[i].gid);
            int is_member = is_process_member_of_group(common_groups[i].gid);
            
            const char *level_str;
            switch (level) {
                case ROOT_ACCESS: level_str = "Root"; break;
                case EFFECTIVE_ACCESS: level_str = "Effective"; break;
                case PRIMARY_ACCESS: level_str = "Primary"; break;
                case SUPPLEMENTARY_ACCESS: level_str = "Supplementary"; break;
                default: level_str = "None"; break;
            }
            
            printf("%-12s %-8d %-15s %s\n",
                   common_groups[i].name,
                   common_groups[i].gid,
                   level_str,
                   is_member ? "是" : "否");
        }
    }
}

int main() {
    check_common_groups();
    return 0;
}

9. 实际应用场景

getgroups 在以下场景中非常有用：

场景1：权限验证

int can_access_resource(gid_t required_group) {
    return is_process_member_of_group(required_group);
}

场景2：安全审计

void audit_process_groups() {
    int count = getgroups(0, NULL);
    syslog(LOG_INFO, "进程拥有 %d 个补充组", count);
}

场景3：访问控制

int check_file_group_permission(const char *filename) {
    struct stat file_stat;
    if (stat(filename, &file_stat) == 0) {
        return is_process_member_of_group(file_stat.st_gid);
    }
    return 0;
}

10. 注意事项

使用 getgroups 时需要注意：

1. 缓冲区大小: 确保缓冲区足够大，避免 EINVAL 错误
2. 内存管理: 正确分配和释放内存
3. 错误处理: 检查返回值和 errno
4. 系统限制: 了解 NGROUPS_MAX 限制
5. 并发安全: 在多线程环境中注意数据一致性

总结

getgroups 是管理进程组权限的重要函数，关键要点：

1. 补充组获取: 获取进程除主要组外的所有组
2. 双重调用: 通常需要先获取数量，再获取实际数据
3. 权限检查: 是权限验证和访问控制的基础
4. 安全相关: 在安全审计和权限管理中广泛使用
5. 系统集成: 与 /etc/group 等系统文件紧密相关

正确使用 getgroups 可以帮助程序准确了解当前的组权限状态，实现更精细的访问控制和安全检查

semget – 获取信号量集标识符

函数介绍

semget系统调用用于创建或访问一个System V信号量集。信号量是一种用于进程间同步的机制，主要用于控制对共享资源的访问，防止多个进程同时访问同一资源造成冲突。

函数原型

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

int semget(key_t key, int nsems, int semflg);

功能

创建新的信号量集或获取现有信号量集的标识符。

参数

• key_t key: 信号量集的键值
  • IPC_PRIVATE: 创建私有信号量集
  • 正整数: 通过ftok()函数生成的键值
• int nsems: 信号量集中信号量的个数（创建时使用）
• int semflg: 标志位组合
  • IPC_CREAT: 如果信号量集不存在则创建
  • IPC_EXCL: 与IPC_CREAT配合使用，如果已存在则失败
  • 权限位: 如0666（读写权限）

返回值

• 成功时返回信号量集的标识符（非负整数）
• 失败时返回-1，并设置errno：
  • EACCES: 权限不足
  • EEXIST: 信号量集已存在（使用IPC_EXCL时）
  • EINVAL: 参数无效
  • ENOENT: 信号量集不存在且未指定IPC_CREAT

相似函数

• semctl(): 控制信号量集
• semop(): 操作信号量集
• ftok(): 生成System V IPC键值

示例代码

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <errno.h>
#include <string.h>

// 信号量操作联合体（某些系统需要）
union semun {
    int val;               // 用于SETVAL
    struct semid_ds *buf;  // 用于IPC_STAT和IPC_SET
    unsigned short *array; // 用于GETALL和SETALL
};

int main() {
    key_t key;
    int semid;
    
    printf("=== Semget函数示例 ===\n");
    
    // 示例1: 使用IPC_PRIVATE创建私有信号量集
    printf("\n示例1: 创建私有信号量集\n");
    semid = semget(IPC_PRIVATE, 1, 0666 | IPC_CREAT);
    if (semid == -1) {
        perror("semget IPC_PRIVATE失败");
        exit(EXIT_FAILURE);
    }
    printf("  成功创建私有信号量集，标识符: %d\n", semid);
    
    // 删除信号量集
    if (semctl(semid, 0, IPC_RMID) == -1) {
        perror("删除信号量集失败");
    } else {
        printf("  成功删除信号量集\n");
    }
    
    // 示例2: 使用ftok生成键值创建信号量集
    printf("\n示例2: 使用ftok创建信号量集\n");
    
    // 生成键值（基于当前文件和项目ID）
    key = ftok(".", 'a');
    if (key == -1) {
        perror("ftok失败");
        exit(EXIT_FAILURE);
    }
    printf("  生成的键值: %d\n", key);
    
    // 创建信号量集（包含3个信号量）
    semid = semget(key, 3, 0666 | IPC_CREAT);
    if (semid == -1) {
        perror("semget创建失败");
        exit(EXIT_FAILURE);
    }
    printf("  成功创建信号量集，标识符: %d\n", semid);
    
    // 示例3: 尝试创建已存在的信号量集
    printf("\n示例3: 尝试重复创建信号量集\n");
    int semid2 = semget(key, 3, 0666 | IPC_CREAT | IPC_EXCL);
    if (semid2 == -1) {
        if (errno == EEXIST) {
            printf("  信号量集已存在\n");
        } else {
            perror("  semget失败");
        }
    } else {
        printf("  意外创建了新的信号量集: %d\n", semid2);
    }
    
    // 示例4: 获取已存在的信号量集
    printf("\n示例4: 获取已存在的信号量集\n");
    int semid3 = semget(key, 0, 0666);
    if (semid3 == -1) {
        perror("获取信号量集失败");
    } else {
        printf("  成功获取信号量集，标识符: %d\n", semid3);
        // 验证是否为同一个信号量集
        if (semid3 == semid) {
            printf("  确认为同一个信号量集\n");
        }
    }
    
    // 示例5: 错误处理演示
    printf("\n示例5: 错误处理\n");
    
    // 尝试访问不存在的信号量集（不创建）
    int semid4 = semget(12345, 1, 0666);
    if (semid4 == -1) {
        if (errno == ENOENT) {
            printf("  信号量集不存在: %s\n", strerror(errno));
        } else {
            perror("  其他错误");
        }
    }
    
    // 清理：删除创建的信号量集
    printf("\n清理资源...\n");
    if (semctl(semid, 0, IPC_RMID) == -1) {
        perror("清理信号量集失败");
    } else {
        printf("  成功清理信号量集\n");
    }
    
    return 0;
}

semop – 信号量操作

函数介绍

semop系统调用用于对System V信号量集执行操作。它是信号量机制的核心操作函数，通过原子性地执行一系列信号量操作来实现进程同步。
](https://www.calcguide.tech/2025/08/18/semop%e7%b3%bb%e7%bb%9f%e8%b0%83%e7%94%a8%e5%8f%8a%e7%a4%ba%e4%be%8b/)

函数原型

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

int semop(int semid, struct sembuf *sops, unsigned nsops);

功能

对信号量集执行原子操作，用于进程间同步。

参数

• int semid: 信号量集的标识符（由semget返回）
• struct sembuf *sops: 指向sembuf结构体数组的指针struct sembuf { unsigned short sem_num; // 信号量在集合中的索引 short sem_op; // 操作类型 short sem_flg; // 操作标志 };
  • sem_op > 0: 释放资源（V操作），将sem_op加到信号量值上
  • sem_op < 0: 请求资源（P操作），从信号量值中减去sem_op的绝对值
  • sem_op = 0: 等待信号量值变为0
• unsigned nsops: sops数组中操作的数量

返回值

• 成功时返回0
• 失败时返回-1，并设置errno：
  • EAGAIN: 操作会阻塞但设置了IPC_NOWAIT
  • EIDRM: 信号量集已被删除
  • EINTR: 系统调用被信号中断
  • EINVAL: 参数无效
  • EFBIG: sem_op绝对值过大

相似函数

• semtimedop(): 带超时的信号量操作
• semget(): 获取信号量集
• semctl(): 控制信号量集

示例代码

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <errno.h>
#include <string.h>
#include <sys/wait.h>

// 信号量操作联合体
union semun {
    int val;
    struct semid_ds *buf;
    unsigned short *array;
};

// P操作（等待/减1）
int P(int semid, int sem_num) {
    struct sembuf sb;
    sb.sem_num = sem_num;
    sb.sem_op = -1;  // P操作
    sb.sem_flg = 0;
    return semop(semid, &sb, 1);
}

// V操作（发送/加1）
int V(int semid, int sem_num) {
    struct sembuf sb;
    sb.sem_num = sem_num;
    sb.sem_op = 1;   // V操作
    sb.sem_flg = 0;
    return semop(semid, &sb, 1);
}

// 等待信号量为0
int wait_zero(int semid, int sem_num) {
    struct sembuf sb;
    sb.sem_num = sem_num;
    sb.sem_op = 0;
    sb.sem_flg = 0;
    return semop(semid, &sb, 1);
}

int main() {
    key_t key;
    int semid;
    union semun arg;
    
    printf("=== Semop函数示例 ===\n");
    
    // 创建信号量集
    key = ftok(".", 'b');
    if (key == -1) {
        perror("ftok失败");
        exit(EXIT_FAILURE);
    }
    
    semid = semget(key, 2, 0666 | IPC_CREAT | IPC_EXCL);
    if (semid == -1) {
        if (errno == EEXIST) {
            // 如果已存在，先删除再创建
            semid = semget(key, 2, 0666);
            semctl(semid, 0, IPC_RMID);
            semid = semget(key, 2, 0666 | IPC_CREAT | IPC_EXCL);
        } else {
            perror("semget失败");
            exit(EXIT_FAILURE);
        }
    }
    
    if (semid == -1) {
        perror("创建信号量集失败");
        exit(EXIT_FAILURE);
    }
    printf("成功创建信号量集，标识符: %d\n", semid);
    
    // 初始化信号量
    // 信号量0：用于互斥，初始值为1（二进制信号量）
    // 信号量1：用于资源计数，初始值为3（表示有3个资源）
    unsigned short init_values[2] = {1, 3};
    arg.array = init_values;
    if (semctl(semid, 0, SETALL, arg) == -1) {
        perror("初始化信号量失败");
        semctl(semid, 0, IPC_RMID);
        exit(EXIT_FAILURE);
    }
    printf("信号量初始化完成\n");
    printf("  信号量0（互斥）: %d\n", semctl(semid, 0, GETVAL));
    printf("  信号量1（资源）: %d\n", semctl(semid, 1, GETVAL));
    
    // 示例1: 基本的P/V操作
    printf("\n示例1: 基本的P/V操作\n");
    printf("操作前 - 信号量0: %d, 信号量1: %d\n",
           semctl(semid, 0, GETVAL), semctl(semid, 1, GETVAL));
    
    // P操作获取互斥锁
    printf("执行P操作获取互斥锁...\n");
    if (P(semid, 0) == -1) {
        perror("P操作失败");
    } else {
        printf("成功获取互斥锁\n");
        printf("操作后 - 信号量0: %d, 信号量1: %d\n",
               semctl(semid, 0, GETVAL), semctl(semid, 1, GETVAL));
        
        // V操作释放互斥锁
        printf("执行V操作释放互斥锁...\n");
        if (V(semid, 0) == -1) {
            perror("V操作失败");
        } else {
            printf("成功释放互斥锁\n");
            printf("操作后 - 信号量0: %d, 信号量1: %d\n",
                   semctl(semid, 0, GETVAL), semctl(semid, 1, GETVAL));
        }
    }
    
    // 示例2: 多进程同步演示
    printf("\n示例2: 多进程同步演示\n");
    pid_t pid = fork();
    
    if (pid == -1) {
        perror("fork失败");
        semctl(semid, 0, IPC_RMID);
        exit(EXIT_FAILURE);
    } else if (pid == 0) {
        // 子进程
        printf("子进程 %d 开始执行\n", getpid());
        
        // 模拟需要互斥访问的临界区
        printf("子进程尝试获取互斥锁...\n");
        if (P(semid, 0) == 0) {
            printf("子进程 %d 进入临界区\n", getpid());
            printf("子进程在临界区工作2秒...\n");
            sleep(2);
            printf("子进程 %d 离开临界区\n", getpid());
            V(semid, 0);  // 释放锁
        }
        
        exit(EXIT_SUCCESS);
    } else {
        // 父进程
        sleep(1);  // 让子进程先运行
        
        printf("父进程 %d 开始执行\n", getpid());
        printf("父进程尝试获取互斥锁...\n");
        
        if (P(semid, 0) == 0) {
            printf("父进程 %d 进入临界区\n", getpid());
            printf("父进程在临界区工作2秒...\n");
            sleep(2);
            printf("父进程 %d 离开临界区\n", getpid());
            V(semid, 0);  // 释放锁
        }
        
        // 等待子进程结束
        wait(NULL);
    }
    
    // 示例3: 资源计数信号量演示
    printf("\n示例3: 资源计数信号量演示\n");
    printf("当前可用资源数: %d\n", semctl(semid, 1, GETVAL));
    
    // 模拟多个进程竞争资源
    for (int i = 0; i < 4; i++) {
        pid = fork();
        if (pid == 0) {
            // 子进程
            printf("进程 %d 尝试获取资源...\n", getpid());
            
            // P操作获取资源
            if (P(semid, 1) == 0) {
                printf("进程 %d 成功获取资源，剩余资源: %d\n", 
                       getpid(), semctl(semid, 1, GETVAL));
                
                // 使用资源
                printf("进程 %d 使用资源2秒...\n", getpid());
                sleep(2);
                
                // V操作释放资源
                V(semid, 1);
                printf("进程 %d 释放资源，剩余资源: %d\n", 
                       getpid(), semctl(semid, 1, GETVAL));
            } else {
                printf("进程 %d 获取资源失败\n", getpid());
            }
            
            exit(EXIT_SUCCESS);
        }
    }
    
    // 等待所有子进程结束
    for (int i = 0; i < 4; i++) {
        wait(NULL);
    }
    
    // 清理资源
    printf("\n清理资源...\n");
    if (semctl(semid, 0, IPC_RMID) == -1) {
        perror("删除信号量集失败");
    } else {
        printf("成功删除信号量集\n");
    }
    
    return 0;
}

1. 函数介绍

seccomp 是Linux系统调用过滤机制，用于限制进程可以执行的系统调用。它通过Berkeley Packet Filter (BPF) 程序来定义哪些系统调用是允许的，哪些是禁止的。seccomp 是构建沙箱环境、提高应用程序安全性的重要工具，可以有效防止恶意代码执行危险的系统调用。

2. 函数原型

#include <linux/seccomp.h>
#include <linux/filter.h>
#include <sys/prctl.h>
#include <unistd.h>

int prctl(int option, unsigned long arg2, unsigned long arg3, 
          unsigned long arg4, unsigned long arg5);

int seccomp(unsigned int operation, unsigned int flags, void *args);

3. 功能

seccomp 提供了系统调用级别的安全控制，可以：

• 限制进程可执行的系统调用集合
• 定义系统调用的执行策略（允许、错误、终止）
• 使用BPF程序实现复杂的过滤逻辑
• 构建安全的沙箱环境

4. 参数

prctl方式：

• int option: 控制选项（如PR_SET_SECCOMP）
• unsigned long arg2: seccomp模式（SECCOMP_MODE_STRICT/SECCOMP_MODE_FILTER）
• 其他参数: 根据选项而定

seccomp系统调用：

• unsigned int operation: 操作类型（SECCOMP_SET_MODE_STRICT/SECCOMP_SET_MODE_FILTER）
• unsigned int flags: 标志位（通常为0）
• *void args: 操作参数（BPF程序指针等）

5. 返回值

• 成功: 返回0
• 失败: 返回-1，并设置errno

6. 相似函数，或关联函数

• prctl: 进程控制接口
• personality: 设置进程执行特性
• chroot: 改变根目录
• capset: 设置进程权限

7. 示例代码

示例1：基础seccomp使用

#define _GNU_SOURCE
#include <linux/seccomp.h>
#include <linux/filter.h>
#include <sys/prctl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/syscall.h>

/**
 * 演示基础seccomp使用方法
 */
int demo_seccomp_basic() {
    printf("=== 基础seccomp使用示例 ===\n");
    
    // 显示当前seccomp状态
    int current_mode = prctl(PR_GET_SECCOMP, 0, 0, 0, 0);
    printf("当前seccomp模式: ");
    switch (current_mode) {
        case 0:
            printf("SECCOMP_MODE_DISABLED (禁用)\n");
            break;
        case 1:
            printf("SECCOMP_MODE_STRICT (严格模式)\n");
            break;
        case 2:
            printf("SECCOMP_MODE_FILTER (过滤模式)\n");
            break;
        default:
            printf("未知模式 (%d)\n", current_mode);
            break;
    }
    
    // 测试普通系统调用（应该成功）
    printf("测试普通系统调用...\n");
    write(STDOUT_FILENO, "  普通write调用成功\n", 21);
    
    // 启用严格模式seccomp
    printf("启用seccomp严格模式...\n");
    if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT, 0, 0, 0) == -1) {
        printf("启用seccomp失败: %s\n", strerror(errno));
        printf("注意：严格模式只允许read/write/exit/exit_group系统调用\n");
        return -1;
    }
    
    printf("seccomp严格模式启用成功\n");
    printf("当前seccomp模式: %d\n", prctl(PR_GET_SECCOMP, 0, 0, 0, 0));
    
    // 测试允许的系统调用
    printf("测试允许的系统调用...\n");
    write(STDOUT_FILENO, "  write调用仍然允许\n", 20);
    
    // 测试不允许的系统调用（这会导致程序终止）
    printf("测试不允许的系统调用（程序将终止）...\n");
    printf("  尝试调用getpid()...\n");
    
    // 注意：下面的调用会导致程序被SIGKILL终止
    // 为了演示目的，我们注释掉危险操作
    /*
    pid_t pid = getpid();  // 这会导致程序终止！
    printf("getpid()返回: %d\n", pid);
    */
    
    printf("  注意：getpid()等系统调用在严格模式下会被禁止\n");
    printf("  实际执行会导致程序被SIGKILL终止\n");
    
    return 0;
}

int main() {
    return demo_seccomp_basic();
}

示例2：自定义BPF过滤器

#define _GNU_SOURCE
#include <linux/seccomp.h>
#include <linux/filter.h>
#include <linux/audit.h>
#include <sys/prctl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/syscall.h>

/**
 * 创建允许特定系统调用的BPF过滤器
 */
int demo_custom_bpf_filter() {
    printf("=== 自定义BPF过滤器示例 ===\n");
    
    // 定义BPF过滤器程序
    // 允许的系统调用：read, write, exit, exit_group
    struct sock_filter filter[] = {
        // 加载系统调用号到累加器
        BPF_STMT(BPF_LD | BPF_W | BPF_ABS, offsetof(struct seccomp_data, nr)),
        
        // 允许 read 系统调用 (SYS_read = 0)
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SYS_read, 0, 1),
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
        
        // 允许 write 系统调用 (SYS_write = 1)
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SYS_write, 0, 1),
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
        
        // 允许 exit 系统调用 (SYS_exit = 60 on x86_64)
#ifdef __x86_64__
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 60, 0, 1),
#elif defined(__i386__)
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 1, 0, 1),
#endif
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
        
        // 允许 exit_group 系统调用
#ifdef __x86_64__
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 231, 0, 1),
#elif defined(__i386__)
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 252, 0, 1),
#endif
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
        
        // 其他系统调用返回EPERM错误
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ERRNO | (EPERM & 0xFFFF)),
    };
    
    struct sock_fprog prog = {
        .len = sizeof(filter) / sizeof(filter[0]),
        .filter = filter,
    };
    
    // 显示过滤器信息
    printf("创建BPF过滤器，允许系统调用:\n");
    printf("  read(%d), write(%d), exit(%d), exit_group(%d)\n", 
#ifdef __x86_64__
           SYS_read, SYS_write, 60, 231
#elif defined(__i386__)
           SYS_read, SYS_write, 1, 252
#endif
    );
    printf("其他系统调用将返回EPERM错误\n");
    
    // 应用BPF过滤器
    if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0) == -1) {
        printf("应用BPF过滤器失败: %s\n", strerror(errno));
        printf("可能的原因：\n");
        printf("  1. 内核不支持seccomp BPF\n");
        printf("  2. 缺少CAP_SYS_ADMIN权限\n");
        printf("  3. 已经设置了seccomp策略\n");
        return -1;
    }
    
    printf("BPF过滤器应用成功\n");
    
    // 测试允许的系统调用
    printf("\n测试允许的系统调用:\n");
    write(STDOUT_FILENO, "  write调用成功\n", 16);
    
    char buffer[10];
    ssize_t bytes_read = read(STDIN_FILENO, buffer, sizeof(buffer));
    if (bytes_read >= 0) {
        printf("  read调用成功\n");
    }
    
    // 测试不允许的系统调用
    printf("\n测试不允许的系统调用:\n");
    long result = syscall(SYS_getpid);
    if (result == -1) {
        printf("  getpid调用被阻止: %s\n", strerror(errno));
    } else {
        printf("  getpid调用意外成功: %ld\n", result);
    }
    
    result = syscall(SYS_open, "/etc/passwd", 0);
    if (result == -1) {
        printf("  open调用被阻止: %s\n", strerror(errno));
    } else {
        printf("  open调用意外成功: %ld\n", result);
    }
    
    printf("\n安全的系统调用仍然可以正常工作\n");
    
    return 0;
}

int main() {
    return demo_custom_bpf_filter();
}

示例3：只读沙箱环境

#define _GNU_SOURCE
#include <linux/seccomp.h>
#include <linux/filter.h>
#include <linux/audit.h>
#include <sys/prctl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/syscall.h>
#include <fcntl.h>
#include <sys/stat.h>

/**
 * 创建只读沙箱环境的BPF过滤器
 */
int demo_readonly_sandbox() {
    printf("=== 只读沙箱环境示例 ===\n");
    
    // 定义只读沙箱的BPF过滤器
    // 允许读操作和基本系统调用，禁止写操作
    struct sock_filter filter[] = {
        // 加载系统调用号
        BPF_STMT(BPF_LD | BPF_W | BPF_ABS, offsetof(struct seccomp_data, nr)),
        
        // 允许 read 系统调用
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SYS_read, 0, 1),
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
        
        // 允许 write 系统调用（仅允许写到stdout/stderr）
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SYS_write, 0, 5),
        // 检查文件描述符是否为stdout(1)或stderr(2)
        BPF_STMT(BPF_LD | BPF_W | BPF_ABS, offsetof(struct seccomp_data, args[0])),
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 1, 0, 1),  // stdout
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 2, 0, 1),  // stderr
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ERRNO | (EPERM & 0xFFFF)),
        
        // 允许 exit 和 exit_group
#ifdef __x86_64__
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 60, 0, 1),   // exit
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 231, 0, 1),  // exit_group
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
#elif defined(__i386__)
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 1, 0, 1),    // exit
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 252, 0, 1),  // exit_group
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
#endif
        
        // 允许 read-only 文件操作
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SYS_open, 0, 3),
        // 检查打开标志是否包含O_RDONLY
        BPF_STMT(BPF_LD | BPF_W | BPF_ABS, offsetof(struct seccomp_data, args[1])),
        BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, O_RDONLY, 0, 1),
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ERRNO | (EPERM & 0xFFFF)),
        
        // 允许 close 系统调用
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SYS_close, 0, 1),
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
        
        // 禁止其他所有系统调用
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ERRNO | (EPERM & 0xFFFF)),
    };
    
    struct sock_fprog prog = {
        .len = sizeof(filter) / sizeof(filter[0]),
        .filter = filter,
    };
    
    printf("创建只读沙箱环境\n");
    printf("允许的操作：\n");
    printf("  - 读取文件（只读模式）\n");
    printf("  - 写入标准输出和标准错误\n");
    printf("  - 基本的进程控制\n");
    printf("禁止的操作：\n");
    printf("  - 写入文件\n");
    printf("  - 网络操作\n");
    printf("  - 进程创建\n");
    printf("  - 其他危险操作\n");
    
    // 应用过滤器
    if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0) == -1) {
        printf("创建沙箱失败: %s\n", strerror(errno));
        return -1;
    }
    
    printf("只读沙箱创建成功\n");
    
    // 测试沙箱功能
    printf("\n=== 沙箱功能测试 ===\n");
    
    // 测试允许的读操作
    printf("1. 测试允许的读操作:\n");
    int fd = open("/etc/passwd", O_RDONLY);
    if (fd != -1) {
        char buffer[100];
        ssize_t bytes = read(fd, buffer, sizeof(buffer));
        if (bytes > 0) {
            printf("  读取/etc/passwd成功 (%zd 字节)\n", bytes);
        }
        close(fd);
    } else {
        printf("  打开/etc/passwd失败: %s\n", strerror(errno));
    }
    
    // 测试允许的写操作（stdout/stderr）
    printf("\n2. 测试允许的写操作:\n");
    write(STDOUT_FILENO, "  写入stdout成功\n", 17);
    write(STDERR_FILENO, "  写入stderr成功\n", 17);
    
    // 测试禁止的写操作
    printf("\n3. 测试禁止的写操作:\n");
    fd = open("/tmp/test_seccomp", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd == -1) {
        printf("  创建文件被阻止: %s\n", strerror(errno));
    } else {
        printf("  创建文件意外成功\n");
        close(fd);
        unlink("/tmp/test_seccomp");
    }
    
    // 测试禁止的系统调用
    printf("\n4. 测试禁止的系统调用:\n");
    long result = syscall(SYS_fork);
    if (result == -1) {
        printf("  fork被阻止: %s\n", strerror(errno));
    }
    
    result = syscall(SYS_socket, AF_INET, SOCK_STREAM, 0);
    if (result == -1) {
        printf("  socket被阻止: %s\n", strerror(errno));
    }
    
    printf("\n沙箱环境测试完成\n");
    
    return 0;
}

int main() {
    return demo_readonly_sandbox();
}

示例4：进程监控和日志

#define _GNU_SOURCE
#include <linux/seccomp.h>
#include <linux/filter.h>
#include <linux/audit.h>
#include <sys/prctl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/syscall.h>
#include <signal.h>
#include <sys/wait.h>

/**
 * 信号处理函数
 */
void signal_handler(int sig) {
    printf("捕获信号 %d\n", sig);
    if (sig == SIGSYS) {
        printf("检测到被禁止的系统调用\n");
    }
}

/**
 * 演示seccomp的监控和日志功能
 */
int demo_seccomp_monitoring() {
    printf("=== seccomp监控和日志示例 ===\n");
    
    // 注册信号处理程序来捕获SIGSYS
    signal(SIGSYS, signal_handler);
    
    // 创建带日志的BPF过滤器
    struct sock_filter filter[] = {
        // 加载系统调用号
        BPF_STMT(BPF_LD | BPF_W | BPF_ABS, offsetof(struct seccomp_data, nr)),
        
        // 允许基本的读写操作
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SYS_read, 0, 1),
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
        
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SYS_write, 0, 1),
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
        
        // 允许exit相关调用
#ifdef __x86_64__
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 60, 0, 1),   // exit
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
        BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 231, 0, 1),  // exit_group
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
#endif
        
        // 对于其他系统调用，返回追踪标志（用于日志）
        BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_TRACE | (1 & 0xFFFF)),
    };
    
    struct sock_fprog prog = {
        .len = sizeof(filter) / sizeof(filter[0]),
        .filter = filter,
    };
    
    printf("创建带监控的日志过滤器\n");
    printf("SECCOMP_RET_TRACE可以用于:\n");
    printf("  - 系统调用追踪\n");
    printf("  - 安全审计\n");
    printf("  - 调试和分析\n");
    
    // 启用seccomp
    if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog) == -1) {
        printf("启用seccomp失败: %s\n", strerror(errno));
        return -1;
    }
    
    printf("seccomp监控启用成功\n");
    
    // 测试监控功能
    printf("\n测试监控功能:\n");
    
    // 允许的系统调用
    write(STDOUT_FILENO, "允许的write调用\n", 17);
    
    // 被监控的系统调用
    printf("测试被监控的系统调用:\n");
    
    pid_t pid = getpid();
    printf("getpid()返回: %d\n", (int)pid);
    
    uid_t uid = getuid();
    printf("getuid()返回: %d\n", (int)uid);
    
    printf("注意：在实际应用中，SECCOMP_RET_TRACE会触发ptrace事件\n");
    printf("这需要额外的监控进程来处理追踪事件\n");
    
    return 0;
}

int main() {
    return demo_seccomp_monitoring();
}

示例5：安全沙箱应用

#define _GNU_SOURCE
#include <linux/seccomp.h>
#include <linux/filter.h>
#include <linux/audit.h>
#include <sys/prctl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/syscall.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/mman.h>

/**
 * 安全沙箱配置
 */
typedef struct {
    int allow_network;
    int allow_file_write;
    int allow_process_creation;
    int allow_memory_mapping;
} sandbox_config_t;

/**
 * 创建安全沙箱
 */
int create_secure_sandbox(const sandbox_config_t *config) {
    printf("=== 创建安全沙箱 ===\n");
    
    // 根据配置创建BPF过滤器
    struct sock_filter filter[100];
    int filter_index = 0;
    
    // 基础加载系统调用号指令
    filter[filter_index++] = BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 
                                     offsetof(struct seccomp_data, nr));
    
    // 始终允许的系统调用
    int essential_calls[] = {SYS_read, SYS_write, 
#ifdef __x86_64__
                           60,  // exit
                           231  // exit_group
#elif defined(__i386__)
                           1,   // exit
                           252  // exit_group
#endif
    };
    
    for (size_t i = 0; i < sizeof(essential_calls)/sizeof(essential_calls[0]); i++) {
        filter[filter_index++] = BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 
                                         essential_calls[i], 0, 1);
        filter[filter_index++] = BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW);
    }
    
    // 根据配置允许额外的系统调用
    if (config->allow_file_write) {
        filter[filter_index++] = BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SYS_open, 0, 1);
        filter[filter_index++] = BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW);
        
        filter[filter_index++] = BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SYS_openat, 0, 1);
        filter[filter_index++] = BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW);
        
        filter[filter_index++] = BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SYS_close, 0, 1);
        filter[filter_index++] = BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW);
    }
    
    if (config->allow_network) {
        filter[filter_index++] = BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SYS_socket, 0, 1);
        filter[filter_index++] = BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW);
        
        filter[filter_index++] = BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SYS_connect, 0, 1);
        filter[filter_index++] = BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW);
    }
    
    if (config->allow_process_creation) {
        filter[filter_index++] = BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SYS_fork, 0, 1);
        filter[filter_index++] = BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW);
        
        filter[filter_index++] = BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SYS_clone, 0, 1);
        filter[filter_index++] = BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW);
    }
    
    if (config->allow_memory_mapping) {
        filter[filter_index++] = BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SYS_mmap, 0, 1);
        filter[filter_index++] = BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW);
        
        filter[filter_index++] = BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SYS_munmap, 0, 1);
        filter[filter_index++] = BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW);
    }
    
    // 默认拒绝所有其他系统调用
    filter[filter_index++] = BPF_STMT(BPF_RET | BPF_K, 
                                     SECCOMP_RET_ERRNO | (EPERM & 0xFFFF));
    
    struct sock_fprog prog = {
        .len = filter_index,
        .filter = filter,
    };
    
    printf("沙箱配置:\n");
    printf("  网络访问: %s\n", config->allow_network ? "允许" : "禁止");
    printf("  文件写入: %s\n", config->allow_file_write ? "允许" : "禁止");
    printf("  进程创建: %s\n", config->allow_process_creation ? "允许" : "禁止");
    printf("  内存映射: %s\n", config->allow_memory_mapping ? "允许" : "禁止");
    
    // 应用沙箱
    if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0) == -1) {
        printf("创建沙箱失败: %s\n", strerror(errno));
        return -1;
    }
    
    printf("安全沙箱创建成功\n");
    return 0;
}

/**
 * 演示不同安全级别的沙箱
 */
int demo_security_levels() {
    sandbox_config_t configs[3] = {
        // 最严格：只允许基本I/O
        {0, 0, 0, 0},
        
        // 中等：允许文件操作
        {0, 1, 0, 1},
        
        // 宽松：允许网络和进程创建
        {1, 1, 1, 1}
    };
    
    const char *level_names[] = {"最高安全", "中等安全", "较低安全"};
    
    printf("=== 不同安全级别沙箱演示 ===\n");
    
    for (int level = 0; level < 3; level++) {
        printf("\n--- %s级别沙箱 ---\n", level_names[level]);
        
        if (create_secure_sandbox(&configs[level]) == 0) {
            printf("沙箱 %s 创建成功\n", level_names[level]);
            
            // 测试沙箱功能
            write(STDOUT_FILENO, "基本I/O测试成功\n", 17);
            
            if (configs[level].allow_network) {
                printf("网络功能可用\n");
            }
            
            if (configs[level].allow_file_write) {
                printf("文件写入功能可用\n");
            }
            
            // 由于seccomp策略一旦设置就不能放松，我们需要在子进程中测试
            break;  // 只测试第一个配置
        }
    }
    
    return 0;
}

/**
 * 演示沙箱的实际应用
 */
int demo_practical_sandbox() {
    printf("=== 实际沙箱应用演示 ===\n");
    
    // 创建一个限制性的沙箱：只允许基本操作
    sandbox_config_t config = {0, 0, 0, 0};  // 最严格
    
    if (create_secure_sandbox(&config) != 0) {
        return -1;
    }
    
    printf("\n沙箱环境中运行测试程序:\n");
    
    // 测试基本功能
    printf("1. 基本输出测试:\n");
    printf("   标准输出工作正常\n");
    write(STDOUT_FILENO, "   write系统调用工作正常\n", 24);
    
    // 测试被限制的功能
    printf("\n2. 被限制功能测试:\n");
    
    // 尝试网络操作
    long result = syscall(SYS_socket, AF_INET, SOCK_STREAM, 0);
    if (result == -1) {
        printf("   网络操作被成功阻止: %s\n", strerror(errno));
    }
    
    // 尝试文件写入
    result = syscall(SYS_open, "/tmp/test", O_WRONLY | O_CREAT, 0644);
    if (result == -1) {
        printf("   文件写入被成功阻止: %s\n", strerror(errno));
    }
    
    // 尝试进程创建
    result = syscall(SYS_fork);
    if (result == -1) {
        printf("   进程创建被成功阻止: %s\n", strerror(errno));
    }
    
    printf("\n3. 沙箱优势:\n");
    printf("   ✓ 防止恶意代码执行危险操作\n");
    printf("   ✓ 限制程序的权限范围\n");
    printf("   ✓ 提供额外的安全层\n");
    printf("   ✓ 可以与其它安全机制配合使用\n");
    
    printf("\n4. 使用场景:\n");
    printf("   - 插件或扩展的安全执行\n");
    printf("   - 不可信代码的沙箱运行\n");
    printf("   - 容器和虚拟化环境\n");
    printf("   - 安全审计和监控\n");
    
    return 0;
}

int main() {
    printf("seccomp - Linux系统调用过滤机制\n");
    printf("================================\n\n");
    
    // 由于seccomp策略一旦设置就会影响整个进程，
    // 我们分别在不同的子进程中演示不同功能
    
    if (fork() == 0) {
        return demo_practical_sandbox();
    }
    
    int status;
    wait(&status);
    
    return 0;
}

seccomp 使用注意事项

系统要求：

1. 内核版本: 需要Linux 3.5或更高版本
2. 架构支持: 支持多种CPU架构
3. 编译选项: 需要内核编译时启用CONFIG_SECCOMP

权限要求：

1. CAP_SYS_ADMIN: 通常需要管理员权限
2. 无特权进程: 可以使用SECCOMP_MODE_STRICT
3. 容器环境: Docker等容器可能有限制

安全考虑：

1. 策略不可逆: 一旦应用，seccomp策略不能放松
2. 调试困难: 被阻止的系统调用可能难以调试
3. 兼容性: 可能影响程序的正常功能
4. 性能影响: BPF过滤会增加系统调用开销

最佳实践：

1. 渐进式应用: 从宽松策略开始，逐步收紧
2. 充分测试: 在生产环境前充分测试
3. 错误处理: 妥善处理被阻止的系统调用
4. 日志记录: 记录安全相关事件
5. 备份方案: 提供策略失效时的处理方案

seccomp 模式详解

SECCOMP_MODE_STRICT (模式1)：

• 特点: 最简单的模式，只允许read/write/exit/exit_group
• 优点: 简单、高效、安全
• 缺点: 功能极其有限
• 适用: 极度安全要求的简单程序

SECCOMP_MODE_FILTER (模式2)：

• 特点: 使用BPF程序定义复杂过滤规则
• 优点: 灵活、功能强大
• 缺点: 配置复杂
• 适用: 大多数实际应用场景

常见系统调用编号

x86_64架构：

• SYS_read = 0
• SYS_write = 1
• SYS_open = 2
• SYS_close = 3
• SYS_stat = 4
• SYS_fstat = 5
• SYS_lstat = 6
• SYS_poll = 7
• SYS_lseek = 8
• SYS_mmap = 9
• SYS_mprotect = 10
• SYS_munmap = 11
• SYS_brk = 12
• SYS_rt_sigaction = 13
• SYS_rt_sigprocmask = 14
• SYS_rt_sigreturn = 15
• SYS_ioctl = 16
• SYS_pread64 = 17
• SYS_pwrite64 = 18
• SYS_readv = 19
• SYS_writev = 20
• SYS_access = 21
• SYS_pipe = 22
• SYS_select = 23
• SYS_sched_yield = 24
• SYS_mremap = 25
• SYS_msync = 26
• SYS_mincore = 27
• SYS_madvise = 28
• SYS_shmget = 29
• SYS_shmat = 30
• SYS_shmctl = 31
• SYS_dup = 32
• SYS_dup2 = 33
• SYS_pause = 34
• SYS_nanosleep = 35
• SYS_getitimer = 36
• SYS_alarm = 37
• SYS_setitimer = 38
• SYS_getpid = 39
• SYS_sendfile = 40
• SYS_socket = 41
• SYS_connect = 42
• SYS_accept = 43
• SYS_sendto = 44
• SYS_recvfrom = 45
• SYS_sendmsg = 46
• SYS_recvmsg = 47
• SYS_shutdown = 48
• SYS_bind = 49
• SYS_listen = 50
• SYS_getsockname = 51
• SYS_getpeername = 52
• SYS_socketpair = 53
• SYS_setsockopt = 54
• SYS_getsockopt = 55
• SYS_clone = 56
• SYS_fork = 57
• SYS_vfork = 58
• SYS_execve = 59
• SYS_exit = 60
• SYS_wait4 = 61
• SYS_kill = 62
• SYS_uname = 63
• SYS_semget = 64
• SYS_semop = 65
• SYS_semctl = 66
• SYS_shmdt = 67
• SYS_msgget = 68
• SYS_msgsnd = 69
• SYS_msgrcv = 70
• SYS_msgctl = 71
• SYS_fcntl = 72
• SYS_flock = 73
• SYS_fsync = 74
• SYS_fdatasync = 75
• SYS_truncate = 76
• SYS_ftruncate = 77
• SYS_getdents = 78
• SYS_getcwd = 79
• SYS_chdir = 80
• SYS_fchdir = 81
• SYS_rename = 82
• SYS_mkdir = 83
• SYS_rmdir = 84
• SYS_creat = 85
• SYS_link = 86
• SYS_unlink = 87
• SYS_symlink = 88
• SYS_readlink = 89
• SYS_chmod = 90
• SYS_fchmod = 91
• SYS_chown = 92
• SYS_fchown = 93
• SYS_lchown = 94
• SYS_umask = 95
• SYS_gettimeofday = 96
• SYS_getrlimit = 97
• SYS_getrusage = 98
• SYS_sysinfo = 99
• SYS_times = 100
• SYS_ptrace = 101
• SYS_getuid = 102
• SYS_syslog = 103
• SYS_getgid = 104
• SYS_setuid = 105
• SYS_setgid = 106
• SYS_geteuid = 107
• SYS_getegid = 108
• SYS_setpgid = 109
• SYS_getppid = 110
• SYS_getpgrp = 111
• SYS_setsid = 112
• SYS_setreuid = 113
• SYS_setregid = 114
• SYS_getgroups = 115
• SYS_setgroups = 116
• SYS_setresuid = 117
• SYS_getresuid = 118
• SYS_setresgid = 119
• SYS_getresgid = 120
• SYS_getpgid = 121
• SYS_setfsuid = 122
• SYS_setfsgid = 123
• SYS_getsid = 124
• SYS_capget = 125
• SYS_capset = 126
• SYS_rt_sigpending = 127
• SYS_rt_sigtimedwait = 128
• SYS_rt_sigqueueinfo = 129
• SYS_rt_sigsuspend = 130
• SYS_sigaltstack = 131
• SYS_utime = 132
• SYS_mknod = 133
• SYS_uselib = 134
• SYS_personality = 135
• SYS_ustat = 136
• SYS_statfs = 137
• SYS_fstatfs = 138
• SYS_sysfs = 139
• SYS_getpriority = 140
• SYS_setpriority = 141
• SYS_sched_setparam = 142
• SYS_sched_getparam = 143
• SYS_sched_setscheduler = 144
• SYS_sched_getscheduler = 145
• SYS_sched_get_priority_max = 146
• SYS_sched_get_priority_min = 147
• SYS_sched_rr_get_interval = 148
• SYS_mlock = 149
• SYS_munlock = 150
• SYS_mlockall = 151
• SYS_munlockall = 152
• SYS_vhangup = 153
• SYS_modify_ldt = 154
• SYS_pivot_root = 155
• SYS__sysctl = 156
• SYS_prctl = 157
• SYS_arch_prctl = 158
• SYS_adjtimex = 159
• SYS_setrlimit = 160
• SYS_chroot = 161
• SYS_sync = 162
• SYS_acct = 163
• SYS_settimeofday = 164
• SYS_mount = 165
• SYS_umount2 = 166
• SYS_swapon = 167
• SYS_swapoff = 168
• SYS_reboot = 169
• SYS_sethostname = 170
• SYS_setdomainname = 171
• SYS_iopl = 172
• SYS_ioperm = 173
• SYS_create_module = 174
• SYS_init_module = 175
• SYS_delete_module = 176
• SYS_get_kernel_syms = 177
• SYS_query_module = 178
• SYS_quotactl = 179
• SYS_nfsservctl = 180
• SYS_getpmsg = 181
• SYS_putpmsg = 182
• SYS_afs_syscall = 183
• SYS_tuxcall = 184
• SYS_security = 185
• SYS_gettid = 186
• SYS_readahead = 187
• SYS_setxattr = 188
• SYS_lsetxattr = 189
• SYS_fsetxattr = 190
• SYS_getxattr = 191
• SYS_lgetxattr = 192
• SYS_fgetxattr = 193
• SYS_listxattr = 194
• SYS_llistxattr = 195
• SYS_flistxattr = 196
• SYS_removexattr = 197
• SYS_lremovexattr = 198
• SYS_fremovexattr = 199
• SYS_tkill = 200
• SYS_time = 201
• SYS_futex = 202
• SYS_sched_setaffinity = 203
• SYS_sched_getaffinity = 204
• SYS_set_thread_area = 205
• SYS_io_setup = 206
• SYS_io_destroy = 207
• SYS_io_getevents = 208
• SYS_io_submit = 209
• SYS_io_cancel = 210
• SYS_get_thread_area = 211
• SYS_lookup_dcookie = 212
• SYS_epoll_create = 213
• SYS_epoll_ctl_old = 214
• SYS_epoll_wait_old = 215
• SYS_remap_file_pages = 216
• SYS_getdents64 = 217
• SYS_set_tid_address = 218
• SYS_restart_syscall = 219
• SYS_semtimedop = 220
• SYS_fadvise64 = 221
• SYS_timer_create = 222
• SYS_timer_settime = 223
• SYS_timer_gettime = 224
• SYS_timer_getoverrun = 225
• SYS_timer_delete = 226
• SYS_clock_settime = 227
• SYS_clock_gettime = 228
• SYS_clock_getres = 229
• SYS_clock_nanosleep = 230
• SYS_exit_group = 231
• SYS_epoll_wait = 232
• SYS_epoll_ctl = 233
• SYS_tgkill = 234
• SYS_utimes = 235
• SYS_vserver = 236
• SYS_mbind = 237
• SYS_set_mempolicy = 238
• SYS_get_mempolicy = 239
• SYS_mq_open = 240
• SYS_mq_unlink = 241
• SYS_mq_timedsend = 242
• SYS_mq_timedreceive = 243
• SYS_mq_notify = 244
• SYS_mq_getsetattr = 245
• SYS_kexec_load = 246
• SYS_waitid = 247
• SYS_add_key = 248
• SYS_request_key = 249
• SYS_keyctl = 250
• SYS_ioprio_set = 251
• SYS_ioprio_get = 252
• SYS_inotify_init = 253
• SYS_inotify_add_watch = 254
• SYS_inotify_rm_watch = 255
• SYS_migrate_pages = 256
• SYS_openat = 257
• SYS_mkdirat = 258
• SYS_mknodat = 259
• SYS_fchownat = 260
• SYS_futimesat = 261
• SYS_newfstatat = 262
• SYS_unlinkat = 263
• SYS_renameat = 264
• SYS_linkat = 265
• SYS_symlinkat = 266
• SYS_readlinkat = 267
• SYS_fchmodat = 268
• SYS_faccessat = 269
• SYS_pselect6 = 270
• SYS_ppoll = 271
• SYS_unshare = 272
• SYS_set_robust_list = 273
• SYS_get_robust_list = 274
• SYS_splice = 275
• SYS_tee = 276
• SYS_sync_file_range = 277
• SYS_vmsplice = 278
• SYS_move_pages = 279
• SYS_utimensat = 280
• SYS_epoll_pwait = 281
• SYS_signalfd = 282
• SYS_timerfd_create = 283
• SYS_eventfd = 284
• SYS_fallocate = 285
• SYS_timerfd_settime = 286
• SYS_timerfd_gettime = 287
• SYS_accept4 = 288
• SYS_signalfd4 = 289
• SYS_eventfd2 = 290
• SYS_epoll_create1 = 291
• SYS_dup3 = 292
• SYS_pipe2 = 293
• SYS_inotify_init1 = 294
• SYS_preadv = 295
• SYS_pwritev = 296
• SYS_rt_tgsigqueueinfo = 297
• SYS_perf_event_open = 298
• SYS_recvmmsg = 299
• SYS_fanotify_init = 300
• SYS_fanotify_mark = 301
• SYS_prlimit64 = 302
• SYS_name_to_handle_at = 303
• SYS_open_by_handle_at = 304
• SYS_clock_adjtime = 305
• SYS_syncfs = 306
• SYS_sendmmsg = 307
• SYS_setns = 308
• SYS_getcpu = 309
• SYS_process_vm_readv = 310
• SYS_process_vm_writev = 311
• SYS_kcmp = 312
• SYS_finit_module = 313
• SYS_sched_setattr = 314
• SYS_sched_getattr = 315
• SYS_renameat2 = 316
• SYS_seccomp = 317
• SYS_getrandom = 318
• SYS_memfd_create = 319
• SYS_kexec_file_load = 320
• SYS_bpf = 321
• SYS_execveat = 322
• SYS_userfaultfd = 323
• SYS_membarrier = 324
• SYS_mlock2 = 325
• SYS_copy_file_range = 326
• SYS_preadv2 = 327
• SYS_pwritev2 = 328
• SYS_pkey_mprotect = 329
• SYS_pkey_alloc = 330
• SYS_pkey_free = 331
• SYS_statx = 332
• SYS_io_pgetevents = 333
• SYS_rseq = 334

总结

seccomp 是Linux系统中强大的安全机制，提供了：

1. 系统调用级别的访问控制: 精确控制进程可以执行的操作
2. 灵活的策略定义: 通过BPF程序实现复杂过滤逻辑
3. 高效的执行: 内核级别的过滤，性能开销小
4. 广泛的应用场景: 适用于沙箱、容器、安全审计等

通过合理使用seccomp，可以显著提高应用程序的安全性，构建更加安全可靠的计算环境。在实际应用中，需要仔细设计过滤策略，充分测试，并考虑错误处理和调试需求。

我们继续学习 Linux 系统编程中的重要函数。这次我们介绍 pipe 函数，它用于创建匿名管道，这是一种在相关进程（如父子进程）之间进行单向数据通信的重要机制。

pipe 函数介绍

1. 函数介绍

pipe 是一个 Linux 系统调用，用于创建一个匿名管道（Anonymous Pipe）。管道是一种半双工（单向）的进程间通信（IPC）机制，数据只能在一个方向上流动。

管道通常用于具有亲缘关系的进程之间通信，最常见的场景是父进程和子进程之间的数据传递。创建管道后，会得到两个文件描述符：一个用于读取（read end），一个用于写入（write end）。写入端写入的数据会被内核缓冲，然后可以从读取端读取出来。

管道是 Unix/Linux “一切皆文件” 哲学的体现，管道的两端都可以像普通文件一样使用 read() 和 write() 系统调用进行操作。

重要特性:

• 匿名性: 管道没有名字，不能通过文件系统路径访问。
• 单向性: 数据只能从写端流向读端。
• 亲缘性: 通常用于有亲缘关系的进程间通信。
• 阻塞性: 默认情况下，读写操作可能会阻塞。
• 缓冲性: 内核提供缓冲区来存储管道中的数据。

2. 函数原型

#include <unistd.h> // 必需

int pipe(int pipefd[2]);

3. 功能

• 创建管道: 在内核中创建一个管道缓冲区。
• 返回文件描述符: 通过 pipefd 数组返回两个文件描述符：
  • pipefd[0]: 管道的读取端（read end）。
  • pipefd[1]: 管道的写入端（write end）。

4. 参数

• int pipefd[2]: 一个包含两个整数的数组，用于接收返回的文件描述符。
  • pipefd[0]: 管道的读取端文件描述符。进程可以使用 read(pipefd[0], buffer, size) 从此端读取数据。
  • pipefd[1]: 管道的写入端文件描述符。进程可以使用 write(pipefd[1], buffer, size) 向此端写入数据。
  • 注意: 创建管道后，通常会使用 fork() 创建子进程，然后父子进程分别关闭不需要的端。例如，父进程负责写入，则应关闭 pipefd[0]；子进程负责读取，则应关闭 pipefd[1]。

5. 返回值

• 成功时: 返回 0。
• 失败时:
  • 返回 -1，并设置全局变量 errno 来指示具体的错误原因：
    • EFAULT: pipefd 数组指针无效。
    • EMFILE: 进程已打开的文件描述符数量达到上限 (RLIMIT_NOFILE)。
    • ENFILE: 系统范围内已打开的文件数量达到上限。

6. 相似函数，或关联函数

• pipe2(int pipefd[2], int flags): pipe 的扩展版本，允许设置额外的标志，如 O_CLOEXEC（执行时关闭）或 O_NONBLOCK（非阻塞模式）。
• mkfifo(const char *pathname, mode_t mode): 创建命名管道（FIFO），它是一个存在于文件系统中的特殊文件，可以让无亲缘关系的进程通信。
• socketpair(int domain, int type, int protocol, int sv[2]): 创建一对相互连接的套接字，可以实现全双工通信。
• popen(const char *command, const char *type), pclose(FILE *stream): 高级函数，创建一个管道并启动一个 shell 来执行命令，方便地实现程序间的数据交换。

7. 示例代码

示例 1：基本的父子进程管道通信

这个例子演示了最经典的管道使用场景：父进程向子进程发送数据。

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/wait.h>

#define BUFFER_SIZE 256

int main() {
    int pipefd[2];
    pid_t pid;
    char buffer[BUFFER_SIZE];

    printf("=== 基本父子进程管道通信 ===\n");

    // 1. 创建管道
    if (pipe(pipefd) == -1) {
        perror("pipe 创建失败");
        exit(EXIT_FAILURE);
    }
    printf("管道创建成功: 读端=%d, 写端=%d\n", pipefd[0], pipefd[1]);

    // 2. 创建子进程
    pid = fork();
    if (pid == -1) {
        perror("fork 失败");
        // 清理管道文件描述符
        close(pipefd[0]);
        close(pipefd[1]);
        exit(EXIT_FAILURE);
    }

    if (pid == 0) {
        // 子进程：读取数据
        printf("子进程 (PID: %d) 开始读取数据...\n", getpid());
        
        // 关闭写端（子进程不需要写入）
        close(pipefd[1]);
        
        // 从管道读取数据
        ssize_t bytes_read = read(pipefd[0], buffer, BUFFER_SIZE - 1);
        if (bytes_read > 0) {
            buffer[bytes_read] = '\0'; // 确保字符串以 null 结尾
            printf("子进程读取到数据: %s", buffer);
        } else if (bytes_read == 0) {
            printf("子进程读取结束 (写端已关闭)\n");
        } else {
            perror("子进程读取失败");
        }
        
        // 关闭读端
        close(pipefd[0]);
        printf("子进程结束\n");
        exit(EXIT_SUCCESS);
        
    } else {
        // 父进程：写入数据
        printf("父进程 (PID: %d) 开始写入数据...\n", getpid());
        
        // 关闭读端（父进程不需要读取）
        close(pipefd[0]);
        
        // 向管道写入数据
        const char *message = "Hello from parent process through pipe!\n";
        ssize_t bytes_written = write(pipefd[1], message, strlen(message));
        if (bytes_written == -1) {
            perror("父进程写入失败");
        } else {
            printf("父进程写入 %ld 字节数据\n", bytes_written);
        }
        
        // 关闭写端，这会通知读端数据已写完
        close(pipefd[1]);
        
        // 等待子进程结束
        int status;
        waitpid(pid, &status, 0);
        if (WIFEXITED(status)) {
            printf("子进程正常退出，退出码: %d\n", WEXITSTATUS(status));
        } else {
            printf("子进程异常退出\n");
        }
        
        printf("父进程结束\n");
    }

    return 0;
}

代码解释:

1. 首先调用 pipe(pipefd) 创建管道，得到读端 pipefd[0] 和写端 pipefd[1]。
2. 调用 fork() 创建子进程。此时，父子进程都拥有管道两端的文件描述符副本。
3. 在子进程中：
   • 关闭不需要的写端 pipefd[1]。
   • 使用 read(pipefd[0], ...) 从管道读取数据。
   • 读取完成后关闭读端 pipefd[0]。
4. 在父进程中：
   • 关闭不需要的读端 pipefd[0]。
   • 使用 write(pipefd[1], ...) 向管道写入数据。
   • 写入完成后关闭写端 pipefd[1]，这会通知读端没有更多数据。
   • 使用 waitpid() 等待子进程结束。

示例 2：双向管道通信

这个例子演示如何使用两个管道实现父子进程之间的双向通信。

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/wait.h>

#define BUFFER_SIZE 256

int main() {
    int parent_to_child_pipe[2];  // 父进程向子进程发送数据
    int child_to_parent_pipe[2];  // 子进程向父进程发送数据
    pid_t pid;
    char buffer[BUFFER_SIZE];

    printf("=== 双向管道通信 ===\n");

    // 1. 创建两个管道
    if (pipe(parent_to_child_pipe) == -1 || pipe(child_to_parent_pipe) == -1) {
        perror("管道创建失败");
        exit(EXIT_FAILURE);
    }
    printf("管道创建成功\n");
    printf("父到子管道: 读端=%d, 写端=%d\n", parent_to_child_pipe[0], parent_to_child_pipe[1]);
    printf("子到父管道: 读端=%d, 写端=%d\n", child_to_parent_pipe[0], child_to_parent_pipe[1]);

    // 2. 创建子进程
    pid = fork();
    if (pid == -1) {
        perror("fork 失败");
        close(parent_to_child_pipe[0]);
        close(parent_to_child_pipe[1]);
        close(child_to_parent_pipe[0]);
        close(child_to_parent_pipe[1]);
        exit(EXIT_FAILURE);
    }

    if (pid == 0) {
        // 子进程
        printf("子进程 (PID: %d) 启动\n", getpid());
        
        // 关闭不需要的文件描述符
        close(parent_to_child_pipe[1]);  // 子进程不写入父到子管道
        close(child_to_parent_pipe[0]);  // 子进程不读取子到父管道
        
        // 1. 从父进程接收消息
        printf("子进程等待接收父进程消息...\n");
        ssize_t bytes_read = read(parent_to_child_pipe[0], buffer, BUFFER_SIZE - 1);
        if (bytes_read > 0) {
            buffer[bytes_read] = '\0';
            printf("子进程收到消息: %s", buffer);
            
            // 2. 向父进程发送回复
            const char *reply = "Hello parent! I'm child process.\n";
            ssize_t bytes_written = write(child_to_parent_pipe[1], reply, strlen(reply));
            if (bytes_written == -1) {
                perror("子进程发送回复失败");
            } else {
                printf("子进程发送回复 (%ld 字节)\n", bytes_written);
            }
        }
        
        // 关闭管道
        close(parent_to_child_pipe[0]);
        close(child_to_parent_pipe[1]);
        printf("子进程结束\n");
        exit(EXIT_SUCCESS);
        
    } else {
        // 父进程
        printf("父进程 (PID: %d) 启动\n", getpid());
        
        // 关闭不需要的文件描述符
        close(parent_to_child_pipe[0]);  // 父进程不读取父到子管道
        close(child_to_parent_pipe[1]);  // 父进程不写入子到父管道
        
        // 1. 向子进程发送消息
        const char *message = "Hello child! I'm parent process.\n";
        printf("父进程向子进程发送消息...\n");
        ssize_t bytes_written = write(parent_to_child_pipe[1], message, strlen(message));
        if (bytes_written == -1) {
            perror("父进程发送消息失败");
        } else {
            printf("父进程发送消息 (%ld 字节)\n", bytes_written);
        }
        
        // 2. 等待并接收子进程的回复
        printf("父进程等待子进程回复...\n");
        ssize_t bytes_read = read(child_to_parent_pipe[0], buffer, BUFFER_SIZE - 1);
        if (bytes_read > 0) {
            buffer[bytes_read] = '\0';
            printf("父进程收到回复: %s", buffer);
        }
        
        // 关闭管道
        close(parent_to_child_pipe[1]);
        close(child_to_parent_pipe[0]);
        
        // 等待子进程结束
        int status;
        waitpid(pid, &status, 0);
        printf("父进程结束\n");
    }

    return 0;
}

代码解释:

1. 创建两个管道：一个用于父进程向子进程发送数据，另一个用于子进程向父进程发送数据。
2. 在父子进程中分别关闭不需要的管道端。
3. 通过协调读写操作，实现双向通信。

示例 3：管道与错误处理

这个例子重点演示管道的错误处理和一些特殊情况。

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/wait.h>
#include <fcntl.h>

#define BUFFER_SIZE 256

// 演示管道错误处理
void demonstrate_pipe_errors() {
    printf("=== 管道错误处理演示 ===\n");
    
    // 1. 传递无效指针
    printf("1. 传递无效指针给 pipe()...\n");
    if (pipe(NULL) == -1) {
        printf("   错误: %s\n", strerror(errno));
        if (errno == EFAULT) {
            printf("   说明: pipe() 参数不能为 NULL\n");
        }
    }
    
    printf("\n");
}

// 演示管道读写特性
void demonstrate_pipe_characteristics() {
    printf("=== 管道特性演示 ===\n");
    
    int pipefd[2];
    if (pipe(pipefd) == -1) {
        perror("pipe 创建失败");
        return;
    }
    
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork 失败");
        close(pipefd[0]);
        close(pipefd[1]);
        return;
    }
    
    if (pid == 0) {
        // 子进程
        close(pipefd[1]); // 关闭写端
        
        char buffer[BUFFER_SIZE];
        printf("子进程: 尝试从空管道读取 (会阻塞)...\n");
        
        // 读取数据
        ssize_t bytes_read = read(pipefd[0], buffer, BUFFER_SIZE - 1);
        if (bytes_read > 0) {
            buffer[bytes_read] = '\0';
            printf("子进程: 读取到数据: %s", buffer);
        } else if (bytes_read == 0) {
            printf("子进程: 读取到文件结束 (所有写端都已关闭)\n");
        } else {
            perror("子进程: 读取失败");
        }
        
        close(pipefd[0]);
        exit(EXIT_SUCCESS);
    } else {
        // 父进程
        close(pipefd[0]); // 关闭读端
        
        // 写入一些数据
        const char *message = "Message from parent\n";
        printf("父进程: 向管道写入数据...\n");
        write(pipefd[1], message, strlen(message));
        
        // 关闭写端，通知子进程结束
        printf("父进程: 关闭写端，通知子进程结束...\n");
        close(pipefd[1]);
        
        wait(NULL);
    }
    
    printf("\n");
}

// 演示管道容量和阻塞行为
void demonstrate_pipe_capacity() {
    printf("=== 管道容量和阻塞行为演示 ===\n");
    printf("注意: 这个演示可能需要较长时间\n");
    
    int pipefd[2];
    if (pipe(pipefd) == -1) {
        perror("pipe 创建失败");
        return;
    }
    
    // 获取管道容量（Linux 特定）
    int pipe_capacity = fcntl(pipefd[1], F_GETPIPE_SZ);
    if (pipe_capacity != -1) {
        printf("管道容量: %d 字节\n", pipe_capacity);
    }
    
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork 失败");
        close(pipefd[0]);
        close(pipefd[1]);
        return;
    }
    
    if (pid == 0) {
        // 子进程：读取端
        close(pipefd[1]); // 关闭写端
        
        sleep(2); // 让父进程先填满管道
        
        char buffer[1024];
        int total_read = 0;
        ssize_t bytes_read;
        
        printf("子进程: 开始读取数据...\n");
        while ((bytes_read = read(pipefd[0], buffer, sizeof(buffer))) > 0) {
            total_read += bytes_read;
            printf("子进程: 读取 %ld 字节，总计 %d 字节\n", bytes_read, total_read);
        }
        
        printf("子进程: 读取完成，总计 %d 字节\n", total_read);
        close(pipefd[0]);
        exit(EXIT_SUCCESS);
    } else {
        // 父进程：写入端
        close(pipefd[0]); // 关闭读端
        
        char data[1024];
        memset(data, 'A', sizeof(data) - 1);
        data[sizeof(data) - 1] = '\0';
        
        int total_written = 0;
        ssize_t bytes_written;
        
        printf("父进程: 开始写入大量数据...\n");
        // 写入数据直到管道满（会阻塞）
        for (int i = 0; i < 100; i++) {
            bytes_written = write(pipefd[1], data, strlen(data));
            if (bytes_written == -1) {
                perror("父进程: 写入失败");
                break;
            }
            total_written += bytes_written;
            printf("父进程: 写入 %ld 字节，总计 %d 字节\n", bytes_written, total_written);
        }
        
        printf("父进程: 写入完成，总计 %d 字节\n", total_written);
        close(pipefd[1]);
        wait(NULL);
    }
    
    printf("\n");
}

// 演示 pipe2 和非阻塞管道
void demonstrate_pipe2_and_nonblocking() {
    printf("=== pipe2 和非阻塞管道演示 ===\n");
    
#ifdef __linux__
    int pipefd[2];
    
    // 使用 pipe2 创建非阻塞管道
    if (pipe2(pipefd, O_NONBLOCK) == -1) {
        perror("pipe2 创建失败");
        printf("可能是因为系统不支持 pipe2\n");
        return;
    }
    
    printf("使用 pipe2 创建了非阻塞管道: 读端=%d, 写端=%d\n", pipefd[0], pipefd[1]);
    
    // 尝试从空的非阻塞管道读取
    char buffer[10];
    ssize_t bytes_read = read(pipefd[0], buffer, sizeof(buffer));
    if (bytes_read == -1) {
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            printf("从空的非阻塞管道读取: %s\n", strerror(errno));
            printf("说明: 非阻塞模式下，没有数据时立即返回错误\n");
        } else {
            perror("读取失败");
        }
    }
    
    close(pipefd[0]);
    close(pipefd[1]);
#else
    printf("pipe2 在此系统上不可用\n");
#endif
    
    printf("\n");
}

int main() {
    printf("管道 (pipe) 函数演示程序\n");
    printf("当前进程 PID: %d\n\n", getpid());
    
    demonstrate_pipe_errors();
    demonstrate_pipe_characteristics();
    // demonstrate_pipe_capacity(); // 这个演示可能需要较长时间，可选择性运行
    demonstrate_pipe2_and_nonblocking();
    
    printf("=== 总结 ===\n");
    printf("管道 (pipe) 关键知识点:\n");
    printf("1. 单向通信: 数据只能从写端流向读端\n");
    printf("2. 亲缘进程: 通常用于父子进程通信\n");
    printf("3. 阻塞特性: 默认情况下读写可能阻塞\n");
    printf("4. 文件结束: 当所有写端关闭时，读端返回 0\n");
    printf("5. 缓冲机制: 内核提供缓冲区存储数据\n");
    printf("6. 错误处理: 注意 EFAULT, EMFILE, ENFILE 等错误\n");
    printf("7. 资源清理: 使用完后必须关闭文件描述符\n");
    printf("8. 双向通信: 需要创建两个管道\n\n");
    
    printf("最佳实践:\n");
    printf("- 及时关闭不需要的管道端\n");
    printf("- 正确处理读写返回值\n");
    printf("- 考虑使用 pipe2 设置 O_CLOEXEC 标志\n");
    printf("- 对于复杂通信，考虑使用命名管道 (FIFO) 或套接字\n");
    
    return 0;
}

代码解释:

1. demonstrate_pipe_errors 演示了传递无效参数给 pipe() 的错误处理。
2. demonstrate_pipe_characteristics 演示了管道的基本读写行为和文件结束条件。
3. demonstrate_pipe_capacity 演示了管道的容量限制和阻塞行为（注释掉了，因为可能运行时间较长）。
4. demonstrate_pipe2_and_nonblocking 演示了 pipe2 函数和非阻塞模式的使用。
5. main 函数协调各个演示部分，并在最后总结关键知识点。

编译和运行:

# 编译示例
gcc -o pipe_example1 pipe_example1.c
gcc -o pipe_example2 pipe_example2.c
gcc -o pipe_example3 pipe_example3.c

# 运行示例
./pipe_example1
./pipe_example2
./pipe_example3

总结:

pipe 函数是 Linux 进程间通信的基础工具之一。它简单高效，特别适合父子进程间的数据传递。理解其单向性、阻塞性和缓冲机制对于正确使用管道至关重要。在实际编程中，要注意及时关闭不需要的文件描述符，正确处理各种返回值和错误情况，并根据需要考虑使用 pipe2 或其他更高级的 IPC 机制。

getcpu – 获取当前 CPU 和 NUMA 节点信息]()

1. 函数介绍

getcpu 是一个 Linux 系统调用，用于获取当前线程正在运行的 CPU 核心编号和 NUMA（Non-Uniform Memory Access）节点编号。这个函数对于性能分析、负载均衡、线程亲和性设置等场景非常有用。

NUMA 是一种多处理器计算机内存设计，其中内存访问时间取决于内存相对于处理器的位置。了解当前线程在哪个 CPU 核心和 NUMA 节点上运行，有助于优化程序性能。

2. 函数原型

#define _GNU_SOURCE
#include <linux/getcpu.h>
#include <sys/syscall.h>
#include <unistd.h>

long getcpu(unsigned *cpu, unsigned *node, struct getcpu_cache *tcache);

注意：该函数不是标准 C 库的一部分，需要通过 syscall() 调用或者包含 glibc 2.29+ 版本后才能直接调用。

3. 功能

获取当前线程正在运行的 CPU 核心编号和 NUMA 节点编号。这是一个轻量级的操作，通常用于性能监控和调度优化。

4. 参数

• unsigned *cpu: 指向存储 CPU 核心编号的变量的指针
  • 如果为 NULL：不返回 CPU 信息
  • 如果非 NULL：存储当前 CPU 核心编号（从 0 开始）
• unsigned *node: 指向存储 NUMA 节点编号的变量的指针
  • 如果为 NULL：不返回 NUMA 节点信息
  • 如果非 NULL：存储当前 NUMA 节点编号（从 0 开始）
• struct getcpu_cache *tcache: 缓存结构体指针，用于优化性能
  • 通常传入 NULL（内核会使用默认缓存机制）
  • 主要供内核内部使用

5. 返回值

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

6. 常见 errno 错误码

• EFAULT: 指针参数指向无效内存地址
• EINVAL: 无效参数
• ENOSYS: 系统不支持该功能

7. 相似函数，或关联函数

• sched_getcpu(): glibc 提供的获取当前 CPU 的便捷函数
• sched_setaffinity(): 设置进程 CPU 亲和性
• sched_getaffinity(): 获取进程 CPU 亲和性
• pthread_setaffinity_np(): 设置线程 CPU 亲和性
• pthread_getaffinity_np(): 获取线程 CPU 亲和性
• /proc/cpuinfo: 查看 CPU 信息
• /sys/devices/system/cpu/: CPU 拓扑信息
• numactl: NUMA 控制工具

8. 示例代码

示例1：基本使用 – 获取当前 CPU 和 NUMA 节点信息

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <linux/getcpu.h>
#include <errno.h>
#include <string.h>

#ifndef SYS_getcpu
# define SYS_getcpu 309  // x86_64 架构下的系统调用号
#endif

int main() {
    unsigned cpu, node;
    long result;
    
    printf("=== 获取当前 CPU 和 NUMA 节点信息 ===\n");
    
    // 使用 syscall 调用 getcpu
    result = syscall(SYS_getcpu, &cpu, &node, NULL);
    
    if (result == -1) {
        printf("getcpu 调用失败: %s\n", strerror(errno));
        return 1;
    }
    
    printf("当前线程运行信息:\n");
    printf("  CPU 核心编号: %u\n", cpu);
    printf("  NUMA 节点编号: %u\n", node);
    
    // 验证系统 CPU 数量
    long nprocs = sysconf(_SC_NPROCESSORS_ONLN);
    printf("  系统在线 CPU 数: %ld\n", nprocs);
    
    if (cpu >= nprocs) {
        printf("  警告: CPU 编号超出系统 CPU 数范围\n");
    }
    
    return 0;
}

示例2：使用 glibc 提供的 sched_getcpu 函数

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sched.h>
#include <errno.h>
#include <string.h>

int main() {
    int cpu;
    
    printf("=== 使用 sched_getcpu 获取 CPU 信息 ===\n");
    
    cpu = sched_getcpu();
    if (cpu == -1) {
        perror("sched_getcpu 调用失败");
        return 1;
    }
    
    printf("当前 CPU 核心编号: %d\n", cpu);
    
    // 获取系统信息进行验证
    long nprocs_conf = sysconf(_SC_NPROCESSORS_CONF);
    long nprocs_onln = sysconf(_SC_NPROCESSORS_ONLN);
    
    printf("系统配置 CPU 数: %ld\n", nprocs_conf);
    printf("系统在线 CPU 数: %ld\n", nprocs_onln);
    
    if (cpu >= nprocs_onln) {
        printf("警告: CPU 编号超出在线 CPU 范围\n");
    }
    
    return 0;
}

示例3：监控 CPU 迁移情况

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <linux/getcpu.h>
#include <sched.h>
#include <time.h>

#ifndef SYS_getcpu
# define SYS_getcpu 309
#endif

void monitor_cpu_migration(int duration_seconds) {
    unsigned cpu, node;
    unsigned last_cpu = (unsigned)-1;
    unsigned last_node = (unsigned)-1;
    int migrations = 0;
    time_t start_time = time(NULL);
    time_t current_time;
    
    printf("开始监控 CPU 迁移情况 (%d 秒)...\n", duration_seconds);
    printf("%-10s %-6s %-6s %-15s\n", "时间", "CPU", "Node", "状态");
    printf("%-10s %-6s %-6s %-15s\n", "----", "---", "----", "----");
    
    while ((current_time = time(NULL)) - start_time < duration_seconds) {
        if (syscall(SYS_getcpu, &cpu, &node, NULL) == 0) {
            char status[20] = "运行中";
            
            if (last_cpu != (unsigned)-1) {
                if (cpu != last_cpu) {
                    snprintf(status, sizeof(status), "CPU迁移 %u->%u", last_cpu, cpu);
                    migrations++;
                } else if (node != last_node) {
                    snprintf(status, sizeof(status), "Node迁移 %u->%u", last_node, node);
                    migrations++;
                }
            }
            
            printf("%-10ld %-6u %-6u %-15s\n", 
                   current_time - start_time, cpu, node, status);
            
            last_cpu = cpu;
            last_node = node;
        }
        
        usleep(500000);  // 休眠 0.5 秒
    }
    
    printf("\n监控结束:\n");
    printf("  总迁移次数: %d\n", migrations);
    printf("  平均迁移间隔: %.2f 秒\n", 
           migrations > 0 ? (double)duration_seconds / migrations : 0.0);
}

int main() {
    printf("=== CPU 迁移监控演示 ===\n");
    
    // 获取初始信息
    unsigned cpu, node;
    if (syscall(SYS_getcpu, &cpu, &node, NULL) == 0) {
        printf("初始位置: CPU %u, Node %u\n", cpu, node);
    }
    
    // 监控 10 秒钟的 CPU 迁移情况
    monitor_cpu_migration(10);
    
    return 0;
}

示例4：多线程环境下的 CPU 信息

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/syscall.h>
#include <linux/getcpu.h>
#include <sched.h>

#ifndef SYS_getcpu
# define SYS_getcpu 309
#endif

void* thread_function(void *arg) {
    int thread_id = *(int*)arg;
    unsigned cpu, node;
    cpu_set_t cpuset;
    int ret;
    
    // 获取当前线程的 CPU 信息
    if (syscall(SYS_getcpu, &cpu, &node, NULL) == 0) {
        printf("线程 %d: 初始位置 CPU %u, Node %u\n", thread_id, cpu, node);
    }
    
    // 获取当前 CPU 亲和性
    ret = pthread_getaffinity_np(pthread_self(), sizeof(cpuset), &cpuset);
    if (ret == 0) {
        printf("线程 %d: 可运行在 CPU ", thread_id);
        for (int i = 0; i < CPU_SETSIZE; i++) {
            if (CPU_ISSET(i, &cpuset)) {
                printf("%d ", i);
            }
        }
        printf("\n");
    }
    
    // 执行一些工作
    for (int i = 0; i < 5; i++) {
        sleep(1);
        if (syscall(SYS_getcpu, &cpu, &node, NULL) == 0) {
            printf("线程 %d: 当前位置 CPU %u, Node %u\n", thread_id, cpu, node);
        }
    }
    
    return NULL;
}

int main() {
    pthread_t threads[3];
    int thread_ids[3] = {1, 2, 3};
    
    printf("=== 多线程 CPU 信息演示 ===\n");
    
    // 创建多个线程
    for (int i = 0; i < 3; i++) {
        if (pthread_create(&threads[i], NULL, thread_function, &thread_ids[i]) != 0) {
            perror("创建线程失败");
            return 1;
        }
    }
    
    // 等待所有线程完成
    for (int i = 0; i < 3; i++) {
        pthread_join(threads[i], NULL);
    }
    
    printf("所有线程执行完成\n");
    
    return 0;
}

9. NUMA 系统信息查看

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

void print_numa_info() {
    FILE *fp;
    char line[256];
    
    printf("\n=== NUMA 系统信息 ===\n");
    
    // 检查 NUMA 支持
    if (access("/proc/numa_maps", F_OK) == 0) {
        printf("系统支持 NUMA\n");
    } else {
        printf("系统不支持 NUMA 或无访问权限\n");
        return;
    }
    
    // 查看 NUMA 节点信息
    fp = fopen("/sys/devices/system/node/online", "r");
    if (fp) {
        if (fgets(line, sizeof(line), fp)) {
            printf("在线 NUMA 节点: %s", line);
        }
        fclose(fp);
    }
    
    // 查看 CPU 拓扑
    system("lscpu | grep -E 'NUMA|CPU(s)'");
}

10. 性能优化应用场景

getcpu 在以下场景中非常有用：

场景1：线程绑定优化

#include <sched.h>
#include <pthread.h>

void bind_thread_to_cpu(int target_cpu) {
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    CPU_SET(target_cpu, &cpuset);
    pthread_setaffinity_np(pthread_self(), sizeof(cpuset), &cpuset);
}

场景2：内存分配优化

#include <numa.h>

void* allocate_local_memory(size_t size) {
    if (numa_available() == -1) {
        return malloc(size);  // NUMA 不可用，使用普通分配
    }
    return numa_alloc_local(size);  // 分配在本地 NUMA 节点
}

11. 实际系统中的应用

1. 数据库系统: 将查询线程绑定到特定 CPU 以提高缓存命中率
2. Web 服务器: 均衡分配请求处理线程到不同 CPU 核心
3. 高性能计算: 优化 MPI 进程的 CPU 和 NUMA 布局
4. 实时系统: 确保关键任务在指定 CPU 上运行
5. 容器技术: Docker 和 Kubernetes 中的 CPU 资源管理

总结

getcpu 是一个重要的系统调用，用于获取当前线程的 CPU 和 NUMA 节点信息。关键要点：

1. 轻量级操作: 快速获取当前执行环境信息
2. NUMA 感知: 支持现代多核 NUMA 系统
3. 性能优化: 为调度和内存访问优化提供基础信息
4. 多线程支持: 在并发环境中准确反映线程位置
5. 系统监控: 用于负载均衡和性能分析工具

在编写高性能应用程序时，了解和利用 CPU 和 NUMA 信息可以显著提升程序性能，特别是在多核和 NUMA 系统上。】

CSDN-LINK：https://blog.csdn.net/timberwolf007/article/details/150473820?sharetype=blogdetail&sharerId=150473820&sharerefer=PC&sharesource=zidier215&spm=1011.2480.3001.8118

Python二进制文件编码探测工具

背景
实现基于python语言cchardet库的二进制文件分析程序，按照预设分段参数对文件进行读取和cchardet的文本编码探测。脚本具备跳过文件头n字节，按照m字节分段二进制文件及分段后数据连续4字节探测功能。
结果输出会展示每段的序号，偏移起始，片内置信度识别偏移字节，片大小，编码方式，置信度，高置信度提示信息字段；

如何使用脚本：

# 1. 基本用法：分析整个文件
python encoding_detector.py myfile.bin

# 2. 指定块大小
python encoding_detector.py -s 512 myfile.bin

# 3. 跳过每个块的前 10 个字节
python encoding_detector.py -s 100 -h 10 myfile.bin

# 4. 从文件偏移 1116 开始分析
python encoding_detector.py -s 100 -o 1116 ../ftp-pcap/ftp-utf8-long.pcap

# 5. 结合使用：从偏移 1000 开始，每块 256 字节，跳过每块前 20 字节
python encoding_detector.py -s 256 -h 20 -o 1000 myfile.bin

# 6. 通过管道输入
cat myfile.bin | python encoding_detector.py -s 512

Python脚本是实现

#!/usr/bin/env python3
import cchardet
import sys
import os

def print_hex(data, width=16):
    """以十六进制和ASCII形式打印字节数据"""
    for i in range(0, len(data), width):
        # 十六进制部分
        hex_part = ' '.join(f'{byte:02x}' for byte in data[i:i+width])
        # ASCII部分 (可打印字符或'.')
        ascii_part = ''.join(chr(byte) if 32 <= byte <= 126 else '.' for byte in data[i:i+width])
        # 打印地址偏移、十六进制和ASCII
        print(f'{i:08x}: {hex_part:<{width*3}} |{ascii_part}|')

def detect_chunks_from_file(filename, chunk_size=1024, from_head_bytes=0, from_file_offset=0):
    """
    将文件按指定大小切块，并对每个块进行编码检测。
    如果检测置信度为0，则尝试偏移1-4字节重新检测。
    from_file_offset: 从文件的哪个字节偏移开始读取。
    """
    if not os.path.exists(filename):
        print(f"Error: File '{filename}' does not exist.", file=sys.stderr)
        return

    try:
        file_size = os.path.getsize(filename)
        print(f"Analyzing file: {filename} (Total size: {file_size} bytes)")
        print(f"Chunk size: {chunk_size} bytes")
        if from_head_bytes > 0:
            print(f"Skipping first {from_head_bytes} bytes of each chunk for detection.")
        if from_file_offset > 0:
            print(f"Starting analysis from file offset: {from_file_offset}")
        print("-" * 50)

        with open(filename, 'rb') as f:
            # 定位到文件的起始偏移
            if from_file_offset > 0:
                f.seek(from_file_offset)
            
            chunk_number = 0
            while True:
                chunk_data = f.read(chunk_size)
                if not chunk_
                    break

                # 计算当前块在原始文件中的基础偏移量
                offset = from_file_offset + chunk_number * chunk_size

                # 裁剪用于检测的数据（跳过头部字节）
                detection_data = chunk_data[from_head_bytes:] if len(chunk_data) > from_head_bytes else b''

                # --- 初始检测 ---
                encoding = None
                confidence = 0.0
                offset_by_used = 0 # 记录最终使用的偏移量

                if len(detection_data) > 0:
                    try:
                        result = cchardet.detect(detection_data)
                        if isinstance(result, dict):
                            encoding = result.get('encoding')
                            temp_confidence = result.get('confidence')
                            if temp_confidence is None:
                                confidence = 0.0
                            else:
                                confidence = temp_confidence
                            
                            if encoding is not None and not isinstance(encoding, str):
                                print(f"Warning: Unexpected encoding type in chunk {chunk_number}: {type(encoding)}", file=sys.stderr)
                                encoding = str(encoding) if encoding is not None else None
                        else:
                            print(f"Warning: cchardet returned unexpected type in chunk {chunk_number}: {type(result)}", file=sys.stderr)
                    except Exception as e:
                        print(f"Warning: cchardet failed on chunk {chunk_number}: {e}", file=sys.stderr)
                        encoding = "Error"
                        confidence = 0.0

                # --- 偏移优化逻辑 ---
                max_offset_attempts = 4
                if confidence == 0.0 and len(detection_data) > max_offset_attempts:
                    for offset_by in range(1, max_offset_attempts + 1):
                        if len(detection_data) > offset_by:
                            adjusted_detection_data = detection_data[offset_by:]
                            if len(adjusted_detection_data) > 0:
                                try:
                                    adjusted_result = cchardet.detect(adjusted_detection_data)
                                    if isinstance(adjusted_result, dict):
                                        adjusted_confidence = adjusted_result.get('confidence')
                                        if adjusted_confidence is None:
                                            adjusted_confidence = 0.0
                                        
                                        if adjusted_confidence > confidence:
                                            encoding = adjusted_result.get('encoding')
                                            confidence = adjusted_confidence
                                            offset_by_used = offset_by # 记录使用的偏移量
                                            
                                            if confidence > 0.0:
                                                break
                                except Exception:
                                    pass
                        else:
                            break

                # --- 格式化输出 ---
                encoding_display = encoding if encoding is not None else "N/A"
                output_line = (f"Chunk {chunk_number:4d} | Offset {offset:8d} | "
                               f"offset_by {offset_by_used:2d} | "
                               f"Size {len(chunk_data):4d} | "
                               f"Encoding: {encoding_display:>12} | "
                               f"Confidence: {confidence:6.4f}")
                
                # 可以根据置信度调整输出格式，例如高亮高置信度结果
                if confidence >= 0.75:
                     print(output_line) # 或用不同颜色/符号标记，这里简化为普通打印
                else:
                     print(output_line)

                # 如果置信度为0，可以选择打印数据内容（当前被注释掉）
                # if confidence == 0.0 and len(chunk_data) > 0:
                #     print ("\n")
                #     print_hex(chunk_data)
                #     print ("\n")
                    
                chunk_number += 1

            # 文件读取结束后的检查
            # f.tell() 在 seek 后返回的是绝对位置
            absolute_tell = f.tell()
            if absolute_tell < file_size:
                 print(f"Warning: Stopped reading before end of file '{filename}'. "
                      f"Read up to file offset {absolute_tell} bytes out of {file_size} bytes.", file=sys.stderr)

    except IOError as e:
        print(f"Error reading file '{filename}': {e}", file=sys.stderr)
    except Exception as e:
        print(f"An unexpected error occurred while processing '{filename}': {e}", file=sys.stderr)
    
    print("-" * 50 + f" Analysis of '{filename}' finished. " + "-" * 10 + "\n")


def detect_chunks_from_bytes(data, source_name="Byte Input", chunk_size=1024, from_head_bytes=0):
    """
    将字节数据按指定大小切块，并对每个块进行编码检测。
    如果检测置信度为0，则尝试偏移1-3字节重新检测。
    """
    data_len = len(data)
    print(f"Analyzing data from: {source_name} (Total size: {data_len} bytes)")
    print(f"Chunk size: {chunk_size} bytes")
    if from_head_bytes > 0:
        print(f"Skipping first {from_head_bytes} bytes of each chunk for detection.")
    print("-" * 50)

    if data_len == 0:
        print("Input data is empty.")
        return

    chunk_number = 0
    for i in range(0, data_len, chunk_size):
        chunk_data = data[i:i + chunk_size]
        if not chunk_
            break

        offset = i
        detection_data = chunk_data[from_head_bytes:] if len(chunk_data) > from_head_bytes else b''

        encoding = None
        confidence = 0.0
        
        if len(detection_data) > 0:
            try:
                result = cchardet.detect(detection_data)
                if isinstance(result, dict):
                    encoding = result.get('encoding')
                    temp_confidence = result.get('confidence')
                    if temp_confidence is None:
                        confidence = 0.0
                    else:
                        confidence = temp_confidence
                    
                    if encoding is not None and not isinstance(encoding, str):
                        print(f"Warning: Unexpected encoding type in chunk {chunk_number}: {type(encoding)}", file=sys.stderr)
                        encoding = str(encoding) if encoding is not None else None
                else:
                    print(f"Warning: cchardet returned unexpected type in chunk {chunk_number}: {type(result)}", file=sys.stderr)
            except Exception as e:
                print(f"Warning: cchardet failed on chunk {chunk_number}: {e}", file=sys.stderr)
                encoding = "Error"
                confidence = 0.0

        # --- 偏移优化逻辑 (针对 bytes 输入)---
        max_offset_attempts = 3
        offset_by_used = 0
        if confidence == 0.0 and len(detection_data) > max_offset_attempts:
            for offset_by in range(1, max_offset_attempts + 1):
                if len(detection_data) > offset_by:
                    adjusted_detection_data = detection_data[offset_by:]
                    if len(adjusted_detection_data) > 0:
                        try:
                            adjusted_result = cchardet.detect(adjusted_detection_data)
                            if isinstance(adjusted_result, dict):
                                adjusted_confidence = adjusted_result.get('confidence')
                                if adjusted_confidence is None:
                                    adjusted_confidence = 0.0
                                
                                if adjusted_confidence > confidence:
                                    encoding = adjusted_result.get('encoding')
                                    confidence = adjusted_confidence
                                    offset_by_used = offset_by
                                    
                                    if confidence > 0.0:
                                        break
                        except Exception:
                            pass
                else:
                    break

        # 格式化输出 (bytes 输入也显示 offset_by)
        encoding_display = encoding if encoding is not None else "N/A"
        print(f"Chunk {chunk_number:4d} | Offset {offset:8d} | "
              f"offset_by {offset_by_used:2d} | " # 添加 offset_by 显示
              f"Size {len(chunk_data):4d} | "
              f"Encoding: {encoding_display:>12} | "
              f"Confidence: {confidence:6.4f}")

        # 如果置信度为0，打印数据内容
        # if confidence == 0.0 and len(chunk_data) > 0:
        #     print ("\n")
        #     print_hex(chunk_data)
        #     print ("\n")

        chunk_number += 1

    print("-" * 50 + f" Analysis of '{source_name}' finished. " + "-" * 10 + "\n")


def main():
    """
    主函数，处理命令行参数并调用相应的检测函数。
    """
    if len(sys.argv) < 2:
        print("No filename provided. Reading binary data from STDIN...", file=sys.stderr)
        try:
            data = sys.stdin.buffer.read()
            detect_chunks_from_bytes(data, source_name="STDIN", chunk_size=1024)
        except KeyboardInterrupt:
            print("\nInterrupted by user.", file=sys.stderr)
        except Exception as e:
            print(f"Error reading from STDIN: {e}", file=sys.stderr)
        sys.exit(0)

    # 默认参数
    chunk_size = 1024
    from_head_bytes = 0
    from_file_offset = 0 # 新增默认参数
    filenames = []

    # 解析命令行参数
    i = 1
    while i < len(sys.argv):
        if sys.argv[i] == '-s':
            if i + 1 < len(sys.argv):
                try:
                    chunk_size = int(sys.argv[i + 1])
                    if chunk_size <= 0:
                        raise ValueError("Chunk size must be positive.")
                    i += 2
                except ValueError as e:
                    print(f"Error: Invalid chunk size '-s {sys.argv[i + 1]}': {e}", file=sys.stderr)
                    sys.exit(1)
            else:
                print("Error: Option '-s' requires an argument.", file=sys.stderr)
                sys.exit(1)
        elif sys.argv[i] == '-h':
             if i + 1 < len(sys.argv):
                try:
                    from_head_bytes = int(sys.argv[i + 1])
                    if from_head_bytes < 0:
                        raise ValueError("Head bytes to skip must be non-negative.")
                    i += 2
                except ValueError as e:
                    print(f"Error: Invalid head bytes '-h {sys.argv[i + 1]}': {e}", file=sys.stderr)
                    sys.exit(1)
             else:
                print("Error: Option '-h' requires an argument.", file=sys.stderr)
                sys.exit(1)
        # --- 新增：解析 -o 参数 ---
        elif sys.argv[i] == '-o':
             if i + 1 < len(sys.argv):
                try:
                    from_file_offset = int(sys.argv[i + 1])
                    if from_file_offset < 0:
                        raise ValueError("File offset must be non-negative.")
                    i += 2
                except ValueError as e:
                    print(f"Error: Invalid file offset '-o {sys.argv[i + 1]}': {e}", file=sys.stderr)
                    sys.exit(1)
             else:
                print("Error: Option '-o' requires an argument.", file=sys.stderr)
                sys.exit(1)
        # --- 新增结束 ---
        else:
            filenames.append(sys.argv[i])
            i += 1

    if not filenames:
        print("Error: No filename provided.", file=sys.stderr)
        sys.exit(1)

    # 对每个提供的文件进行处理
    for filename in filenames:
        # --- 修改：传递 from_file_offset 参数 ---
        detect_chunks_from_file(filename, chunk_size, from_head_bytes, from_file_offset)


if __name__ == "__main__":
    main()

关键词（keywords）：文本编码，二进制，python文本编码，cchardet

kcmp 函数详解

1. 函数介绍

kcmp 是 Linux 系统中用于比较两个进程的内核资源的系统调用。可以把 kcmp 想象成”内核级别的资源比较器”——它能够检查两个进程是否共享相同的内核资源（如文件描述符、虚拟内存区域等），就像比较两个人是否使用相同的银行账户或信用卡一样。

在容器化和虚拟化环境中，kcmp 非常有用，因为它可以帮助确定两个进程是否属于同一个容器或命名空间，或者它们之间是否存在资源共享关系。。

2. 函数原型

#include <linux/kcmp.h>
#include <sys/syscall.h>
#include <unistd.h>

int kcmp(pid_t pid1, pid_t pid2, int type, unsigned long idx1, unsigned long idx2);

3. 功能

kcmp 函数用于比较两个进程的指定内核资源。它可以确定两个进程的特定资源是否指向内核中的同一个对象。。

4. 参数

• pid1: 第一个进程的进程 ID（0 表示调用进程）
• pid2: 第二个进程的进程 ID（0 表示调用进程）
• type: 比较的资源类型
• idx1: 第一个进程的资源索引（根据 type 而定）
• idx2: 第二个进程的资源索引（根据 type 而定）

5. 资源类型（type 参数）

6. 返回值

• 0: 两个资源相同（指向内核中的同一对象）
• 1: 两个资源不同
• 2: 目标进程不存在或无法访问
• 负值: 错误，设置相应的 errno

7. 错误码

• EPERM: 权限不足（无法访问目标进程信息）
• ESRCH: 进程不存在
• EINVAL: 参数无效
• EACCES: 访问被拒绝

8. 相似函数或关联函数

• clone: 创建进程时可以共享资源
• unshare: 使进程脱离共享资源
• setns: 加入命名空间
• /proc 文件系统: 查看进程信息
• ptrace: 进程跟踪和调试

9. 示例代码

示例1：基础用法 – 比较文件描述符。

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <linux/kcmp.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>

// kcmp 系统调用包装函数
int kcmp_wrapper(pid_t pid1, pid_t pid2, int type, unsigned long idx1, unsigned long idx2) {
    return syscall(SYS_kcmp, pid1, pid2, type, idx1, idx2);
}

// 将 kcmp 结果转换为字符串
const char* kcmp_result_to_string(int result) {
    switch (result) {
        case 0: return "相同";
        case 1: return "不同";
        case 2: return "进程不存在或无法访问";
        default: return "错误";
    }
}

int main() {
    int fd1, fd2, fd3;
    pid_t current_pid = getpid();
    int result;
    
    printf("=== kcmp 基础示例 - 文件描述符比较 ===\n\n");
    
    // 创建测试文件
    fd1 = open("test1.txt", O_CREAT | O_RDWR | O_TRUNC, 0644);
    fd2 = open("test2.txt", O_CREAT | O_RDWR | O_TRUNC, 0644);
    fd3 = dup(fd1);  // fd3 是 fd1 的副本
    
    if (fd1 == -1 || fd2 == -1 || fd3 == -1) {
        perror("open/dup");
        return 1;
    }
    
    printf("创建的文件描述符:\n");
    printf("  fd1: %d (test1.txt)\n", fd1);
    printf("  fd2: %d (test2.txt)\n", fd2);
    printf("  fd3: %d (test1.txt 的副本)\n", fd3);
    printf("\n");
    
    // 比较相同的文件描述符
    printf("比较相同文件描述符:\n");
    result = kcmp_wrapper(current_pid, current_pid, KCMP_FILE, fd1, fd1);
    printf("  fd1 vs fd1: %s (结果: %d)\n", kcmp_result_to_string(result), result);
    
    // 比较不同的文件描述符（不同文件）
    printf("比较不同文件的文件描述符:\n");
    result = kcmp_wrapper(current_pid, current_pid, KCMP_FILE, fd1, fd2);
    printf("  fd1 vs fd2: %s (结果: %d)\n", kcmp_result_to_string(result), result);
    
    // 比较相同的文件描述符（通过 dup 创建）
    printf("比较相同文件的文件描述符:\n");
    result = kcmp_wrapper(current_pid, current_pid, KCMP_FILE, fd1, fd3);
    printf("  fd1 vs fd3: %s (结果: %d)\n", kcmp_result_to_string(result), result);
    
    // 比较文件描述符表
    printf("比较文件描述符表:\n");
    result = kcmp_wrapper(current_pid, current_pid, KCMP_FILES, 0, 0);
    printf("  FILES 表: %s (结果: %d)\n", kcmp_result_to_string(result), result);
    
    // 清理资源
    close(fd1);
    close(fd2);
    close(fd3);
    unlink("test1.txt");
    unlink("test2.txt");
    
    return 0;
}

示例2：进程间资源比较。

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <linux/kcmp.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <sys/wait.h>
#include <sys/stat.h>

// kcmp 系统调用包装函数
int kcmp_wrapper(pid_t pid1, pid_t pid2, int type, unsigned long idx1, unsigned long idx2) {
    return syscall(SYS_kcmp, pid1, pid2, type, idx1, idx2);
}

// 显示 kcmp 结果
void show_kcmp_result(const char* description, int result) {
    printf("%-30s: ", description);
    switch (result) {
        case 0: printf("相同\n"); break;
        case 1: printf("不同\n"); break;
        case 2: printf("进程不存在或无法访问\n"); break;
        default: printf("错误 (%s)\n", strerror(errno)); break;
    }
}

// 创建测试环境
int setup_test_environment(int *fd1, int *fd2) {
    // 创建测试文件
    *fd1 = open("shared_file.txt", O_CREAT | O_RDWR | O_TRUNC, 0644);
    *fd2 = open("different_file.txt", O_CREAT | O_RDWR | O_TRUNC, 0644);
    
    if (*fd1 == -1 || *fd2 == -1) {
        perror("创建测试文件失败");
        return -1;
    }
    
    // 写入一些数据
    const char *data = "测试数据";
    write(*fd1, data, strlen(data));
    write(*fd2, data, strlen(data));
    
    return 0;
}

int main() {
    pid_t parent_pid = getpid();
    pid_t child_pid;
    int fd1, fd2;
    int result;
    
    printf("=== kcmp 进程间资源比较示例 ===\n\n");
    
    // 设置测试环境
    if (setup_test_environment(&fd1, &fd2) == -1) {
        return 1;
    }
    
    printf("父进程 PID: %d\n", parent_pid);
    printf("测试文件描述符: fd1=%d, fd2=%d\n\n", fd1, fd2);
    
    // 创建子进程
    child_pid = fork();
    if (child_pid == -1) {
        perror("fork");
        close(fd1);
        close(fd2);
        unlink("shared_file.txt");
        unlink("different_file.txt");
        return 1;
    }
    
    if (child_pid == 0) {
        // 子进程
        int child_fd1, child_fd2;
        pid_t my_pid = getpid();
        
        printf("子进程 PID: %d\n", my_pid);
        
        // 子进程打开相同的文件
        child_fd1 = open("shared_file.txt", O_RDWR);
        child_fd2 = open("different_file.txt", O_RDWR);
        
        if (child_fd1 == -1 || child_fd2 == -1) {
            perror("子进程打开文件失败");
            exit(1);
        }
        
        printf("子进程文件描述符: fd1=%d, fd2=%d\n\n", child_fd1, child_fd2);
        
        // 比较父子进程的文件描述符
        printf("父子进程文件描述符比较:\n");
        result = kcmp_wrapper(parent_pid, my_pid, KCMP_FILE, fd1, child_fd1);
        show_kcmp_result("父fd1 vs 子fd1 (相同文件)", result);
        
        result = kcmp_wrapper(parent_pid, my_pid, KCMP_FILE, fd2, child_fd2);
        show_kcmp_result("父fd2 vs 子fd2 (相同文件)", result);
        
        result = kcmp_wrapper(parent_pid, my_pid, KCMP_FILE, fd1, child_fd2);
        show_kcmp_result("父fd1 vs 子fd2 (不同文件)", result);
        
        // 比较进程资源表
        printf("\n进程资源表比较:\n");
        result = kcmp_wrapper(parent_pid, my_pid, KCMP_FILES, 0, 0);
        show_kcmp_result("文件描述符表", result);
        
        result = kcmp_wrapper(parent_pid, my_pid, KCMP_VM, 0, 0);
        show_kcmp_result("虚拟内存", result);
        
        result = kcmp_wrapper(parent_pid, my_pid, KCMP_FS, 0, 0);
        show_kcmp_result("文件系统信息", result);
        
        result = kcmp_wrapper(parent_pid, my_pid, KCMP_SIGHAND, 0, 0);
        show_kcmp_result("信号处理", result);
        
        // 清理子进程资源
        close(child_fd1);
        close(child_fd2);
        
        exit(0);
    } else {
        // 父进程等待子进程完成
        int status;
        waitpid(child_pid, &status, 0);
        
        // 清理父进程资源
        close(fd1);
        close(fd2);
        unlink("shared_file.txt");
        unlink("different_file.txt");
        
        printf("\n=== 容器和命名空间检测示例 ===\n");
        printf("kcmp 在容器技术中的应用:\n");
        printf("1. 检测进程是否在相同容器中\n");
        printf("2. 验证资源隔离效果\n");
        printf("3. 调试容器间资源共享\n");
    }
    
    return 0;
}

示例3：完整的进程关系分析工具。

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <linux/kcmp.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <getopt.h>
#include <pwd.h>
#include <grp.h>

// kcmp 系统调用包装函数
int kcmp_wrapper(pid_t pid1, pid_t pid2, int type, unsigned long idx1, unsigned long idx2) {
    return syscall(SYS_kcmp, pid1, pid2, type, idx1, idx2);
}

// 资源类型名称
const char* get_resource_type_name(int type) {
    switch (type) {
        case KCMP_FILE: return "FILE";
        case KCMP_VM: return "VM";
        case KCMP_FILES: return "FILES";
        case KCMP_FS: return "FS";
        case KCMP_SIGHAND: return "SIGHAND";
        case KCMP_IO: return "IO";
        case KCMP_SYSVSEM: return "SYSVSEM";
        default: return "UNKNOWN";
    }
}

// 显示详细的 kcmp 结果
void show_detailed_result(const char* description, int result, int show_details) {
    printf("%-25s: ", description);
    
    switch (result) {
        case 0:
            printf("相同 ✓");
            if (show_details) printf(" (共享同一内核资源)");
            break;
        case 1:
            printf("不同 ✗");
            if (show_details) printf(" (使用不同内核资源)");
            break;
        case 2:
            printf("无法访问");
            if (show_details) printf(" (进程不存在或权限不足)");
            break;
        default:
            printf("错误 (%d)", result);
            if (show_details) printf(" (%s)", strerror(errno));
            break;
    }
    printf("\n");
}

// 分析两个进程的关系
void analyze_process_relationship(pid_t pid1, pid_t pid2) {
    printf("=== 进程关系分析 ===\n");
    printf("进程1 PID: %d\n", pid1);
    printf("进程2 PID: %d\n\n", pid2);
    
    // 基本信息检查
    if (pid1 == pid2) {
        printf("注意: 比较的是同一进程\n\n");
    }
    
    // 逐个比较资源类型
    int resource_types[] = {
        KCMP_FILES, KCMP_VM, KCMP_FS, KCMP_SIGHAND, KCMP_IO, KCMP_SYSVSEM
    };
    int num_types = sizeof(resource_types) / sizeof(resource_types[0]);
    
    printf("资源共享分析:\n");
    printf("%-25s  %s\n", "资源类型", "状态");
    printf("%-25s  %s\n", "--------", "----");
    
    int shared_count = 0;
    for (int i = 0; i < num_types; i++) {
        int result = kcmp_wrapper(pid1, pid2, resource_types[i], 0, 0);
        show_detailed_result(get_resource_type_name(resource_types[i]), result, 0);
        
        if (result == 0) {
            shared_count++;
        }
    }
    
    printf("\n共享资源统计: %d/%d 类型共享\n", shared_count, num_types);
    
    // 关系判断
    printf("\n关系判断:\n");
    if (shared_count == num_types) {
        printf("✓ 进程很可能有父子关系或克隆关系\n");
    } else if (shared_count >= 3) {
        printf("○ 进程可能在相同环境中运行\n");
    } else if (shared_count > 0) {
        printf("⚠ 进程部分资源共享\n");
    } else {
        printf("✗ 进程完全独立\n");
    }
    
    // 容器检测提示
    if (shared_count < 3) {
        printf("\n容器环境检测:\n");
        printf("  如果进程在不同容器中，大多数资源应该显示为'不同'\n");
    }
}

// 比较特定文件描述符
void compare_file_descriptors(pid_t pid1, pid_t pid2, int fd1, int fd2) {
    printf("\n=== 文件描述符比较 ===\n");
    
    int result = kcmp_wrapper(pid1, pid2, KCMP_FILE, fd1, fd2);
    
    printf("进程 %d fd%d vs 进程 %d fd%d: ", pid1, fd1, pid2, fd2);
    switch (result) {
        case 0: printf("指向同一文件 ✓\n"); break;
        case 1: printf("指向不同文件 ✗\n"); break;
        case 2: printf("无法访问进程\n"); break;
        default: printf("比较失败 (%s)\n", strerror(errno)); break;
    }
}

// 显示帮助信息
void show_help(const char *program_name) {
    printf("用法: %s [选项]\n", program_name);
    printf("\n选项:\n");
    printf("  -1, --pid1=PID         第一个进程 ID (默认: 当前进程)\n");
    printf("  -2, --pid2=PID         第二个进程 ID (默认: 父进程)\n");
    printf("  -f, --fd=FD1:FD2       比较特定文件描述符\n");
    printf("  -t, --type=TYPE        比较特定资源类型\n");
    printf("  -a, --all              显示详细分析\n");
    printf("  -h, --help             显示此帮助信息\n");
    printf("\n资源类型:\n");
    printf("  file    - 文件描述符\n");
    printf("  vm      - 虚拟内存\n");
    printf("  files   - 文件描述符表\n");
    printf("  fs      - 文件系统信息\n");
    printf("  sighand - 信号处理\n");
    printf("  io      - I/O 信息\n");
    printf("  sysvsem - System V 信号量\n");
    printf("\n示例:\n");
    printf("  %s -1 1234 -2 5678     # 比较进程 1234 和 5678\n");
    printf("  %s -f 3:4              # 比较当前进程的 fd3 和 fd4\n");
    printf("  %s -t vm               # 比较虚拟内存\n");
}

int main(int argc, char *argv[]) {
    pid_t pid1 = 0;  // 0 表示当前进程
    pid_t pid2 = getppid();  // 默认比较当前进程和父进程
    int fd1 = -1, fd2 = -1;
    int resource_type = -1;
    int show_all = 0;
    int specific_fd = 0;
    
    // 解析命令行参数
    static struct option long_options[] = {
        {"pid1",    required_argument, 0, '1'},
        {"pid2",    required_argument, 0, '2'},
        {"fd",      required_argument, 0, 'f'},
        {"type",    required_argument, 0, 't'},
        {"all",     no_argument,       0, 'a'},
        {"help",    no_argument,       0, 'h'},
        {0, 0, 0, 0}
    };
    
    int c;
    while (1) {
        int option_index = 0;
        c = getopt_long(argc, argv, "1:2:f:t:ah", long_options, &option_index);
        
        if (c == -1)
            break;
            
        switch (c) {
            case '1':
                pid1 = atoi(optarg);
                break;
            case '2':
                pid2 = atoi(optarg);
                break;
            case 'f':
                if (sscanf(optarg, "%d:%d", &fd1, &fd2) == 2) {
                    specific_fd = 1;
                } else {
                    fprintf(stderr, "错误: 文件描述符格式应为 FD1:FD2\n");
                    return 1;
                }
                break;
            case 't':
                if (strcmp(optarg, "file") == 0) resource_type = KCMP_FILE;
                else if (strcmp(optarg, "vm") == 0) resource_type = KCMP_VM;
                else if (strcmp(optarg, "files") == 0) resource_type = KCMP_FILES;
                else if (strcmp(optarg, "fs") == 0) resource_type = KCMP_FS;
                else if (strcmp(optarg, "sighand") == 0) resource_type = KCMP_SIGHAND;
                else if (strcmp(optarg, "io") == 0) resource_type = KCMP_IO;
                else if (strcmp(optarg, "sysvsem") == 0) resource_type = KCMP_SYSVSEM;
                else {
                    fprintf(stderr, "错误: 未知的资源类型 '%s'\n", optarg);
                    return 1;
                }
                break;
            case 'a':
                show_all = 1;
                break;
            case 'h':
                show_help(argv[0]);
                return 0;
            case '?':
                return 1;
        }
    }
    
    printf("=== kcmp 进程资源比较工具 ===\n\n");
    
    // 如果指定了特定文件描述符比较
    if (specific_fd) {
        compare_file_descriptors(pid1, pid2, fd1, fd2);
        return 0;
    }
    
    // 如果指定了特定资源类型
    if (resource_type != -1) {
        int result = kcmp_wrapper(pid1, pid2, resource_type, 0, 0);
        printf("进程 %d 和 %d 的 %s 资源比较: ", 
               pid1 ? pid1 : getpid(), pid2 ? pid2 : getppid(),
               get_resource_type_name(resource_type));
        
        switch (result) {
            case 0: printf("相同\n"); break;
            case 1: printf("不同\n"); break;
            case 2: printf("无法访问\n"); break;
            default: printf("错误 (%s)\n", strerror(errno)); break;
        }
        return 0;
    }
    
    // 执行完整的进程关系分析
    analyze_process_relationship(pid1 ? pid1 : getpid(), pid2 ? pid2 : getppid());
    
    // 显示系统信息
    printf("\n=== 系统信息 ===\n");
    printf("当前进程: %d\n", getpid());
    printf("父进程: %d\n", getppid());
    printf("用户 ID: %d\n", getuid());
    
    struct passwd *pwd = getpwuid(getuid());
    if (pwd) {
        printf("用户名: %s\n", pwd->pw_name);
    }
    
    // 使用建议
    printf("\n=== kcmp 使用建议 ===\n");
    printf("典型应用场景:\n");
    printf("1. 容器技术: 检测进程是否在同一容器中\n");
    printf("2. 调试工具: 分析进程间资源共享情况\n");
    printf("3. 安全审计: 验证进程隔离效果\n");
    printf("4. 系统监控: 跟踪进程关系变化\n");
    printf("\n注意事项:\n");
    printf("1. 需要适当权限才能比较其他进程\n");
    printf("2. 结果可能受 SELinux 等安全模块影响\n");
    printf("3. 某些资源类型可能不适用于所有内核版本\n");
    
    return 0;
}

编译和运行说明

# 编译示例程序
gcc -o kcmp_example1 example1.c
gcc -o kcmp_example2 example2.c
gcc -o kcmp_example3 example3.c

# 运行示例
./kcmp_example1
./kcmp_example2
./kcmp_example3 --help
./kcmp_example3 -a
./kcmp_example3 -1 1 -2 $$

系统要求检查

# 检查内核版本（需要 3.5+）
uname -r

# 检查 kcmp 系统调用支持
grep -w kcmp /usr/include/asm/unistd_64.h

# 查看系统调用表
cat /proc/kallsyms | grep kcmp

重要注意事项

1. 内核版本: 需要 Linux 3.5+ 内核支持
2. 权限要求: 通常需要 ptrace 权限才能比较其他进程
3. 安全限制: SELinux、AppArmor 等可能限制访问
4. 进程存在性: 目标进程必须存在且可访问
5. 错误处理: 始终检查返回值和 errno。

实际应用场景

1. 容器技术: Docker、LXC 等容器中检测进程关系
2. 系统调试: 分析进程间资源共享情况
3. 安全审计: 验证进程隔离和沙箱效果
4. 性能分析: 理解进程资源使用模式
5. 故障排查: 诊断进程间意外的资源共享。

容器环境中的应用

// 检测进程是否在同一容器中
int are_processes_in_same_container(pid_t pid1, pid_t pid2) {
    // 比较关键资源
    int results[] = {
        kcmp_wrapper(pid1, pid2, KCMP_FILES, 0, 0),
        kcmp_wrapper(pid1, pid2, KCMP_FS, 0, 0),
        kcmp_wrapper(pid1, pid2, KCMP_SIGHAND, 0, 0)
    };
    
    // 如果大多数关键资源不同，可能在不同容器中
    int different_count = 0;
    for (int i = 0; i < 3; i++) {
        if (results[i] == 1) different_count++;
    }
    
    return (different_count >= 2) ? 0 : 1;  // 0=不同容器, 1=可能同容器
}

最佳实践

// 安全地使用 kcmp
int safe_kcmp(pid_t pid1, pid_t pid2, int type, unsigned long idx1, unsigned long idx2) {
    // 验证参数
    if (type < KCMP_FILE || type > KCMP_SYSVSEM) {
        errno = EINVAL;
        return -1;
    }
    
    // 检查权限
    if ((pid1 != 0 && pid1 != getpid()) || (pid2 != 0 && pid2 != getpid())) {
        // 可能需要额外权限检查
        printf("注意: 比较其他进程需要适当权限\n");
    }
    
    int result = kcmp_wrapper(pid1, pid2, type, idx1, idx2);
    
    // 处理常见错误
    if (result == 2) {
        printf("警告: 目标进程可能不存在或无法访问\n");
    } else if (result < 0) {
        printf("错误: kcmp 调用失败 (%s)\n", strerror(errno));
    }
    
    return result;
}

文档标题: kcmp系统调用及示例 在这些示例中，展示了kcmp函数的多种使用情况，从基本的资源比较到完整的进程关系分析工具，有助于全面了解Linux系统中的进程资源比较机制。文档标题: kcmp系统调用及示例 在这些示例中，展示了kcmp函数的多种使用情况，从基本的资源比较到完整的进程关系分析工具，有助于全面了解Linux系统中的进程资源比较机制。文档标题: kcmp系统调用及示例 在这些示例中，展示了kcmp函数的多种使用情况，从基本的资源比较到完整的进程关系分析工具，有助于全面了解Linux系统中的进程资源比较机制。

kexec_load – 加载新的内核镜像用于快速重启

1. 函数介绍

kexec_load 是一个 Linux 系统调用，用于加载新的内核镜像到内存中，以便通过 kexec 机制进行快速内核切换。kexec 是一种允许在不经过 BIOS/UEFI 初始化过程的情况下直接启动新内核的技术，大大减少了系统重启时间。

2. 函数原型

#include <linux/kexec.h>

long kexec_load(unsigned long entry, unsigned long nr_segments,
                struct kexec_segment *segments, unsigned long flags);

注意：这不是标准 C 库函数，需要通过 syscall() 调用。

3. 功能

将指定的内核镜像加载到内存中，为后续的 kexec 调用做准备。加载的内核可以在任何时候通过 reboot() 系统调用的 LINUX_REBOOT_CMD_KEXEC 命令激活。

4. 参数

• unsigned long entry: 新内核的入口点地址
• unsigned long nr_segments: 段的数量
• struct kexec_segment *segments: 指向段描述符数组的指针
• unsigned long flags: 控制标志
  • KEXEC_ON_CRASH: 为内核崩溃转储加载内核
  • KEXEC_PRESERVE_CONTEXT: 保留 CPU 状态
  • KEXEC_ARCH_MASK: 架构相关标志

5. kexec_segment 结构体

struct kexec_segment {
    void *buf;          /* 缓冲区指针 */
    size_t bufsz;       /* 缓冲区大小 */
    void *mem;          /* 内存地址 */
    size_t memsz;       /* 内存段大小 */
};

6. 返回值

• 成功时：返回 0
• 失败时：返回 -1，并设置 errno

7. 常见 errno 错误码

• EBUSY: kexec 子系统正在使用中
• EINVAL: 参数无效
• EPERM: 权限不足（需要 CAP_SYS_BOOT 能力）
• ENOMEM: 内存不足
• EADDRNOTAVAIL: 指定的内存地址不可用
• ENOEXEC: 内核镜像格式无效

8. 相似函数，或关联函数

• reboot(): 系统重启函数，用于激活已加载的内核
• kexec_file_load(): 更现代的内核加载接口（Linux 3.17+）
• syscall(): 系统调用接口
• /sbin/kexec: 用户态 kexec 工具
• /proc/iomem: 查看系统内存布局
• /sys/kernel/kexec_crash_loaded: 检查崩溃内核是否已加载

9. 示例代码

示例1：基本使用 – kexec 加载框架

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <linux/kexec.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/mman.h>

#ifndef SYS_kexec_load
# define SYS_kexec_load 246  // x86_64 架构下的系统调用号
#endif

#ifndef SYS_reboot
# define SYS_reboot 169
#endif

#define LINUX_REBOOT_MAGIC1 0xfee1dead
#define LINUX_REBOOT_MAGIC2 0x28121969
#define LINUX_REBOOT_CMD_KEXEC 0x45584543

// 检查 kexec 支持
int check_kexec_support() {
    if (access("/proc/iomem", R_OK) == -1) {
        printf("系统不支持 /proc/iomem\n");
        return -1;
    }
    
    FILE *fp = fopen("/proc/cmdline", "r");
    if (fp) {
        char cmdline[1024];
        if (fgets(cmdline, sizeof(cmdline), fp)) {
            if (strstr(cmdline, "nokexec")) {
                printf("内核启动参数禁用了 kexec\n");
                fclose(fp);
                return -1;
            }
        }
        fclose(fp);
    }
    
    return 0;
}

// 检查权限
int check_kexec_permissions() {
    if (geteuid() != 0) {
        printf("需要 root 权限执行 kexec\n");
        return -1;
    }
    
    // 检查 CAP_SYS_BOOT 能力
    // 这里简化处理，实际需要使用 libcap
    
    return 0;
}

// 加载内核文件到内存
void* load_kernel_file(const char *filename, size_t *size) {
    int fd = open(filename, O_RDONLY);
    if (fd == -1) {
        printf("无法打开内核文件: %s\n", filename);
        return NULL;
    }
    
    struct stat st;
    if (fstat(fd, &st) == -1) {
        printf("无法获取文件状态: %s\n", strerror(errno));
        close(fd);
        return NULL;
    }
    
    void *buffer = malloc(st.st_size);
    if (!buffer) {
        printf("内存分配失败\n");
        close(fd);
        return NULL;
    }
    
    ssize_t bytes_read = read(fd, buffer, st.st_size);
    if (bytes_read != st.st_size) {
        printf("读取文件失败\n");
        free(buffer);
        close(fd);
        return NULL;
    }
    
    *size = st.st_size;
    close(fd);
    return buffer;
}

int main() {
    printf("=== kexec 加载框架演示 ===\n");
    
    // 检查系统支持
    if (check_kexec_support() == -1) {
        printf("系统不支持 kexec 功能\n");
        return 1;
    }
    
    // 检查权限
    if (check_kexec_permissions() == -1) {
        printf("权限不足，无法执行 kexec\n");
        return 1;
    }
    
    printf("系统支持 kexec，权限检查通过\n");
    
    // 显示系统信息
    printf("当前内核版本: ");
    system("uname -r");
    
    printf("系统架构: ");
    system("uname -m");
    
    // 检查 kexec 状态
    printf("\n当前 kexec 状态:\n");
    system("ls /sys/kernel/kexec* 2>/dev/null || echo 'kexec 信息不可用'");
    
    return 0;
}

示例2：kexec 文件加载接口（现代方法）

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <linux/kexec.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>

#ifndef SYS_kexec_file_load
# define SYS_kexec_file_load 311  // x86_64 架构下的系统调用号
#endif

// kexec_file_load 系统调用（Linux 3.17+）
long kexec_file_load_syscall(int kernel_fd, int initrd_fd,
                            unsigned long cmdline_len,
                            const char *cmdline_ptr,
                            unsigned long flags) {
    return syscall(SYS_kexec_file_load, kernel_fd, initrd_fd,
                   cmdline_len, cmdline_ptr, flags);
}

void demonstrate_kexec_file_load() {
    printf("=== kexec_file_load 演示 ===\n");
    
    if (geteuid() != 0) {
        printf("需要 root 权限\n");
        return;
    }
    
    // 检查系统是否支持 kexec_file_load
    long result = syscall(SYS_kexec_file_load, -1, -1, 0, NULL, 0);
    if (result == -1 && errno == ENOSYS) {
        printf("系统不支持 kexec_file_load 系统调用\n");
        printf("需要 Linux 内核 3.17 或更高版本\n");
        return;
    }
    
    printf("系统支持 kexec_file_load 接口\n");
    
    // 显示可用的内核文件
    printf("\n可用的内核文件:\n");
    system("ls /boot/vmlinuz* 2>/dev/null | head -5 || echo '未找到内核文件'");
    
    // 显示 initrd 文件
    printf("\n可用的 initrd 文件:\n");
    system("ls /boot/initrd* /boot/initramfs* 2>/dev/null | head -5 || echo '未找到 initrd 文件'");
    
    // 显示当前 kexec 状态
    printf("\n当前 kexec 状态:\n");
    system("cat /sys/kernel/kexec_loaded 2>/dev/null || echo 'kexec_loaded 不可用'");
    system("cat /sys/kernel/kexec_crash_loaded 2>/dev/null || echo 'kexec_crash_loaded 不可用'");
}

int main() {
    demonstrate_kexec_file_load();
    return 0;
}

示例3：kexec 状态检查工具

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>

void check_kexec_status() {
    printf("=== kexec 状态检查 ===\n");
    
    // 检查内核配置
    printf("内核 kexec 支持:\n");
    system("grep CONFIG_KEXEC /boot/config-$(uname -r) 2>/dev/null || "
           "zgrep CONFIG_KEXEC /proc/config.gz 2>/dev/null || "
           "echo '无法确定内核配置'");
    
    // 检查 kexec 模块参数
    printf("\nkexec 模块信息:\n");
    system("lsmod | grep kexec 2>/dev/null || echo 'kexec 作为内建功能或未加载'");
    
    // 检查 sysfs 接口
    printf("\n系统 kexec 状态:\n");
    system("echo 'kexec 加载状态: ' && "
           "cat /sys/kernel/kexec_loaded 2>/dev/null || echo '未知'");
    system("echo '崩溃内核状态: ' && "
           "cat /sys/kernel/kexec_crash_loaded 2>/dev/null || echo '未知'");
    system("echo 'kexec 锁定状态: ' && "
           "cat /sys/kernel/kexec_crash_size 2>/dev/null || echo '未知'");
    
    // 检查内存布局
    printf("\n系统内存布局 (相关部分):\n");
    system("grep -E 'System RAM|Kernel code|Kernel data' /proc/iomem 2>/dev/null || "
           "echo '无法读取内存布局'");
    
    // 检查权限
    printf("\n权限检查:\n");
    printf("当前 UID: %d\n", getuid());
    printf("当前 EUID: %d\n", geteuid());
    
    if (geteuid() == 0) {
        printf("✓ 以 root 身份运行\n");
    } else {
        printf("✗ 需要 root 权限\n");
    }
    
    // 检查能力
    printf("\n能力检查:\n");
    system("cat /proc/self/status | grep Cap 2>/dev/null || echo '无法读取能力信息'");
}

void show_kexec_limits() {
    printf("\n=== kexec 限制和配置 ===\n");
    
    // 显示硬件限制
    printf("硬件架构限制:\n");
    system("uname -m");
    
    // 显示内存限制
    printf("\n内存相关信息:\n");
    system("free -h");
    
    // 显示 kexec 相关的内核参数
    printf("\n相关内核参数:\n");
    system("sysctl -a 2>/dev/null | grep -E 'kexec|crash' | head -10 || "
           "echo '无法读取内核参数'");
    
    // 显示安全限制
    printf("\n安全相关设置:\n");
    system("cat /proc/sys/kernel/kptr_restrict 2>/dev/null || echo 'kptr_restrict 未设置'");
    system("cat /proc/sys/kernel/perf_event_paranoid 2>/dev/null || echo 'perf_event_paranoid 未设置'");
}

void demonstrate_kexec_commands() {
    printf("\n=== kexec 相关命令 ===\n");
    
    printf("常用 kexec 命令:\n");
    printf("  kexec -l <kernel>          # 加载内核\n");
    printf("  kexec -e                   # 执行已加载的内核\n");
    printf("  kexec -p <kernel>          # 加载崩溃内核\n");
    printf("  kexec -u                   # 卸载当前内核\n");
    
    printf("\n示例用法:\n");
    printf("  # 加载新内核\n");
    printf("  kexec -l /boot/vmlinuz-$(uname -r) \\\n");
    printf("        --initrd=/boot/initrd.img-$(uname -r) \\\n");
    printf("        --command-line=\"$(cat /proc/cmdline)\"\n");
    printf("  \n");
    printf("  # 快速重启\n");
    printf("  kexec -e\n");
    
    // 检查 kexec 命令是否存在
    printf("\n系统中的 kexec 工具:\n");
    system("which kexec 2>/dev/null && echo '✓ kexec 命令可用' || echo '✗ kexec 命令不可用'");
}

int main() {
    check_kexec_status();
    show_kexec_limits();
    demonstrate_kexec_commands();
    
    return 0;
}

示例4：kexec 安全和监控工具

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>

void security_analysis() {
    printf("=== kexec 安全分析 ===\n");
    
    // 检查 kexec 锁定状态
    printf("kexec 锁定检查:\n");
    int fd = open("/proc/sys/kernel/kexec_load_disabled", O_RDONLY);
    if (fd != -1) {
        char buf[16];
        ssize_t n = read(fd, buf, sizeof(buf) - 1);
        if (n > 0) {
            buf[n] = '\0';
            printf("kexec 加载已%s\n", atoi(buf) ? "禁用" : "启用");
        }
        close(fd);
    } else {
        printf("无法检查 kexec 锁定状态\n");
    }
    
    // 检查安全启动状态
    printf("\n安全启动状态:\n");
    system("mokutil --sb-state 2>/dev/null || echo 'mokutil 不可用或安全启动未启用'");
    
    // 检查 IMA/EVM 状态
    printf("\nIMA/EVM 状态:\n");
    system("cat /sys/kernel/security/ima/policy_count 2>/dev/null || echo 'IMA 不可用'");
    
    // 检查 SELinux/AppArmor 状态
    printf("\n强制访问控制:\n");
    system("getenforce 2>/dev/null || echo 'SELinux 不可用'");
    system("aa-status 2>/dev/null | head -5 || echo 'AppArmor 信息不可用'");
}

void performance_benchmark() {
    printf("\n=== kexec 性能优势 ===\n");
    
    printf("传统重启 vs kexec 重启:\n");
    printf("  传统重启时间:     30-120 秒\n");
    printf("  kexec 重启时间:   2-10 秒\n");
    printf("  时间节省:         80-95%%\n");
    
    printf("\n适用场景:\n");
    printf("  • 高可用性集群\n");
    printf("  • 实时系统维护\n");
    printf("  • 内核升级测试\n");
    printf("  • 故障恢复\n");
    printf("  • 开发调试\n");
    
    printf("\n性能考虑:\n");
    printf("  • 需要足够的内存保留空间\n");
    printf("  • 内核镜像大小影响加载时间\n");
    printf("  • 内存碎片可能影响加载成功率\n");
}

void crash_dump_analysis() {
    printf("\n=== 崩溃转储支持 ===\n");
    
    printf("kexec 崩溃转储功能:\n");
    printf("  • 内核崩溃时保存内存状态\n");
    printf("  • 快速重启并保存转储信息\n");
    printf("  • 支持 vmcore 分析\n");
    
    // 检查崩溃转储配置
    printf("\n崩溃转储配置:\n");
    system("cat /proc/sys/kernel/panic 2>/dev/null || echo 'panic 设置不可用'");
    system("cat /proc/sys/kernel/panic_on_oops 2>/dev/null || echo 'panic_on_oops 设置不可用'");
    system("cat /sys/kernel/kexec_crash_size 2>/dev/null || echo '崩溃内存大小未设置'");
    
    printf("\n相关工具:\n");
    printf("  • crash: 内存转储分析工具\n");
    printf("  • makedumpfile: 转储文件处理工具\n");
    printf("  • kgdb: 内核调试器\n");
}

void best_practices() {
    printf("\n=== kexec 最佳实践 ===\n");
    
    printf("使用建议:\n");
    printf("  1. 确保新内核与硬件兼容\n");
    printf("  2. 备份重要数据\n");
    printf("  3. 测试内核参数\n");
    printf("  4. 监控系统日志\n");
    printf("  5. 准备回滚方案\n");
    
    printf("\n安全注意事项:\n");
    printf("  • 验证内核镜像完整性\n");
    printf("  • 限制 kexec 权限\n");
    printf("  • 启用审计日志\n");
    printf("  • 定期更新内核\n");
    
    printf("\n故障排除:\n");
    printf("  • 检查内核日志: dmesg | grep kexec\n");
    printf("  • 验证内存: free -h\n");
    printf("  • 检查权限: ls -l /proc/sys/kernel/kexec*\n");
}

int main() {
    printf("=== kexec 综合分析工具 ===\n");
    
    security_analysis();
    performance_benchmark();
    crash_dump_analysis();
    best_practices();
    
    printf("\n=== 总结 ===\n");
    printf("kexec 是 Linux 系统中重要的快速重启技术，\n");
    printf("适用于需要最小化停机时间的场景。\n");
    printf("使用时需注意安全性和兼容性问题。\n");
    
    return 0;
}

10. kexec 相关结构体和常量

// kexec 标志位
#define KEXEC_ON_CRASH          0x00000001
#define KEXEC_PRESERVE_CONTEXT  0x00000002
#define KEXEC_ARCH_MASK         0xffff0000

// 架构相关标志
#define KEXEC_ARCH_DEFAULT      (0 << 16)
#define KEXEC_ARCH_386          (3 << 16)
#define KEXEC_ARCH_68K          (4 << 16)
#define KEXEC_ARCH_PARISC       (15 << 16)
#define KEXEC_ARCH_X86_64       (62 << 16)
#define KEXEC_ARCH_PPC          (20 << 16)
#define KEXEC_ARCH_PPC64        (21 << 16)
#define KEXEC_ARCH_IA_64        (50 << 16)
#define KEXEC_ARCH_ARM          (40 << 16)
#define KEXEC_ARCH_S390         (22 << 16)
#define KEXEC_ARCH_SH           (42 << 16)
#define KEXEC_ARCH_MIPS_LE      (10 << 16)
#define KEXEC_ARCH_MIPS         (8 << 16)

// 重启命令
#define LINUX_REBOOT_CMD_KEXEC  0x45584543

11. 实际应用场景

场景1：高可用性集群

void ha_cluster_kexec() {
    // 在 HA 集群中使用 kexec 进行快速故障转移
    // 减少服务中断时间
}

场景2：内核开发调试

void kernel_development_kexec() {
    // 快速测试新内核版本
    // 避免漫长的 BIOS/UEFI 初始化过程
}

场景3：系统维护

void system_maintenance_kexec() {
    // 在维护窗口期间快速重启
    // 最大化可用性
}

12. 注意事项

使用 kexec 时需要注意：

1. 权限要求: 需要 CAP_SYS_BOOT 能力或 root 权限
2. 内存需求: 需要足够的内存来加载新内核
3. 兼容性: 新内核必须与硬件兼容
4. 安全性: 内核镜像需要验证完整性
5. 调试困难: kexec 后的调试信息可能有限
6. 硬件初始化: 跳过 BIOS/UEFI 可能影响某些硬件

13. 现代替代方案

// kexec_file_load (推荐的现代接口)
long kexec_file_load(int kernel_fd, int initrd_fd,
                    unsigned long cmdline_len,
                    const char *cmdline_ptr,
                    unsigned long flags);

总结

kexec_load 是 Linux 系统中实现快速内核切换的核心系统调用：

关键特性:
1. 快速重启: 跳过 BIOS/UEFI 初始化
2. 内存加载: 将新内核加载到内存中
3. 灵活控制: 支持多种加载选项
4. 崩溃支持: 支持崩溃转储功能

主要应用:
1. 高可用性系统快速故障恢复
2. 内核开发和测试
3. 系统维护和升级
4. 崩溃分析和调试

使用要点:
1. 需要特殊权限和内核支持
2. 注意内存和兼容性要求
3. 建议使用现代的 kexec_file_load 接口
4. 配合用户态工具使用效果更佳

kexec 技术显著提高了 Linux 系统的可用性和维护效率，是企业级系统管理的重要工具。

keyctl – 密钥管理控制接口

1. 函数介绍

keyctl 是一个 Linux 系统调用，用于管理和操作内核密钥保留服务（Key Retention Service）。它提供了对内核密钥管理子系统的完整控制接口，允许进程创建、检索、更新和删除各种类型的密钥。

密钥保留服务是 Linux 内核的安全基础设施组件，用于安全地存储和管理密钥、密码、证书等敏感信息。

2. 函数原型

#include <sys/types.h>
#include <keyutils.h>

long keyctl(int cmd, ...);

注意：这不是标准 C 库函数，需要通过 syscall() 调用或使用 libkeyutils 库。

3. 功能

执行各种密钥管理操作，包括：

• 创建和删除密钥
• 设置和获取密钥属性
• 链接和取消链接密钥
• 搜索和查找密钥
• 设置密钥权限
• 管理密钥环

4. 常用命令参数

// 密钥管理命令
#define KEYCTL_GET_KEYRING_ID     0  /* 获取密钥环 ID */
#define KEYCTL_JOIN_SESSION_KEYRING 1  /* 加入会话密钥环 */
#define KEYCTL_UPDATE             2  /* 更新密钥 */
#define KEYCTL_REVOKE             3  /* 撤销密钥 */
#define KEYCTL_CHOWN              4  /* 更改密钥所有者 */
#define KEYCTL_SETPERM            5  /* 设置密钥权限 */
#define KEYCTL_DESCRIBE           6  /* 描述密钥 */
#define KEYCTL_CLEAR              7  /* 清空密钥环 */
#define KEYCTL_LINK               8  /* 链接密钥 */
#define KEYCTL_UNLINK             9  /* 取消链接密钥 */
#define KEYCTL_SEARCH            10  /* 搜索密钥 */
#define KEYCTL_READ              11  /* 读取密钥 */
#define KEYCTL_INSTANTIATE       12  /* 实例化密钥 */
#define KEYCTL_NEGATE            13  /* 否定密钥 */
#define KEYCTL_SET_REQKEY_KEYRING 14 /* 设置请求密钥环 */
#define KEYCTL_SET_TIMEOUT       15  /* 设置密钥超时 */
#define KEYCTL_ASSUME_AUTHORITY  16  /* 假设权限 */
#define KEYCTL_GET_SECURITY      17  /* 获取安全上下文 */
#define KEYCTL_SESSION_TO_PARENT 18  /* 会话到父进程 */
#define KEYCTL_REJECT            19  /* 拒绝密钥 */
#define KEYCTL_INSTANTIATE_IOV   20  /* 实例化密钥 (iov) */
#define KEYCTL_INVALIDATE        21  /* 使密钥无效 */
#define KEYCTL_GET_PERSISTENT    22  /* 获取持久密钥环 */

5. 密钥类型

// 常见密钥类型
"user"        // 用户定义的密钥
"logon"       // 登录凭证密钥
"trusted"     // 受信任的密钥
"encrypted"   // 加密密钥
"dns_resolver" // DNS 解析器密钥
"rxrpc"       // RxRPC 密钥
"syzkaller"   // 系统调用模糊测试密钥

6. 返回值

• 成功时：返回值取决于具体命令
• 失败时：返回 -1，并设置 errno

7. 常见 errno 错误码

• ENOKEY: 密钥不存在
• EKEYEXPIRED: 密钥已过期
• EKEYREVOKED: 密钥已被撤销
• EACCES: 权限不足
• EPERM: 操作被拒绝
• EINVAL: 参数无效
• ENOMEM: 内存不足
• EDQUOT: 配额超限
• EOPNOTSUPP: 操作不支持

8. 相似函数，或关联函数

• add_key(): 添加新密钥
• request_key(): 请求密钥
• keyctl() 系列函数
• /sbin/keyctl: 用户态密钥管理工具
• /proc/keys: 查看系统密钥信息
• /proc/key-users: 查看密钥用户信息

9. 示例代码

示例1：基本使用 – 密钥创建和管理

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <keyutils.h>
#include <errno.h>
#include <string.h>

#ifndef SYS_keyctl
# define SYS_keyctl 250  // x86_64 架构下的系统调用号
#endif

// keyctl 系统调用包装函数
long keyctl_wrapper(int cmd, ...) {
    va_list args;
    va_start(args, cmd);
    long result = syscall(SYS_keyctl, cmd, va_arg(args, long), 
                         va_arg(args, long), va_arg(args, long), 
                         va_arg(args, long));
    va_end(args);
    return result;
}

int main() {
    printf("=== keyctl 基本使用演示 ===\n");
    
    // 检查密钥支持
    key_serial_t session_keyring = keyctl(KEYCTL_GET_KEYRING_ID, 
                                         KEY_SPEC_SESSION_KEYRING, 0);
    if (session_keyring == -1) {
        printf("错误: 系统不支持密钥保留服务: %s\n", strerror(errno));
        return 1;
    }
    
    printf("✓ 密钥保留服务可用\n");
    printf("会话密钥环 ID: %d\n", session_keyring);
    
    // 创建一个用户密钥
    const char *key_desc = "my_test_key";
    const char *key_data = "This is my secret data";
    
    key_serial_t key = add_key("user", key_desc, key_data, strlen(key_data), 
                              KEY_SPEC_SESSION_KEYRING);
    if (key == -1) {
        printf("创建密钥失败: %s\n", strerror(errno));
        return 1;
    }
    
    printf("✓ 成功创建密钥，ID: %d\n", key);
    
    // 描述密钥
    char description[256];
    long desc_len = keyctl(KEYCTL_DESCRIBE, key, (long)description, 
                          sizeof(description), 0);
    if (desc_len != -1) {
        description[desc_len] = '\0';
        printf("密钥描述: %s\n", description);
    }
    
    // 读取密钥数据
    char read_data[256];
    long data_len = keyctl(KEYCTL_READ, key, (long)read_data, 
                          sizeof(read_data), 0);
    if (data_len != -1) {
        read_data[data_len] = '\0';
        printf("密钥数据: %s\n", read_data);
    }
    
    // 设置密钥超时（30秒后过期）
    if (keyctl(KEYCTL_SET_TIMEOUT, key, 30, 0, 0) == 0) {
        printf("✓ 设置密钥超时为 30 秒\n");
    }
    
    // 获取密钥安全上下文
    char security_context[256];
    long sec_len = keyctl(KEYCTL_GET_SECURITY, key, 
                         (long)security_context, sizeof(security_context), 0);
    if (sec_len != -1) {
        security_context[sec_len] = '\0';
        printf("安全上下文: %s\n", security_context);
    }
    
    // 撤销密钥
    if (keyctl(KEYCTL_REVOKE, key, 0, 0, 0) == 0) {
        printf("✓ 成功撤销密钥\n");
    }
    
    return 0;
}

示例2：密钥环操作

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <keyutils.h>
#include <errno.h>
#include <string.h>

void demonstrate_keyring_operations() {
    printf("=== 密钥环操作演示 ===\n");
    
    // 获取各种密钥环 ID
    key_serial_t session_ring = keyctl(KEYCTL_GET_KEYRING_ID, 
                                      KEY_SPEC_SESSION_KEYRING, 0);
    key_serial_t process_ring = keyctl(KEYCTL_GET_KEYRING_ID, 
                                      KEY_SPEC_PROCESS_KEYRING, 0);
    key_serial_t thread_ring = keyctl(KEYCTL_GET_KEYRING_ID, 
                                     KEY_SPEC_THREAD_KEYRING, 0);
    
    printf("密钥环 ID:\n");
    printf("  会话密钥环: %d\n", session_ring);
    printf("  进程密钥环: %d\n", process_ring);
    printf("  线程密钥环: %d\n", thread_ring);
    
    // 创建自定义密钥环
    key_serial_t custom_ring = add_key("keyring", "my_custom_ring", 
                                      NULL, 0, KEY_SPEC_SESSION_KEYRING);
    if (custom_ring != -1) {
        printf("✓ 创建自定义密钥环: %d\n", custom_ring);
        
        // 在自定义密钥环中创建密钥
        key_serial_t ring_key = add_key("user", "ring_key", 
                                       "data in ring", 12, custom_ring);
        if (ring_key != -1) {
            printf("✓ 在自定义密钥环中创建密钥: %d\n", ring_key);
        }
        
        // 清空自定义密钥环
        if (keyctl(KEYCTL_CLEAR, custom_ring, 0, 0, 0) == 0) {
            printf("✓ 清空自定义密钥环\n");
        }
        
        // 撤销自定义密钥环
        if (keyctl(KEYCTL_REVOKE, custom_ring, 0, 0, 0) == 0) {
            printf("✓ 撤销自定义密钥环\n");
        }
    }
    
    // 加入新的会话密钥环
    key_serial_t new_session = keyctl(KEYCTL_JOIN_SESSION_KEYRING, 
                                     (long)"new_session", 0, 0, 0);
    if (new_session != -1) {
        printf("✓ 加入新的会话密钥环: %d\n", new_session);
    }
}

void demonstrate_key_search() {
    printf("\n=== 密钥搜索演示 ===\n");
    
    // 创建测试密钥
    key_serial_t test_key = add_key("user", "search_test", 
                                   "search data", 11, 
                                   KEY_SPEC_SESSION_KEYRING);
    if (test_key == -1) {
        printf("创建测试密钥失败: %s\n", strerror(errno));
        return;
    }
    
    printf("创建测试密钥: %d\n", test_key);
    
    // 搜索密钥
    key_serial_t found_key = keyctl(KEYCTL_SEARCH, 
                                   KEY_SPEC_SESSION_KEYRING,
                                   (long)"user", (long)"search_test", 0);
    if (found_key != -1) {
        printf("✓ 找到密钥: %d\n", found_key);
        
        // 验证找到的密钥
        if (found_key == test_key) {
            printf("✓ 验证成功：找到的密钥 ID 匹配\n");
        }
    } else {
        printf("搜索密钥失败: %s\n", strerror(errno));
    }
    
    // 撤销测试密钥
    keyctl(KEYCTL_REVOKE, test_key, 0, 0, 0);
}

void demonstrate_key_permissions() {
    printf("\n=== 密钥权限演示 ===\n");
    
    // 创建测试密钥
    key_serial_t perm_key = add_key("user", "perm_test", 
                                   "permission data", 15, 
                                   KEY_SPEC_SESSION_KEYRING);
    if (perm_key == -1) {
        printf("创建权限测试密钥失败: %s\n", strerror(errno));
        return;
    }
    
    printf("创建权限测试密钥: %d\n", perm_key);
    
    // 设置密钥权限
    // 权限格式: possessor|user|group|other
    // 每个字段: view|read|write|search|link|setattr|all
    key_perm_t permissions = KEY_POS_ALL | KEY_USR_VIEW | KEY_USR_READ;
    
    if (keyctl(KEYCTL_SETPERM, perm_key, permissions, 0, 0) == 0) {
        printf("✓ 设置密钥权限成功\n");
        
        // 描述密钥查看权限
        char desc[256];
        long desc_len = keyctl(KEYCTL_DESCRIBE, perm_key, 
                              (long)desc, sizeof(desc), 0);
        if (desc_len != -1) {
            desc[desc_len] = '\0';
            printf("更新后的密钥描述: %s", desc);
        }
    } else {
        printf("设置密钥权限失败: %s\n", strerror(errno));
    }
    
    // 更改密钥所有者（需要特权）
    if (keyctl(KEYCTL_CHOWN, perm_key, getuid(), 0, 0) == 0) {
        printf("✓ 更改密钥所有者成功\n");
    } else {
        if (errno == EPERM) {
            printf("ℹ 更改所有者需要特权权限\n");
        } else {
            printf("更改所有者失败: %s\n", strerror(errno));
        }
    }
    
    // 撤销密钥
    keyctl(KEYCTL_REVOKE, perm_key, 0, 0, 0);
}

int main() {
    printf("=== keyctl 密钥环操作演示 ===\n");
    
    // 检查密钥支持
    if (keyctl(KEYCTL_GET_KEYRING_ID, KEY_SPEC_SESSION_KEYRING, 0) == -1) {
        printf("错误: 系统不支持密钥保留服务\n");
        return 1;
    }
    
    demonstrate_keyring_operations();
    demonstrate_key_search();
    demonstrate_key_permissions();
    
    return 0;
}

示例3：密钥安全和加密操作

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <keyutils.h>
#include <errno.h>
#include <string.h>
#include <time.h>

void demonstrate_encrypted_keys() {
    printf("=== 加密密钥演示 ===\n");
    
    // 检查是否支持加密密钥
    printf("系统支持的密钥类型:\n");
    system("cat /proc/key-types 2>/dev/null | grep -E 'user|encrypted|trusted' || "
           "echo '无法读取密钥类型信息'");
    
    // 创建用户密钥（基础加密）
    const char *encrypted_data = "sensitive_encrypted_data";
    key_serial_t enc_key = add_key("user", "encrypted_secret", 
                                  encrypted_data, strlen(encrypted_data),
                                  KEY_SPEC_SESSION_KEYRING);
    
    if (enc_key != -1) {
        printf("✓ 创建加密数据密钥: %d\n", enc_key);
        
        // 设置超时以增强安全性
        if (keyctl(KEYCTL_SET_TIMEOUT, enc_key, 300, 0, 0) == 0) {  // 5分钟
            printf("✓ 设置密钥超时为 5 分钟\n");
        }
        
        // 读取密钥数据
        char buffer[256];
        long read_len = keyctl(KEYCTL_READ, enc_key, (long)buffer, 
                              sizeof(buffer), 0);
        if (read_len != -1) {
            buffer[read_len] = '\0';
            printf("读取加密数据长度: %ld 字节\n", read_len);
        }
    } else {
        printf("创建加密密钥失败: %s\n", strerror(errno));
    }
}

void demonstrate_key_lifecycle() {
    printf("\n=== 密钥生命周期管理 ===\n");
    
    // 创建密钥
    const char *key_data = "lifecycle_test_data";
    key_serial_t key = add_key("user", "lifecycle_test", 
                              key_data, strlen(key_data),
                              KEY_SPEC_SESSION_KEYRING);
    
    if (key == -1) {
        printf("创建密钥失败: %s\n", strerror(errno));
        return;
    }
    
    printf("1. 创建密钥: %d\n", key);
    
    // 描述密钥状态
    char desc[256];
    long desc_len = keyctl(KEYCTL_DESCRIBE, key, (long)desc, sizeof(desc), 0);
    if (desc_len != -1) {
        desc[desc_len] = '\0';
        printf("2. 密钥状态: %s", desc);
    }
    
    // 更新密钥数据
    const char *new_data = "updated_lifecycle_data";
    if (keyctl(KEYCTL_UPDATE, key, (long)new_data, strlen(new_data), 0) == 0) {
        printf("3. ✓ 更新密钥数据成功\n");
    }
    
    // 设置短期超时
    if (keyctl(KEYCTL_SET_TIMEOUT, key, 10, 0, 0) == 0) {  // 10秒
        printf("4. ✓ 设置 10 秒超时\n");
    }
    
    // 等待几秒观察超时效果
    printf("5. 等待 12 秒观察超时效果...\n");
    sleep(12);
    
    // 尝试访问已过期的密钥
    char buffer[256];
    long read_len = keyctl(KEYCTL_READ, key, (long)buffer, sizeof(buffer), 0);
    if (read_len == -1) {
        if (errno == EKEYEXPIRED) {
            printf("6. ✓ 密钥已正确过期\n");
        } else {
            printf("6. 访问密钥失败: %s\n", strerror(errno));
        }
    }
    
    // 撤销密钥（即使已过期）
    if (keyctl(KEYCTL_REVOKE, key, 0, 0, 0) == 0) {
        printf("7. ✓ 撤销密钥成功\n");
    }
}

void demonstrate_key_security_analysis() {
    printf("\n=== 密钥安全分析 ===\n");
    
    // 显示当前用户的密钥使用情况
    printf("当前密钥使用情况:\n");
    system("cat /proc/key-users 2>/dev/null | head -10 || echo '无法读取密钥用户信息'");
    
    // 显示系统密钥信息
    printf("\n系统密钥信息:\n");
    system("cat /proc/keys 2>/dev/null | head -10 || echo '无法读取密钥信息'");
    
    // 显示密钥配额信息
    printf("\n密钥配额信息:\n");
    system("cat /proc/sys/kernel/keys/* 2>/dev/null || echo '无法读取密钥配额'");
    
    // 安全建议
    printf("\n密钥安全最佳实践:\n");
    printf("  • 使用适当的超时设置\n");
    printf("  • 设置最小必要权限\n");
    printf("  • 定期清理过期密钥\n");
    printf("  • 避免在日志中记录密钥数据\n");
    printf("  • 使用加密存储敏感数据\n");
    printf("  • 监控密钥使用情况\n");
}

int main() {
    printf("=== keyctl 安全和加密操作演示 ===\n");
    
    // 检查密钥支持
    if (keyctl(KEYCTL_GET_KEYRING_ID, KEY_SPEC_SESSION_KEYRING, 0) == -1) {
        printf("错误: 系统不支持密钥保留服务\n");
        return 1;
    }
    
    printf("✓ 密钥保留服务可用\n");
    
    demonstrate_encrypted_keys();
    demonstrate_key_lifecycle();
    demonstrate_key_security_analysis();
    
    return 0;
}

示例4：密钥管理工具和监控

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <keyutils.h>
#include <errno.h>
#include <string.h>
#include <time.h>

void show_key_statistics() {
    printf("=== 密钥统计信息 ===\n");
    
    // 显示密钥数量
    printf("系统密钥统计:\n");
    system("wc -l /proc/keys 2>/dev/null | awk '{print \"总密钥数: \" $1-1}' || "
           "echo '无法统计密钥数量'");
    
    // 显示密钥用户信息
    printf("\n密钥用户统计:\n");
    system("cat /proc/key-users 2>/dev/null | head -5 || echo '无法读取用户统计'");
    
    // 显示密钥类型分布
    printf("\n密钥类型分布:\n");
    system("awk '{print $4}' /proc/keys 2>/dev/null | sort | uniq -c | head -10 || "
           "echo '无法分析密钥类型'");
}

void interactive_key_manager() {
    int choice;
    char input[256];
    
    while (1) {
        printf("\n=== 密钥管理菜单 ===\n");
        printf("1. 列出当前密钥\n");
        printf("2. 创建新密钥\n");
        printf("3. 查找密钥\n");
        printf("4. 删除密钥\n");
        printf("5. 显示密钥统计\n");
        printf("6. 清空会话密钥环\n");
        printf("0. 退出\n");
        printf("请选择操作: ");
        
        if (scanf("%d", &choice) != 1) {
            printf("输入无效，请重新选择\n");
            while (getchar() != '\n');  // 清空输入缓冲区
            continue;
        }
        
        switch (choice) {
            case 1:
                printf("当前会话密钥:\n");
                system("keyctl list @s 2>/dev/null || echo '无法列出密钥'");
                break;
                
            case 2: {
                printf("输入密钥描述: ");
                scanf("%255s", input);
                
                printf("输入密钥数据: ");
                scanf("%255s", input + 128);  // 简化处理
                
                key_serial_t new_key = add_key("user", input, 
                                              input + 128, 
                                              strlen(input + 128),
                                              KEY_SPEC_SESSION_KEYRING);
                if (new_key != -1) {
                    printf("✓ 成功创建密钥: %d\n", new_key);
                } else {
                    printf("❌ 创建密钥失败: %s\n", strerror(errno));
                }
                break;
            }
            
            case 3: {
                printf("输入要查找的密钥描述: ");
                scanf("%255s", input);
                
                key_serial_t found_key = keyctl(KEYCTL_SEARCH,
                                               KEY_SPEC_SESSION_KEYRING,
                                               (long)"user", (long)input, 0);
                if (found_key != -1) {
                    printf("✓ 找到密钥: %d\n", found_key);
                } else {
                    printf("❌ 未找到密钥: %s\n", strerror(errno));
                }
                break;
            }
            
            case 4: {
                printf("输入要删除的密钥 ID: ");
                int key_id;
                if (scanf("%d", &key_id) == 1) {
                    if (keyctl(KEYCTL_REVOKE, key_id, 0, 0, 0) == 0) {
                        printf("✓ 成功撤销密钥: %d\n", key_id);
                    } else {
                        printf("❌ 撤销密钥失败: %s\n", strerror(errno));
                    }
                } else {
                    printf("输入无效\n");
                }
                break;
            }
            
            case 5:
                show_key_statistics();
                break;
                
            case 6:
                if (keyctl(KEYCTL_CLEAR, KEY_SPEC_SESSION_KEYRING, 0, 0, 0) == 0) {
                    printf("✓ 成功清空会话密钥环\n");
                } else {
                    printf("❌ 清空密钥环失败: %s\n", strerror(errno));
                }
                break;
                
            case 0:
                printf("退出密钥管理工具\n");
                return;
                
            default:
                printf("无效选择，请重新输入\n");
                break;
        }
    }
}

void demonstrate_advanced_key_operations() {
    printf("\n=== 高级密钥操作 ===\n");
    
    // 创建密钥环
    key_serial_t keyring = add_key("keyring", "advanced_test_ring", 
                                  NULL, 0, KEY_SPEC_SESSION_KEYRING);
    if (keyring != -1) {
        printf("✓ 创建测试密钥环: %d\n", keyring);
        
        // 在密钥环中创建多个密钥
        for (int i = 1; i <= 3; i++) {
            char desc[32], data[32];
            snprintf(desc, sizeof(desc), "key_%d", i);
            snprintf(data, sizeof(data), "data_%d", i);
            
            key_serial_t key = add_key("user", desc, data, strlen(data), keyring);
            if (key != -1) {
                printf("  ✓ 创建密钥 %s: %d\n", desc, key);
            }
        }
        
        // 列出密钥环内容
        printf("密钥环内容:\n");
        char buffer[1024];
        long len = keyctl(KEYCTL_READ, keyring, (long)buffer, sizeof(buffer), 0);
        if (len != -1) {
            // 简化显示
            printf("  密钥环包含 %ld 字节数据\n", len);
        }
        
        // 清空密钥环
        if (keyctl(KEYCTL_CLEAR, keyring, 0, 0, 0) == 0) {
            printf("✓ 清空密钥环成功\n");
        }
        
        // 撤销密钥环
        keyctl(KEYCTL_REVOKE, keyring, 0, 0, 0);
    }
}

void key_monitoring_demo() {
    printf("\n=== 密钥监控演示 ===\n");
    
    printf("实时密钥监控 (按 Ctrl+C 停止):\n");
    
    // 显示初始状态
    printf("初始密钥数量: ");
    system("wc -l /proc/keys 2>/dev/null | awk '{print $1-1}' || echo 'unknown'");
    
    // 创建测试密钥并监控变化
    key_serial_t test_key = add_key("user", "monitor_test", 
                                   "monitor data", 12, 
                                   KEY_SPEC_SESSION_KEYRING);
    if (test_key != -1) {
        printf("创建测试密钥后数量: ");
        system("wc -l /proc/keys 2>/dev/null | awk '{print $1-1}' || echo 'unknown'");
        
        // 撤销密钥
        keyctl(KEYCTL_REVOKE, test_key, 0, 0, 0);
        printf("撤销测试密钥后数量: ");
        system("wc -l /proc/keys 2>/dev/null | awk '{print $1-1}' || echo 'unknown'");
    }
}

int main() {
    printf("=== keyctl 高级管理和监控工具 ===\n");
    
    // 检查密钥支持
    if (keyctl(KEYCTL_GET_KEYRING_ID, KEY_SPEC_SESSION_KEYRING, 0) == -1) {
        printf("错误: 系统不支持密钥保留服务\n");
        return 1;
    }
    
    printf("✓ 密钥保留服务可用\n");
    
    // 显示系统信息
    printf("\n系统密钥信息:\n");
    system("uname -a");
    
    // 执行高级操作演示
    demonstrate_advanced_key_operations();
    
    // 显示统计信息
    show_key_statistics();
    
    // 监控演示
    key_monitoring_demo();
    
    // 启动交互式管理器（如果需要）
    char choice;
    printf("\n是否启动交互式密钥管理器? (y/N): ");
    if (scanf(" %c", &choice) == 1 && (choice == 'y' || choice == 'Y')) {
        interactive_key_manager();
    }
    
    return 0;
}

10. 密钥权限说明

// 密钥权限位定义
#define KEY_POS_VIEW    0x01000000  /* 持有者可查看 */
#define KEY_POS_READ    0x02000000  /* 持有者可读取 */
#define KEY_POS_WRITE   0x04000000  /* 持有者可写入 */
#define KEY_POS_SEARCH  0x08000000  /* 持有者可搜索 */
#define KEY_POS_LINK    0x10000000  /* 持有者可链接 */
#define KEY_POS_SETATTR 0x20000000  /* 持有者可设置属性 */
#define KEY_POS_ALL     0x3f000000  /* 持有者所有权限 */

#define KEY_USR_VIEW    0x00010000  /* 用户可查看 */
#define KEY_USR_READ    0x00020000  /* 用户可读取 */
#define KEY_USR_WRITE   0x00040000  /* 用户可写入 */
#define KEY_USR_SEARCH  0x00080000  /* 用户可搜索 */
#define KEY_USR_LINK    0x00100000  /* 用户可链接 */
#define KEY_USR_SETATTR 0x00200000  /* 用户可设置属性 */
#define KEY_USR_ALL     0x003f0000  /* 用户所有权限 */

#define KEY_GRP_VIEW    0x00000100  /* 组可查看 */
#define KEY_GRP_READ    0x00000200  /* 组可读取 */
#define KEY_GRP_WRITE   0x00000400  /* 组可写入 */
#define KEY_GRP_SEARCH  0x00000800  /* 组可搜索 */
#define KEY_GRP_LINK    0x00001000  /* 组可链接 */
#define KEY_GRP_SETATTR 0x00002000  /* 组可设置属性 */
#define KEY_GRP_ALL     0x00003f00  /* 组所有权限 */

#define KEY_OTH_VIEW    0x00000001  /* 其他可查看 */
#define KEY_OTH_READ    0x00000002  /* 其他可读取 */
#define KEY_OTH_WRITE   0x00000004  /* 其他可写入 */
#define KEY_OTH_SEARCH  0x00000008  /* 其他可搜索 */
#define KEY_OTH_LINK    0x00000010  /* 其他可链接 */
#define KEY_OTH_SETATTR 0x00000020  /* 其他可设置属性 */
#define KEY_OTH_ALL     0x0000003f  /* 其他所有权限 */

11. 实际应用场景

场景1：网络认证

void network_authentication_keys() {
    // 存储网络认证凭证
    add_key("user", "wifi_password", "secret123", 9, 
            KEY_SPEC_SESSION_KEYRING);
}

场景2：文件系统加密

void filesystem_encryption_keys() {
    // 存储加密文件系统密钥
    add_key("encrypted", "fs_encryption_key", key_data, key_len,
            KEY_SPEC_SESSION_KEYRING);
}

场景3：安全通信

void secure_communication_keys() {
    // 存储 TLS/SSL 会话密钥
    add_key("user", "tls_session_key", session_key, key_len,
            KEY_SPEC_PROCESS_KEYRING);
}

12. 注意事项

使用 keyctl 时需要注意：

1. 权限要求: 某些操作需要特殊权限
2. 内存安全: 密钥数据在内存中的安全处理
3. 生命周期: 正确管理密钥的创建、使用和销毁
4. 超时设置: 合理设置密钥超时以增强安全性
5. 权限控制: 设置最小必要权限
6. 系统资源: 监控密钥使用对系统资源的影响

13. 系统配置检查

# 检查密钥支持
grep CONFIG_KEYS /boot/config-$(uname -r)

# 查看密钥信息
cat /proc/keys
cat /proc/key-users

# 检查密钥配额
cat /proc/sys/kernel/keys/maxkeys
cat /proc/sys/kernel/keys/maxbytes

# 使用 keyctl 工具
keyctl list @s
keyctl show

总结

keyctl 是 Linux 系统中强大的密钥管理接口：

关键特性:
1. 安全存储: 内核级密钥安全存储
2. 权限控制: 细粒度的访问控制
3. 生命周期管理: 完整的密钥生命周期控制
4. 多种密钥类型: 支持各种应用场景
5. 系统集成: 与 Linux 安全子系统深度集成

主要应用:
1. 网络认证和安全通信
2. 文件系统加密
3. 应用程序密钥管理
4. 系统安全服务
5. 容器和虚拟化安全

使用要点:
1. 需要理解密钥权限模型
2. 注意密钥生命周期管理
3. 合理设置超时和权限
4. 监控密钥使用情况
5. 配合用户态工具使用效果更佳

正确使用 keyctl 可以显著提高应用程序的安全性，是现代 Linux 系统安全架构的重要组成部分。

kill – 发送信号给进程

函数介绍

kill系统调用用于向指定的进程发送信号。信号是Linux系统中进程间通信的一种方式，用于通知进程发生了某种事件。通过kill可以控制其他进程的行为，如终止、暂停、继续等。

函数原型

#include <sys/types.h>
#include <signal.h>

int kill(pid_t pid, int sig);

功能

向指定进程发送信号，用于进程控制和通信。

参数

• pid_t pid: 目标进程ID
  • > 0: 发送给指定进程ID
  • = 0: 发送给当前进程组的所有进程
  • -1: 发送给有权限发送的所有进程（除init）
  • < -1: 发送给进程组ID为-pid的所有进程
• int sig: 要发送的信号编号
  • 0: 空信号，用于检查进程是否存在
  • SIGTERM(15): 终止信号（默认）
  • SIGKILL(9): 强制终止信号
  • SIGSTOP(17): 暂停信号
  • SIGCONT(19): 继续信号

返回值

• 成功时返回0
• 失败时返回-1，并设置errno：
  • EINVAL: 信号编号无效
  • EPERM: 权限不足
  • ESRCH: 进程不存在

相似函数

• raise(): 向当前进程发送信号
• killpg(): 向进程组发送信号
• signal(): 设置信号处理函数
• sigaction(): 更高级的信号处理函数

示例代码

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <signal.h>
#include <errno.h>
#include <string.h>

int main() {
    pid_t current_pid = getpid();
    pid_t parent_pid = getppid();
    
    printf("=== Kill函数示例 ===\n");
    printf("当前进程PID: %d\n", current_pid);
    printf("父进程PID: %d\n", parent_pid);
    
    // 示例1: 发送空信号检查进程是否存在
    printf("\n示例1: 检查进程是否存在\n");
    if (kill(current_pid, 0) == 0) {
        printf("  进程 %d 存在\n", current_pid);
    } else {
        printf("  进程 %d 不存在\n", current_pid);
    }
    
    // 示例2: 向自己发送SIGTERM信号
    printf("\n示例2: 向自己发送SIGTERM信号\n");
    printf("  发送SIGTERM信号前...\n");
    
    // 创建子进程来演示，避免终止主进程
    pid_t child_pid = fork();
    if (child_pid == 0) {
        // 子进程
        printf("  子进程 %d 准备接收信号\n", getpid());
        sleep(1);
        printf("  子进程退出\n");
        exit(0);
    } else if (child_pid > 0) {
        // 父进程
        sleep(1); // 等待子进程准备就绪
        printf("  向子进程 %d 发送SIGTERM信号\n", child_pid);
        if (kill(child_pid, SIGTERM) == 0) {
            printf("  信号发送成功\n");
        } else {
            perror("  kill失败");
        }
        wait(NULL); // 等待子进程结束
    }
    
    // 示例3: 演示不同信号的效果
    printf("\n示例3: 不同信号的效果\n");
    
    // 创建用于演示的子进程
    child_pid = fork();
    if (child_pid == 0) {
        // 子进程循环运行
        printf("  子进程 %d 开始运行...\n", getpid());
        int i = 0;
        while (i < 10) {
            printf("  子进程运行中... %d\n", i++);
            sleep(1);
        }
        printf("  子进程正常退出\n");
        exit(0);
    } else if (child_pid > 0) {
        // 父进程
        sleep(2); // 让子进程运行一会儿
        
        printf("  向子进程 %d 发送SIGSTOP信号(暂停)\n", child_pid);
        kill(child_pid, SIGSTOP);
        sleep(2);
        
        printf("  向子进程 %d 发送SIGCONT信号(继续)\n", child_pid);
        kill(child_pid, SIGCONT);
        sleep(2);
        
        printf("  向子进程 %d 发送SIGTERM信号(终止)\n", child_pid);
        kill(child_pid, SIGTERM);
        wait(NULL);
    }
    
    // 示例4: 错误处理
    printf("\n示例4: 错误处理\n");
    if (kill(999999, SIGTERM) == -1) {
        printf("  向不存在的进程发送信号: %s\n", strerror(errno));
    }
    
    if (kill(parent_pid, 999) == -1) {
        printf("  发送无效信号: %s\n", strerror(errno));
    }
    
    printf("\n程序执行完毕\n");
    return 0;
}

(https://www.calcguide.tech/2025/08/16/kill%e7%b3%bb%e7%bb%9f%e8%b0%83%e7%94%a8%e5%8f%8a%e7%a4%ba%e4%be%8b/)

继续学习 Linux 系统编程中的重要函数。这次我们介绍 listen 函数，它是 TCP 服务器模型中不可或缺的一环，用于将一个已绑定的套接字置于监听状态，准备接收来自客户端的连接请求。

1. 函数介绍

listen 是一个 Linux 系统调用，专门用于 TCP 服务器。它的核心作用是将一个已经绑定到本地地址（通过 bind）的套接字的状态从默认的主动打开（active open）转变为被动打开（passive open）。

简单来说，listen 告诉操作系统内核：

“嘿，内核，我这个套接字（sockfd）已经绑定了一个地址（IP 和端口），现在我想开始监听这个地址，等待客户端的连接请求。请帮我管理这些连接请求，把它们排好队，等我用 accept 来处理。”

你可以把 listen 想象成商店开门营业：

• 商店（套接字）已经选好了地址（通过 bind）。
• listen 就像是老板在门口挂上“营业中”的牌子，并告诉店员（内核）：“有人来敲门（连接请求），先让他们在门外等一会儿（排队），别让他们直接冲进来。”
• accept 则像是店员去开门，把排队的顾客（客户端）迎进来，开始一对一的服务。

2. 函数原型

#include <sys/socket.h> // 必需

int listen(int sockfd, int backlog);

3. 功能

• 启用监听: 将套接字 sockfd 的状态设置为监听模式。
• 建立队列: 告诉内核为此套接字创建两个队列（具体实现可能有所不同，但概念如此）：
  1. 未完成连接队列 (incomplete connection queue)：存放那些正在执行 TCP 三次握手但尚未完成的连接请求。
  2. 已完成连接队列 (completed connection queue)：存放那些已经完成 TCP 三次握手、等待服务器程序通过 accept 接受的连接。
• 限制队列长度: backlog 参数用于提示内核这两个队列的最大总长度。当队列满时，新的连接请求可能会被忽略或拒绝。

4. 参数

• int sockfd: 这是一个已经成功调用 bind 的套接字文件描述符。
  • 必须是面向连接的套接字，如 SOCK_STREAM (TCP)。
  • 不能是无连接的套接字，如 SOCK_DGRAM (UDP)。对 UDP 套接字调用 listen 会失败。
• int backlog: 这个参数用于指定连接请求队列的最大长度。
  • 它告诉内核，最多允许多少个已完成（或接近完成）的连接请求在此套接字上排队等待 accept。
  • 实际队列长度: 内核可能会将这个值视为一个提示，并可能根据系统资源或配置将其调整为一个不同的、通常是不超过 SOMAXCONN 的值。SOMAXCONN 是系统定义的最大队列长度（在 Linux 上通常是 128 或 4096）。
  • 选择合适的值:
    • 过小: 可能导致客户端连接被拒绝（ECONNREFUSED），特别是在高并发场景下。
    • 过大: 可能消耗过多内核资源。
    • 常见做法: 传统上使用 5 (#define LISTENQ 5)。现代高性能服务器可能会设置一个更大的值，如 128 或 1024。#define LISTENQ 1024 是一个常用的较大值。
    • 现代建议: 可以直接使用 SOMAXCONN 常量，让系统决定最大值。

5. 返回值

• 成功时: 返回 0。套接字 sockfd 现在处于监听状态。
• 失败时: 返回 -1，并设置全局变量 errno 来指示具体的错误原因（例如 EADDRINUSE 本地地址已被使用，EBADF sockfd 无效，EINVAL 套接字未绑定或不支持监听，ENOMEM 内存不足等）。

6. 相似函数，或关联函数

• socket: 创建套接字。
• bind: 将套接字绑定到本地地址，是 listen 的前置步骤。
• accept: 从 listen 创建的已完成连接队列中取出一个连接，是 listen 的后续步骤。
• connect: 客户端使用此函数向监听的服务器发起连接请求。

7. 示例代码

示例 1：标准的 TCP 服务器 socket -> bind -> listen 流程

这个例子演示了设置一个 TCP 服务器的标准三步流程。

// tcp_listen_server.c
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define PORT 8088
// 使用 SOMAXCONN 作为 backlog，让系统选择合适的最大队列长度
#define BACKLOG SOMAXCONN
// 或者使用一个自定义值，如 #define BACKLOG 128

int main() {
    int server_fd;
    struct sockaddr_in address;
    int opt = 1;

    // 1. 创建套接字 (第一步)
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }
    printf("Step 1: Socket created successfully (fd: %d)\n", server_fd);

    // 2. 设置套接字选项
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) {
        perror("setsockopt failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    // 3. 配置服务器地址结构
    memset(&address, 0, sizeof(address));
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    // 4. 绑定套接字到地址和端口 (第二步)
    printf("Step 2: Binding socket to port %d...\n", PORT);
    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("bind failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }
    printf("Socket bound successfully to 0.0.0.0:%d\n", PORT);

    // 5. 使套接字进入监听状态 (第三步，关键)
    printf("Step 3: Putting socket into listening mode with backlog %d...\n", BACKLOG);
    if (listen(server_fd, BACKLOG) < 0) {
        perror("listen failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }
    printf("Server is now LISTENING on port %d with backlog %d.\n", PORT, BACKLOG);

    printf("\nServer setup complete. Waiting for connections...\n");
    printf("Run a client to connect, e.g., 'telnet localhost %d' or 'nc localhost %d'\n", PORT, PORT);

    // --- 服务器已准备好，可以调用 accept() 来接受连接 ---
    // 按 Ctrl+C 退出程序
    pause(); // 永久挂起，直到收到信号

    close(server_fd);
    printf("Server socket closed.\n");
    return 0;
}

代码解释:

1. 创建套接字: socket(AF_INET, SOCK_STREAM, 0) 创建一个 IPv4 TCP 套接字。
2. 设置选项: setsockopt(... SO_REUSEADDR ...) 设置地址重用选项。
3. 绑定地址: bind(...) 将套接字绑定到所有接口 (INADDR_ANY) 的 PORT 端口。
4. **监听连接 **(关键步骤) 调用 listen(server_fd, BACKLOG)。
   • server_fd: 要监听的套接字。
   • BACKLOG: 连接队列的最大长度。这里使用 SOMAXCONN，让系统决定。
5. 调用成功后，服务器套接字进入监听状态。内核开始为该套接字维护连接请求队列。
6. 程序挂起，等待客户端连接。实际的连接处理需要在后续调用 accept()。

示例 2：演示 listen 失败的情况

这个例子演示了在错误的情况下调用 listen 会发生什么。

// listen_failures.c
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    int sock;

    // --- 情况 1: 对未绑定的套接字调用 listen ---
    printf("--- Test 1: listen() on an unbound socket ---\n");
    sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock < 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    if (listen(sock, 5) < 0) {
        perror("listen on unbound socket failed (expected)");
        // 这通常会失败，errno 为 EINVAL
    } else {
        printf("listen on unbound socket unexpectedly succeeded.\n");
    }
    close(sock);

    // --- 情况 2: 对 UDP 套接字调用 listen ---
    printf("\n--- Test 2: listen() on a UDP socket ---\n");
    sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock < 0) {
        perror("UDP socket failed");
        exit(EXIT_FAILURE);
    }

    if (listen(sock, 5) < 0) {
        perror("listen on UDP socket failed (expected)");
        // 这会失败，errno 通常为 EOPNOTSUPP (Operation not supported)
    } else {
        printf("listen on UDP socket unexpectedly succeeded.\n");
    }
    close(sock);

    // --- 情况 3: 对已关闭的套接字调用 listen ---
    printf("\n--- Test 3: listen() on a closed socket ---\n");
    sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock < 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }
    close(sock); // 先关闭

    if (listen(sock, 5) < 0) {
        perror("listen on closed socket failed (expected)");
        // 这会失败，errno 通常为 EBADF (Bad file descriptor)
    } else {
        printf("listen on closed socket unexpectedly succeeded.\n");
    }

    printf("\nAll failure tests completed.\n");
    return 0;
}

代码解释:

1. 测试 1: 创建一个 TCP 套接字后不调用 bind，直接调用 listen。这会失败，通常 errno 为 EINVAL（Invalid argument）。
2. 测试 2: 创建一个 UDP (SOCK_DGRAM) 套接字，然后调用 listen。这会失败，通常 errno 为 EOPNOTSUPP（Operation not supported）。
3. 测试 3: 创建一个套接字，调用 close 关闭它，然后再调用 listen。这会失败，通常 errno 为 EBADF（Bad file descriptor）。

示例 3：listen 与 accept 的结合使用

这个例子将 listen 和 accept 结合起来，展示一个完整的、但简化的服务器循环。

// listen_accept_demo.c
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h> // inet_ntoa

#define PORT 8089
#define BACKLOG 10

void handle_client(int client_fd, struct sockaddr_in *client_addr) {
    printf("Handling client %s:%d (fd: %d)\n",
           inet_ntoa(client_addr->sin_addr), ntohs(client_addr->sin_port), client_fd);
    // 在实际应用中，这里会进行数据读写
    // 为了演示，我们立即关闭连接
    close(client_fd);
    printf("Closed connection to client %s:%d\n",
           inet_ntoa(client_addr->sin_addr), ntohs(client_addr->sin_port));
}

int main() {
    int server_fd, client_fd;
    struct sockaddr_in address, client_address;
    socklen_t client_addr_len = sizeof(client_address);
    int opt = 1;

    // 1. 创建套接字
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    // 2. 设置套接字选项
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) {
        perror("setsockopt failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    // 3. 配置并绑定地址
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("bind failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    // 4. 关键：监听连接
    if (listen(server_fd, BACKLOG) < 0) {
        perror("listen failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }
    printf("Server listening on port %d (backlog: %d)\n", PORT, BACKLOG);

    printf("Accepting connections for 10 seconds...\n");

    // 5. 循环接受连接 (只接受几个演示)
    time_t start_time = time(NULL);
    int connections_handled = 0;
    while (difftime(time(NULL), start_time) < 10.0) {
        // accept 是阻塞调用，会等待直到有连接或出错
        client_fd = accept(server_fd, (struct sockaddr *)&client_address, &client_addr_len);
        if (client_fd < 0) {
            perror("accept failed");
            continue;
        }

        connections_handled++;
        printf("New connection #%d accepted.\n", connections_handled);
        handle_client(client_fd, &client_address);

        // 简单限制演示连接数
        if (connections_handled >= 3) {
            break;
        }
    }

    printf("Handled %d connections in 10 seconds. Shutting down.\n", connections_handled);
    close(server_fd);
    return 0;
}

如何测试:

1. 编译并运行服务器：gcc -o listen_accept_demo listen_accept_demo.c ./listen_accept_demo
2. 在另一个或多个终端中，快速运行客户端命令：telnet localhost 8089 # 或者 nc localhost 8089

代码解释:

1. 执行标准的 socket -> setsockopt -> bind -> listen 流程。
2. 进入一个循环，持续调用 accept(server_fd, ...)。
3. accept 是一个阻塞调用。如果没有待处理的连接，程序会在此处挂起等待。
4. 当有客户端连接请求到达并完成三次握手后，accept 会从已完成连接队列中取出该连接，返回一个新的文件描述符 client_fd，专门用于与该客户端通信。
5. 调用 handle_client 函数（这里只是简单地打印信息并关闭连接）。
6. 主循环继续调用 accept，处理下一个连接。

重要提示与注意事项:

1. 顺序至关重要: 必须严格按照 socket() -> bind() -> listen() -> accept() 的顺序进行。
2. 仅用于面向连接的套接字: listen 只能用于 SOCK_STREAM (TCP) 类型的套接字。对 SOCK_DGRAM (UDP) 调用会失败。
3. backlog 的含义: 理解 backlog 是队列长度的提示，而不是严格保证。内核可能会调整它。对于高并发服务器，设置一个较大的 backlog 是明智的。
4. accept 是关键: listen 只是设置了监听状态和队列，真正接受连接的操作是由 accept 完成的。
5. 错误处理: 始终检查 listen 的返回值。最常见的错误是 EINVAL（套接字未绑定）和 EOPNOTSUPP（套接字类型不支持）。
6. 队列溢出: 如果连接请求的速度超过了服务器 accept 的速度，且队列已满，新的连接请求可能会被内核丢弃，客户端会收到连接被拒（ECONNREFUSED）的错误。

总结:

listen 是 TCP 服务器编程模型的核心组件之一。它将一个绑定好的套接字转变为可以接收连接请求的状态，并由内核管理一个连接队列。理解其作用和参数（特别是 backlog）对于构建能够处理并发连接请求的服务器至关重要。它是连接 bind 和 accept 的桥梁。

open_by_handle_at 函数详解

1. 函数介绍

open_by_handle_at 是 Linux 系统中用于通过文件句柄打开文件的系统调用。可以把文件句柄想象成”文件的身份证号码”，而 open_by_handle_at 就是通过这个”身份证号码”来访问文件的工具。

与传统的通过路径名打开文件不同，open_by_handle_at 不依赖于文件路径，即使文件被移动、重命名或删除后恢复，只要文件系统支持，仍然可以通过句柄访问文件。这就像你通过身份证号码在任何地方都能找到一个人一样。

2. 函数原型

#define _GNU_SOURCE
#include <fcntl.h>

int open_by_handle_at(int mount_fd, struct file_handle *handle, int flags);

3. 功能

open_by_handle_at 函数用于通过文件句柄打开文件，返回一个文件描述符，可以像普通文件一样进行读写操作。

4. 参数

• mount_fd: 挂载点文件描述符
  • 可以是任何该文件系统中的文件描述符
  • 通常使用 AT_FDCWD 表示当前工作目录
  • 也可以是该文件系统根目录的文件描述符
• handle: 指向 file_handle 结构体的指针
  • 包含之前通过 name_to_handle_at 获取的文件句柄
• flags: 文件打开标志
  • O_RDONLY: 只读打开
  • O_WRONLY: 只写打开
  • O_RDWR: 读写打开
  • O_CREAT, O_TRUNC 等标志不适用（文件必须已存在）

5. file_handle 结构体

struct file_handle {
    unsigned int  handle_bytes;   /* 句柄数据的字节数 */
    int           handle_type;    /* 句柄类型 */
    unsigned char f_handle[0];    /* 句柄数据（变长数组）*/
};

6. 返回值

• 成功: 返回文件描述符（非负整数）
• 失败: 返回 -1，并设置相应的 errno 错误码

7. 常见错误码

• EACCES: 权限不足
• EBADF: mount_fd 不是有效的文件描述符
• EFAULT: handle 指针无效
• EINVAL: 参数无效（如 handle 为 NULL 或 flags 无效）
• EMFILE: 进程文件描述符过多
• ENFILE: 系统文件描述符过多
• ENOMEM: 内存不足
• ENOSPC: 磁盘空间不足（写操作）
• ENOTDIR: mount_fd 不是目录
• EOPNOTSUPP: 文件系统不支持文件句柄
• ESTALE: 文件句柄已失效（文件可能已被删除）

8. 相似函数或关联函数

• name_to_handle_at: 获取文件句柄
• open/openat: 通过路径名打开文件
• openat2: 增强版的 openat
• fstat: 通过文件描述符获取文件状态
• read/write: 文件读写操作

9. 示例代码

示例1：基础用法 – 通过句柄打开文件

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <string.h>

// 创建测试文件
int create_test_file(const char *filename) {
    int fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd == -1) {
        perror("创建测试文件失败");
        return -1;
    }
    
    const char *content = "这是测试文件的内容\n用于演示通过句柄打开文件的功能\n";
    ssize_t bytes_written = write(fd, content, strlen(content));
    if (bytes_written == -1) {
        perror("写入文件失败");
        close(fd);
        return -1;
    }
    
    printf("创建测试文件: %s (写入 %zd 字节)\n", filename, bytes_written);
    close(fd);
    return 0;
}

// 获取文件句柄
int get_file_handle(const char *filename, struct file_handle **handle, int *mount_id) {
    size_t handle_size = sizeof(struct file_handle);
    *handle = malloc(handle_size);
    if (!*handle) {
        perror("内存分配失败");
        return -1;
    }
    
    (*handle)->handle_bytes = 0;
    
    int result = name_to_handle_at(AT_FDCWD, filename, *handle, mount_id, 0);
    if (result == -1 && errno == EOVERFLOW) {
        handle_size = sizeof(struct file_handle) + (*handle)->handle_bytes;
        free(*handle);
        
        *handle = malloc(handle_size);
        if (!*handle) {
            perror("内存分配失败");
            return -1;
        }
        
        result = name_to_handle_at(AT_FDCWD, filename, *handle, mount_id, 0);
    }
    
    return result;
}

// 通过句柄打开文件
int open_file_by_handle(struct file_handle *handle, int flags) {
    printf("通过句柄打开文件 (标志: 0x%x)...\n", flags);
    
    int fd = open_by_handle_at(AT_FDCWD, handle, flags);
    if (fd != -1) {
        printf("✓ 成功打开文件，文件描述符: %d\n", fd);
        
        // 获取文件信息
        struct stat st;
        if (fstat(fd, &st) == 0) {
            printf("  文件大小: %ld 字节\n", (long)st.st_size);
            printf("  修改时间: %s", ctime(&st.st_mtime));
            printf("  权限: %o\n", st.st_mode & 0777);
        }
        
        return fd;
    } else {
        printf("✗ 打开文件失败: %s\n", strerror(errno));
        return -1;
    }
}

// 读取文件内容
int read_file_content(int fd) {
    char buffer[256];
    ssize_t bytes_read = read(fd, buffer, sizeof(buffer) - 1);
    
    if (bytes_read > 0) {
        buffer[bytes_read] = '\0';
        printf("读取到的内容 (%zd 字节):\n%s", bytes_read, buffer);
        return 0;
    } else if (bytes_read == 0) {
        printf("文件为空\n");
        return 0;
    } else {
        perror("读取文件失败");
        return -1;
    }
}

int main() {
    const char *test_file = "handle_open_test.txt";
    struct file_handle *handle = NULL;
    int mount_id;
    int fd;
    
    printf("=== open_by_handle_at 基础示例 ===\n\n");
    
    // 创建测试文件
    if (create_test_file(test_file) == -1) {
        return 1;
    }
    
    // 获取文件句柄
    printf("\n1. 获取文件句柄:\n");
    if (get_file_handle(test_file, &handle, &mount_id) == 0) {
        printf("  ✓ 成功获取文件句柄\n");
        printf("  挂载 ID: %d\n", mount_id);
        printf("  句柄类型: %d\n", handle->handle_type);
        printf("  句柄大小: %u 字节\n", handle->handle_bytes);
    } else {
        printf("  ✗ 获取文件句柄失败: %s\n", strerror(errno));
        unlink(test_file);
        return 1;
    }
    
    // 通过句柄以只读方式打开文件
    printf("\n2. 通过句柄以只读方式打开文件:\n");
    fd = open_file_by_handle(handle, O_RDONLY);
    if (fd != -1) {
        read_file_content(fd);
        close(fd);
    }
    
    // 通过句柄以读写方式打开文件
    printf("\n3. 通过句柄以读写方式打开文件:\n");
    fd = open_file_by_handle(handle, O_RDWR);
    if (fd != -1) {
        printf("  向文件追加内容...\n");
        const char *append_content = "追加的内容\n";
        lseek(fd, 0, SEEK_END);  // 移动到文件末尾
        ssize_t bytes_written = write(fd, append_content, strlen(append_content));
        if (bytes_written > 0) {
            printf("  ✓ 成功追加 %zd 字节\n", bytes_written);
        }
        
        // 重新读取文件内容
        printf("  重新读取文件内容:\n");
        lseek(fd, 0, SEEK_SET);  // 移动到文件开头
        read_file_content(fd);
        
        close(fd);
    }
    
    // 测试错误情况
    printf("\n4. 测试错误情况:\n");
    printf("  尝试使用无效句柄打开文件:\n");
    struct file_handle invalid_handle = {0};
    int invalid_fd = open_by_handle_at(AT_FDCWD, &invalid_handle, O_RDONLY);
    if (invalid_fd == -1) {
        printf("    ✓ 正确处理无效句柄: %s\n", strerror(errno));
    }
    
    // 清理资源
    if (handle) {
        free(handle);
    }
    unlink(test_file);
    
    printf("\n=== 文件句柄打开特点 ===\n");
    printf("1. 路径无关: 不依赖文件路径名\n");
    printf("2. 持久性: 文件移动后仍可访问\n");
    printf("3. 安全性: 防止路径遍历攻击\n");
    printf("4. 唯一性: 每个文件有唯一句柄\n");
    printf("5. 系统级: 由内核维护，无法伪造\n");
    printf("\n");
    printf("使用场景:\n");
    printf("1. 文件监控系统\n");
    printf("2. 备份和同步工具\n");
    printf("3. 容器文件系统\n");
    printf("4. 网络文件传输\n");
    printf("5. 安全文件访问\n");
    
    return 0;
}

示例2：文件句柄的持久性和安全性

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <string.h>
#include <time.h>

// 文件信息结构体
struct persistent_file {
    char original_name[256];
    char current_name[256];
    struct file_handle *handle;
    int mount_id;
    time_t create_time;
};

// 创建测试文件
int create_test_file_with_content(const char *filename, const char *content) {
    int fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd == -1) {
        perror("创建测试文件失败");
        return -1;
    }
    
    ssize_t bytes_written = write(fd, content, strlen(content));
    if (bytes_written == -1) {
        perror("写入文件失败");
        close(fd);
        return -1;
    }
    
    printf("创建测试文件: %s (%zd 字节)\n", filename, bytes_written);
    close(fd);
    return 0;
}

// 获取文件句柄
int get_file_handle_safe(const char *filename, struct file_handle **handle, int *mount_id) {
    size_t handle_size = sizeof(struct file_handle);
    *handle = malloc(handle_size);
    if (!*handle) {
        return -1;
    }
    
    (*handle)->handle_bytes = 0;
    
    int result = name_to_handle_at(AT_FDCWD, filename, *handle, mount_id, 0);
    if (result == -1 && errno == EOVERFLOW) {
        handle_size = sizeof(struct file_handle) + (*handle)->handle_bytes;
        free(*handle);
        
        *handle = malloc(handle_size);
        if (!*handle) {
            return -1;
        }
        
        result = name_to_handle_at(AT_FDCWD, filename, *handle, mount_id, 0);
    }
    
    return result;
}

// 通过句柄安全地打开文件
int open_file_by_handle_safe(struct file_handle *handle, int flags, const char *description) {
    printf("通过句柄打开文件: %s\n", description ? description : "未知文件");
    
    int fd = open_by_handle_at(AT_FDCWD, handle, flags);
    if (fd != -1) {
        printf("  ✓ 成功打开文件 (fd: %d)\n", fd);
        return fd;
    } else {
        printf("  ✗ 打开文件失败: %s\n", strerror(errno));
        return -1;
    }
}

// 读取并验证文件内容
int verify_file_content(int fd, const char *expected_content, const char *description) {
    if (lseek(fd, 0, SEEK_SET) == -1) {
        perror("定位文件开头失败");
        return -1;
    }
    
    char *buffer = malloc(strlen(expected_content) + 1);
    if (!buffer) {
        perror("内存分配失败");
        return -1;
    }
    
    ssize_t bytes_read = read(fd, buffer, strlen(expected_content));
    if (bytes_read > 0) {
        buffer[bytes_read] = '\0';
        printf("  %s内容验证: ", description ? description : "");
        if (strcmp(buffer, expected_content) == 0) {
            printf("通过 ✓\n");
            free(buffer);
            return 0;
        } else {
            printf("失败 ✗\n");
            printf("    期望: %s", expected_content);
            printf("    实际: %s", buffer);
            free(buffer);
            return -1;
        }
    } else {
        perror("读取文件失败");
        free(buffer);
        return -1;
    }
}

int main() {
    struct persistent_file file_info;
    const char *original_name = "persistent_original.txt";
    const char *renamed_name = "persistent_renamed.txt";
    const char *content = "这是持久化文件的内容\n创建时间: ";
    
    printf("=== 文件句柄持久性和安全性示例 ===\n\n");
    
    // 构造带时间戳的内容
    char full_content[512];
    time_t now = time(NULL);
    snprintf(full_content, sizeof(full_content), "%s%s", content, ctime(&now));
    
    // 创建测试文件
    printf("1. 创建测试文件:\n");
    if (create_test_file_with_content(original_name, full_content) == -1) {
        return 1;
    }
    
    strncpy(file_info.original_name, original_name, sizeof(file_info.original_name) - 1);
    file_info.original_name[sizeof(file_info.original_name) - 1] = '\0';
    file_info.create_time = now;
    
    // 获取文件句柄
    printf("\n2. 获取文件句柄:\n");
    if (get_file_handle_safe(original_name, &file_info.handle, &file_info.mount_id) == 0) {
        printf("  ✓ 成功获取文件句柄\n");
        printf("  挂载 ID: %d\n", file_info.mount_id);
        printf("  句柄大小: %u 字节\n", file_info.handle->handle_bytes);
    } else {
        printf("  ✗ 获取文件句柄失败: %s\n", strerror(errno));
        unlink(original_name);
        return 1;
    }
    
    // 通过句柄访问原始文件
    printf("\n3. 通过句柄访问原始文件:\n");
    int fd = open_file_by_handle_safe(file_info.handle, O_RDONLY, "原始文件");
    if (fd != -1) {
        if (verify_file_content(fd, full_content, "原始文件") == 0) {
            printf("  ✓ 原始文件内容验证通过\n");
        }
        close(fd);
    }
    
    // 重命名文件
    printf("\n4. 重命名文件 (模拟文件移动):\n");
    if (rename(original_name, renamed_name) == 0) {
        printf("  ✓ 成功重命名文件: %s -> %s\n", original_name, renamed_name);
        strncpy(file_info.current_name, renamed_name, sizeof(file_info.current_name) - 1);
        file_info.current_name[sizeof(file_info.current_name) - 1] = '\0';
    } else {
        printf("  ✗ 重命名文件失败: %s\n", strerror(errno));
        free(file_info.handle);
        unlink(original_name);
        return 1;
    }
    
    // 通过句柄访问重命名后的文件
    printf("\n5. 通过句柄访问重命名后的文件:\n");
    fd = open_file_by_handle_safe(file_info.handle, O_RDONLY, "重命名后的文件");
    if (fd != -1) {
        if (verify_file_content(fd, full_content, "重命名文件") == 0) {
            printf("  ✓ 重命名文件内容验证通过\n");
            printf("  ✓ 证明: 文件句柄不受文件名变化影响\n");
        }
        close(fd);
    }
    
    // 创建符号链接并测试
    printf("\n6. 创建符号链接测试:\n");
    const char *symlink_name = "persistent_symlink.txt";
    if (symlink(renamed_name, symlink_name) == 0) {
        printf("  ✓ 创建符号链接: %s -> %s\n", symlink_name, renamed_name);
        
        // 获取符号链接的句柄
        struct file_handle *symlink_handle = NULL;
        int symlink_mount_id;
        if (get_file_handle_safe(symlink_name, &symlink_handle, &symlink_mount_id) == 0) {
            printf("  ✓ 获取符号链接句柄成功\n");
            
            // 通过符号链接句柄打开
            fd = open_file_by_handle_safe(symlink_handle, O_RDONLY, "符号链接");
            if (fd != -1) {
                if (verify_file_content(fd, full_content, "符号链接") == 0) {
                    printf("  ✓ 符号链接内容验证通过\n");
                }
                close(fd);
            }
            free(symlink_handle);
        }
        unlink(symlink_name);
    }
    
    // 测试不同打开标志
    printf("\n7. 测试不同打开标志:\n");
    
    // 只读打开
    printf("  只读打开 (O_RDONLY):\n");
    fd = open_file_by_handle_safe(file_info.handle, O_RDONLY, "只读模式");
    if (fd != -1) {
        printf("    ✓ 只读打开成功\n");
        close(fd);
    }
    
    // 读写打开
    printf("  读写打开 (O_RDWR):\n");
    fd = open_file_by_handle_safe(file_info.handle, O_RDWR, "读写模式");
    if (fd != -1) {
        printf("    ✓ 读写打开成功\n");
        close(fd);
    }
    
    // 只写打开
    printf("  只写打开 (O_WRONLY):\n");
    fd = open_file_by_handle_safe(file_info.handle, O_WRONLY, "只写模式");
    if (fd != -1) {
        printf("    ✓ 只写打开成功\n");
        close(fd);
    }
    
    // 尝试写入只读打开的文件
    printf("  测试写入权限:\n");
    fd = open_file_by_handle_safe(file_info.handle, O_RDONLY, "只读模式测试写入");
    if (fd != -1) {
        const char *test_write = "测试写入";
        ssize_t write_result = write(fd, test_write, strlen(test_write));
        if (write_result == -1) {
            printf("    ✓ 正确拒绝写入操作: %s\n", strerror(errno));
        } else {
            printf("    ✗ 意外允许写入操作\n");
        }
        close(fd);
    }
    
    // 清理资源
    printf("\n8. 清理资源:\n");
    free(file_info.handle);
    unlink(renamed_name);
    printf("  ✓ 清理完成\n");
    
    printf("\n=== 文件句柄安全性和持久性总结 ===\n");
    printf("安全性优势:\n");
    printf("1. 路径无关: 不受符号链接攻击影响\n");
    printf("2. 权限控制: 仍然遵循文件系统权限\n");
    printf("3. 系统级: 由内核维护，无法伪造\n");
    printf("4. 访问控制: 可以通过打开标志控制访问权限\n");
    printf("\n");
    printf("持久性优势:\n");
    printf("1. 文件移动: 重命名后句柄仍然有效\n");
    printf("2. 目录重组: 目录结构调整不影响句柄\n");
    printf("3. 跨会话: 可以在不同进程间传递\n");
    printf("4. 稳定标识: 提供稳定的文件标识机制\n");
    printf("\n");
    printf("适用场景:\n");
    printf("1. 文件监控和审计\n");
    printf("2. 备份和同步系统\n");
    printf("3. 容器文件系统\n");
    printf("4. 网络文件传输\n");
    printf("5. 安全文件访问控制\n");
    
    return 0;
}

示例3：完整的文件句柄管理工具

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <string.h>
#include <getopt.h>
#include <time.h>

// 配置结构体
struct handle_tool_config {
    char *filename;
    char *handle_file;
    int create_handle;
    int open_file;
    int show_info;
    int verbose;
    int flags;
    char *output_file;
};

// 保存文件句柄到文件
int save_handle_to_file(const struct file_handle *handle, int mount_id, const char *filename) {
    FILE *fp = fopen(filename, "wb");
    if (!fp) {
        perror("打开句柄文件失败");
        return -1;
    }
    
    // 写入挂载 ID
    if (fwrite(&mount_id, sizeof(mount_id), 1, fp) != 1) {
        perror("写入挂载 ID 失败");
        fclose(fp);
        return -1;
    }
    
    // 写入句柄大小
    if (fwrite(&handle->handle_bytes, sizeof(handle->handle_bytes), 1, fp) != 1) {
        perror("写入句柄大小失败");
        fclose(fp);
        return -1;
    }
    
    // 写入句柄类型
    if (fwrite(&handle->handle_type, sizeof(handle->handle_type), 1, fp) != 1) {
        perror("写入句柄类型失败");
        fclose(fp);
        return -1;
    }
    
    // 写入句柄数据
    if (fwrite(handle->f_handle, handle->handle_bytes, 1, fp) != 1) {
        perror("写入句柄数据失败");
        fclose(fp);
        return -1;
    }
    
    fclose(fp);
    printf("✓ 句柄已保存到: %s\n", filename);
    return 0;
}

// 从文件加载文件句柄
struct file_handle* load_handle_from_file(const char *filename, int *mount_id) {
    FILE *fp = fopen(filename, "rb");
    if (!fp) {
        perror("打开句柄文件失败");
        return NULL;
    }
    
    // 读取挂载 ID
    if (fread(mount_id, sizeof(*mount_id), 1, fp) != 1) {
        perror("读取挂载 ID 失败");
        fclose(fp);
        return NULL;
    }
    
    // 读取句柄大小
    unsigned int handle_bytes;
    if (fread(&handle_bytes, sizeof(handle_bytes), 1, fp) != 1) {
        perror("读取句柄大小失败");
        fclose(fp);
        return NULL;
    }
    
    // 分配句柄内存
    size_t handle_size = sizeof(struct file_handle) + handle_bytes;
    struct file_handle *handle = malloc(handle_size);
    if (!handle) {
        perror("内存分配失败");
        fclose(fp);
        return NULL;
    }
    
    handle->handle_bytes = handle_bytes;
    
    // 读取句柄类型
    if (fread(&handle->handle_type, sizeof(handle->handle_type), 1, fp) != 1) {
        perror("读取句柄类型失败");
        free(handle);
        fclose(fp);
        return NULL;
    }
    
    // 读取句柄数据
    if (fread(handle->f_handle, handle_bytes, 1, fp) != 1) {
        perror("读取句柄数据失败");
        free(handle);
        fclose(fp);
        return NULL;
    }
    
    fclose(fp);
    printf("✓ 从 %s 加载句柄成功\n", filename);
    return handle;
}

// 获取文件句柄
int get_file_handle_safe(const char *filename, struct file_handle **handle, int *mount_id) {
    size_t handle_size = sizeof(struct file_handle);
    *handle = malloc(handle_size);
    if (!*handle) {
        return -1;
    }
    
    (*handle)->handle_bytes = 0;
    
    int result = name_to_handle_at(AT_FDCWD, filename, *handle, mount_id, 0);
    if (result == -1 && errno == EOVERFLOW) {
        handle_size = sizeof(struct file_handle) + (*handle)->handle_bytes;
        free(*handle);
        
        *handle = malloc(handle_size);
        if (!*handle) {
            return -1;
        }
        
        result = name_to_handle_at(AT_FDCWD, filename, *handle, mount_id, 0);
    }
    
    return result;
}

// 通过句柄打开文件
int open_file_by_handle_safe(struct file_handle *handle, int flags, const char *description) {
    if (description) {
        printf("通过句柄打开文件: %s\n", description);
    }
    
    int fd = open_by_handle_at(AT_FDCWD, handle, flags);
    if (fd != -1) {
        if (description) {
            printf("  ✓ 成功打开文件 (fd: %d)\n", fd);
        }
        return fd;
    } else {
        if (description) {
            printf("  ✗ 打开文件失败: %s\n", strerror(errno));
        }
        return -1;
    }
}

// 显示句柄信息
void show_handle_info(const struct file_handle *handle, int mount_id) {
    printf("=== 文件句柄信息 ===\n");
    printf("挂载 ID: %d\n", mount_id);
    printf("句柄类型: %d\n", handle->handle_type);
    printf("句柄大小: %u 字节\n", handle->handle_bytes);
    
    printf("句柄数据 (十六进制): ");
    for (unsigned int i = 0; i < handle->handle_bytes && i < 64; i++) {
        printf("%02x", handle->f_handle[i]);
    }
    if (handle->handle_bytes > 64) {
        printf("...(还有 %u 字节)", handle->handle_bytes - 64);
    }
    printf("\n");
}

// 复制文件内容
int copy_file_content(int src_fd, const char *output_filename) {
    int dst_fd = open(output_filename, O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (dst_fd == -1) {
        perror("创建输出文件失败");
        return -1;
    }
    
    char buffer[4096];
    ssize_t bytes_read, bytes_written;
    off_t total_bytes = 0;
    
    while ((bytes_read = read(src_fd, buffer, sizeof(buffer))) > 0) {
        bytes_written = write(dst_fd, buffer, bytes_read);
        if (bytes_written != bytes_read) {
            perror("写入输出文件失败");
            close(dst_fd);
            return -1;
        }
        total_bytes += bytes_written;
    }
    
    if (bytes_read == -1) {
        perror("读取源文件失败");
        close(dst_fd);
        return -1;
    }
    
    close(dst_fd);
    printf("✓ 成功复制 %ld 字节到: %s\n", (long)total_bytes, output_filename);
    return 0;
}

// 显示帮助信息
void show_help(const char *program_name) {
    printf("用法: %s [选项]\n", program_name);
    printf("\n选项:\n");
    printf("  -f, --file=FILE        源文件名\n");
    printf("  -h, --handle=FILE      句柄文件名\n");
    printf("  -c, --create           创建文件句柄\n");
    printf("  -o, --open             通过句柄打开文件\n");
    printf("  -i, --info             显示句柄信息\n");
    printf("  -r, --read-only        以只读方式打开\n");
    printf("  -w, --read-write       以读写方式打开\n");
    printf("  -O, --output=FILE      输出文件名（用于复制）\n");
    printf("  -v, --verbose          详细输出\n");
    printf("  --help                 显示此帮助信息\n");
    printf("\n示例:\n");
    printf("  %s -f /etc/passwd -c -h passwd.handle    # 创建句柄\n", program_name);
    printf("  %s -h passwd.handle -o -r                # 通过句柄只读打开\n", program_name);
    printf("  %s -h passwd.handle -o -w -O copy.txt    # 通过句柄复制文件\n", program_name);
    printf("  %s -h passwd.handle -i                   # 显示句柄信息\n", program_name);
}

int main(int argc, char *argv[]) {
    struct handle_tool_config config = {
        .filename = NULL,
        .handle_file = NULL,
        .create_handle = 0,
        .open_file = 0,
        .show_info = 0,
        .verbose = 0,
        .flags = O_RDONLY,
        .output_file = NULL
    };
    
    printf("=== 文件句柄管理工具 ===\n\n");
    
    // 解析命令行参数
    static struct option long_options[] = {
        {"file",      required_argument, 0, 'f'},
        {"handle",    required_argument, 0, 'h'},
        {"create",    no_argument,       0, 'c'},
        {"open",      no_argument,       0, 'o'},
        {"info",      no_argument,       0, 'i'},
        {"read-only", no_argument,       0, 'r'},
        {"read-write", no_argument,      0, 'w'},
        {"output",    required_argument, 0, 'O'},
        {"verbose",   no_argument,       0, 'v'},
        {"help",      no_argument,       0, 1000},
        {0, 0, 0, 0}
    };
    
    int opt;
    while ((opt = getopt_long(argc, argv, "f:h:coirwO:v", long_options, NULL)) != -1) {
        switch (opt) {
            case 'f':
                config.filename = optarg;
                break;
            case 'h':
                config.handle_file = optarg;
                break;
            case 'c':
                config.create_handle = 1;
                break;
            case 'o':
                config.open_file = 1;
                break;
            case 'i':
                config.show_info = 1;
                break;
            case 'r':
                config.flags = O_RDONLY;
                break;
            case 'w':
                config.flags = O_RDWR;
                break;
            case 'O':
                config.output_file = optarg;
                break;
            case 'v':
                config.verbose = 1;
                break;
            case 1000:  // --help
                show_help(argv[0]);
                return 0;
            default:
                fprintf(stderr, "使用 '%s --help' 查看帮助信息\n", argv[0]);
                return 1;
        }
    }
    
    // 验证参数
    if (!config.create_handle && !config.open_file && !config.show_info) {
        show_help(argv[0]);
        return 0;
    }
    
    struct file_handle *handle = NULL;
    int mount_id;
    
    // 如果需要创建句柄
    if (config.create_handle && config.filename) {
        if (access(config.filename, F_OK) != 0) {
            fprintf(stderr, "文件不存在: %s\n", config.filename);
            return 1;
        }
        
        printf("创建文件句柄: %s\n", config.filename);
        
        if (get_file_handle_safe(config.filename, &handle, &mount_id) == 0) {
            printf("✓ 成功获取文件句柄\n");
            
            if (config.show_info) {
                show_handle_info(handle, mount_id);
            }
            
            if (config.handle_file) {
                if (save_handle_to_file(handle, mount_id, config.handle_file) == 0) {
                    printf("✓ 句柄保存成功\n");
                } else {
                    fprintf(stderr, "句柄保存失败\n");
                    free(handle);
                    return 1;
                }
            }
        } else {
            fprintf(stderr, "获取文件句柄失败: %s\n", strerror(errno));
            return 1;
        }
    }
    // 如果需要加载句柄
    else if (config.handle_file) {
        if (access(config.handle_file, F_OK) != 0) {
            fprintf(stderr, "句柄文件不存在: %s\n", config.handle_file);
            return 1;
        }
        
        handle = load_handle_from_file(config.handle_file, &mount_id);
        if (!handle) {
            return 1;
        }
        
        if (config.show_info) {
            show_handle_info(handle, mount_id);
        }
    } else {
        fprintf(stderr, "需要指定文件或句柄文件\n");
        show_help(argv[0]);
        return 1;
    }
    
    // 通过句柄打开文件
    if (config.open_file && handle) {
        int fd = open_file_by_handle_safe(handle, config.flags, 
                                         config.filename ? config.filename : "加载的句柄");
        if (fd != -1) {
            printf("✓ 文件打开成功\n");
            
            // 获取文件信息
            struct stat st;
            if (fstat(fd, &st) == 0) {
                printf("文件信息:\n");
                printf("  大小: %ld 字节\n", (long)st.st_size);
                printf("  权限: %o\n", st.st_mode & 0777);
                printf("  修改时间: %s", ctime(&st.st_mtime));
            }
            
            // 如果指定了输出文件，复制内容
            if (config.output_file) {
                if (copy_file_content(fd, config.output_file) != 0) {
                    close(fd);
                    free(handle);
                    return 1;
                }
            }
            // 否则显示部分内容
            else if (config.flags & (O_RDONLY | O_RDWR)) {
                printf("文件内容预览:\n");
                char buffer[512];
                ssize_t bytes_read = read(fd, buffer, sizeof(buffer) - 1);
                if (bytes_read > 0) {
                    buffer[bytes_read] = '\0';
                    // 只显示前 200 个字符
                    if (strlen(buffer) > 200) {
                        buffer[200] = '\0';
                        printf("%s...\n", buffer);
                    } else {
                        printf("%s\n", buffer);
                    }
                }
            }
            
            close(fd);
        } else {
            free(handle);
            return 1;
        }
    }
    
    // 清理资源
    if (handle) {
        free(handle);
    }
    
    printf("\n=== 文件句柄工具使用建议 ===\n");
    printf("适用场景:\n");
    printf("1. 文件监控和审计系统\n");
    printf("2. 备份和同步工具\n");
    printf("3. 容器和虚拟化环境\n");
    printf("4. 网络文件传输\n");
    printf("5. 安全文件访问控制\n");
    printf("\n");
    printf("安全建议:\n");
    printf("1. 妥善保管句柄文件\n");
    printf("2. 使用适当的文件权限\n");
    printf("3. 验证句柄的有效性\n");
    printf("4. 及时关闭文件描述符\n");
    printf("5. 处理句柄失效的情况\n");
    printf("\n");
    printf("性能优化:\n");
    printf("1. 批量处理多个文件\n");
    printf("2. 缓存常用文件句柄\n");
    printf("3. 异步操作大文件\n");
    printf("4. 合理设置缓冲区大小\n");
    
    return 0;
}

编译和运行说明

# 编译示例程序
gcc -o open_by_handle_at_example1 example1.c
gcc -o open_by_handle_at_example2 example2.c
gcc -o open_by_handle_at_example3 example3.c

# 运行示例
./open_by_handle_at_example1
./open_by_handle_at_example2
./open_by_handle_at_example3 --help

# 基本操作示例
./open_by_handle_at_example3 -f /etc/passwd -c -h passwd.handle
./open_by_handle_at_example3 -h passwd.handle -o -r
./open_by_handle_at_example3 -h passwd.handle -i
./open_by_handle_at_example3 -h passwd.handle -o -w -O passwd_copy.txt

系统要求检查

# 检查内核版本（需要 2.6.39+）
uname -r

# 检查文件系统支持
grep -i handle /boot/config-$(uname -r)

# 检查系统调用支持
grep -w open_by_handle_at /usr/include/asm/unistd_64.h

# 查看文件系统类型
df -T /etc/passwd

# 检查当前用户权限
id

重要注意事项

1. 内核版本: 需要 Linux 2.6.39+ 内核支持
2. 文件系统: 不是所有文件系统都支持文件句柄
3. 权限要求: 需要对文件有适当访问权限
4. 错误处理: 始终检查返回值和 errno
5. 内存管理: 正确分配和释放句柄内存
6. 文件描述符: 及时关闭打开的文件描述符
7. 句柄失效: 处理文件删除导致的句柄失效

实际应用场景

1. 文件监控: 监控特定文件的变更而不依赖路径
2. 备份系统: 标识和跟踪备份文件
3. 容器技术: 容器内文件系统管理
4. 网络传输: 安全的文件标识和传输
5. 审计系统: 文件访问审计和追踪
6. 数据库系统: 文件标识和管理

最佳实践

// 安全的文件句柄打开函数
int safe_open_by_handle(struct file_handle *handle, int flags, const char *description) {
    // 验证参数
    if (!handle) {
        errno = EINVAL;
        return -1;
    }
    
    // 验证标志
    if (flags & (O_CREAT | O_EXCL | O_TRUNC)) {
        fprintf(stderr, "警告: 文件句柄打开不支持创建/截断标志\n");
        flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
    }
    
    // 打开文件
    int fd = open_by_handle_at(AT_FDCWD, handle, flags);
    if (fd == -1) {
        switch (errno) {
            case EACCES:
                fprintf(stderr, "权限不足访问文件");
                if (description) fprintf(stderr, ": %s", description);
                fprintf(stderr, "\n");
                break;
            case ESTALE:
                fprintf(stderr, "文件句柄已失效");
                if (description) fprintf(stderr, ": %s", description);
                fprintf(stderr, "\n");
                break;
            case EOPNOTSUPP:
                fprintf(stderr, "文件系统不支持文件句柄");
                if (description) fprintf(stderr, ": %s", description);
                fprintf(stderr, "\n");
                break;
        }
    } else if (description) {
        printf("通过句柄成功打开文件: %s (fd: %d)\n", description, fd);
    }
    
    return fd;
}

// 句柄管理结构体
typedef struct {
    struct file_handle *handle;
    int mount_id;
    int fd;
    char *filename;
    time_t create_time;
} handle_manager_t;

// 初始化句柄管理器
int handle_manager_init(handle_manager_t *mgr, const char *filename) {
    mgr->filename = strdup(filename);
    if (!mgr->filename) {
        return -1;
    }
    
    mgr->create_time = time(NULL);
    mgr->fd = -1;
    mgr->handle = NULL;
    
    return get_file_handle_safe(filename, &mgr->handle, &mgr->mount_id);
}

// 通过句柄打开文件
int handle_manager_open(handle_manager_t *mgr, int flags) {
    if (mgr->fd != -1) {
        close(mgr->fd);
    }
    
    mgr->fd = safe_open_by_handle(mgr->handle, flags, mgr->filename);
    return mgr->fd;
}

// 清理句柄管理器
void handle_manager_cleanup(handle_manager_t *mgr) {
    if (mgr->fd != -1) {
        close(mgr->fd);
        mgr->fd = -1;
    }
    
    if (mgr->handle) {
        free(mgr->handle);
        mgr->handle = NULL;
    }
    
    if (mgr->filename) {
        free(mgr->filename);
        mgr->filename = NULL;
    }
}

这些示例展示了 open_by_handle_at 函数的各种使用方法，从基础的句柄打开到完整的管理工具，帮助你全面掌握 Linux 系统中通过文件句柄访问文件的机制。

openat – 相对于目录文件描述符打开文件

1. 函数介绍

openat 是一个 Linux 系统调用，用于相对于指定目录文件描述符打开文件。它是 open 函数的扩展版本，提供了更灵活的文件打开方式，支持相对路径操作，避免了某些竞态条件。

2. 函数原型

#include <fcntl.h>

int openat(int dirfd, const char *pathname, int flags);
int openat(int dirfd, const char *pathname, int flags, mode_t mode);

3. 功能

相对于目录文件描述符 dirfd 打开或创建文件。如果 pathname 是相对路径，则相对于 dirfd 指定的目录解析；如果是绝对路径，则忽略 dirfd。

4. 参数

• int dirfd: 目录文件描述符
  • AT_FDCWD: 使用当前工作目录
  • 有效的目录文件描述符：相对于该目录进行操作
  • 负数：特殊值（如 AT_FDCWD）
• const char *pathname: 文件路径名
  • 绝对路径：从根目录开始
  • 相对路径：相对于 dirfd 指定的目录
• int flags: 文件打开标志
  • O_RDONLY: 只读打开
  • O_WRONLY: 只写打开
  • O_RDWR: 读写打开
  • O_CREAT: 文件不存在时创建
  • O_EXCL: 与 O_CREAT 配合使用，确保原子创建
  • O_TRUNC: 截断已存在的文件
  • O_APPEND: 追加模式
  • O_NONBLOCK: 非阻塞模式
  • O_SYNC: 同步写入
  • 等等…
• mode_t mode: 文件权限模式（当使用 O_CREAT 时必需）
  • 例如：0644, 0755 等

5. 返回值

• 成功时返回新的文件描述符（非负整数）
• 失败时返回 -1，并设置 errno

6. 常见 errno 错误码

• EACCES: 权限不足
• EEXIST: 文件已存在（使用 O_CREAT|O_EXCL 时）
• EISDIR: 路径指向目录而非文件
• ENOENT: 文件或路径不存在
• ENOTDIR: dirfd 不是目录文件描述符
• EACCES: 访问权限不足
• ELOOP: 符号链接层级过深
• ENAMETOOLONG: 路径名过长
• ENOMEM: 内存不足
• ENOSPC: 磁盘空间不足
• EROFS: 文件系统为只读

7. 相似函数，或关联函数

• open(): 传统的文件打开函数
• creat(): 创建文件（已废弃，使用 open 代替）
• close(): 关闭文件描述符
• read(), write(): 文件读写操作
• fstatat(): 相对于目录文件描述符获取文件状态
• mkdirat(): 相对于目录文件描述符创建目录
• unlinkat(): 相对于目录文件描述符删除文件
• readlinkat(): 相对于目录文件描述符读取符号链接

8. 示例代码

示例1：基本使用 – 相对路径文件操作

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <string.h>

int main() {
    printf("=== openat 基本使用演示 ===\n");
    
    // 创建测试目录结构
    if (mkdir("test_dir", 0755) == -1 && errno != EEXIST) {
        perror("创建测试目录失败");
        exit(EXIT_FAILURE);
    }
    
    printf("创建测试目录: test_dir\n");
    
    // 方法1: 使用 AT_FDCWD（当前工作目录）打开文件
    int fd1 = openat(AT_FDCWD, "test_dir/test_file1.txt", 
                     O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd1 == -1) {
        perror("使用 AT_FDCWD 创建文件失败");
        rmdir("test_dir");
        exit(EXIT_FAILURE);
    }
    
    printf("✓ 使用 AT_FDCWD 成功创建文件: test_dir/test_file1.txt (fd: %d)\n", fd1);
    
    // 写入数据
    const char *content1 = "This is test file 1 content.\n";
    write(fd1, content1, strlen(content1));
    close(fd1);
    
    // 方法2: 打开目录获取文件描述符，然后相对打开文件
    int dirfd = open("test_dir", O_RDONLY);
    if (dirfd == -1) {
        perror("打开目录失败");
        unlink("test_dir/test_file1.txt");
        rmdir("test_dir");
        exit(EXIT_FAILURE);
    }
    
    printf("✓ 成功打开目录: test_dir (dirfd: %d)\n", dirfd);
    
    // 相对于目录文件描述符创建文件
    int fd2 = openat(dirfd, "test_file2.txt", O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd2 == -1) {
        perror("相对目录创建文件失败");
        close(dirfd);
        unlink("test_dir/test_file1.txt");
        rmdir("test_dir");
        exit(EXIT_FAILURE);
    }
    
    printf("✓ 相对目录成功创建文件: test_file2.txt (fd: %d)\n", fd2);
    
    // 写入数据
    const char *content2 = "This is test file 2 content.\n";
    write(fd2, content2, strlen(content2));
    close(fd2);
    
    // 验证文件创建结果
    printf("\n验证创建的文件:\n");
    
    // 读取第一个文件
    int fd_read1 = openat(AT_FDCWD, "test_dir/test_file1.txt", O_RDONLY);
    if (fd_read1 != -1) {
        char buffer[256];
        ssize_t bytes_read = read(fd_read1, buffer, sizeof(buffer) - 1);
        if (bytes_read > 0) {
            buffer[bytes_read] = '\0';
            printf("  test_file1.txt 内容: %s", buffer);
        }
        close(fd_read1);
    }
    
    // 相对读取第二个文件
    int fd_read2 = openat(dirfd, "test_file2.txt", O_RDONLY);
    if (fd_read2 != -1) {
        char buffer[256];
        ssize_t bytes_read = read(fd_read2, buffer, sizeof(buffer) - 1);
        if (bytes_read > 0) {
            buffer[bytes_read] = '\0';
            printf("  test_file2.txt 内容: %s", buffer);
        }
        close(fd_read2);
    }
    
    // 清理资源
    close(dirfd);
    unlink("test_dir/test_file1.txt");
    unlink("test_dir/test_file2.txt");
    rmdir("test_dir");
    
    printf("✓ 完成 openat 基本使用演示\n");
    
    return 0;
}

示例2：错误处理和特殊情况

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <string.h>

void test_openat_errors(int dirfd, const char *pathname, int flags, const char *description) {
    printf("\n测试 %s:\n", description);
    printf("  dirfd: %d\n", dirfd);
    printf("  pathname: %s\n", pathname);
    printf("  flags: 0x%x\n", flags);
    
    int fd = openat(dirfd, pathname, flags);
    if (fd == -1) {
        printf("  结果: 失败 - %s\n", strerror(errno));
        switch (errno) {
            case EACCES:
                printf("    原因: 权限不足\n");
                break;
            case ENOENT:
                printf("    原因: 文件或目录不存在\n");
                break;
            case ENOTDIR:
                printf("    原因: dirfd 不是目录文件描述符\n");
                break;
            case EISDIR:
                printf("    原因: 路径指向目录\n");
                break;
            case EEXIST:
                printf("    原因: 文件已存在 (O_CREAT|O_EXCL)\n");
                break;
            case ELOOP:
                printf("    原因: 符号链接层级过深\n");
                break;
            case ENAMETOOLONG:
                printf("    原因: 路径名过长\n");
                break;
            default:
                printf("    原因: 其他错误\n");
                break;
        }
    } else {
        printf("  结果: 成功 (fd: %d)\n", fd);
        close(fd);
    }
}

int main() {
    printf("=== openat 错误处理测试 ===\n");
    
    // 创建测试环境
    if (mkdir("error_test_dir", 0755) == -1 && errno != EEXIST) {
        perror("创建测试目录失败");
        exit(EXIT_FAILURE);
    }
    
    // 创建测试文件
    int test_fd = open("error_test_dir/test_file.txt", O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (test_fd != -1) {
        write(test_fd, "test content", 12);
        close(test_fd);
        printf("创建测试文件: error_test_dir/test_file.txt\n");
    }
    
    // 打开目录获取文件描述符
    int dirfd = open("error_test_dir", O_RDONLY);
    if (dirfd == -1) {
        perror("打开测试目录失败");
        unlink("error_test_dir/test_file.txt");
        rmdir("error_test_dir");
        exit(EXIT_FAILURE);
    }
    
    printf("打开测试目录: error_test_dir (dirfd: %d)\n", dirfd);
    
    // 测试正常情况
    test_openat_errors(dirfd, "test_file.txt", O_RDONLY, "正常相对路径打开");
    test_openat_errors(AT_FDCWD, "error_test_dir/test_file.txt", O_RDONLY, "AT_FDCWD 绝对路径打开");
    
    // 测试各种错误情况
    test_openat_errors(dirfd, "nonexistent.txt", O_RDONLY, "不存在的文件");
    test_openat_errors(-2, "test_file.txt", O_RDONLY, "无效的 dirfd");
    test_openat_errors(dirfd, "../outside_file.txt", O_RDONLY, "跳出目录的路径");
    test_openat_errors(dirfd, "", O_RDONLY, "空路径名");
    
    // 测试创建已存在的文件（不使用 O_EXCL）
    test_openat_errors(dirfd, "test_file.txt", O_CREAT | O_WRONLY, "创建已存在的文件");
    
    // 测试原子创建（使用 O_EXCL）
    test_openat_errors(dirfd, "test_file.txt", O_CREAT | O_EXCL | O_WRONLY, 0644, 
                      "原子创建已存在的文件");
    
    // 测试目录作为文件打开
    test_openat_errors(AT_FDCWD, "error_test_dir", O_RDONLY, "将目录作为文件打开");
    
    // 清理测试环境
    close(dirfd);
    unlink("error_test_dir/test_file.txt");
    rmdir("error_test_dir");
    
    return 0;
}

示例3：相对路径和安全性演示

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <string.h>
#include <dirent.h>

void demonstrate_security_benefits() {
    printf("=== openat 安全性优势演示 ===\n");
    
    // 创建测试目录结构
    if (mkdir("security_test", 0755) == -1 && errno != EEXIST) {
        perror("创建安全测试目录失败");
        return;
    }
    
    // 在测试目录中创建文件
    int fd = open("security_test/data.txt", O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd != -1) {
        write(fd, "sensitive data", 14);
        close(fd);
        printf("创建敏感数据文件: security_test/data.txt\n");
    }
    
    // 打开目录获取文件描述符
    int dirfd = open("security_test", O_RDONLY);
    if (dirfd == -1) {
        perror("打开安全测试目录失败");
        unlink("security_test/data.txt");
        rmdir("security_test");
        return;
    }
    
    printf("✓ 成功打开安全目录 (dirfd: %d)\n", dirfd);
    
    // 演示安全性优势
    printf("\n安全性优势对比:\n");
    
    // 传统方式：可能受到竞态条件影响
    printf("传统方式风险:\n");
    printf("  1. 先检查文件是否存在\n");
    printf("  2. 再打开文件进行操作\n");
    printf("  3. 在步骤1和2之间，文件可能被修改\n");
    
    // openat 方式：更安全
    printf("\nopenat 方式优势:\n");
    printf("  1. 基于已打开的目录文件描述符操作\n");
    printf("  2. 避免路径解析过程中的竞态条件\n");
    printf("  3. 防止目录遍历攻击\n");
    printf("  4. 确保操作在指定目录范围内\n");
    
    // 演示相对路径限制
    printf("\n相对路径限制演示:\n");
    
    // 尝试访问上级目录（应该失败或受限）
    int restricted_fd = openat(dirfd, "../outside_file.txt", O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (restricted_fd != -1) {
        printf("  警告: 能够访问上级目录文件\n");
        close(restricted_fd);
        unlink("../outside_file.txt");
    } else {
        printf("  ✓ 正确限制了目录遍历访问\n");
    }
    
    // 正常的相对路径操作
    int normal_fd = openat(dirfd, "data.txt", O_RDONLY);
    if (normal_fd != -1) {
        char buffer[64];
        ssize_t bytes_read = read(normal_fd, buffer, sizeof(buffer) - 1);
        if (bytes_read > 0) {
            buffer[bytes_read] = '\0';
            printf("  ✓ 正常访问相对路径文件: %s\n", buffer);
        }
        close(normal_fd);
    }
    
    // 清理资源
    close(dirfd);
    unlink("security_test/data.txt");
    rmdir("security_test");
}

void demonstrate_relative_path_operations() {
    printf("\n=== 相对路径操作演示 ===\n");
    
    // 创建多层目录结构
    if (mkdir("multi_level", 0755) == -1 && errno != EEXIST) {
        perror("创建多层目录失败");
        return;
    }
    
    if (mkdir("multi_level/subdir1", 0755) == -1 && errno != EEXIST) {
        perror("创建子目录1失败");
        rmdir("multi_level");
        return;
    }
    
    if (mkdir("multi_level/subdir2", 0755) == -1 && errno != EEXIST) {
        perror("创建子目录2失败");
        rmdir("multi_level/subdir1");
        rmdir("multi_level");
        return;
    }
    
    printf("创建多层目录结构:\n");
    printf("  multi_level/\n");
    printf("    subdir1/\n");
    printf("    subdir2/\n");
    
    // 打开根目录
    int root_fd = open("multi_level", O_RDONLY);
    if (root_fd == -1) {
        perror("打开根目录失败");
        rmdir("multi_level/subdir1");
        rmdir("multi_level/subdir2");
        rmdir("multi_level");
        return;
    }
    
    printf("✓ 打开根目录 (fd: %d)\n", root_fd);
    
    // 相对于根目录在 subdir1 中创建文件
    int subdir1_fd = openat(root_fd, "subdir1", O_RDONLY);
    if (subdir1_fd != -1) {
        int file1_fd = openat(subdir1_fd, "file1.txt", O_CREAT | O_WRONLY | O_TRUNC, 0644);
        if (file1_fd != -1) {
            write(file1_fd, "Content in subdir1", 18);
            close(file1_fd);
            printf("✓ 在 subdir1 中创建文件\n");
        }
        close(subdir1_fd);
    }
    
    // 相对于根目录在 subdir2 中创建文件
    int subdir2_fd = openat(root_fd, "subdir2", O_RDONLY);
    if (subdir2_fd != -1) {
        int file2_fd = openat(subdir2_fd, "file2.txt", O_CREAT | O_WRONLY | O_TRUNC, 0644);
        if (file2_fd != -1) {
            write(file2_fd, "Content in subdir2", 18);
            close(file2_fd);
            printf("✓ 在 subdir2 中创建文件\n");
        }
        close(subdir2_fd);
    }
    
    // 验证创建的文件
    printf("\n验证创建的文件:\n");
    
    // 读取 subdir1 中的文件
    subdir1_fd = openat(root_fd, "subdir1", O_RDONLY);
    if (subdir1_fd != -1) {
        int read_fd = openat(subdir1_fd, "file1.txt", O_RDONLY);
        if (read_fd != -1) {
            char buffer[64];
            ssize_t bytes_read = read(read_fd, buffer, sizeof(buffer) - 1);
            if (bytes_read > 0) {
                buffer[bytes_read] = '\0';
                printf("  subdir1/file1.txt: %s\n", buffer);
            }
            close(read_fd);
        }
        close(subdir1_fd);
    }
    
    // 读取 subdir2 中的文件
    subdir2_fd = openat(root_fd, "subdir2", O_RDONLY);
    if (subdir2_fd != -1) {
        int read_fd = openat(subdir2_fd, "file2.txt", O_RDONLY);
        if (read_fd != -1) {
            char buffer[64];
            ssize_t bytes_read = read(read_fd, buffer, sizeof(buffer) - 1);
            if (bytes_read > 0) {
                buffer[bytes_read] = '\0';
                printf("  subdir2/file2.txt: %s\n", buffer);
            }
            close(read_fd);
        }
        close(subdir2_fd);
    }
    
    // 清理资源
    close(root_fd);
    
    // 删除创建的文件和目录
    unlink("multi_level/subdir1/file1.txt");
    unlink("multi_level/subdir2/file2.txt");
    rmdir("multi_level/subdir1");
    rmdir("multi_level/subdir2");
    rmdir("multi_level");
    
    printf("✓ 完成相对路径操作演示\n");
}

int main() {
    printf("=== openat 安全性和相对路径演示 ===\n");
    
    demonstrate_security_benefits();
    demonstrate_relative_path_operations();
    
    return 0;
}

示例4：高级文件操作工具

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
#include <string.h>
#include <dirent.h>

typedef struct {
    int fd;
    char path[256];
    int is_dir;
} file_handle_t;

#define MAX_HANDLES 64
static file_handle_t handles[MAX_HANDLES];
static int handle_count = 0;

int register_handle(int fd, const char *path, int is_dir) {
    if (handle_count >= MAX_HANDLES) {
        return -1;
    }
    
    handles[handle_count].fd = fd;
    strncpy(handles[handle_count].path, path, sizeof(handles[handle_count].path) - 1);
    handles[handle_count].path[sizeof(handles[handle_count].path) - 1] = '\0';
    handles[handle_count].is_dir = is_dir;
    
    return handle_count++;
}

int unregister_handle(int fd) {
    for (int i = 0; i < handle_count; i++) {
        if (handles[i].fd == fd) {
            // 将后续句柄前移
            for (int j = i; j < handle_count - 1; j++) {
                handles[j] = handles[j + 1];
            }
            handle_count--;
            return 0;
        }
    }
    return -1;
}

void list_handles() {
    printf("=== 当前打开的文件句柄 ===\n");
    
    if (handle_count == 0) {
        printf("没有打开的文件句柄\n");
        return;
    }
    
    printf("%-4s %-6s %-8s %s\n", "ID", "FD", "类型", "路径");
    printf("%-4s %-6s %-8s %s\n", "--", "--", "--", "--");
    
    for (int i = 0; i < handle_count; i++) {
        printf("%-4d %-6d %-8s %s\n",
               i, handles[i].fd,
               handles[i].is_dir ? "目录" : "文件",
               handles[i].path);
    }
    
    printf("总计: %d 个句柄\n", handle_count);
}

void interactive_file_manager() {
    int choice;
    char path[256];
    int dirfd;
    int flags;
    mode_t mode;
    
    while (1) {
        printf("\n=== openat 文件管理工具 ===\n");
        printf("1. 相对打开文件\n");
        printf("2. 打开目录\n");
        printf("3. 创建文件\n");
        printf("4. 关闭文件句柄\n");
        printf("5. 列出所有句柄\n");
        printf("6. 读取文件内容\n");
        printf("7. 写入文件内容\n");
        printf("8. 显示文件状态\n");
        printf("0. 退出\n");
        printf("请选择操作: ");
        
        if (scanf("%d", &choice) != 1) {
            printf("输入无效\n");
            while (getchar() != '\n');  // 清空输入缓冲区
            continue;
        }
        
        switch (choice) {
            case 1:
                printf("相对打开文件:\n");
                printf("输入目录句柄 ID (或 -1 表示 AT_FDCWD): ");
                int dir_id;
                if (scanf("%d", &dir_id) == 1) {
                    if (dir_id == -1) {
                        dirfd = AT_FDCWD;
                    } else if (dir_id >= 0 && dir_id < handle_count && handles[dir_id].is_dir) {
                        dirfd = handles[dir_id].fd;
                    } else {
                        printf("无效的目录句柄 ID\n");
                        break;
                    }
                    
                    printf("输入文件路径: ");
                    scanf("%255s", path);
                    
                    printf("输入打开标志 (O_RDONLY=0, O_WRONLY=1, O_RDWR=2): ");
                    int flag_choice;
                    if (scanf("%d", &flag_choice) == 1) {
                        switch (flag_choice) {
                            case 0: flags = O_RDONLY; break;
                            case 1: flags = O_WRONLY; break;
                            case 2: flags = O_RDWR; break;
                            default: flags = O_RDONLY; break;
                        }
                        
                        int fd = openat(dirfd, path, flags);
                        if (fd != -1) {
                            char full_path[512];
                            if (dir_id == -1) {
                                snprintf(full_path, sizeof(full_path), "%s", path);
                            } else {
                                snprintf(full_path, sizeof(full_path), "%s/%s", 
                                        handles[dir_id].path, path);
                            }
                            
                            int id = register_handle(fd, full_path, 0);
                            if (id != -1) {
                                printf("✓ 成功打开文件 (ID: %d, FD: %d)\n", id, fd);
                            } else {
                                printf("✗ 注册句柄失败\n");
                                close(fd);
                            }
                        } else {
                            printf("✗ 打开文件失败: %s\n", strerror(errno));
                        }
                    }
                }
                break;
                
            case 2:
                printf("打开目录:\n");
                printf("输入目录路径: ");
                scanf("%255s", path);
                
                int dir_fd = open(path, O_RDONLY);
                if (dir_fd != -1) {
                    int id = register_handle(dir_fd, path, 1);
                    if (id != -1) {
                        printf("✓ 成功打开目录 (ID: %d, FD: %d)\n", id, dir_fd);
                    } else {
                        printf("✗ 注册句柄失败\n");
                        close(dir_fd);
                    }
                } else {
                    printf("✗ 打开目录失败: %s\n", strerror(errno));
                }
                break;
                
            case 3:
                printf("创建文件:\n");
                printf("输入目录句柄 ID (或 -1 表示 AT_FDCWD): ");
                if (scanf("%d", &dir_id) == 1) {
                    if (dir_id == -1) {
                        dirfd = AT_FDCWD;
                    } else if (dir_id >= 0 && dir_id < handle_count && handles[dir_id].is_dir) {
                        dirfd = handles[dir_id].fd;
                    } else {
                        printf("无效的目录句柄 ID\n");
                        break;
                    }
                    
                    printf("输入文件路径: ");
                    scanf("%255s", path);
                    
                    flags = O_CREAT | O_WRONLY | O_TRUNC;
                    mode = 0644;
                    
                    int fd = openat(dirfd, path, flags, mode);
                    if (fd != -1) {
                        char full_path[512];
                        if (dir_id == -1) {
                            snprintf(full_path, sizeof(full_path), "%s", path);
                        } else {
                            snprintf(full_path, sizeof(full_path), "%s/%s", 
                                    handles[dir_id].path, path);
                        }
                        
                        int id = register_handle(fd, full_path, 0);
                        if (id != -1) {
                            printf("✓ 成功创建文件 (ID: %d, FD: %d)\n", id, fd);
                        } else {
                            printf("✗ 注册句柄失败\n");
                            close(fd);
                        }
                    } else {
                        printf("✗ 创建文件失败: %s\n", strerror(errno));
                    }
                }
                break;
                
            case 4: {
                if (handle_count == 0) {
                    printf("没有打开的句柄\n");
                    break;
                }
                
                list_handles();
                printf("输入要关闭的句柄 ID: ");
                int handle_id;
                if (scanf("%d", &handle_id) == 1) {
                    if (handle_id >= 0 && handle_id < handle_count) {
                        printf("关闭句柄: %s (FD: %d)\n", 
                               handles[handle_id].path, handles[handle_id].fd);
                        
                        close(handles[handle_id].fd);
                        unregister_handle(handles[handle_id].fd);
                        printf("✓ 成功关闭句柄\n");
                    } else {
                        printf("无效的句柄 ID\n");
                    }
                }
                break;
            }
            
            case 5:
                list_handles();
                break;
                
            case 6: {
                if (handle_count == 0) {
                    printf("没有打开的句柄\n");
                    break;
                }
                
                list_handles();
                printf("输入要读取的文件句柄 ID: ");
                int handle_id;
                if (scanf("%d", &handle_id) == 1) {
                    if (handle_id >= 0 && handle_id < handle_count && !handles[handle_id].is_dir) {
                        char buffer[256];
                        ssize_t bytes_read = read(handles[handle_id].fd, buffer, sizeof(buffer) - 1);
                        if (bytes_read > 0) {
                            buffer[bytes_read] = '\0';
                            printf("文件内容:\n%s\n", buffer);
                        } else if (bytes_read == 0) {
                            printf("文件为空\n");
                        } else {
                            printf("读取文件失败: %s\n", strerror(errno));
                        }
                    } else {
                        printf("无效的文件句柄 ID\n");
                    }
                }
                break;
            }
            
            case 7: {
                if (handle_count == 0) {
                    printf("没有打开的句柄\n");
                    break;
                }
                
                list_handles();
                printf("输入要写入的文件句柄 ID: ");
                int handle_id;
                if (scanf("%d", &handle_id) == 1) {
                    if (handle_id >= 0 && handle_id < handle_count && !handles[handle_id].is_dir) {
                        printf("输入要写入的内容: ");
                        char content[256];
                        scanf("%255s", content);
                        
                        ssize_t bytes_written = write(handles[handle_id].fd, content, strlen(content));
                        if (bytes_written > 0) {
                            printf("✓ 成功写入 %zd 字节\n", bytes_written);
                        } else {
                            printf("✗ 写入文件失败: %s\n", strerror(errno));
                        }
                    } else {
                        printf("无效的文件句柄 ID\n");
                    }
                }
                break;
            }
            
            case 8: {
                if (handle_count == 0) {
                    printf("没有打开的句柄\n");
                    break;
                }
                
                list_handles();
                printf("输入要查看状态的句柄 ID: ");
                int handle_id;
                if (scanf("%d", &handle_id) == 1) {
                    if (handle_id >= 0 && handle_id < handle_count) {
                        struct stat st;
                        if (fstat(handles[handle_id].fd, &st) == 0) {
                            printf("文件状态:\n");
                            printf("  路径: %s\n", handles[handle_id].path);
                            printf("  大小: %ld 字节\n", (long)st.st_size);
                            printf("  权限: %o\n", st.st_mode & 0777);
                            printf("  inode: %ld\n", (long)st.st_ino);
                            printf("  链接数: %ld\n", (long)st.st_nlink);
                            printf("  所有者: %d\n", st.st_uid);
                            printf("  组: %d\n", st.st_gid);
                        } else {
                            printf("获取文件状态失败: %s\n", strerror(errno));
                        }
                    } else {
                        printf("无效的句柄 ID\n");
                    }
                }
                break;
            }
            
            case 0:
                printf("退出文件管理工具\n");
                // 清理所有打开的句柄
                for (int i = 0; i < handle_count; i++) {
                    close(handles[i].fd);
                }
                handle_count = 0;
                return;
                
            default:
                printf("无效选择\n");
                break;
        }
    }
}

void demonstrate_openat_features() {
    printf("=== openat 特性演示 ===\n");
    
    printf("openat 主要特性:\n");
    printf("1. 相对路径支持: 相对于目录文件描述符打开文件\n");
    printf("2. 安全性提升: 避免路径解析竞态条件\n");
    printf("3. 灵活性: 支持 AT_FDCWD 和绝对路径\n");
    printf("4. 原子操作: 结合 O_CREAT|O_EXCL 实现原子创建\n");
    printf("5. 容器友好: 在受限环境中更安全\n");
    
    printf("\n使用场景:\n");
    printf("• 容器和沙箱环境中的文件操作\n");
    printf("• 多线程程序中的安全文件访问\n");
    printf("• 需要避免竞态条件的文件操作\n");
    printf("• 相对路径操作的系统工具\n");
}

int main() {
    printf("=== openat 高级文件操作工具 ===\n");
    
    // 显示系统信息
    printf("系统信息:\n");
    printf("  PID: %d\n", getpid());
    printf("  页面大小: %ld 字节\n", (long)getpagesize());
    
    // 演示特性
    demonstrate_openat_features();
    
    // 启动交互式管理器
    char choice;
    printf("\n是否启动交互式文件管理器? (y/N): ");
    if (scanf(" %c", &choice) == 1 && (choice == 'y' || choice == 'Y')) {
        interactive_file_manager();
    }
    
    return 0;
}

9. openat 与 open 的对比

// open vs openat 对比:

// 传统 open 函数:
int fd1 = open("/path/to/file.txt", O_RDONLY);
// • 只能使用绝对或相对于当前目录的路径
// • 可能存在竞态条件
// • 在多线程环境中不够安全

// 现代 openat 函数:
int dirfd = open("/path/to", O_RDONLY);
int fd2 = openat(dirfd, "file.txt", O_RDONLY);
// • 支持相对路径操作
// • 基于已打开的目录文件描述符
// • 避免路径解析竞态条件
// • 更安全的文件操作方式

// 特殊值 AT_FDCWD:
int fd3 = openat(AT_FDCWD, "relative/path.txt", O_RDONLY);
// • 等同于传统的相对路径 open
// • 提供统一的接口

10. 实际应用场景

场景1：安全的文件操作

int secure_file_operation(const char *base_dir, const char *filename) {
    // 打开基础目录
    int dirfd = open(base_dir, O_RDONLY);
    if (dirfd == -1) {
        return -1;
    }
    
    // 相对打开文件（防止目录遍历攻击）
    int fd = openat(dirfd, filename, O_RDONLY);
    if (fd == -1) {
        close(dirfd);
        return -1;
    }
    
    // 执行安全的文件操作
    // ...
    
    close(fd);
    close(dirfd);
    return 0;
}

场景2：容器环境文件访问

int container_file_access(int root_dirfd, const char *path) {
    // 在容器根目录中安全访问文件
    // 防止跳出容器文件系统
    return openat(root_dirfd, path, O_RDONLY);
}

场景3：批量文件操作

int process_directory_files(const char *dirname) {
    int dirfd = open(dirname, O_RDONLY);
    if (dirfd == -1) return -1;
    
    DIR *dir = fdopendir(dirfd);
    if (!dir) {
        close(dirfd);
        return -1;
    }
    
    struct dirent *entry;
    while ((entry = readdir(dir)) != NULL) {
        if (entry->d_name[0] == '.') continue;
        
        // 相对打开每个文件
        int fd = openat(dirfd, entry->d_name, O_RDONLY);
        if (fd != -1) {
            // 处理文件...
            process_file(fd);
            close(fd);
        }
    }
    
    closedir(dir);
    return 0;
}

11. 注意事项

使用 openat 时需要注意：

1. 目录文件描述符: dirfd 必须是有效的目录文件描述符
2. 路径安全: 防止目录遍历攻击（如 ../）
3. 资源管理: 及时关闭文件描述符避免资源泄漏
4. 错误处理: 仔细处理各种可能的错误情况
5. 权限检查: 确保有足够的权限访问目标文件
6. 竞态条件: 在多线程环境中注意同步

12. 系统配置检查

# 查看系统支持的文件操作特性
grep -i openat /proc/self/maps

# 查看文件系统信息
df -T

# 查看进程打开的文件描述符
ls -la /proc/self/fd/

# 检查系统调用表
ausyscall openat

# 查看系统限制
ulimit -n

总结

openat 是现代 Linux 系统中推荐使用的文件打开函数：

关键特性:
1. 相对路径支持: 相对于目录文件描述符打开文件
2. 安全性提升: 避免路径解析竞态条件
3. 灵活性增强: 支持多种操作模式
4. 容器友好: 在受限环境中更安全

主要应用:
1. 安全的文件操作程序
2. 容器和虚拟化环境
3. 系统管理和监控工具
4. 需要避免竞态条件的应用

使用要点:
1. 理解 dirfd 参数的含义和使用
2. 正确处理相对路径和绝对路径
3. 注意资源管理和错误处理
4. 利用安全性优势防止攻击

openat 为现代 Linux 应用程序提供了更安全、更灵活的文件操作方式，是系统编程的重要工具。

我们继续学习 Linux 系统编程中的重要函数。这次我们介绍 pause 函数，它是一个非常简单的系统调用，功能是使调用它的进程（或线程）进入睡眠（阻塞）状态，直到该进程接收到一个信号（signal）为止。

1. 函数介绍

pause 是一个 Linux 系统调用，它的作用非常直接：挂起调用它的进程，使其进入可中断的睡眠状态（interruptible sleep state）。进程会一直保持睡眠，不消耗 CPU 时间，直到发生以下两种情况之一：

1. 接收到信号: 进程被一个信号中断。这可以是任何信号，例如 SIGINT (Ctrl+C), SIGTERM (终止), SIGUSR1 (用户自定义信号) 等。
2. 进程被杀死: 例如收到 SIGKILL 信号，但这通常不会让 pause 返回，因为进程直接被终止了。
当进程因信号而被唤醒时，pause 调用会返回。

pause 通常用于那些需要无限期等待某个外部事件（通过信号来通知）的程序中。它提供了一种简单、高效（不占用 CPU）的等待机制。

你可以把它想象成一个人在等待电话。他什么也不做，只是静静地坐着（睡眠），直到电话铃响（收到信号），他才会起身去接电话（pause 返回）。

2. 函数原型

#include <unistd.h> // 必需

int pause(void);

3. 功能

• 进入睡眠: 调用 pause 的进程会立即放弃 CPU，并被放入内核的等待队列中。
• 等待信号: 进程进入睡眠状态，直到有任何信号递达（delivered）到该进程。
• 被信号中断: 当信号被递达时（并且该信号没有被忽略或导致进程终止），进程会从 pause 调用中返回。

4. 参数

• void: pause 函数不接受任何参数。

5. 返回值

• 总是返回 -1: pause 调用永远不会成功返回一个非负值。
• 总是设置 errno: 当 pause 因接收到信号而返回时，它会将 errno 设置为 EINTR (Interrupted system call)。

重要: pause 的返回唯一原因就是被信号中断。因此，检查返回值和 errno 通常是确认 pause 是因信号返回的标准做法。

6. 相似函数，或关联函数

• sleep, nanosleep: 这些函数使进程睡眠指定的时间。pause 是无限期睡眠，直到信号。
• sigsuspend: 这是一个更高级、更安全的用于等待信号的函数。它允许在等待信号的原子性操作中临时替换进程的信号掩码（blocked signals set）。这可以避免在设置信号掩码和调用 pause 之间收到信号的竞态条件（race condition）。
• 信号处理函数 (signal, sigaction): 用于设置当进程收到特定信号时应执行的操作。
• sigprocmask: 用于检查或修改进程的信号掩码（哪些信号被阻塞）。
• wait, waitpid: 使进程等待子进程状态改变（结束、停止等），这也是一种阻塞等待。

7. 示例代码

示例 1：基本的 pause 使用和信号处理

这个例子演示了如何使用 pause 使进程等待信号，并通过信号处理函数来响应信号。

#include <unistd.h>   // pause
#include <stdio.h>    // printf, perror
#include <stdlib.h>   // exit
#include <signal.h>   // signal, SIGINT, SIGTERM
#include <errno.h>    // errno
#include <string.h>   // memset

// 全局标志，用于在信号处理函数和主循环间通信
volatile sig_atomic_t signal_received = 0;
volatile int last_signal = 0;

// 信号处理函数
void signal_handler(int sig) {
    printf("\nSignal handler called for signal %d\n", sig);
    signal_received = 1;
    last_signal = sig;
    // 注意：在信号处理函数中，应只调用异步信号安全的函数
    // printf 通常被认为是安全的，但严格来说不是 100% 可靠
    // 更安全的做法是只设置标志位，然后在主循环中检查
}

int main() {
    printf("Process PID: %d\n", getpid());
    printf("Try sending signals using 'kill %d' or pressing Ctrl+C\n", getpid());
    printf("Send SIGTERM (kill %d) or SIGINT (Ctrl+C) to exit.\n", getpid());

    // 1. 设置信号处理函数
    if (signal(SIGINT, signal_handler) == SIG_ERR) {
        perror("signal SIGINT");
        exit(EXIT_FAILURE);
    }
    if (signal(SIGTERM, signal_handler) == SIG_ERR) {
        perror("signal SIGTERM");
        exit(EXIT_FAILURE);
    }
    // 忽略 SIGUSR1，但它仍然会中断 pause
    if (signal(SIGUSR1, SIG_IGN) == SIG_ERR) {
        perror("signal SIGUSR1");
        exit(EXIT_FAILURE);
    }

    printf("Entering main loop with pause()...\n");

    // 2. 主循环
    while (1) {
        // 3. 调用 pause 进入睡眠
        printf("Going to sleep... (waiting for a signal)\n");
        int result = pause(); // 进程在此处挂起

        // 4. pause 返回（唯一原因是被信号中断）
        if (result == -1 && errno == EINTR) {
            printf("pause() was interrupted by a signal (errno=EINTR).\n");
            
            // 5. 检查是哪个信号
            if (signal_received) {
                printf("Handled signal %d in signal handler.\n", last_signal);
                if (last_signal == SIGINT || last_signal == SIGTERM) {
                    printf("Received exit signal. Cleaning up and exiting.\n");
                    break; // 退出主循环
                }
                // 为下一次循环重置标志
                signal_received = 0;
            }
        } else {
            // 这理论上不应该发生，因为 pause 总是返回 -1 和 EINTR
            printf("Unexpected return from pause(): result=%d, errno=%d (%s)\n",
                   result, errno, strerror(errno));
        }
    }

    printf("Main loop exited. Performing cleanup...\n");
    // 这里可以执行一些清理工作

    printf("Program exiting normally.\n");
    return 0;
}

代码解释: