Linux系统编程

kcmp系统调用及示例

kcmp 函数详解

  1. 函数介绍

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

data-ad-format="fluid" data-ad-layout-key="-7k+ex-4a-9w+4a">

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

  1. 函数原型
1
2
3
4
5
6
#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);

  1. 功能

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

  1. 参数

  • pid1: 第一个进程的进程 ID（0 表示调用进程）

  • pid2: 第二个进程的进程 ID（0 表示调用进程）

  • type: 比较的资源类型

  • idx1: 第一个进程的资源索引（根据 type 而定）

  • idx2: 第二个进程的资源索引（根据 type 而定）

  1. 资源类型（type 参数）

类型值说明KCMP_FILE0比较文件描述符KCMP_VM1比较虚拟内存KCMP_FILES2比较文件描述符表KCMP_FS3比较文件系统信息KCMP_SIGHAND4比较信号处理信息KCMP_IO5比较 I/O 信息KCMP_SYSVSEM6比较 System V 信号量

  1. 返回值

  • 0: 两个资源相同（指向内核中的同一对象）

  • 1: 两个资源不同

  • 2: 目标进程不存在或无法访问

  • 负值: 错误，设置相应的 errno

  1. 错误码

  • EPERM: 权限不足（无法访问目标进程信息）

  • ESRCH: 进程不存在

  • EINVAL: 参数无效

  • EACCES: 访问被拒绝

  1. 相似函数或关联函数

  • clone: 创建进程时可以共享资源

  • unshare: 使进程脱离共享资源

  • setns: 加入命名空间

  • /proc 文件系统: 查看进程信息

  • ptrace: 进程跟踪和调试

  1. 示例代码

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#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：进程间资源比较。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
#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：完整的进程关系分析工具。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
#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&#91;] = {
        KCMP_FILES, KCMP_VM, KCMP_FS, KCMP_SIGHAND, KCMP_IO, KCMP_SYSVSEM
    };
    int num_types = sizeof(resource_types) / sizeof(resource_types&#91;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&#91;i], 0, 0);
        show_detailed_result(get_resource_type_name(resource_types&#91;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 &#91;选项]\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&#91;]) {
    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&#91;] = {
        {"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&#91;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;
}

编译和运行说明

1
2
3
4
5
6
7
8
9
10
11
12
# 编译示例程序
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 $$

系统要求检查

1
2
3
4
5
6
7
8
9
# 检查内核版本（需要 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. 故障排查: 诊断进程间意外的资源共享。

容器环境中的应用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 检测进程是否在同一容器中
int are_processes_in_same_container(pid_t pid1, pid_t pid2) {
    // 比较关键资源
    int results&#91;] = {
        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&#91;i] == 1) different_count++;
    }
    
    return (different_count >= 2) ? 0 : 1;  // 0=不同容器, 1=可能同容器
}

最佳实践

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// 安全地使用 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系统中的进程资源比较机制。

data-ad-format="auto" data-full-width-responsive="true">

📚 相关文章