2025-08-08

tuxcall系统调用及示例

tuxcall函数详解

函数介绍

tuxcall函数是Linux内核中一个特殊的系统调用，主要用于TUX（Threaded linUX web server）Web服务器的内核级操作。TUX是一个实验性的高性能Web服务器，它将HTTP请求处理的某些部分直接在内核空间完成，以减少用户空间和内核空间之间的上下文切换开销。

可以把tuxcall想象成一个”内核级Web服务接口”，它允许用户空间程序与内核中的TUX Web服务器模块进行通信。通过tuxcall，应用程序可以执行一些原本需要在内核中处理的Web服务器操作，如缓存管理、连接处理等。

重要说明: tuxcall是一个非常特殊的函数，它：

不是标准的POSIX系统调用
主要用于特定的内核模块（TUX Web服务器）
在现代Linux发行版中很少使用
需要特定的内核配置和支持

使用场景：

与TUX内核Web服务器交互
高性能Web服务器开发
内核模块与用户空间通信
学习Linux内核网络子系统

函数原型

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

// tuxcall不是标准库函数，需要通过系统调用直接调用
long syscall(SYS_tuxcall, int subcall, void *arg1, void *arg2);

注意：tuxcall在标准的系统调用表中可能不存在，因为它是一个实验性功能。

功能

tuxcall函数的主要功能是作为用户空间程序与TUX内核Web服务器模块之间的通信接口。它支持多种子调用，每种子调用执行不同的Web服务器相关操作：

缓存管理: 管理内核中的HTTP内容缓存
连接控制: 控制网络连接的状态
统计信息: 获取Web服务器的运行统计
配置管理: 配置内核Web服务器参数

参数

subcall: 子调用类型

类型：int
含义：指定要执行的具体操作类型

常用值（如果支持）：

TUX_INIT：初始化TUX系统
TUX_CACHE_ADD：添加缓存项
TUX_CACHE_DEL：删除缓存项
TUX_CACHE_LOOKUP：查找缓存项
TUX_STATS_GET：获取统计信息
TUX_CONFIG_SET：设置配置参数

arg1: 第一个参数

类型：void*
含义：根据subcall类型而定的参数，通常是指向数据结构的指针

arg2: 第二个参数

类型：void*
含义：根据subcall类型而定的第二个参数，可能为NULL

返回值

成功: 返回0或具体操作的返回值

失败: 返回-1，并设置errno错误码

ENOSYS：系统调用不支持
EINVAL：参数无效
EPERM：权限不足
ENODEV：设备或模块不存在

相似函数或关联函数

syscall(): 通用系统调用接口
ioctl(): 设备控制接口
socketcall(): 套接字相关系统调用
TUX内核模块: 实际提供功能的内核组件
sendfile(): 高效文件传输函数
splice(): 管道数据传输函数

示例代码

示例1：检测tuxcall支持

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

// 尝试定义tuxcall系统调用号（可能不存在）
#ifndef SYS_tuxcall
#define SYS_tuxcall 184  // 这是一个假设的系统调用号
#endif

// TUX子调用类型（假设定义）
#define TUX_NOP         0
#define TUX_INIT        1
#define TUX_VERSION     2
#define TUX_STATS       3

// 检测系统是否支持tuxcall
int check_tuxcall_support() {
    printf("检测tuxcall系统调用支持...\n");
    
    // 尝试调用一个无害的NOP操作
    long result = syscall(SYS_tuxcall, TUX_NOP, NULL, NULL);
    
    if (result == -1) {
        if (errno == ENOSYS) {
            printf("✗ tuxcall系统调用不被支持\n");
            printf("  错误: %s\n", strerror(errno));
            return 0;
        } else {
            printf("? tuxcall系统调用存在但调用失败\n");
            printf("  错误: %s\n", strerror(errno));
            return 1;  // 系统调用存在但参数错误是正常的
        }
    } else {
        printf("✓ tuxcall系统调用支持\n");
        return 1;
    }
}

// 获取TUX版本信息
int get_tux_version() {
    char version_buffer&#91;256];
    long result = syscall(SYS_tuxcall, TUX_VERSION, version_buffer, sizeof(version_buffer));
    
    if (result == -1) {
        printf("获取TUX版本失败: %s\n", strerror(errno));
        return -1;
    }
    
    printf("TUX版本: %s\n", version_buffer);
    return 0;
}

int main() {
    printf("=== tuxcall函数检测示例 ===\n");
    printf("注意: tuxcall是一个实验性功能，可能不被当前系统支持\n\n");
    
    // 检测系统支持
    if (!check_tuxcall_support()) {
        printf("\n由于系统不支持tuxcall，演示程序结束\n");
        printf("这在现代Linux系统中是正常现象\n");
        return 0;
    }
    
    // 尝试初始化TUX（如果支持）
    printf("\n尝试初始化TUX系统...\n");
    long init_result = syscall(SYS_tuxcall, TUX_INIT, NULL, NULL);
    if (init_result == -1) {
        if (errno == EPERM) {
            printf("初始化失败: 权限不足（需要root权限）\n");
        } else if (errno == ENODEV) {
            printf("初始化失败: TUX模块未加载\n");
        } else {
            printf("初始化失败: %s\n", strerror(errno));
        }
    } else {
        printf("TUX系统初始化成功\n");
    }
    
    // 尝试获取版本信息
    printf("\n获取TUX版本信息...\n");
    get_tux_version();
    
    // 演示统计信息获取
    printf("\n获取TUX统计信息...\n");
    struct {
        unsigned long requests;
        unsigned long cache_hits;
        unsigned long cache_misses;
        unsigned long errors;
    } stats;
    
    long stats_result = syscall(SYS_tuxcall, TUX_STATS, &stats, sizeof(stats));
    if (stats_result == -1) {
        printf("获取统计信息失败: %s\n", strerror(errno));
    } else {
        printf("TUX统计信息:\n");
        printf("  总请求数: %lu\n", stats.requests);
        printf("  缓存命中: %lu\n", stats.cache_hits);
        printf("  缓存未命中: %lu\n", stats.cache_misses);
        printf("  错误数: %lu\n", stats.errors);
    }
    
    printf("\n=== tuxcall检测完成 ===\n");
    printf("注意: 如果看到'系统调用不被支持'，这是正常现象\n");
    printf("现代Linux系统通常不包含TUX Web服务器支持\n");
    
    return 0;
}

示例2：模拟tuxcall接口（用于学习）

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

// 模拟TUX相关的数据结构和常量
#define TUX_MAX_CACHE_ENTRIES 1000

// 模拟的缓存项结构
typedef struct {
    char url&#91;256];
    char content&#91;1024];
    time_t timestamp;
    int valid;
} tux_cache_entry_t;

// 模拟的统计结构
typedef struct {
    unsigned long total_requests;
    unsigned long cache_hits;
    unsigned long cache_misses;
    unsigned long errors;
    time_t start_time;
} tux_stats_t;

// 模拟的TUX系统状态
static tux_cache_entry_t cache&#91;TUX_MAX_CACHE_ENTRIES];
static tux_stats_t stats = {0};
static int tux_initialized = 0;

// TUX子调用类型
#define TUX_NOP         0
#define TUX_INIT        1
#define TUX_SHUTDOWN    2
#define TUX_VERSION     3
#define TUX_CACHE_ADD   4
#define TUX_CACHE_DEL   5
#define TUX_CACHE_LOOKUP 6
#define TUX_STATS       7
#define TUX_CLEAR_CACHE 8

// 模拟的tuxcall实现
long simulate_tuxcall(int subcall, void *arg1, void *arg2) {
    switch (subcall) {
        case TUX_NOP:
            return 0;
            
        case TUX_INIT:
            if (!tux_initialized) {
                memset(&stats, 0, sizeof(stats));
                stats.start_time = time(NULL);
                memset(cache, 0, sizeof(cache));
                tux_initialized = 1;
                printf("&#91;模拟] TUX系统初始化完成\n");
            }
            return 0;
            
        case TUX_SHUTDOWN:
            if (tux_initialized) {
                tux_initialized = 0;
                printf("&#91;模拟] TUX系统已关闭\n");
            }
            return 0;
            
        case TUX_VERSION:
            if (arg1 && arg2) {
                snprintf((char*)arg1, (size_t)arg2, "TUX Web Server 2.0 (模拟版本)");
                return 0;
            }
            errno = EINVAL;
            return -1;
            
        case TUX_CACHE_ADD:
            if (arg1) {
                // 简化的缓存添加逻辑
                printf("&#91;模拟] 添加缓存项\n");
                stats.total_requests++;
                return 0;
            }
            errno = EINVAL;
            return -1;
            
        case TUX_CACHE_DEL:
            if (arg1) {
                printf("&#91;模拟] 删除缓存项: %s\n", (char*)arg1);
                return 0;
            }
            errno = EINVAL;
            return -1;
            
        case TUX_CACHE_LOOKUP:
            if (arg1 && arg2) {
                printf("&#91;模拟] 查找缓存项: %s\n", (char*)arg1);
                stats.total_requests++;
                stats.cache_misses++;
                // 模拟未找到
                return -1;
            }
            errno = EINVAL;
            return -1;
            
        case TUX_STATS:
            if (arg1 && arg2) {
                if ((size_t)arg2 >= sizeof(tux_stats_t)) {
                    memcpy(arg1, &stats, sizeof(tux_stats_t));
                    return 0;
                }
            }
            errno = EINVAL;
            return -1;
            
        case TUX_CLEAR_CACHE:
            memset(cache, 0, sizeof(cache));
            printf("&#91;模拟] 缓存已清空\n");
            return 0;
            
        default:
            errno = EINVAL;
            return -1;
    }
}

// 模拟的系统调用封装
long my_tuxcall(int subcall, void *arg1, void *arg2) {
    // 在实际系统中，这里会调用真正的syscall
    // return syscall(SYS_tuxcall, subcall, arg1, arg2);
    
    // 现在我们模拟这个调用
    return simulate_tuxcall(subcall, arg1, arg2);
}

// 工具函数：显示TUX状态
void show_tux_status() {
    printf("\n=== TUX系统状态 ===\n");
    printf("初始化状态: %s\n", tux_initialized ? "已初始化" : "未初始化");
    if (tux_initialized) {
        printf("运行时间: %ld 秒\n", time(NULL) - stats.start_time);
    }
    printf("==================\n\n");
}

int main() {
    printf("=== 模拟tuxcall接口示例 ===\n");
    printf("注意: 这是一个模拟实现，用于演示tuxcall的概念\n\n");
    
    // 显示初始状态
    show_tux_status();
    
    // 测试初始化
    printf("1. 测试TUX初始化:\n");
    if (my_tuxcall(TUX_INIT, NULL, NULL) == 0) {
        printf("✓ 初始化成功\n");
    } else {
        printf("✗ 初始化失败: %s\n", strerror(errno));
    }
    
    show_tux_status();
    
    // 测试版本获取
    printf("2. 测试版本获取:\n");
    char version&#91;256];
    if (my_tuxcall(TUX_VERSION, version, sizeof(version)) == 0) {
        printf("✓ TUX版本: %s\n", version);
    } else {
        printf("✗ 获取版本失败: %s\n", strerror(errno));
    }
    
    // 测试缓存操作
    printf("\n3. 测试缓存操作:\n");
    
    // 添加缓存项
    const char* test_url = "/index.html";
    if (my_tuxcall(TUX_CACHE_ADD, (void*)test_url, NULL) == 0) {
        printf("✓ 添加缓存项: %s\n", test_url);
    } else {
        printf("✗ 添加缓存项失败: %s\n", strerror(errno));
    }
    
    // 查找缓存项
    if (my_tuxcall(TUX_CACHE_LOOKUP, (void*)test_url, NULL) == 0) {
        printf("✓ 缓存命中: %s\n", test_url);
    } else {
        printf("✗ 缓存未命中: %s\n", test_url);
    }
    
    // 删除缓存项
    if (my_tuxcall(TUX_CACHE_DEL, (void*)test_url, NULL) == 0) {
        printf("✓ 删除缓存项: %s\n", test_url);
    } else {
        printf("✗ 删除缓存项失败: %s\n", strerror(errno));
    }
    
    // 测试统计信息
    printf("\n4. 测试统计信息:\n");
    tux_stats_t current_stats;
    if (my_tuxcall(TUX_STATS, &current_stats, sizeof(current_stats)) == 0) {
        printf("✓ 获取统计信息成功:\n");
        printf("  总请求数: %lu\n", current_stats.total_requests);
        printf("  缓存命中: %lu\n", current_stats.cache_hits);
        printf("  缓存未命中: %lu\n", current_stats.cache_misses);
        printf("  错误数: %lu\n", current_stats.errors);
        printf("  运行时间: %ld 秒\n", time(NULL) - current_stats.start_time);
    } else {
        printf("✗ 获取统计信息失败: %s\n", strerror(errno));
    }
    
    // 测试缓存清空
    printf("\n5. 测试缓存清空:\n");
    if (my_tuxcall(TUX_CLEAR_CACHE, NULL, NULL) == 0) {
        printf("✓ 缓存清空成功\n");
    } else {
        printf("✗ 缓存清空失败: %s\n", strerror(errno));
    }
    
    // 测试关闭
    printf("\n6. 测试TUX关闭:\n");
    if (my_tuxcall(TUX_SHUTDOWN, NULL, NULL) == 0) {
        printf("✓ TUX系统关闭成功\n");
    } else {
        printf("✗ TUX系统关闭失败: %s\n", strerror(errno));
    }
    
    show_tux_status();
    
    // 测试错误处理
    printf("7. 测试错误处理:\n");
    if (my_tuxcall(999, NULL, NULL) == -1) {
        printf("✓ 无效子调用正确返回错误: %s\n", strerror(errno));
    }
    
    if (my_tuxcall(TUX_STATS, NULL, NULL) == -1) {
        printf("✓ 无效参数正确返回错误: %s\n", strerror(errno));
    }
    
    printf("\n=== 模拟演示完成 ===\n");
    printf("说明: 这是一个概念演示，展示了tuxcall可能的功能\n");
    printf("实际的tuxcall需要内核支持，现代系统通常不包含此功能\n");
    
    return 0;
}

示例3：tuxcall与Web服务器集成概念

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

// Web服务器配置结构
typedef struct {
    int port;
    int max_connections;
    int cache_size;
    char document_root&#91;256];
    int enable_logging;
} web_config_t;

// HTTP请求结构
typedef struct {
    char method&#91;16];
    char url&#91;256];
    char version&#91;16];
    char headers&#91;1024];
} http_request_t;

// HTTP响应结构
typedef struct {
    int status_code;
    char status_text&#91;64];
    char headers&#91;512];
    char* body;
    size_t body_length;
} http_response_t;

// 模拟的TUX相关常量
#define TUX_WEB_INIT        10
#define TUX_WEB_CONFIGURE   11
#define TUX_WEB_HANDLE_REQ  12
#define TUX_WEB_SHUTDOWN    13
#define TUX_WEB_GET_METRICS 14

// 模拟的Web服务器状态
static int web_server_running = 0;
static web_config_t current_config = {0};
static unsigned long total_requests = 0;
static unsigned long served_pages = 0;
static unsigned long errors = 0;

// 模拟的tuxcall Web服务器接口
long web_tuxcall(int subcall, void *arg1, void *arg2) {
    switch (subcall) {
        case TUX_WEB_INIT:
            if (!web_server_running) {
                web_server_running = 1;
                total_requests = 0;
                served_pages = 0;
                errors = 0;
                printf("&#91;Web服务器] 初始化完成\n");
                return 0;
            }
            return 0;
            
        case TUX_WEB_CONFIGURE:
            if (arg1 && web_server_running) {
                memcpy(&current_config, arg1, sizeof(web_config_t));
                printf("&#91;Web服务器] 配置更新完成\n");
                printf("  端口: %d\n", current_config.port);
                printf("  最大连接数: %d\n", current_config.max_connections);
                printf("  文档根目录: %s\n", current_config.document_root);
                return 0;
            }
            errno = EINVAL;
            return -1;
            
        case TUX_WEB_HANDLE_REQ:
            if (arg1 && arg2 && web_server_running) {
                http_request_t *req = (http_request_t*)arg1;
                http_response_t *resp = (http_response_t*)arg2;
                
                total_requests++;
                
                printf("&#91;Web服务器] 处理请求: %s %s\n", req->method, req->url);
                
                // 简单的请求处理逻辑
                if (strcmp(req->url, "/") == 0 || strcmp(req->url, "/index.html") == 0) {
                    resp->status_code = 200;
                    strcpy(resp->status_text, "OK");
                    resp->body = "<html><body><h1>Hello from TUX Web Server!</h1></body></html>";
                    resp->body_length = strlen(resp->body);
                    served_pages++;
                    return 0;
                } else if (strcmp(req->url, "/status") == 0) {
                    resp->status_code = 200;
                    strcpy(resp->status_text, "OK");
                    static char status_page&#91;512];
                    snprintf(status_page, sizeof(status_page),
                             "<html><body><h1>Server Status</h1>"
                             "<p>Total Requests: %lu</p>"
                             "<p>Served Pages: %lu</p>"
                             "<p>Errors: %lu</p></body></html>",
                             total_requests, served_pages, errors);
                    resp->body = status_page;
                    resp->body_length = strlen(status_page);
                    served_pages++;
                    return 0;
                } else {
                    resp->status_code = 404;
                    strcpy(resp->status_text, "Not Found");
                    resp->body = "<html><body><h1>404 - Page Not Found</h1></body></html>";
                    resp->body_length = strlen(resp->body);
                    errors++;
                    return 0;
                }
            }
            errno = EINVAL;
            return -1;
            
        case TUX_WEB_SHUTDOWN:
            if (web_server_running) {
                web_server_running = 0;
                printf("&#91;Web服务器] 已关闭\n");
                return 0;
            }
            return 0;
            
        case TUX_WEB_GET_METRICS:
            if (arg1 && arg2) {
                size_t *size = (size_t*)arg2;
                if (*size >= sizeof(unsigned long) * 3) {
                    unsigned long *metrics = (unsigned long*)arg1;
                    metrics&#91;0] = total_requests;
                    metrics&#91;1] = served_pages;
                    metrics&#91;2] = errors;
                    return 0;
                }
            }
            errno = EINVAL;
            return -1;
            
        default:
            errno = EINVAL;
            return -1;
    }
}

// 模拟的系统调用封装
long my_web_tuxcall(int subcall, void *arg1, void *arg2) {
    return web_tuxcall(subcall, arg1, arg2);
}

// 创建测试请求
void create_test_request(http_request_t *req, const char* method, const char* url) {
    strncpy(req->method, method, sizeof(req->method) - 1);
    strncpy(req->url, url, sizeof(req->url) - 1);
    strcpy(req->version, "HTTP/1.1");
    strcpy(req->headers, "Host: localhost\r\nUser-Agent: tuxcall-test\r\n");
}

// 显示响应
void show_response(const http_response_t *resp) {
    printf("HTTP/%s %d %s\n", "1.1", resp->status_code, resp->status_text);
    printf("Content-Length: %zu\n", resp->body_length);
    printf("\n%s\n", resp->body ? resp->body : "");
}

int main() {
    printf("=== tuxcall Web服务器概念演示 ===\n");
    printf("说明: 演示tuxcall在Web服务器中的潜在应用\n\n");
    
    // 1. 初始化Web服务器
    printf("1. 初始化Web服务器:\n");
    if (my_web_tuxcall(TUX_WEB_INIT, NULL, NULL) == 0) {
        printf("✓ Web服务器初始化成功\n\n");
    } else {
        printf("✗ Web服务器初始化失败\n");
        return 1;
    }
    
    // 2. 配置Web服务器
    printf("2. 配置Web服务器:\n");
    web_config_t config = {
        .port = 8080,
        .max_connections = 1000,
        .cache_size = 100,
        .document_root = "/var/www",
        .enable_logging = 1
    };
    
    if (my_web_tuxcall(TUX_WEB_CONFIGURE, &config, NULL) == 0) {
        printf("✓ Web服务器配置完成\n\n");
    } else {
        printf("✗ Web服务器配置失败\n");
    }
    
    // 3. 处理HTTP请求
    printf("3. 处理HTTP请求:\n");
    
    http_request_t request;
    http_response_t response;
    
    // 测试主页请求
    printf("处理主页请求:\n");
    create_test_request(&request, "GET", "/");
    memset(&response, 0, sizeof(response));
    
    if (my_web_tuxcall(TUX_WEB_HANDLE_REQ, &request, &response) == 0) {
        show_response(&response);
    } else {
        printf("处理请求失败: %s\n", strerror(errno));
    }
    
    // 测试状态页面请求
    printf("处理状态页面请求:\n");
    create_test_request(&request, "GET", "/status");
    memset(&response, 0, sizeof(response));
    
    if (my_web_tuxcall(TUX_WEB_HANDLE_REQ, &request, &response) == 0) {
        show_response(&response);
    } else {
        printf("处理请求失败: %s\n", strerror(errno));
    }
    
    // 测试404页面请求
    printf("处理404页面请求:\n");
    create_test_request(&request, "GET", "/nonexistent.html");
    memset(&response, 0, sizeof(response));
    
    if (my_web_tuxcall(TUX_WEB_HANDLE_REQ, &request, &response) == 0) {
        show_response(&response);
    } else {
        printf("处理请求失败: %s\n", strerror(errno));
    }
    
    // 4. 获取服务器指标
    printf("4. 获取服务器指标:\n");
    unsigned long metrics&#91;3];
    size_t metrics_size = sizeof(metrics);
    
    if (my_web_tuxcall(TUX_WEB_GET_METRICS, metrics, &metrics_size) == 0) {
        printf("服务器运行指标:\n");
        printf("  总请求数: %lu\n", metrics&#91;0]);
        printf("  服务页面数: %lu\n", metrics&#91;1]);
        printf("  错误数: %lu\n", metrics&#91;2]);
    } else {
        printf("获取指标失败: %s\n", strerror(errno));
    }
    
    // 5. 性能测试
    printf("\n5. 性能测试:\n");
    printf("模拟处理1000个请求...\n");
    
    time_t start_time = time(NULL);
    
    for (int i = 0; i < 1000; i++) {
        create_test_request(&request, "GET", i % 3 == 0 ? "/" : 
                           (i % 3 == 1 ? "/status" : "/test"));
        my_web_tuxcall(TUX_WEB_HANDLE_REQ, &request, &response);
    }
    
    time_t end_time = time(NULL);
    printf("处理1000个请求耗时: %ld 秒\n", end_time - start_time);
    
    // 再次获取指标
    if (my_web_tuxcall(TUX_WEB_GET_METRICS, metrics, &metrics_size) == 0) {
        printf("更新后的指标:\n");
        printf("  总请求数: %lu\n", metrics&#91;0]);
        printf("  服务页面数: %lu\n", metrics&#91;1]);
        printf("  错误数: %lu\n", metrics&#91;2]);
    }
    
    // 6. 关闭Web服务器
    printf("\n6. 关闭Web服务器:\n");
    if (my_web_tuxcall(TUX_WEB_SHUTDOWN, NULL, NULL) == 0) {
        printf("✓ Web服务器已关闭\n");
    } else {
        printf("✗ 关闭Web服务器失败\n");
    }
    
    printf("\n=== Web服务器演示完成 ===\n");
    printf("说明: 这展示了tuxcall在高性能Web服务器中的潜在应用\n");
    printf("实际使用需要内核支持TUX模块\n");
    
    return 0;
}

编译和运行

# 编译示例1
gcc -o tuxcall_example1 tuxcall_example1.c
./tuxcall_example1

# 编译示例2
gcc -o tuxcall_example2 tuxcall_example2.c
./tuxcall_example2

# 编译示例3
gcc -o tuxcall_example3 tuxcall_example3.c
./tuxcall_example3

重要注意事项

实验性功能: tuxcall是Linux内核的实验性功能，现代系统通常不支持

内核依赖: 需要特定的内核配置和TUX模块支持

系统调用号: tuxcall的系统调用号在不同内核版本中可能不同

权限要求: 某些操作可能需要root权限

兼容性: 不是标准POSIX接口，可移植性差

维护状态: TUX项目已经不再积极维护

替代方案: 现代高性能Web服务器通常使用用户空间解决方案

现代替代方案

由于tuxcall的局限性，现代高性能Web服务器通常采用：

epoll/kqueue: 高效的I/O多路复用

sendfile/splice: 零拷贝数据传输

异步I/O: 提高并发处理能力

用户空间Web服务器: 如Nginx、Apache等

内核旁路技术: 如DPDK等

通过这些示例，你可以理解tuxcall作为内核级Web服务器接口的概念，虽然在现代系统中很少使用，但它体现了Linux内核网络性能优化的设计思想。

2025-08-08

Linux系统编程

umask系统调用及示例

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

1. 函数介绍

在 Linux 系统中，每个文件和目录都有与之相关的权限（Permissions），这些权限决定了谁（用户、组、其他人）可以对文件或目录执行什么操作（读、写、执行）。

当你创建一个新文件或目录时，系统需要决定这个新文件/目录的初始权限是什么。你可能会想当然地认为，比如用 touch newfile.txt 创建文件，这个文件的权限应该是 rw-rw-rw- (666)，即所有用户都可读写。但实际上，Linux 为了安全，默认创建的文件权限会更严格一些。

umask (User File Creation Mask) 不是一个系统调用，而是一个 shell 内置命令和一个 C 标准库函数。它用于设置或查询当前用户的文件权限掩码。

这个“掩码”就像一个“过滤器”或“模具”。当你创建一个新文件或目录时，系统会先有一个“默认”的宽松权限（文件是 666，目录是 777），然后用 umask 的值来“过滤”掉（屏蔽掉）其中某些权限位，最终得到文件或目录的实际权限。

简单来说，umask 就是让你设置一个“权限过滤器”，决定了你新建的文件和目录默认有多“开放”。

典型应用场景：

用户自定义默认权限：用户可以通过 umask 命令设置自己的默认权限偏好。例如，设置 umask 077 可以让新建的文件和目录只有自己能访问，提高隐私性。
程序设置安全默认值：编写程序时，可以在程序开始时调用 umask() 来设置一个安全的掩码，确保程序创建的临时文件等不会被其他用户意外访问。

2. 函数原型

#include <sys/stat.h> // 包含 umask 函数声明

// 设置文件权限掩码并返回旧的掩码
mode_t umask(mode_t mask);

3. 功能

设置调用进程（及其子进程）的文件权限创建掩码为 mask，并返回调用前的旧掩码。

4. 参数

mask:

mode_t 类型。
指定新的文件权限掩码。这个值通常用八进制表示（以 0 开头，如 022, 077, 002）。
掩码中的位为 1 表示对应的权限将被屏蔽（从默认权限中移除）。
掩码中的位为 0 表示对应的权限不会被屏蔽（保留默认权限中的该位）。

5. 返回值

总是返回调用 umask 之前的旧掩码。这使得程序可以临时改变掩码，用完后再恢复。

6. 权限计算方式

这是理解 umask 的关键：

确定默认权限：

新文件：默认权限是 666 (rw-rw-rw-)。
新目录：默认权限是 777 (rwxrwxrwx)。

应用掩码：将默认权限与 umask 进行按位与非 (& ~) 操作。

最终权限 = 默认权限 & (~ umask)

示例：

umask 022:

文件默认权限：666 (110 110 110)
umask：022 (000 010 010)
~umask：755 (111 101 101)
文件最终权限：666 & 755 = 644 (rw-r–r–)
目录默认权限：777 (111 111 111)
目录最终权限：777 & 755 = 755 (rwxr-xr-x)
效果：同组用户和其他用户失去了写权限。

umask 077:

文件默认权限：666 (110 110 110)
umask：077 (000 111 111)
~umask：700 (111 000 000)
文件最终权限：666 & 700 = 600 (rw——-)
目录默认权限：777 (111 111 111)
目录最终权限：777 & 700 = 700 (rwx——)
效果：只有文件所有者有权限，同组和其他用户没有任何权限。这是非常私密的设置。

umask 002:

文件默认权限：666 (110 110 110)
umask：002 (000 000 010)
~umask：775 (111 111 101)
文件最终权限：666 & 775 = 664 (rw-rw-r–)
目录默认权限：777 (111 111 111)
目录最终权限：777 & 775 = 775 (rwxrwxr-x)
效果：只有“其他人”失去了写权限，组内用户有完全权限。常用于协作环境。

7. 相似函数或关联函数

chmod: 用于更改已存在文件或目录的权限。
mkdir / open / creat: 这些创建文件或目录的函数会受到 umask 的影响。
umask shell 命令: 用于在 shell 中查看或设置当前 shell 会话的 umask 值。

8. 示例代码

下面的示例演示了如何在 C 程序中使用 umask() 函数来控制创建文件和目录的默认权限。

#define _GNU_SOURCE // 启用 GNU 扩展
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h> // 包含 umask, mkdir, stat
#include <fcntl.h>    // 包含 open, O_* flags
#include <string.h>
#include <errno.h>

// 辅助函数：将 mode_t 转换为字符串表示 (简化版)
void print_permissions(mode_t mode) {
    printf( (mode & S_IRUSR) ? "r" : "-");
    printf( (mode & S_IWUSR) ? "w" : "-");
    printf( (mode & S_IXUSR) ? "x" : "-");
    printf( (mode & S_IRGRP) ? "r" : "-");
    printf( (mode & S_IWGRP) ? "w" : "-");
    printf( (mode & S_IXGRP) ? "x" : "-");
    printf( (mode & S_IROTH) ? "r" : "-");
    printf( (mode & S_IWOTH) ? "w" : "-");
    printf( (mode & S_IXOTH) ? "x" : "-");
}

// 辅助函数：获取并打印文件/目录的权限
void check_permissions(const char* path) {
    struct stat sb;
    if (stat(path, &sb) == 0) {
        printf("Permissions for '%s': ", path);
        print_permissions(sb.st_mode);
        printf(" (%o)\n", sb.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO));
    } else {
        perror("stat");
    }
}

int main() {
    mode_t old_mask;
    int fd;

    printf("--- Demonstrating umask ---\n");
    printf("PID: %d\n", getpid());

    // 1. 查看当前的 umask 值
    // 通过设置 umask(0) 并立即恢复旧值来查询
    old_mask = umask(0);
    umask(old_mask); // 立即恢复
    printf("Initial umask: %03o\n", old_mask);

    // 2. 创建文件和目录，使用初始 umask
    printf("\n--- Creating files/dirs with initial umask ---\n");
    fd = open("file_with_initial_umask.txt", O_CREAT | O_WRONLY | O_TRUNC, 0666);
    if (fd != -1) close(fd);
    mkdir("dir_with_initial_umask", 0777);
    check_permissions("file_with_initial_umask.txt");
    check_permissions("dir_with_initial_umask");

    // 3. 改变 umask 为 077 (非常私密)
    printf("\n--- Changing umask to 077 ---\n");
    old_mask = umask(0077); // 返回旧的 umask
    printf("Old umask was: %03o\n", old_mask);
    printf("New umask is: 077\n");

    // 4. 再次创建文件和目录
    fd = open("file_with_umask_077.txt", O_CREAT | O_WRONLY | O_TRUNC, 0666);
    if (fd != -1) close(fd);
    mkdir("dir_with_umask_077", 0777);
    check_permissions("file_with_umask_077.txt");
    check_permissions("dir_with_umask_077");

    // 5. 改变 umask 为 002 (组协作)
    printf("\n--- Changing umask to 002 ---\n");
    old_mask = umask(0002);
    printf("Old umask was: %03o\n", old_mask);
    printf("New umask is: 002\n");

    // 6. 再次创建文件和目录
    fd = open("file_with_umask_002.txt", O_CREAT | O_WRONLY | O_TRUNC, 0666);
    if (fd != -1) close(fd);
    mkdir("dir_with_umask_002", 0777);
    check_permissions("file_with_umask_002.txt");
    check_permissions("dir_with_umask_002");

    // 7. 恢复原始 umask
    printf("\n--- Restoring original umask ---\n");
    umask(old_mask);
    printf("Restored umask to: %03o\n", old_mask);

    printf("\n--- Summary ---\n");
    printf("1. umask acts as a filter on default permissions (666 for files, 777 for dirs).\n");
    printf("2. Bits set to 1 in umask REMOVE the corresponding permission.\n");
    printf("3. umask 022: Owner has full access, Group/Others have read/execute (not write).\n");
    printf("4. umask 077: Only Owner has access (very private).\n");
    printf("5. umask 002: Owner/Group have full access, Others lack write (collaborative).\n");
    printf("6. The umask set in a program affects files/dirs it creates.\n");

    // 8. 清理 (可选)
    // unlink("file_with_initial_umask.txt");
    // rmdir("dir_with_initial_umask");
    // unlink("file_with_umask_077.txt");
    // rmdir("dir_with_umask_077");
    // unlink("file_with_umask_002.txt");
    // rmdir("dir_with_umask_002");

    return 0;
}

9. 编译和运行

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

# 运行程序
./umask_example

10. 预期输出 (取决于你运行时的初始 umask)

假设你的初始 umask 是 022：

--- Demonstrating umask ---
PID: 12345
Initial umask: 022

--- Creating files/dirs with initial umask ---
Permissions for 'file_with_initial_umask.txt': rw-r--r-- (644)
Permissions for 'dir_with_initial_umask': rwxr-xr-x (755)

--- Changing umask to 077 ---
Old umask was: 022
New umask is: 077
Permissions for 'file_with_umask_077.txt': rw------- (600)
Permissions for 'dir_with_umask_077': rwx------ (700)

--- Changing umask to 002 ---
Old umask was: 077
New umask is: 002
Permissions for 'file_with_umask_002.txt': rw-rw-r-- (664)
Permissions for 'dir_with_umask_002': rwxrwxr-x (775)

--- Restoring original umask ---
Restored umask to: 002

--- Summary ---
1. umask acts as a filter on default permissions (666 for files, 777 for dirs).
2. Bits set to 1 in umask REMOVE the corresponding permission.
3. umask 022: Owner has full access, Group/Others have read/execute (not write).
4. umask 077: Only Owner has access (very private).
5. umask 002: Owner/Group have full access, Others lack write (collaborative).
6. The umask set in a program affects files/dirs it creates.

11. 在 Shell 中使用 umask 命令

你也可以直接在终端中使用 umask 命令：

# 查看当前 umask
umask

# 设置 umask 为 077
umask 077

# 创建一个文件测试权限
touch test_file_umask_077.txt
ls -l test_file_umask_077.txt
# 输出类似：-rw------- 1 user user 0 date time test_file_umask_077.txt

# 恢复为常见的 022
umask 022
touch test_file_umask_022.txt
ls -l test_file_umask_022.txt
# 输出类似：-rw-r--r-- 1 user user 0 date time test_file_umask_022.txt

12. 总结

umask() 函数（以及 umask shell 命令）是 Linux 系统中控制新建文件和目录默认权限的重要工具。

它通过一个“掩码”来过滤掉默认权限中的某些位。
理解其计算方式（默认权限 & ~umask）是掌握它的关键。

常见的 umask 值：

022：最常见的默认值，保护文件不被同组和他人修改。
077：最私密，只有所有者能访问。
002：协作环境常用，保护文件不被他人修改，但同组用户有完全权限。

在编写需要创建文件的程序时，合理设置 umask 可以增强程序的安全性。

它只影响新创建的文件和目录，不影响已存在的文件。

2025-08-08

Linux系统编程

umount2系统调用及示例

umount2 函数详解

函数介绍

umount2 是Linux系统调用，用于卸载文件系统。它是 umount 函数的增强版本，支持更多的卸载选项和标志。通过 umount2，程序可以更精细地控制文件系统的卸载过程，包括强制卸载、延迟卸载等高级功能。

函数原型

1
2
3

#include <sys/mount.h>
int umount2(const char *target, int flags);

功能

umount2 卸载指定挂载点的文件系统，并支持多种卸载标志来控制卸载行为。它可以处理繁忙的文件系统、只读文件系统等情况，提供更灵活的卸载选项。

参数

*const char target: 要卸载的文件系统挂载点路径
int flags: 卸载标志，控制卸载行为

返回值

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

相似函数，或关联函数

umount: 基础卸载函数（等同于umount2(target, 0)）
mount: 挂载文件系统
getmntent: 获取挂载信息
/proc/mounts: 挂载信息文件

示例代码

示例1：基础umount2使用

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

/**
 * 显示当前挂载信息
 */
void show_mount_info() {
    printf("=== 当前挂载信息 ===\n");
    system("cat /proc/mounts | head -10");  // 显示前10行挂载信息
    printf("\n");
}

/**
 * 创建测试挂载点
 */
int create_test_mountpoint(const char *mountpoint) {
    struct stat st;
    
    // 检查挂载点是否存在
    if (stat(mountpoint, &st) == 0) {
        printf("挂载点 %s 已存在\n", mountpoint);
        return 0;
    }
    
    // 创建挂载点目录
    if (mkdir(mountpoint, 0755) == -1) {
        perror("创建挂载点目录失败");
        return -1;
    }
    
    printf("创建挂载点: %s\n", mountpoint);
    return 0;
}

/**
 * 演示基础umount2使用方法
 */
int demo_umount2_basic() {
    const char *test_mountpoint = "/tmp/test_umount2";
    int result;
    
    printf("=== 基础umount2使用示例 ===\n");
    
    // 显示原始挂载信息
    printf("1. 原始挂载信息:\n");
    show_mount_info();
    
    // 创建测试挂载点
    printf("2. 创建测试挂载点:\n");
    if (create_test_mountpoint(test_mountpoint) != 0) {
        return -1;
    }
    
    // 尝试卸载不存在的挂载点（演示错误处理）
    printf("3. 尝试卸载不存在的挂载点:\n");
    printf("   卸载目标: %s\n", test_mountpoint);
    
    result = umount2(test_mountpoint, 0);
    if (result == -1) {
        printf("   ✓ 卸载失败（预期结果）: %s\n", strerror(errno));
        if (errno == EINVAL) {
            printf("   原因：指定的挂载点不存在\n");
        } else if (errno == EPERM) {
            printf("   原因：权限不足\n");
        } else if (errno == EBUSY) {
            printf("   原因：挂载点正忙\n");
        }
    } else {
        printf("   ✗ 卸载意外成功\n");
    }
    
    // 演示不同卸载标志
    printf("\n4. 卸载标志说明:\n");
    printf("   0: 普通卸载\n");
    printf("   MNT_FORCE: 强制卸载\n");
    printf("   MNT_DETACH: 延迟卸载\n");
    printf("   MNT_EXPIRE: 标记为过期\n");
    
    // 清理测试挂载点
    printf("\n5. 清理测试挂载点:\n");
    if (rmdir(test_mountpoint) == 0) {
        printf("   ✓ 测试挂载点清理成功\n");
    } else {
        printf("   ✗ 测试挂载点清理失败: %s\n", strerror(errno));
    }
    
    return 0;
}

int main() {
    return demo_umount2_basic();
}

示例2：文件系统挂载和卸载管理

#include <sys/mount.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <mntent.h>

/**
 * 挂载点管理器结构
 */
typedef struct {
    char mountpoint&#91;256];
    char filesystem&#91;32];
    char device&#91;256];
    int is_mounted;
    unsigned long mount_options;
} mount_manager_t;

/**
 * 初始化挂载点管理器
 */
int init_mount_manager(mount_manager_t *manager, const char *mountpoint, 
                      const char *device, const char *filesystem) {
    strncpy(manager->mountpoint, mountpoint, sizeof(manager->mountpoint) - 1);
    manager->mountpoint&#91;sizeof(manager->mountpoint) - 1] = '\0';
    
    strncpy(manager->device, device, sizeof(manager->device) - 1);
    manager->device&#91;sizeof(manager->device) - 1] = '\0';
    
    strncpy(manager->filesystem, filesystem, sizeof(manager->filesystem) - 1);
    manager->filesystem&#91;sizeof(manager->filesystem) - 1] = '\0';
    
    manager->is_mounted = 0;
    manager->mount_options = 0;
    
    printf("挂载点管理器初始化:\n");
    printf("  挂载点: %s\n", manager->mountpoint);
    printf("  设备: %s\n", manager->device);
    printf("  文件系统: %s\n", manager->filesystem);
    
    return 0;
}

/**
 * 检查挂载点是否存在
 */
int is_mountpoint_exists(const char *mountpoint) {
    FILE *fp = setmntent("/proc/mounts", "r");
    if (!fp) {
        return -1;
    }
    
    struct mntent *mnt;
    int exists = 0;
    
    while ((mnt = getmntent(fp)) != NULL) {
        if (strcmp(mnt->mnt_dir, mountpoint) == 0) {
            exists = 1;
            break;
        }
    }
    
    endmntent(fp);
    return exists;
}

/**
 * 挂载文件系统
 */
int mount_filesystem(mount_manager_t *manager) {
    // 创建挂载点
    struct stat st;
    if (stat(manager->mountpoint, &st) == -1) {
        if (mkdir(manager->mountpoint, 0755) == -1) {
            perror("创建挂载点失败");
            return -1;
        }
        printf("创建挂载点: %s\n", manager->mountpoint);
    }
    
    // 执行挂载
    printf("挂载文件系统:\n");
    printf("  设备: %s\n", manager->device);
    printf("  挂载点: %s\n", manager->mountpoint);
    printf("  文件系统: %s\n", manager->filesystem);
    
    // 注意：实际挂载需要root权限和有效设备
    // 这里仅演示调用方式
    printf("  注意：实际挂载需要root权限和有效设备\n");
    
    manager->is_mounted = 1;
    return 0;
}

/**
 * 卸载文件系统（使用umount2）
 */
int unmount_filesystem(mount_manager_t *manager, int flags) {
    printf("卸载文件系统:\n");
    printf("  挂载点: %s\n", manager->mountpoint);
    printf("  卸载标志: 0x%x\n", flags);
    
    // 检查挂载点是否存在
    if (!is_mountpoint_exists(manager->mountpoint)) {
        printf("  挂载点不存在，无需卸载\n");
        manager->is_mounted = 0;
        return 0;
    }
    
    // 执行卸载
    int result = umount2(manager->mountpoint, flags);
    if (result == 0) {
        printf("  ✓ 文件系统卸载成功\n");
        manager->is_mounted = 0;
        
        // 清理挂载点目录
        if (rmdir(manager->mountpoint) == 0) {
            printf("  ✓ 挂载点目录清理成功\n");
        } else {
            printf("  ✗ 挂载点目录清理失败: %s\n", strerror(errno));
        }
    } else {
        printf("  ✗ 文件系统卸载失败: %s\n", strerror(errno));
        if (errno == EBUSY) {
            printf("    原因：文件系统正忙\n");
        } else if (errno == EINVAL) {
            printf("    原因：无效的挂载点\n");
        } else if (errno == EPERM) {
            printf("    原因：权限不足\n");
        }
    }
    
    return result;
}

/**
 * 演示文件系统挂载和卸载管理
 */
int demo_filesystem_management() {
    mount_manager_t manager;
    const char *test_mountpoint = "/tmp/test_fs_manager";
    const char *test_device = "/dev/loop0";  // 示例设备
    const char *test_filesystem = "ext4";
    
    printf("=== 文件系统挂载和卸载管理演示 ===\n");
    
    // 初始化管理器
    printf("1. 初始化挂载点管理器:\n");
    if (init_mount_manager(&manager, test_mountpoint, test_device, test_filesystem) != 0) {
        return -1;
    }
    
    // 显示当前挂载状态
    printf("\n2. 当前挂载状态检查:\n");
    int exists = is_mountpoint_exists(manager.mountpoint);
    if (exists == 1) {
        printf("  挂载点已存在\n");
    } else if (exists == 0) {
        printf("  挂载点不存在\n");
    } else {
        printf("  无法检查挂载状态\n");
    }
    
    // 模拟挂载操作
    printf("\n3. 模拟挂载操作:\n");
    if (mount_filesystem(&manager) != 0) {
        printf("挂载操作失败\n");
        return -1;
    }
    
    // 演示不同卸载方式
    printf("\n4. 演示不同卸载方式:\n");
    
    // 方式1：普通卸载
    printf("  方式1：普通卸载 (MNT_UMOUNT):\n");
    unmount_filesystem(&manager, 0);
    
    // 方式2：强制卸载
    printf("\n  方式2：强制卸载 (MNT_FORCE):\n");
    unmount_filesystem(&manager, MNT_FORCE);
    
    // 方式3：延迟卸载
    printf("\n  方式3：延迟卸载 (MNT_DETACH):\n");
    unmount_filesystem(&manager, MNT_DETACH);
    
    // 方式4：过期卸载
    printf("\n  方式4：过期卸载 (MNT_EXPIRE):\n");
    unmount_filesystem(&manager, MNT_EXPIRE);
    
    // 显示最终状态
    printf("\n5. 最终状态:\n");
    printf("  挂载点状态: %s\n", manager.is_mounted ? "已挂载" : "未挂载");
    
    return 0;
}

int main() {
    return demo_filesystem_management();
}

示例3：安全卸载工具

#include <sys/mount.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <mntent.h>
#include <signal.h>
#include <sys/wait.h>

/**
 * 安全卸载结果结构
 */
typedef struct {
    char mountpoint&#91;256];
    int attempts;
    int success;
    int force_used;
    int detach_used;
    int final_status;
    char error_message&#91;256];
} safe_unmount_result_t;

/**
 * 检查挂载点是否正在使用
 */
int is_mountpoint_busy(const char *mountpoint) {
    // 检查是否有进程在使用该挂载点
    char command&#91;512];
    snprintf(command, sizeof(command), "lsof %s 2>/dev/null | wc -l", mountpoint);
    
    FILE *fp = popen(command, "r");
    if (fp) {
        char buffer&#91;16];
        if (fgets(buffer, sizeof(buffer), fp)) {
            int count = atoi(buffer);
            pclose(fp);
            return count > 0;
        }
        pclose(fp);
    }
    
    return 0;  // 默认认为不忙
}

/**
 * 显示挂载点信息
 */
void show_mountpoint_info(const char *mountpoint) {
    FILE *fp = setmntent("/proc/mounts", "r");
    if (!fp) {
        printf("无法读取挂载信息\n");
        return;
    }
    
    struct mntent *mnt;
    printf("挂载点详细信息:\n");
    
    while ((mnt = getmntent(fp)) != NULL) {
        if (strcmp(mnt->mnt_dir, mountpoint) == 0) {
            printf("  设备: %s\n", mnt->mnt_fsname);
            printf("  挂载点: %s\n", mnt->mnt_dir);
            printf("  文件系统: %s\n", mnt->mnt_type);
            printf("  选项: %s\n", mnt->mnt_opts);
            break;
        }
    }
    
    endmntent(fp);
}

/**
 * 安全卸载文件系统
 */
int safe_unmount_filesystem(const char *mountpoint, safe_unmount_result_t *result) {
    int attempt = 0;
    const int max_attempts = 5;
    int result_code = 0;
    
    // 初始化结果结构
    strncpy(result->mountpoint, mountpoint, sizeof(result->mountpoint) - 1);
    result->mountpoint&#91;sizeof(result->mountpoint) - 1] = '\0';
    result->attempts = 0;
    result->success = 0;
    result->force_used = 0;
    result->detach_used = 0;
    result->final_status = 0;
    result->error_message&#91;0] = '\0';
    
    printf("=== 安全卸载文件系统 ===\n");
    printf("目标挂载点: %s\n", mountpoint);
    
    // 检查挂载点是否存在
    if (!is_mountpoint_exists(mountpoint)) {
        printf("挂载点不存在，无需卸载\n");
        result->success = 1;
        return 0;
    }
    
    // 显示挂载点信息
    show_mountpoint_info(mountpoint);
    
    // 检查挂载点是否正在使用
    printf("检查挂载点使用状态...\n");
    if (is_mountpoint_busy(mountpoint)) {
        printf("警告：挂载点正在使用中\n");
    } else {
        printf("挂载点当前未被使用\n");
    }
    
    // 尝试多次卸载
    while (attempt < max_attempts) {
        attempt++;
        result->attempts = attempt;
        printf("第 %d 次卸载尝试:\n", attempt);
        
        // 根据尝试次数选择不同的卸载策略
        int flags = 0;
        if (attempt > 1) {
            printf("  挂载点可能正忙，等待片刻...\n");
            sleep(1);
        }
        
        if (attempt == 2) {
            // 第二次尝试：发送SIGTERM给可能使用该挂载点的进程
            printf("  尝试通知使用该挂载点的进程...\n");
        } else if (attempt == 3) {
            flags = MNT_FORCE;  // 强制卸载
            result->force_used = 1;
            printf("  使用强制卸载模式\n");
        } else if (attempt == 4) {
            flags = 0;  // 再次尝试普通卸载
            printf("  再次尝试普通卸载\n");
        } else if (attempt == 5) {
            flags = MNT_DETACH;  // 延迟卸载
            result->detach_used = 1;
            printf("  使用延迟卸载模式\n");
        }
        
        // 执行卸载
        result_code = umount2(mountpoint, flags);
        if (result_code == 0) {
            printf("  ✓ 卸载成功\n");
            result->success = 1;
            result->final_status = 0;
            break;
        } else {
            printf("  ✗ 卸载失败: %s\n", strerror(errno));
            result->final_status = errno;
            strncpy(result->error_message, strerror(errno), sizeof(result->error_message) - 1);
            result->error_message&#91;sizeof(result->error_message) - 1] = '\0';
            
            // 根据错误类型决定是否继续尝试
            if (errno == EINVAL) {
                printf("  无效的挂载点，停止尝试\n");
                break;
            } else if (errno == EPERM) {
                printf("  权限不足，停止尝试\n");
                break;
            }
        }
    }
    
    // 显示最终结果
    printf("\n=== 卸载结果 ===\n");
    printf("挂载点: %s\n", result->mountpoint);
    printf("尝试次数: %d\n", result->attempts);
    printf("卸载状态: %s\n", result->success ? "成功" : "失败");
    
    if (result->success) {
        printf("卸载方式: ");
        if (result->force_used) {
            printf("强制卸载\n");
        } else if (result->detach_used) {
            printf("延迟卸载\n");
        } else {
            printf("普通卸载\n");
        }
    } else {
        printf("失败原因: %s\n", result->error_message);
        printf("最终错误码: %d\n", result->final_status);
    }
    
    return result->success ? 0 : -1;
}

/**
 * 演示安全卸载工具
 */
int demo_safe_unmount_tool() {
    safe_unmount_result_t result;
    const char *test_mountpoint = "/mnt/test_safe_unmount";
    
    printf("=== 安全卸载工具演示 ===\n");
    
    // 检查权限
    uid_t uid = getuid();
    printf("权限检查:\n");
    printf("  当前用户ID: %d\n", uid);
    if (uid == 0) {
        printf("  ✓ 具有root权限\n");
    } else {
        printf("  ✗ 没有root权限，卸载操作可能失败\n");
        printf("  提示：文件系统卸载通常需要root权限\n");
    }
    
    // 显示当前挂载信息
    printf("\n当前挂载信息:\n");
    system("cat /proc/mounts | grep -E '(tmp|mnt)' | head -5");
    
    // 演示安全卸载
    printf("\n演示安全卸载:\n");
    printf("目标挂载点: %s\n", test_mountpoint);
    
    // 注意：实际演示中避免卸载真实的重要文件系统
    // 这里仅演示调用方式和错误处理
    
    // 模拟卸载不存在的挂载点
    printf("\n1. 卸载不存在的挂载点:\n");
    if (safe_unmount_filesystem(test_mountpoint, &result) != 0) {
        printf("卸载不存在的挂载点（预期失败）\n");
    }
    
    // 演示卸载过程中的错误处理
    printf("\n2. 卸载错误处理演示:\n");
    
    // 尝试卸载根目录（应该失败）
    printf("尝试卸载根目录:\n");
    safe_unmount_filesystem("/", &result);
    
    // 尝试卸载无效路径
    printf("\n尝试卸载无效路径:\n");
    safe_unmount_filesystem("/invalid/mount/point", &result);
    
    // 显示安全卸载建议
    printf("\n=== 安全卸载建议 ===\n");
    printf("1. 卸载前检查:\n");
    printf("   ✓ 确认具有足够权限\n");
    printf("   ✓ 检查挂载点是否存在\n");
    printf("   ✓ 确认没有进程使用该挂载点\n");
    printf("   ✓ 备份重要数据\n");
    
    printf("\n2. 卸载策略:\n");
    printf("   ✓ 首先尝试普通卸载\n");
    printf("   ✓ 失败后等待并重试\n");
    printf("   ✓ 必要时使用强制卸载\n");
    printf("   ✓ 最后考虑延迟卸载\n");
    
    printf("\n3. 错误处理:\n");
    printf("   ✓ 检查返回值和errno\n");
    printf("   ✓ 根据错误类型采取不同措施\n");
    printf("   ✓ 记录卸载操作日志\n");
    printf("   ✓ 提供友好的错误信息\n");
    
    printf("\n4. 安全考虑:\n");
    printf("   ✓ 避免强制卸载重要文件系统\n");
    printf("   ✓ 确保数据一致性\n");
    printf("   ✓ 监控卸载后的系统状态\n");
    printf("   ✓ 准备恢复方案\n");
    
    return 0;
}

int main() {
    return demo_safe_unmount_tool();
}

示例4：批量卸载管理器

#include <sys/mount.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <mntent.h>
#include <fnmatch.h>

/**
 * 批量卸载条目结构
 */
typedef struct {
    char mountpoint&#91;256];
    char filesystem&#91;32];
    char device&#91;256];
    int selected_for_unmount;
    int unmount_result;
    char result_message&#91;128];
} batch_unmount_entry_t;

/**
 * 批量卸载管理器结构
 */
typedef struct {
    batch_unmount_entry_t entries&#91;64];
    int entry_count;
    int selected_count;
    int successful_count;
    int failed_count;
} batch_unmount_manager_t;

/**
 * 初始化批量卸载管理器
 */
void init_batch_unmount_manager(batch_unmount_manager_t *manager) {
    memset(manager, 0, sizeof(batch_unmount_manager_t));
    printf("批量卸载管理器初始化完成\n");
}

/**
 * 从/proc/mounts加载挂载信息
 */
int load_mount_entries(batch_unmount_manager_t *manager) {
    FILE *fp = setmntent("/proc/mounts", "r");
    if (!fp) {
        printf("无法读取挂载信息: %s\n", strerror(errno));
        return -1;
    }
    
    struct mntent *mnt;
    int count = 0;
    
    printf("加载挂载信息:\n");
    
    while ((mnt = getmntent(fp)) != NULL && count < 64) {
        // 过滤系统挂载点
        if (strncmp(mnt->mnt_dir, "/proc", 5) == 0 ||
            strncmp(mnt->mnt_dir, "/sys", 4) == 0 ||
            strncmp(mnt->mnt_dir, "/dev", 4) == 0) {
            continue;  // 跳过系统挂载点
        }
        
        batch_unmount_entry_t *entry = &manager->entries&#91;count];
        strncpy(entry->mountpoint, mnt->mnt_dir, sizeof(entry->mountpoint) - 1);
        entry->mountpoint&#91;sizeof(entry->mountpoint) - 1] = '\0';
        
        strncpy(entry->filesystem, mnt->mnt_type, sizeof(entry->filesystem) - 1);
        entry->filesystem&#91;sizeof(entry->filesystem) - 1] = '\0';
        
        strncpy(entry->device, mnt->mnt_fsname, sizeof(entry->device) - 1);
        entry->device&#91;sizeof(entry->device) - 1] = '\0';
        
        entry->selected_for_unmount = 0;
        entry->unmount_result = 0;
        entry->result_message&#91;0] = '\0';
        
        printf("  %s (%s on %s)\n", entry->mountpoint, entry->filesystem, entry->device);
        count++;
    }
    
    endmntent(fp);
    manager->entry_count = count;
    printf("共加载 %d 个挂载点\n", count);
    
    return 0;
}

/**
 * 根据模式选择挂载点
 */
int select_mountpoints_by_pattern(batch_unmount_manager_t *manager, const char *pattern) {
    int selected = 0;
    
    printf("根据模式选择挂载点: %s\n", pattern);
    
    for (int i = 0; i < manager->entry_count; i++) {
        batch_unmount_entry_t *entry = &manager->entries&#91;i];
        
        if (fnmatch(pattern, entry->mountpoint, 0) == 0) {
            entry->selected_for_unmount = 1;
            selected++;
            printf("  选中: %s\n", entry->mountpoint);
        }
    }
    
    manager->selected_count = selected;
    printf("共选中 %d 个挂载点\n", selected);
    
    return selected;
}

/**
 * 执行批量卸载
 */
int execute_batch_unmount(batch_unmount_manager_t *manager, int flags) {
    printf("=== 执行批量卸载 ===\n");
    printf("卸载标志: 0x%x\n", flags);
    printf("选中挂载点数量: %d\n", manager->selected_count);
    
    manager->successful_count = 0;
    manager->failed_count = 0;
    
    for (int i = 0; i < manager->entry_count; i++) {
        batch_unmount_entry_t *entry = &manager->entries&#91;i];
        
        if (!entry->selected_for_unmount) {
            continue;
        }
        
        printf("\n卸载 %s:\n", entry->mountpoint);
        
        // 执行卸载
        int result = umount2(entry->mountpoint, flags);
        entry->unmount_result = result;
        
        if (result == 0) {
            printf("  ✓ 卸载成功\n");
            manager->successful_count++;
            strncpy(entry->result_message, "成功", sizeof(entry->result_message) - 1);
        } else {
            printf("  ✗ 卸载失败: %s\n", strerror(errno));
            manager->failed_count++;
            strncpy(entry->result_message, strerror(errno), sizeof(entry->result_message) - 1);
            entry->result_message&#91;sizeof(entry->result_message) - 1] = '\0';
        }
    }
    
    printf("\n=== 批量卸载结果 ===\n");
    printf("成功: %d\n", manager->successful_count);
    printf("失败: %d\n", manager->failed_count);
    printf("总计: %d\n", manager->successful_count + manager->failed_count);
    
    // 显示详细结果
    printf("\n详细结果:\n");
    for (int i = 0; i < manager->entry_count; i++) {
        batch_unmount_entry_t *entry = &manager->entries&#91;i];
        if (entry->selected_for_unmount) {
            printf("  %s: %s (%s)\n", 
                   entry->mountpoint,
                   entry->unmount_result == 0 ? "✓" : "✗",
                   entry->result_message);
        }
    }
    
    return (manager->failed_count == 0) ? 0 : -1;
}

/**
 * 显示批量卸载摘要
 */
void show_batch_unmount_summary(const batch_unmount_manager_t *manager) {
    printf("=== 批量卸载摘要 ===\n");
    printf("总挂载点数: %d\n", manager->entry_count);
    printf("选中卸载数: %d\n", manager->selected_count);
    printf("成功卸载数: %d\n", manager->successful_count);
    printf("失败卸载数: %d\n", manager->failed_count);
    printf("成功率: %.1f%%\n", 
           manager->selected_count > 0 ? 
           (double)manager->successful_count / manager->selected_count * 100 : 0);
    
    if (manager->failed_count > 0) {
        printf("\n失败详情:\n");
        for (int i = 0; i < manager->entry_count; i++) {
            const batch_unmount_entry_t *entry = &manager->entries&#91;i];
            if (entry->selected_for_unmount && entry->unmount_result != 0) {
                printf("  %s: %s\n", entry->mountpoint, entry->result_message);
            }
        }
    }
}

/**
 * 演示批量卸载管理器
 */
int demo_batch_unmount_manager() {
    batch_unmount_manager_t manager;
    
    printf("=== 批量卸载管理器演示 ===\n");
    
    // 初始化管理器
    printf("1. 初始化批量卸载管理器:\n");
    init_batch_unmount_manager(&manager);
    
    // 加载挂载信息
    printf("\n2. 加载挂载信息:\n");
    if (load_mount_entries(&manager) != 0) {
        printf("加载挂载信息失败\n");
        return -1;
    }
    
    // 显示可用的卸载选项
    printf("\n3. 可用挂载点:\n");
    for (int i = 0; i < manager.entry_count && i < 10; i++) {
        const batch_unmount_entry_t *entry = &manager.entries&#91;i];
        printf("  %d. %s (%s)\n", i + 1, entry->mountpoint, entry->filesystem);
    }
    
    if (manager.entry_count > 10) {
        printf("  ... (还有 %d 个挂载点)\n", manager.entry_count - 10);
    }
    
    // 演示模式匹配选择
    printf("\n4. 模式匹配选择演示:\n");
    
    // 选择/tmp目录下的挂载点
    select_mountpoints_by_pattern(&manager, "/tmp/*");
    
    // 选择/media目录下的挂载点
    select_mountpoints_by_pattern(&manager, "/media/*");
    
    // 选择所有ext4文件系统
    printf("\n根据文件系统类型选择:\n");
    int ext4_selected = 0;
    for (int i = 0; i < manager.entry_count; i++) {
        batch_unmount_entry_t *entry = &manager.entries&#91;i];
        if (strcmp(entry->filesystem, "ext4") == 0) {
            entry->selected_for_unmount = 1;
            ext4_selected++;
            printf("  选中ext4文件系统: %s\n", entry->mountpoint);
        }
    }
    printf("共选中 %d 个ext4文件系统\n", ext4_selected);
    
    // 显示选中结果
    printf("\n5. 选中挂载点列表:\n");
    for (int i = 0; i < manager.entry_count; i++) {
        const batch_unmount_entry_t *entry = &manager.entries&#91;i];
        if (entry->selected_for_unmount) {
            printf("  %s (%s on %s)\n", 
                   entry->mountpoint, entry->filesystem, entry->device);
        }
    }
    
    // 演示不同卸载模式
    printf("\n6. 不同卸载模式演示:\n");
    
    // 模式1：普通卸载
    printf("模式1：普通卸载\n");
    printf("注意：实际演示中跳过真实卸载操作以避免影响系统\n");
    
    // 模式2：强制卸载
    printf("\n模式2：强制卸载\n");
    printf("卸载标志: MNT_FORCE (0x%x)\n", MNT_FORCE);
    
    // 模式3：延迟卸载
    printf("\n模式3：延迟卸载\n");
    printf("卸载标志: MNT_DETACH (0x%x)\n", MNT_DETACH);
    
    // 模式4：过期卸载
    printf("\n模式4：过期卸载\n");
    printf("卸载标志: MNT_EXPIRE (0x%x)\n", MNT_EXPIRE);
    
    // 显示批量卸载策略
    printf("\n=== 批量卸载策略 ===\n");
    printf("1. 选择策略:\n");
    printf("   ✓ 支持通配符模式匹配\n");
    printf("   ✓ 支持文件系统类型筛选\n");
    printf("   ✓ 支持设备类型筛选\n");
    printf("   ✓ 支持交互式选择\n");
    
    printf("\n2. 卸载策略:\n");
    printf("   ✓ 优先尝试普通卸载\n");
    printf("   ✓ 失败后尝试强制卸载\n");
    printf("   ✓ 最后考虑延迟卸载\n");
    printf("   ✓ 支持批量重试机制\n");
    
    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() {
    return demo_batch_unmount_manager();
}

示例5：文件系统监控和管理

#include <sys/mount.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <mntent.h>
#include <time.h>
#include <sys/statvfs.h>

/**
 * 文件系统统计信息结构
 */
typedef struct {
    char mountpoint&#91;256];
    char filesystem&#91;32];
    char device&#91;256];
    unsigned long long total_size_kb;
    unsigned long long used_size_kb;
    unsigned long long available_size_kb;
    double usage_percent;
    time_t last_check_time;
    int is_mounted;
    int readonly;
} filesystem_stats_t;

/**
 * 文件系统监控器结构
 */
typedef struct {
    filesystem_stats_t filesystems&#91;32];
    int fs_count;
    time_t last_update_time;
    int monitoring_enabled;
} fs_monitor_t;

/**
 * 更新文件系统统计信息
 */
int update_filesystem_stats(filesystem_stats_t *fs) {
    struct statvfs buf;
    
    if (statvfs(fs->mountpoint, &buf) != 0) {
        printf("获取文件系统统计信息失败: %s\n", strerror(errno));
        return -1;
    }
    
    // 计算空间使用情况
    unsigned long long block_size = buf.f_frsize ? buf.f_frsize : buf.f_bsize;
    fs->total_size_kb = (unsigned long long)buf.f_blocks * block_size / 1024;
    fs->available_size_kb = (unsigned long long)buf.f_bavail * block_size / 1024;
    fs->used_size_kb = fs->total_size_kb - (unsigned long long)buf.f_bfree * block_size / 1024;
    
    if (fs->total_size_kb > 0) {
        fs->usage_percent = (double)fs->used_size_kb / fs->total_size_kb * 100;
    } else {
        fs->usage_percent = 0.0;
    }
    
    fs->last_check_time = time(NULL);
    
    // 检查是否为只读
    fs->readonly = (buf.f_flag & ST_RDONLY) ? 1 : 0;
    
    return 0;
}

/**
 * 从/proc/mounts加载文件系统信息
 */
int load_filesystem_info(fs_monitor_t *monitor) {
    FILE *fp = setmntent("/proc/mounts", "r");
    if (!fp) {
        printf("无法读取挂载信息: %s\n", strerror(errno));
        return -1;
    }
    
    struct mntent *mnt;
    int count = 0;
    
    while ((mnt = getmntent(fp)) != NULL && count < 32) {
        // 跳过某些系统挂载点
        if (strncmp(mnt->mnt_dir, "/proc", 5) == 0 ||
            strncmp(mnt->mnt_dir, "/sys", 4) == 0 ||
            strncmp(mnt->mnt_dir, "/dev", 4) == 0) {
            continue;
        }
        
        filesystem_stats_t *fs = &monitor->filesystems&#91;count];
        strncpy(fs->mountpoint, mnt->mnt_dir, sizeof(fs->mountpoint) - 1);
        fs->mountpoint&#91;sizeof(fs->mountpoint) - 1] = '\0';
        
        strncpy(fs->filesystem, mnt->mnt_type, sizeof(fs->filesystem) - 1);
        fs->filesystem&#91;sizeof(fs->filesystem) - 1] = '\0';
        
        strncpy(fs->device, mnt->mnt_fsname, sizeof(fs->device) - 1);
        fs->device&#91;sizeof(fs->device) - 1] = '\0';
        
        fs->is_mounted = 1;
        
        // 更新统计信息
        update_filesystem_stats(fs);
        
        count++;
    }
    
    endmntent(fp);
    monitor->fs_count = count;
    monitor->last_update_time = time(NULL);
    
    printf("加载了 %d 个文件系统信息\n", count);
    return 0;
}

/**
 * 显示文件系统统计信息
 */
void show_filesystem_stats(const filesystem_stats_t *fs) {
    char time_str&#91;64];
    strftime(time_str, sizeof(time_str), "%Y-%m-%d %H:%M:%S", localtime(&fs->last_check_time));
    
    printf("文件系统: %s\n", fs->mountpoint);
    printf("  设备: %s\n", fs->device);
    printf("  类型: %s\n", fs->filesystem);
    printf("  总空间: %.2f GB\n", fs->total_size_kb / (1024.0 * 1024.0));
    printf("  已用空间: %.2f GB (%.1f%%)\n", 
           fs->used_size_kb / (1024.0 * 1024.0), fs->usage_percent);
    printf("  可用空间: %.2f GB\n", fs->available_size_kb / (1024.0 * 1024.0));
    printf("  只读模式: %s\n", fs->readonly ? "是" : "否");
    printf("  最后检查: %s\n", time_str);
}

/**
 * 监控文件系统使用情况
 */
int monitor_filesystem_usage(fs_monitor_t *monitor, const char *mountpoint, double threshold) {
    for (int i = 0; i < monitor->fs_count; i++) {
        filesystem_stats_t *fs = &monitor->filesystems&#91;i];
        
        if (strcmp(fs->mountpoint, mountpoint) == 0) {
            // 更新统计信息
            update_filesystem_stats(fs);
            
            printf("监控文件系统 %s:\n", mountpoint);
            show_filesystem_stats(fs);
            
            // 检查使用率阈值
            if (fs->usage_percent > threshold) {
                printf("⚠ 警告: 文件系统使用率过高 (%.1f%% > %.1f%%)\n", 
                       fs->usage_percent, threshold);
                
                // 根据使用率严重程度提供建议
                if (fs->usage_percent > 95) {
                    printf("  🚨 严重: 立即清理磁盘空间\n");
                } else if (fs->usage_percent > 90) {
                    printf("  ⚠ 警告: 尽快清理磁盘空间\n");
                } else if (fs->usage_percent > 80) {
                    printf("  ℹ 提示: 考虑清理磁盘空间\n");
                }
                
                return 1;  // 超过阈值
            } else {
                printf("✓ 文件系统使用率正常 (%.1f%%)\n", fs->usage_percent);
                return 0;  // 正常
            }
        }
    }
    
    printf("未找到指定的挂载点: %s\n", mountpoint);
    return -1;  // 未找到
}

/**
 * 演示文件系统监控和管理
 */
int demo_filesystem_monitoring() {
    fs_monitor_t monitor = {0};
    uid_t uid = getuid();
    
    printf("=== 文件系统监控和管理演示 ===\n");
    
    // 权限检查
    printf("权限检查:\n");
    printf("  当前用户ID: %d\n", uid);
    if (uid == 0) {
        printf("  ✓ 具有root权限\n");
    } else {
        printf("  ℹ 普通用户权限（部分功能可能受限）\n");
    }
    
    // 加载文件系统信息
    printf("\n1. 加载文件系统信息:\n");
    if (load_filesystem_info(&monitor) != 0) {
        printf("加载文件系统信息失败\n");
        return -1;
    }
    
    // 显示所有文件系统信息
    printf("\n2. 文件系统统计信息:\n");
    for (int i = 0; i < monitor.fs_count && i < 5; i++) {
        printf("\n文件系统 %d:\n", i + 1);
        show_filesystem_stats(&monitor.filesystems&#91;i]);
    }
    
    if (monitor.fs_count > 5) {
        printf("\n... (还有 %d 个文件系统)\n", monitor.fs_count - 5);
    }
    
    // 演示使用率监控
    printf("\n3. 文件系统使用率监控演示:\n");
    
    // 监控各个文件系统
    for (int i = 0; i < monitor.fs_count && i < 3; i++) {
        filesystem_stats_t *fs = &monitor.filesystems&#91;i];
        printf("\n监控 %s:\n", fs->mountpoint);
        
        // 不同阈值的监控
        monitor_filesystem_usage(&monitor, fs->mountpoint, 80.0);  // 警告阈值
        monitor_filesystem_usage(&monitor, fs->mountpoint, 90.0);  // 严重阈值
    }
    
    // 演示umount2在监控中的应用
    printf("\n4. umount2在监控中的应用:\n");
    
    // 模拟需要卸载的情况
    printf("模拟文件系统维护场景:\n");
    
    for (int i = 0; i < monitor.fs_count && i < 2; i++) {
        filesystem_stats_t *fs = &monitor.filesystems&#91;i];
        printf("\n检查 %s 是否需要维护:\n", fs->mountpoint);
        
        // 检查使用率和只读状态
        if (fs->usage_percent > 95) {
            printf("  文件系统使用率过高 (%.1f%%)\n", fs->usage_percent);
            printf("  建议: 卸载后进行文件系统检查\n");
            
            // 演示不同卸载选项
            printf("  卸载选项:\n");
            printf("    1. 普通卸载: umount2(\"%s\", 0)\n", fs->mountpoint);
            printf("    2. 强制卸载: umount2(\"%s\", MNT_FORCE)\n", fs->mountpoint);
            printf("    3. 延迟卸载: umount2(\"%s\", MNT_DETACH)\n", fs->mountpoint);
        } else if (fs->readonly) {
            printf("  文件系统为只读模式\n");
            printf("  可能需要重新挂载为读写模式\n");
        } else {
            printf("  文件系统状态正常\n");
        }
    }
    
    // 显示监控策略和最佳实践
    printf("\n=== 文件系统监控策略 ===\n");
    printf("1. 监控频率:\n");
    printf("   ✓ 关键系统: 每分钟检查\n");
    printf("   ✓ 重要数据: 每5分钟检查\n");
    printf("   ✓ 一般用途: 每小时检查\n");
    
    printf("\n2. 阈值设置:\n");
    printf("   ✓ 警告阈值: 80%% 使用率\n");
    printf("   ✓ 严重阈值: 90%% 使用率\n");
    printf("   ✓ 紧急阈值: 95%% 使用率\n");
    
    printf("\n3. 响应策略:\n");
    printf("   ✓ 自动告警通知\n");
    printf("   ✓ 日志记录\n");
    printf("   ✓ 自动清理临时文件\n");
    printf("   ✓ 邮件/SMS通知\n");
    
    printf("\n4. umount2使用场景:\n");
    printf("   ✓ 系统维护时的安全卸载\n");
    printf("   ✓ 文件系统检查前的准备\n");
    printf("   ✓ 紧急情况下的强制卸载\n");
    printf("   ✓ 资源回收时的延迟卸载\n");
    
    // 显示安全考虑
    printf("\n=== 安全考虑 ===\n");
    printf("1. 权限管理:\n");
    printf("   ✓ 文件系统操作需要适当权限\n");
    printf("   ✓ 避免普通用户执行危险操作\n");
    printf("   ✓ 使用sudo进行权限提升\n");
    
    printf("\n2. 数据安全:\n");
    printf("   ✓ 卸载前确保数据已同步\n");
    printf("   ✓ 避免强制卸载重要数据\n");
    printf("   ✓ 备份重要文件系统\n");
    
    printf("\n3. 系统稳定性:\n");
    printf("   ✓ 避免卸载系统关键挂载点\n");
    printf("   ✓ 监控卸载操作的影响\n");
    printf("   ✓ 准备系统恢复方案\n");
    
    return 0;
}

int main() {
    return demo_filesystem_monitoring();
}

umount2 使用注意事项

系统要求：

内核版本: 支持umount2的Linux内核

权限要求: 通常需要root权限或适当的挂载权限

架构支持: 支持所有主流架构

卸载标志详解：

0: 普通卸载（默认行为）

MNT_FORCE: 强制卸载（即使文件系统正忙）

MNT_DETACH: 延迟卸载（立即返回，后台清理）

MNT_EXPIRE: 标记为过期（如果未被使用则卸载）

错误处理：

EBUSY: 文件系统正忙，无法卸载

EINVAL: 无效的挂载点

EPERM: 权限不足

EACCES: 访问被拒绝

ENOMEM: 内存不足

安全考虑：

权限验证: 确保具有足够的权限

挂载点验证: 验证挂载点的有效性

使用状态检查: 检查文件系统是否正在使用

数据同步: 确保数据已正确同步

最佳实践：

渐进式卸载: 优先尝试普通卸载，失败后再尝试强制卸载

状态检查: 卸载前后检查系统状态

日志记录: 记录所有卸载操作

错误恢复: 准备适当的错误恢复机制

用户通知: 及时通知用户操作结果

umount2标志详细说明

MNT_FORCE (1):

功能: 强制卸载文件系统
使用场景: 文件系统正忙时的紧急卸载
风险: 可能导致数据丢失或文件系统损坏

MNT_DETACH (2):

功能: 延迟卸载（懒卸载）
使用场景: 立即返回，后台清理资源
优势: 不阻塞调用进程

MNT_EXPIRE (4):

功能: 标记挂载点为过期
使用场景: 如果没有进程使用则卸载
特点: 非阻塞操作

系统调用：

// 基础卸载函数
int umount(const char *target);

// 挂载函数
int mount(const char *source, const char *target,
          const char *filesystemtype, unsigned long mountflags,
          const void *data);

命令行工具：

# 普通卸载
umount /mnt/point

# 强制卸载
umount -f /mnt/point

# 延迟卸载
umount -l /mnt/point

# 查看挂载信息
cat /proc/mounts
mount | grep point

常见使用场景

1. 系统维护：

1
2
3

// 维护前安全卸载文件系统
umount2("/mnt/data", 0);

2. 紧急处理：

1
2
3

// 紧急情况下强制卸载
umount2("/mnt/critical", MNT_FORCE);

3. 资源管理：

1
2
3

// 延迟卸载以避免阻塞
umount2("/mnt/temp", MNT_DETACH);

4. 自动化脚本：

// 批量卸载操作
for (int i = 0; i < count; i++) {
    umount2(mountpoints&#91;i], 0);
}

总结

umount2 是Linux系统中强大的文件系统卸载工具，提供了：

灵活的卸载选项: 支持普通、强制、延迟等多种卸载模式

完善的错误处理: 详细的错误码和错误信息

安全的卸载机制: 多种安全检查和保护措施

标准兼容性: 符合POSIX标准，广泛支持

通过合理使用 umount2，可以构建安全可靠的文件系统管理工具。在实际应用中，需要注意权限要求、错误处理和系统稳定性等关键问题，遵循最佳实践确保系统的安全和稳定运行。

2025-08-08

Linux系统编程

uname系统调用及示例

uname - 获取系统信息

函数介绍

uname系统调用用于获取当前Linux系统的详细信息，包括内核名称、版本、硬件架构等。这些信息对于系统管理和程序兼容性检查非常有用。

函数原型

#include <sys/utsname.h>

int uname(struct utsname *buf);

功能

获取系统标识信息，包括内核名称、网络节点名、内核版本、硬件架构等。

参数

struct utsname *buf: 指向utsname结构体的指针，用于存储系统信息struct utsname { char sysname[]; // 系统名称 (如 “Linux”) char nodename[]; // 网络节点名 (主机名) char release[]; // 内核发行版本 char version[]; // 内核版本 char machine[]; // 硬件架构 char domainname[]; // 域名 (NIS/YP) };

返回值

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

相似函数

sysinfo(): 获取系统统计信息
命令行uname工具

示例代码

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <sys/utsname.h>
#include <errno.h>
#include <string.h>

int main() {
    struct utsname system_info;
    
    printf("=== Uname函数示例 ===\n");
    
    // 调用uname获取系统信息
    if (uname(&system_info) == -1) {
        perror("uname调用失败");
        exit(EXIT_FAILURE);
    }
    
    // 打印系统信息
    printf("系统名称 (sysname): %s\n", system_info.sysname);
    printf("网络节点名 (nodename): %s\n", system_info.nodename);
    printf("内核发行版本 (release): %s\n", system_info.release);
    printf("内核版本 (version): %s\n", system_info.version);
    printf("硬件架构 (machine): %s\n", system_info.machine);
    
    #ifdef _GNU_SOURCE
    printf("域名 (domainname): %s\n", system_info.domainname);
    #endif
    
    // 示例应用：根据系统类型执行不同操作
    printf("\n=== 实际应用示例 ===\n");
    
    // 检查操作系统类型
    if (strcmp(system_info.sysname, "Linux") == 0) {
        printf("检测到Linux系统\n");
    } else {
        printf("检测到其他系统: %s\n", system_info.sysname);
    }
    
    // 检查硬件架构
    if (strcmp(system_info.machine, "x86_64") == 0) {
        printf("运行在64位x86架构上\n");
    } else if (strcmp(system_info.machine, "aarch64") == 0) {
        printf("运行在64位ARM架构上\n");
    } else {
        printf("运行在%s架构上\n", system_info.machine);
    }
    
    // 检查内核版本（简单比较）
    printf("内核版本信息: %s\n", system_info.release);
    
    // 解析版本号示例
    int major, minor, patch;
    if (sscanf(system_info.release, "%d.%d.%d", &major, &minor, &patch) == 3) {
        printf("解析的内核版本: %d.%d.%d\n", major, minor, patch);
        
        // 根据内核版本做兼容性检查
        if (major >= 4) {
            printf("内核版本 >= 4.0，支持较新特性\n");
        } else {
            printf("内核版本较低，可能需要特殊处理\n");
        }
    }
    
    // 获取主机名
    printf("主机名: %s\n", system_info.nodename);
    
    return 0;
}

uname函数详解

函数介绍

uname函数是Linux系统中用于获取系统信息的标准函数，它的名字来源于”Unix name”。这个函数就像系统的”身份证”一样，能够提供关于当前运行系统的详细信息，包括操作系统名称、版本、硬件架构等。

可以把uname想象成一个”系统信息查询员”，当你需要了解当前系统的基本信息时，它能够快速提供准确的答案。无论是在程序中需要根据系统类型执行不同逻辑，还是在调试时需要确认系统环境，uname都是一个非常实用的工具。

使用场景：

程序的系统兼容性检查
系统信息显示和日志记录
根据系统类型执行特定代码
系统管理和监控工具
软件安装程序的环境检测

函数原型

#include <sys/utsname.h>

int uname(struct utsname *buf);

功能

uname函数的主要功能是获取当前系统的标识信息。它填充一个utsname结构体，其中包含以下系统信息：

操作系统名称
网络节点名称（主机名）
操作系统发行版本
操作系统版本
硬件架构类型

参数

buf: 系统信息缓冲区

类型：struct utsname*
含义：指向utsname结构体的指针，用于存储系统信息

该结构体包含以下字段：

sysname[]: 操作系统名称
nodename[]: 网络节点名称（主机名）
release[]: 操作系统发行版本
version[]: 操作系统版本
machine[]: 硬件架构类型
domainname[]: 网络域名（某些系统支持）

返回值

成功: 返回0

失败: 返回-1，并设置errno错误码

EFAULT：buf参数指向无效内存地址
EINVAL：参数无效（理论上不会发生）

相似函数或关联函数

gethostname(): 获取主机名
sysconf(): 获取系统配置信息
getdomainname(): 获取网络域名
uname命令: 命令行下的uname工具
/proc/version: 系统版本信息文件
system(): 执行系统命令

示例代码

示例1：基础uname使用 - 获取系统信息

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

int main() {
    struct utsname system_info;
    
    printf("=== 基础uname使用示例 ===\n");
    
    // 调用uname函数获取系统信息
    if (uname(&system_info) == -1) {
        perror("uname调用失败");
        exit(EXIT_FAILURE);
    }
    
    // 显示系统信息
    printf("系统信息:\n");
    printf("----------------------------\n");
    printf("操作系统名称: %s\n", system_info.sysname);
    printf("网络节点名:   %s\n", system_info.nodename);
    printf("内核发行版:   %s\n", system_info.release);
    printf("内核版本:     %s\n", system_info.version);
    printf("硬件架构:     %s\n", system_info.machine);
    
    // 如果支持域名信息
    #ifdef _GNU_SOURCE
    printf("网络域名:     %s\n", system_info.domainname);
    #endif
    
    printf("----------------------------\n");
    
    // 分析系统类型
    printf("\n系统类型分析:\n");
    if (strcmp(system_info.sysname, "Linux") == 0) {
        printf("✓ 这是一个Linux系统\n");
    } else if (strcmp(system_info.sysname, "Darwin") == 0) {
        printf("✓ 这是一个macOS系统\n");
    } else {
        printf("? 这是一个%s系统\n", system_info.sysname);
    }
    
    // 分析硬件架构
    printf("硬件架构分析:\n");
    if (strcmp(system_info.machine, "x86_64") == 0) {
        printf("✓ 64位x86架构\n");
    } else if (strcmp(system_info.machine, "i386") == 0 || 
               strcmp(system_info.machine, "i686") == 0) {
        printf("✓ 32位x86架构\n");
    } else if (strncmp(system_info.machine, "arm", 3) == 0) {
        printf("✓ ARM架构\n");
    } else if (strncmp(system_info.machine, "aarch64", 7) == 0) {
        printf("✓ 64位ARM架构\n");
    } else {
        printf("? %s架构\n", system_info.machine);
    }
    
    return 0;
}

示例2：详细的系统信息分析

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/utsname.h>
#include <string.h>
#include <ctype.h>

// 判断是否为Linux系统
int is_linux_system(const char* sysname) {
    return (strcmp(sysname, "Linux") == 0);
}

// 判断是否为64位系统
int is_64bit_system(const char* machine) {
    return (strcmp(machine, "x86_64") == 0 || 
            strcmp(machine, "aarch64") == 0 ||
            strcmp(machine, "ppc64") == 0 ||
            strcmp(machine, "s390x") == 0 ||
            strncmp(machine, "mips64", 6) == 0);
}

// 判断是否为ARM架构
int is_arm_architecture(const char* machine) {
    return (strncmp(machine, "arm", 3) == 0 || 
            strncmp(machine, "aarch64", 7) == 0);
}

// 分析内核版本
void analyze_kernel_version(const char* release) {
    printf("内核版本分析:\n");
    
    // Linux内核版本通常是 x.y.z 格式
    int major, minor, patch;
    if (sscanf(release, "%d.%d.%d", &major, &minor, &patch) == 3) {
        printf("  主版本号: %d\n", major);
        printf("  次版本号: %d\n", minor);
        printf("  修订版本: %d\n", patch);
        
        // 根据主版本号判断内核新旧
        if (major >= 5) {
            printf("  ✓ 现代Linux内核 (5.x 或更新)\n");
        } else if (major == 4) {
            printf("  ✓ 较新的Linux内核 (4.x)\n");
        } else if (major == 3) {
            printf("  ⚠ 较旧的Linux内核 (3.x)\n");
        } else {
            printf("  ⚠ 非常旧的Linux内核 (%d.x)\n", major);
        }
    } else {
        printf("  无法解析版本格式: %s\n", release);
    }
}

// 分析主机名
void analyze_hostname(const char* nodename) {
    printf("主机名分析:\n");
    printf("  主机名: %s\n", nodename);
    
    // 检查主机名长度
    size_t len = strlen(nodename);
    printf("  长度: %zu 字符\n", len);
    
    // 检查是否包含特殊字符
    int has_special = 0;
    for (size_t i = 0; i < len; i++) {
        if (!isalnum(nodename&#91;i]) && nodename&#91;i] != '-' && nodename&#91;i] != '.') {
            has_special = 1;
            break;
        }
    }
    
    if (has_special) {
        printf("  ⚠ 主机名包含特殊字符\n");
    } else {
        printf("  ✓ 主机名格式规范\n");
    }
}

// 显示系统兼容性信息
void show_compatibility_info(const struct utsname* info) {
    printf("系统兼容性信息:\n");
    
    // 可执行文件格式
    if (is_64bit_system(info->machine)) {
        printf("  可执行格式: 64位 ELF\n");
    } else {
        printf("  可执行格式: 32位 ELF\n");
    }
    
    // 库兼容性
    if (is_linux_system(info->sysname)) {
        printf("  系统调用: Linux ABI\n");
    }
    
    // 字节序信息（通过架构推断）
    if (strcmp(info->machine, "x86_64") == 0 || 
        strcmp(info->machine, "i386") == 0) {
        printf("  字节序: 小端序 (Little Endian)\n");
    }
}

int main() {
    struct utsname system_info;
    
    printf("=== 详细系统信息分析 ===\n\n");
    
    // 获取系统信息
    if (uname(&system_info) == -1) {
        perror("uname调用失败");
        exit(EXIT_FAILURE);
    }
    
    // 基本信息显示
    printf("1. 基本系统信息:\n");
    printf("   操作系统: %s\n", system_info.sysname);
    printf("   主机名:   %s\n", system_info.nodename);
    printf("   内核版本: %s\n", system_info.release);
    printf("   构建版本: %s\n", system_info.version);
    printf("   硬件架构: %s\n", system_info.machine);
    
    // 详细分析
    printf("\n2. 详细分析:\n");
    analyze_hostname(system_info.nodename);
    printf("\n");
    analyze_kernel_version(system_info.release);
    printf("\n");
    show_compatibility_info(&system_info);
    
    // 系统分类
    printf("\n3. 系统分类:\n");
    if (is_linux_system(system_info.sysname)) {
        printf("   ✓ Linux系统家族\n");
        
        // 进一步分类Linux发行版（基于内核版本等信息）
        if (strstr(system_info.version, "Ubuntu")) {
            printf("   ✓ 可能是Ubuntu发行版\n");
        } else if (strstr(system_info.version, "Debian")) {
            printf("   ✓ 可能是Debian发行版\n");
        } else if (strstr(system_info.version, "CentOS") || 
                   strstr(system_info.version, "Red Hat")) {
            printf("   ✓ 可能是Red Hat系列发行版\n");
        } else {
            printf("   ✓ 其他Linux发行版\n");
        }
    }
    
    if (is_64bit_system(system_info.machine)) {
        printf("   ✓ 64位系统\n");
    } else {
        printf("   ✓ 32位系统\n");
    }
    
    if (is_arm_architecture(system_info.machine)) {
        printf("   ✓ ARM架构系统\n");
    }
    
    // 生成系统指纹（用于唯一标识）
    printf("\n4. 系统指纹:\n");
    printf("   指纹字符串: %s-%s-%s\n", 
           system_info.sysname, 
           system_info.release, 
           system_info.machine);
    
    // 应用场景示例
    printf("\n5. 应用场景适配:\n");
    
    // 根据系统类型决定编译选项
    if (is_linux_system(system_info.sysname)) {
        printf("   编译建议: 使用Linux特定优化\n");
    }
    
    // 根据架构决定二进制分发
    if (is_64bit_system(system_info.machine)) {
        printf("   分发建议: 提供64位版本\n");
    } else {
        printf("   分发建议: 提供32位版本\n");
    }
    
    if (is_arm_architecture(system_info.machine)) {
        printf("   优化建议: 针对ARM架构优化\n");
    }
    
    return 0;
}

示例3：系统信息比较和兼容性检查

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/utsname.h>
#include <string.h>
#include <time.h>

// 系统信息结构体
typedef struct {
    struct utsname info;
    time_t timestamp;
} system_snapshot_t;

// 保存系统快照
int save_system_snapshot(system_snapshot_t* snapshot) {
    if (uname(&snapshot->info) == -1) {
        return -1;
    }
    snapshot->timestamp = time(NULL);
    return 0;
}

// 比较两个系统快照
void compare_system_snapshots(const system_snapshot_t* snap1, 
                             const system_snapshot_t* snap2) {
    printf("=== 系统信息比较 ===\n");
    printf("快照1时间: %s", ctime(&snap1->timestamp));
    printf("快照2时间: %s", ctime(&snap2->timestamp));
    
    printf("比较结果:\n");
    
    // 比较操作系统名称
    if (strcmp(snap1->info.sysname, snap2->info.sysname) == 0) {
        printf("✓ 操作系统名称相同: %s\n", snap1->info.sysname);
    } else {
        printf("✗ 操作系统名称不同: %s vs %s\n", 
               snap1->info.sysname, snap2->info.sysname);
    }
    
    // 比较主机名
    if (strcmp(snap1->info.nodename, snap2->info.nodename) == 0) {
        printf("✓ 主机名相同: %s\n", snap1->info.nodename);
    } else {
        printf("⚠ 主机名不同: %s vs %s\n", 
               snap1->info.nodename, snap2->info.nodename);
    }
    
    // 比较内核版本
    if (strcmp(snap1->info.release, snap2->info.release) == 0) {
        printf("✓ 内核版本相同: %s\n", snap1->info.release);
    } else {
        printf("⚠ 内核版本不同: %s vs %s\n", 
               snap1->info.release, snap2->info.release);
    }
    
    // 比较硬件架构
    if (strcmp(snap1->info.machine, snap2->info.machine) == 0) {
        printf("✓ 硬件架构相同: %s\n", snap1->info.machine);
    } else {
        printf("✗ 硬件架构不同: %s vs %s\n", 
               snap1->info.machine, snap2->info.machine);
    }
}

// 检查系统兼容性
int check_system_compatibility(const struct utsname* info) {
    printf("=== 系统兼容性检查 ===\n");
    int compatible = 1;
    
    // 检查操作系统
    if (strcmp(info->sysname, "Linux") != 0) {
        printf("✗ 不支持的操作系统: %s\n", info->sysname);
        compatible = 0;
    } else {
        printf("✓ 支持的操作系统: %s\n", info->sysname);
    }
    
    // 检查内核版本（假设需要3.0以上）
    int major, minor;
    if (sscanf(info->release, "%d.%d", &major, &minor) >= 2) {
        if (major >= 3) {
            printf("✓ 支持的内核版本: %s\n", info->release);
        } else {
            printf("✗ 内核版本过低: %s (需要3.0+)\n", info->release);
            compatible = 0;
        }
    } else {
        printf("? 无法确定内核版本格式\n");
    }
    
    // 检查硬件架构（假设支持x86_64和ARM64）
    if (strcmp(info->machine, "x86_64") == 0 || 
        strcmp(info->machine, "aarch64") == 0) {
        printf("✓ 支持的硬件架构: %s\n", info->machine);
    } else {
        printf("⚠ 可能不支持的硬件架构: %s\n", info->machine);
        // 这里可以根据需要决定是否标记为不兼容
    }
    
    return compatible;
}

// 生成系统报告
void generate_system_report(const struct utsname* info) {
    printf("\n=== 系统详细报告 ===\n");
    
    // 基本信息
    printf("【基本信息】\n");
    printf("  操作系统: %s\n", info->sysname);
    printf("  主机名称: %s\n", info->nodename);
    printf("  硬件架构: %s\n", info->machine);
    
    // 内核信息
    printf("【内核信息】\n");
    printf("  发行版本: %s\n", info->release);
    printf("  构建信息: %s\n", info->version);
    
    // 系统特征
    printf("【系统特征】\n");
    
    // 架构特征
    if (strcmp(info->machine, "x86_64") == 0) {
        printf("  架构类型: 64位Intel/AMD x86\n");
        printf("  指令集: 支持SSE, AVX等扩展指令\n");
    } else if (strcmp(info->machine, "aarch64") == 0) {
        printf("  架构类型: 64位ARM\n");
        printf("  指令集: ARMv8-A架构\n");
    } else if (strncmp(info->machine, "arm", 3) == 0) {
        printf("  架构类型: 32位ARM\n");
        printf("  指令集: ARM架构\n");
    } else {
        printf("  架构类型: %s\n", info->machine);
    }
    
    // 操作系统特征
    if (strcmp(info->sysname, "Linux") == 0) {
        printf("  系统类型: 类Unix操作系统\n");
        printf("  系统调用: POSIX兼容\n");
        printf("  文件系统: 支持ext4, xfs, btrfs等\n");
    }
    
    // 版本特征
    printf("【版本特征】\n");
    if (strstr(info->version, "Ubuntu")) {
        printf("  发行版: Ubuntu系列\n");
    } else if (strstr(info->version, "Debian")) {
        printf("  发行版: Debian系列\n");
    } else if (strstr(info->version, "CentOS") || 
               strstr(info->version, "Red Hat")) {
        printf("  发行版: Red Hat系列\n");
    } else if (strstr(info->version, "SUSE")) {
        printf("  发行版: SUSE系列\n");
    }
    
    // 安全特征
    printf("【安全特征】\n");
    printf("  用户权限: 支持多用户权限管理\n");
    printf("  进程隔离: 支持进程间隔离\n");
    printf("  内存保护: 支持内存保护机制\n");
}

int main() {
    struct utsname current_info;
    system_snapshot_t snapshot1, snapshot2;
    
    printf("=== 系统信息综合应用示例 ===\n\n");
    
    // 获取当前系统信息
    if (uname(&current_info) == -1) {
        perror("uname调用失败");
        exit(EXIT_FAILURE);
    }
    
    // 保存快照
    if (save_system_snapshot(&snapshot1) == -1) {
        perror("保存快照1失败");
        exit(EXIT_FAILURE);
    }
    
    printf("1. 当前系统信息:\n");
    printf("   操作系统: %s\n", current_info.sysname);
    printf("   内核版本: %s\n", current_info.release);
    printf("   硬件架构: %s\n", current_info.machine);
    
    // 模拟系统变化（实际中可能需要等待系统更新）
    sleep(1);
    
    if (save_system_snapshot(&snapshot2) == -1) {
        perror("保存快照2失败");
        exit(EXIT_FAILURE);
    }
    
    // 比较快照
    printf("\n2. 系统快照比较:\n");
    compare_system_snapshots(&snapshot1, &snapshot2);
    
    // 兼容性检查
    printf("\n3. 系统兼容性检查:\n");
    int compatible = check_system_compatibility(&current_info);
    if (compatible) {
        printf("✓ 系统兼容性检查通过\n");
    } else {
        printf("✗ 系统兼容性检查未通过\n");
    }
    
    // 生成详细报告
    printf("\n4. 生成系统详细报告:\n");
    generate_system_report(&current_info);
    
    // 应用场景演示
    printf("\n5. 应用场景演示:\n");
    
    // 根据系统信息选择不同的处理逻辑
    if (strcmp(current_info.sysname, "Linux") == 0) {
        printf("   执行Linux特定代码路径\n");
        
        // 根据架构选择优化
        if (strcmp(current_info.machine, "x86_64") == 0) {
            printf("   启用x86_64优化选项\n");
        } else if (strcmp(current_info.machine, "aarch64") == 0) {
            printf("   启用ARM64优化选项\n");
        }
        
        // 根据内核版本启用特性
        int major, minor;
        if (sscanf(current_info.release, "%d.%d", &major, &minor) >= 2) {
            if (major >= 4) {
                printf("   启用现代内核特性\n");
            }
        }
    }
    
    printf("\n=== 演示完成 ===\n");
    
    return 0;
}

示例4：跨平台系统信息工具

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/utsname.h>
#include <string.h>
#include <time.h>

#ifdef __APPLE__
#include <sys/sysctl.h>
#endif

// 系统信息结构体
typedef struct {
    char os_name&#91;256];
    char hostname&#91;256];
    char kernel_version&#91;256];
    char architecture&#91;256];
    char distribution&#91;256];
    long uptime_seconds;
    int cpu_count;
} extended_system_info_t;

// 获取扩展系统信息
int get_extended_system_info(extended_system_info_t* info) {
    struct utsname basic_info;
    
    // 获取基本系统信息
    if (uname(&basic_info) == -1) {
        return -1;
    }
    
    // 复制基本信息
    strncpy(info->os_name, basic_info.sysname, sizeof(info->os_name) - 1);
    strncpy(info->hostname, basic_info.nodename, sizeof(info->hostname) - 1);
    strncpy(info->kernel_version, basic_info.release, sizeof(info->kernel_version) - 1);
    strncpy(info->architecture, basic_info.machine, sizeof(info->architecture) - 1);
    
    // 初始化其他字段
    strcpy(info->distribution, "Unknown");
    info->uptime_seconds = 0;
    info->cpu_count = 1;
    
    // 根据不同系统获取额外信息
    if (strcmp(basic_info.sysname, "Linux") == 0) {
        // Linux系统特有信息
        
        // 尝试读取发行版信息
        FILE* fp = fopen("/etc/os-release", "r");
        if (fp) {
            char line&#91;256];
            while (fgets(line, sizeof(line), fp)) {
                if (strncmp(line, "PRETTY_NAME=", 12) == 0) {
                    char* start = strchr(line, '"');
                    if (start) {
                        char* end = strchr(start + 1, '"');
                        if (end) {
                            *end = '\0';
                            strncpy(info->distribution, start + 1, sizeof(info->distribution) - 1);
                            break;
                        }
                    }
                }
            }
            fclose(fp);
        }
        
        // 获取系统运行时间
        fp = fopen("/proc/uptime", "r");
        if (fp) {
            double uptime;
            if (fscanf(fp, "%lf", &uptime) == 1) {
                info->uptime_seconds = (long)uptime;
            }
            fclose(fp);
        }
        
        // 获取CPU数量
        fp = fopen("/proc/cpuinfo", "r");
        if (fp) {
            char line&#91;256];
            int cpu_count = 0;
            while (fgets(line, sizeof(line), fp)) {
                if (strncmp(line, "processor", 9) == 0) {
                    cpu_count++;
                }
            }
            if (cpu_count > 0) {
                info->cpu_count = cpu_count;
            }
            fclose(fp);
        }
        
    } 
#ifdef __APPLE__
    else if (strcmp(basic_info.sysname, "Darwin") == 0) {
        // macOS系统特有信息
        strcpy(info->distribution, "macOS");
        
        // 获取CPU数量
        int mib&#91;2] = {CTL_HW, HW_NCPU};
        size_t len = sizeof(info->cpu_count);
        sysctl(mib, 2, &info->cpu_count, &len, NULL, 0);
    }
#endif
    
    return 0;
}

// 格式化显示时间
void format_uptime(long seconds, char* buffer, size_t buffer_size) {
    long days = seconds / 86400;
    long hours = (seconds % 86400) / 3600;
    long minutes = (seconds % 3600) / 60;
    
    if (days > 0) {
        snprintf(buffer, buffer_size, "%ld天 %ld小时 %ld分钟", days, hours, minutes);
    } else if (hours > 0) {
        snprintf(buffer, buffer_size, "%ld小时 %ld分钟", hours, minutes);
    } else {
        snprintf(buffer, buffer_size, "%ld分钟", minutes);
    }
}

// 显示系统信息
void display_system_info(const extended_system_info_t* info) {
    printf("╔══════════════════════════════════════════════════════════════╗\n");
    printf("║                    系统信息报告                              ║\n");
    printf("╠══════════════════════════════════════════════════════════════╣\n");
    printf("║ 操作系统: %-48s ║\n", info->os_name);
    printf("║ 主机名称: %-48s ║\n", info->hostname);
    printf("║ 内核版本: %-48s ║\n", info->kernel_version);
    printf("║ 硬件架构: %-48s ║\n", info->architecture);
    printf("║ 发行版本: %-48s ║\n", info->distribution);
    
    // 显示系统运行时间
    if (info->uptime_seconds > 0) {
        char uptime_str&#91;64];
        format_uptime(info->uptime_seconds, uptime_str, sizeof(uptime_str));
        printf("║ 运行时间: %-48s ║\n", uptime_str);
    }
    
    printf("║ CPU核心数: %-47d ║\n", info->cpu_count);
    printf("╚══════════════════════════════════════════════════════════════╝\n");
}

// 生成JSON格式的系统信息
void generate_json_info(const extended_system_info_t* info) {
    printf("\nJSON格式系统信息:\n");
    printf("{\n");
    printf("  \"os_name\": \"%s\",\n", info->os_name);
    printf("  \"hostname\": \"%s\",\n", info->hostname);
    printf("  \"kernel_version\": \"%s\",\n", info->kernel_version);
    printf("  \"architecture\": \"%s\",\n", info->architecture);
    printf("  \"distribution\": \"%s\",\n", info->distribution);
    printf("  \"uptime_seconds\": %ld,\n", info->uptime_seconds);
    printf("  \"cpu_count\": %d\n", info->cpu_count);
    printf("}\n");
}

// 系统健康检查
void system_health_check(const extended_system_info_t* info) {
    printf("\n系统健康检查:\n");
    printf("----------------\n");
    
    // 检查系统类型
    if (strcmp(info->os_name, "Linux") == 0) {
        printf("✓ Linux系统环境\n");
    } else {
        printf("ℹ 非Linux系统: %s\n", info->os_name);
    }
    
    // 检查架构
    if (strcmp(info->architecture, "x86_64") == 0) {
        printf("✓ 64位x86架构\n");
    } else if (strcmp(info->architecture, "aarch64") == 0) {
        printf("✓ 64位ARM架构\n");
    } else {
        printf("ℹ 其他架构: %s\n", info->architecture);
    }
    
    // 检查CPU数量
    if (info->cpu_count >= 4) {
        printf("✓ 多核心系统 (%d核心)\n", info->cpu_count);
    } else if (info->cpu_count >= 2) {
        printf("✓ 双核心系统\n");
    } else {
        printf("ℹ 单核心系统\n");
    }
    
    // 检查运行时间
    if (info->uptime_seconds > 0) {
        if (info->uptime_seconds > 86400) {  // 超过一天
            printf("✓ 系统稳定运行中\n");
        } else {
            printf("ℹ 系统运行时间较短\n");
        }
    }
}

int main() {
    extended_system_info_t sys_info;
    
    printf("=== 跨平台系统信息工具 ===\n\n");
    
    // 获取扩展系统信息
    if (get_extended_system_info(&sys_info) == -1) {
        perror("获取系统信息失败");
        exit(EXIT_FAILURE);
    }
    
    // 显示系统信息
    display_system_info(&sys_info);
    
    // 系统健康检查
    system_health_check(&sys_info);
    
    // 生成JSON格式信息
    generate_json_info(&sys_info);
    
    // 应用场景示例
    printf("\n应用场景适配:\n");
    printf("----------------\n");
    
    // 根据系统类型选择不同的处理
    if (strcmp(sys_info.os_name, "Linux") == 0) {
        printf("→ 启用Linux优化模式\n");
        
        // 根据发行版调整配置
        if (strstr(sys_info.distribution, "Ubuntu")) {
            printf("→ 应用Ubuntu特定配置\n");
        } else if (strstr(sys_info.distribution, "CentOS") || 
                   strstr(sys_info.distribution, "Red Hat")) {
            printf("→ 应用Red Hat特定配置\n");
        }
        
    } else if (strcmp(sys_info.os_name, "Darwin") == 0) {
        printf("→ 启用macOS优化模式\n");
    } else {
        printf("→ 使用通用配置\n");
    }
    
    // 根据CPU数量调整并行度
    printf("→ 建议并行任务数: %d\n", sys_info.cpu_count);
    
    printf("\n=== 工具执行完成 ===\n");
    
    return 0;
}

编译和运行

# 编译示例1
gcc -o uname_example1 uname_example1.c
./uname_example1

# 编译示例2
gcc -o uname_example2 uname_example2.c
./uname_example2

# 编译示例3
gcc -o uname_example3 uname_example3.c
./uname_example3

# 编译示例4
gcc -o uname_example4 uname_example4.c
./uname_example4

重要注意事项

结构体大小: utsname结构体的大小在不同系统中可能不同

域名支持: domainname字段不是所有系统都支持

权限要求: 通常不需要特殊权限即可调用

线程安全: uname函数是线程安全的

错误处理: 失败时主要返回EFAULT错误

字符编码: 返回的字符串通常是ASCII编码

缓冲区: 传入的结构体必须由调用者分配

常见应用场景

系统兼容性检测: 程序启动时检查运行环境

日志记录: 在日志中记录系统环境信息

调试信息: 帮助开发者了解运行环境

配置管理: 根据系统类型选择不同配置

性能优化: 根据硬件架构选择优化策略

通过这些示例，你可以理解uname函数在获取系统信息方面的强大功能，它为程序提供了识别和适应不同运行环境的能力。

2025-08-07

Linux系统编程

unlink系统调用及示例

unlink - 删除文件或硬链接

函数介绍

unlink系统调用用于删除文件或硬链接。当文件的所有硬链接都被删除且没有进程打开该文件时，文件数据才会被真正删除。

函数原型

#include <unistd.h>

int unlink(const char *pathname);

功能

删除指定路径的文件或硬链接。

参数

const char *pathname: 要删除的文件路径

返回值

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

特殊限制

只能删除文件，不能删除目录（使用rmdir）
如果文件正被进程打开，文件数据不会立即删除

相似函数

rmdir(): 删除空目录
remove(): 删除文件或空目录
unlinkat(): 相对路径版本

示例代码

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

int main() {
    int fd;
    struct stat st;
    
    printf("=== Unlink函数示例 ===\n");
    
    // 示例1: 基本文件删除
    printf("示例1: 基本文件删除\n");
    
    // 创建测试文件
    fd = open("test_unlink.txt", O_CREAT | O_WRONLY, 0644);
    if (fd != -1) {
        write(fd, "Test content for unlink", 23);
        close(fd);
        printf("创建测试文件\n");
    }
    
    // 删除文件
    if (unlink("test_unlink.txt") == -1) {
        perror("删除文件失败");
    } else {
        printf("成功删除文件\n");
        
        // 验证文件已删除
        if (access("test_unlink.txt", F_OK) == -1) {
            printf("文件确实已删除\n");
        }
    }
    
    // 示例2: 硬链接删除演示
    printf("示例2: 硬链接删除演示\n");
    
    // 创建文件和硬链接
    fd = open("multi_link.txt", O_CREAT | O_WRONLY, 0644);
    if (fd != -1) {
        write(fd, "Content with multiple links", 27);
        close(fd);
    }
    
    if (link("multi_link.txt", "second_link.txt") == 0) {
        printf("创建硬链接\n");
        
        // 检查链接数
        if (stat("multi_link.txt", &st) == 0) {
            printf("当前链接数: %ld\n", st.st_nlink);
        }
        
        // 删除一个链接
        if (unlink("second_link.txt") == 0) {
            printf("删除一个链接\n");
            
            if (stat("multi_link.txt", &st) == 0) {
                printf("剩余链接数: %ld\n", st.st_nlink);
                printf("文件数据仍然存在\n");
            }
        }
    }
    
    // 示例3: 文件被打开时的删除
    printf("示例3: 文件被打开时的删除\n");
    
    fd = open("open_file.txt", O_CREAT | O_WRONLY, 0644);
    if (fd != -1) {
        write(fd, "Content of open file", 20);
        printf("创建并打开文件\n");
        
        // 删除已打开的文件
        if (unlink("open_file.txt") == 0) {
            printf("删除已打开的文件（文件仍可访问）\n");
            
            // 仍可以读写文件
            lseek(fd, 0, SEEK_SET);
            char buffer&#91;50];
            int n = read(fd, buffer, sizeof(buffer));
            if (n > 0) {
                buffer&#91;n] = '\0';
                printf("文件内容: %s\n", buffer);
            }
            
            // 关闭文件后，数据才真正删除
            close(fd);
            printf("关闭文件后，数据真正删除\n");
        }
    }
    
    // 清理剩余文件
    unlink("multi_link.txt");
    
    return 0;
}

https://www.calcguide.tech/2025/08/07/unlink系统调用及示例/

https://www.calcguide.tech/2025/08/26/linux开源软件路线图/

2025-08-07

Linux系统编程

unshare系统调用及示例

好的，我们来深入学习 unshare 系统调用

1. 函数介绍

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

通常，当我们使用 clone() 系统调用创建新进程时，可以通过传递特定的 CLONE_NEW* 标志（如 CLONE_NEWNET, CLONE_NEWNS），让新进程在全新的命名空间中启动。

但是，有时候我们希望当前正在运行的进程能够脱离它当前所处的某个命名空间，并进入一个新创建的、空的同类型命名空间。这正是 unshare 系统调用所做的事情。

简单来说，unshare 就是让一个正在运行的进程说：“我不想和别人共享我的 [网络/文件系统/用户ID空间] 了，给我一个全新的、只属于我自己的！”

想象一下，你在一个大办公室（原始命名空间）里工作，突然你想拥有一个完全私密的、只有你一个人的小房间（新命名空间）来处理一些敏感任务。unshare 就像是帮你瞬间建造并搬进这个小房间的过程。

2. 函数原型

#define _GNU_SOURCE // 启用 GNU 扩展以使用 unshare
#include <sched.h>  // 包含 unshare 函数声明和 CLONE_NEW* 常量

int unshare(int flags);

3. 功能

使调用线程（进程）脱离当前由 flags 参数指定的一个或多个命名空间，并使该线程进入新创建的、空的同类型命名空间。

4. 参数

flags:

int 类型。

一个位掩码，指定了调用进程希望脱离并重新加入的命名空间类型。可以是以下一个或多个标志的按位或 (|) 组合：

CLONE_NEWCGROUP: 创建新的 Cgroup 命名空间。
CLONE_NEWIPC: 创建新的 IPC (Inter-Process Communication) 命名空间。
CLONE_NEWNET: 创建新的 Network 命名空间。
CLONE_NEWNS: 创建新的 Mount 命名空间。
CLONE_NEWPID: 创建新的 PID (Process ID) 命名空间。
CLONE_NEWUSER: 创建新的 User 命名空间。
CLONE_NEWUTS: 创建新的 UTS (UNIX Timesharing System) 命名空间。

重要提示：

unshare 只影响调用线程本身。如果进程是多线程的，其他线程仍然留在原来的命名空间中。
新创建的命名空间是空的。例如，新的 Network 命名空间只有 lo (回环) 接口；新的 PID 命名空间中调用进程将成为 PID 1。
权限和限制：创建某些命名空间（尤其是 CLONE_NEWUSER）可能需要特殊权限或遵循复杂的规则。

5. 返回值

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

6. 错误码 (errno)

EFAULT: flags 中指定的地址无效（不太常见）。
EINVAL: flags 包含无效或不支持的标志，或者尝试同时 unshare CLONE_NEWPID 和其他需要特权的命名空间。
ENOMEM: 内核内存不足。

EPERM: 调用者没有权限创建请求的命名空间。例如：

创建 CLONE_NEWUSER 命名空间通常需要进程没有被其他进程跟踪（ptrace）。
创建 CLONE_NEWPID 通常需要进程是多线程的，或者有其他限制。

EUSERS: (对于 CLONE_NEWUSER) 达到了每个用户命名空间的最大所有者数量限制。

ENOSPC: (对于 CLONE_NEWPID) 达到了系统范围内的最大嵌套 PID 命名空间层级限制。

7. 相似函数或关联函数

clone: 创建新进程时，可以通过 CLONE_NEW* 标志使其在新的命名空间中启动。
setns: 将调用进程加入一个已存在的命名空间。
/proc/[pid]/ns/: 这个目录包含了进程所处的各种命名空间的符号链接文件。通过打开这些文件可以获得命名空间的文件描述符。
unshare 命令: 一个命令行工具，可以在取消共享指定的命名空间后执行命令。它在底层使用了 unshare() 系统调用。
namespace 相关系统调用: clone, setns, unshare 共同构成了 Linux 命名空间操作的基础。

8. 示例代码

下面的示例演示了如何使用 unshare 来隔离网络和挂载命名空间。

警告：此示例需要 root 权限来执行某些操作（如挂载文件系统）。

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sched.h>    // 包含 unshare, CLONE_NEW* 常量
#include <sys/mount.h> // 包含 mount
#include <sys/stat.h>  // 包含 mkdir
#include <sys/wait.h>  // 包含 waitpid
#include <errno.h>
#include <string.h>
#include <fcntl.h>    // 包含 open, O_* flags

void print_current_namespaces() {
    char buffer&#91;256];
    pid_t pid = getpid();

    printf("Current namespaces for PID %d:\n", pid);
    // 读取并打印网络命名空间 inode
    ssize_t len = readlink("/proc/self/ns/net", buffer, sizeof(buffer) - 1);
    if (len != -1) {
        buffer&#91;len] = '\0';
        printf("  Network: %s\n", buffer);
    } else {
        perror("  readlink /proc/self/ns/net");
    }

    // 读取并打印挂载命名空间 inode
    len = readlink("/proc/self/ns/mnt", buffer, sizeof(buffer) - 1);
    if (len != -1) {
        buffer&#91;len] = '\0';
        printf("  Mount:   %s\n", buffer);
    } else {
        perror("  readlink /proc/self/ns/mnt");
    }
    printf("\n");
}

int main() {
    printf("--- Demonstrating unshare ---\n");
    printf("Main process PID: %d\n", getpid());

    // 1. 显示初始命名空间
    printf("1. Initial namespaces:\n");
    print_current_namespaces();

    // 2. 使用 unshare 脱离当前的 Network 和 Mount 命名空间
    printf("2. Calling unshare(CLONE_NEWNET | CLONE_NEWNS)...\n");
    if (unshare(CLONE_NEWNET | CLONE_NEWNS) == -1) {
        perror("unshare");
        fprintf(stderr, "Do you have root privileges?\n");
        exit(EXIT_FAILURE);
    }
    printf("unshare() succeeded.\n");

    // 3. 再次显示命名空间，应该已经改变
    printf("3. Namespaces after unshare:\n");
    print_current_namespaces();

    // 4. 在新的 Network 命名空间中，网络接口视图是隔离的
    printf("4. --- Network Isolation ---\n");
    printf("Running 'ip link show' in new network namespace:\n");
    // 使用 system 调用执行命令来查看网络接口
    int ret = system("ip link show");
    if (ret == -1) {
        perror("system ip link");
    }
    printf("Note: You should only see the 'lo' (loopback) interface.\n");
    printf("\n");

    // 5. 在新的 Mount 命名空间中，挂载操作是隔离的
    printf("5. --- Mount Isolation ---\n");
    const char *mount_point = "/tmp/unshare_test_mount";
    if (mkdir(mount_point, 0755) == -1 && errno != EEXIST) {
        perror("mkdir mount point");
    } else {
        printf("Created directory %s\n", mount_point);
    }

    if (mount("tmpfs", mount_point, "tmpfs", 0, NULL) == -1) {
        perror("mount tmpfs");
    } else {
        printf("Mounted tmpfs on %s\n", mount_point);
        printf("This mount is only visible inside this process's mount namespace.\n");
    }

    // 6. 演示挂载隔离：在新的命名空间中创建一个文件
    char test_file_path&#91;256];
    snprintf(test_file_path, sizeof(test_file_path), "%s/test_file.txt", mount_point);
    FILE *f = fopen(test_file_path, "w");
    if (f) {
        fprintf(f, "Hello from process in its own mount namespace!\n");
        fclose(f);
        printf("Created file %s\n", test_file_path);
    } else {
        perror("fopen test_file.txt");
    }

    printf("\n--- Summary ---\n");
    printf("1. The main process called unshare() to get new, isolated Network and Mount namespaces.\n");
    printf("2. Network namespace: 'ip link show' only displays the loopback interface.\n");
    printf("3. Mount namespace: A tmpfs mounted on %s is private to this process.\n", mount_point);
    printf("4. If you run 'mount' or 'ip link show' in another terminal (outside this process),\n");
    printf("   you will see the global network interfaces and mounts, not these isolated ones.\n");

    // 7. 清理 (可选，因为退出时会自动清理命名空间)
    // umount(mount_point);
    // rmdir(mount_point);

    printf("\nProgram finished. The isolated namespaces cease to exist when this process exits.\n");
    return 0;
}

9. 使用 unshare 命令行工具的对比示例

unshare 命令行工具是用户更常接触到的使用 unshare 系统调用的方式。

# 1. 在当前 shell 中取消共享网络命名空间，并运行一个命令
# 这会启动一个新的 shell，它在网络和挂载上都是隔离的
unshare -n -m /bin/bash

# (你现在在一个新的 shell 中，提示符可能略有不同)
# $ ip link show
# 1: lo: <LOOPBACK> mtu 65536 qdisc noop state DOWN mode DEFAULT group default qlen 1000
#     link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
# (只有 lo 接口)

# $ mount -t tmpfs tmpfs /tmp/isolated_tmp
# $ mount | grep isolated_tmp
# tmpfs on /tmp/isolated_tmp type tmpfs (rw,relatime)
# (这个挂载只在这个 unshare 的会话中可见)

# $ exit
# (退出隔离的 shell)

# 2. 回到原 shell，检查隔离效果
# $ ip link show
# (你会看到所有正常的网络接口，如 eth0, wlan0 等)
# $ mount | grep isolated_tmp
# (应该找不到这个挂载点)

10. 编译和运行

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

# 运行程序 (需要 root 权限)
sudo ./unshare_example

11. 预期输出

--- Demonstrating unshare ---
Main process PID: 12345
1. Initial namespaces:
Current namespaces for PID 12345:
  Network: net:&#91;4026531992]
  Mount:   mnt:&#91;4026531991]

2. Calling unshare(CLONE_NEWNET | CLONE_NEWNS)...
unshare() succeeded.
3. Namespaces after unshare:
Current namespaces for PID 12345:
  Network: net:&#91;4026532222]  <-- Changed
  Mount:   mnt:&#91;4026532223]  <-- Changed

4. --- Network Isolation ---
Running 'ip link show' in new network namespace:
1: lo: <LOOPBACK> mtu 65536 qdisc noop state DOWN mode DEFAULT group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
Note: You should only see the 'lo' (loopback) interface.

5. --- Mount Isolation ---
Created directory /tmp/unshare_test_mount
Mounted tmpfs on /tmp/unshare_test_mount
This mount is only visible inside this process's mount namespace.
Created file /tmp/unshare_test_mount/test_file.txt

--- Summary ---
1. The main process called unshare() to get new, isolated Network and Mount namespaces.
2. Network namespace: 'ip link show' only displays the loopback interface.
3. Mount namespace: A tmpfs mounted on /tmp/unshare_test_mount is private to this process.
4. If you run 'mount' or 'ip link show' in another terminal (outside this process),
   you will see the global network interfaces and mounts, not these isolated ones.

Program finished. The isolated namespaces cease to exist when this process exits.

12. 总结

unshare 是 Linux 命名空间功能的关键系统调用之一。

核心作用：让当前运行的进程脱离现有的命名空间，并加入新创建的、空的同类型命名空间。

与 clone 和 setns 的区别：

clone: 创建新进程时分配新命名空间。
setns: 加入一个已存在的命名空间。
unshare: 为当前进程创建并加入新的命名空间。

应用场景：

容器技术：容器运行时使用 unshare 来为容器进程提供隔离环境。
系统管理脚本：在执行可能影响全局环境的操作前，先 unshare 进入隔离环境，避免影响宿主机。
安全沙箱：为不受信任的程序创建隔离的运行环境。

权限：通常需要 root 权限，特别是涉及挂载、网络等操作时。

理解 unshare 有助于深入理解 Linux 容器和进程隔离的原理。对于 Linux 编程新手来说，它是掌握现代 Linux 系统编程和容器化技术的重要一环。

2025-08-07

Linux系统编程

uselib系统调用及示例

uselib 函数详解

函数介绍

uselib 是Linux系统调用，用于将指定的共享库加载到调用进程的地址空间中。它允许程序动态加载和使用共享库，而无需在编译时链接这些库。这个函数主要用于实现动态库加载和插件系统。

函数原型

1
2
3

#include <unistd.h>
int uselib(const char *library);

功能

uselib 将指定路径的共享库文件加载到当前进程的地址空间中，使得库中的符号可以在运行时被解析和使用。它主要用于动态加载共享库，支持构建灵活的插件架构和模块化应用程序。

参数

*const char library: 指向共享库文件路径的字符串指针

返回值

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

相似函数，或关联函数

dlopen/dlsym/dlclose: 更现代的动态库加载接口
mmap: 内存映射文件
ld.so: 动态链接器
RTLD_*: 动态加载标志

示例代码

示例1：基础uselib使用

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

/**
 * 演示基础uselib使用方法
 */
int demo_uselib_basic() {
    const char *library_path = "/lib/x86_64-linux-gnu/libc.so.6";  // 系统C库
    int result;
    
    printf("=== 基础uselib使用示例 ===\n");
    
    // 显示当前系统信息
    printf("系统信息:\n");
    system("uname -a");
    printf("\n");
    
    // 检查库文件是否存在
    printf("1. 检查库文件:\n");
    printf("   库文件路径: %s\n", library_path);
    
    struct stat st;
    if (stat(library_path, &st) == 0) {
        printf("   ✓ 文件存在\n");
        printf("   文件大小: %ld 字节\n", st.st_size);
        printf("   文件权限: %o\n", st.st_mode & 0777);
    } else {
        printf("   ✗ 文件不存在: %s\n", strerror(errno));
        printf("   注意：不同系统的库路径可能不同\n");
        return 0;  // 不返回错误，因为这是演示
    }
    
    // 尝试使用uselib加载库
    printf("\n2. 使用uselib加载库:\n");
    printf("   调用: uselib(\"%s\")\n", library_path);
    
    result = uselib(library_path);
    if (result == 0) {
        printf("   ✓ 库加载成功\n");
        
        // 验证库是否真的被加载
        printf("   验证库加载状态:\n");
        
        // 尝试使用dlopen检查库是否可用
        void *handle = dlopen(library_path, RTLD_LAZY | RTLD_NOLOAD);
        if (handle) {
            printf("   ✓ 通过dlopen验证库已加载\n");
            dlclose(handle);
        } else {
            printf("   ℹ uselib可能只是标记库为已加载\n");
        }
        
    } else {
        printf("   ✗ 库加载失败: %s\n", strerror(errno));
        if (errno == ENOENT) {
            printf("   原因：文件不存在\n");
        } else if (errno == EACCES) {
            printf("   原因：权限不足\n");
        } else if (errno == ENOEXEC) {
            printf("   原因：文件不是有效的可执行文件\n");
        } else if (errno == EPERM) {
            printf("   原因：操作被禁止（可能已过时）\n");
        }
    }
    
    // 演示加载不存在的库
    printf("\n3. 演示加载不存在的库:\n");
    const char *nonexistent_lib = "/nonexistent/library.so";
    printf("   尝试加载: %s\n", nonexistent_lib);
    
    result = uselib(nonexistent_lib);
    if (result == -1) {
        printf("   ✓ 预期失败: %s\n", strerror(errno));
        if (errno == ENOENT) {
            printf("   正确：文件不存在\n");
        }
    } else {
        printf("   ✗ 意外成功\n");
    }
    
    // 显示uselib的历史和现状
    printf("\n4. uselib状态说明:\n");
    printf("   历史作用：早期Linux用于动态加载共享库\n");
    printf("   当前状态：在现代Linux中已被弃用\n");
    printf("   替代方案：使用dlopen/dlsym等现代接口\n");
    printf("   兼容性：某些系统可能仍支持，但不推荐使用\n");
    
    return 0;
}

int main() {
    return demo_uselib_basic();
}

示例2：现代动态库加载对比

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

/**
 * 现代动态库加载演示
 */
int demo_modern_dl_loading() {
    const char *system_lib = "/lib/x86_64-linux-gnu/libc.so.6";
    const char *math_lib = "/lib/x86_64-linux-gnu/libm.so.6";
    
    printf("=== 现代动态库加载对比演示 ===\n");
    
    // 1. 使用dlopen加载系统库
    printf("1. 使用dlopen加载系统库:\n");
    printf("   加载目标: %s\n", system_lib);
    
    void *libc_handle = dlopen(system_lib, RTLD_LAZY);
    if (libc_handle) {
        printf("   ✓ dlopen加载成功\n");
        
        // 获取函数符号
        void *(*malloc_func)(size_t) = dlsym(libc_handle, "malloc");
        if (malloc_func) {
            printf("   ✓ 成功获取malloc函数地址: %p\n", malloc_func);
            
            // 测试函数调用
            void *ptr = malloc_func(1024);
            if (ptr) {
                printf("   ✓ malloc函数调用成功\n");
                void (*free_func)(void*) = dlsym(libc_handle, "free");
                if (free_func) {
                    free_func(ptr);
                    printf("   ✓ free函数调用成功\n");
                }
            }
        } else {
            printf("   ✗ 获取malloc函数失败: %s\n", dlerror());
        }
        
        // 不立即关闭，继续使用
    } else {
        printf("   ✗ dlopen加载失败: %s\n", dlerror());
    }
    
    // 2. 加载数学库
    printf("\n2. 加载数学库:\n");
    printf("   加载目标: %s\n", math_lib);
    
    void *libm_handle = dlopen(math_lib, RTLD_LAZY);
    if (libm_handle) {
        printf("   ✓ 数学库加载成功\n");
        
        // 获取sin函数
        double (*sin_func)(double) = dlsym(libm_handle, "sin");
        if (sin_func) {
            printf("   ✓ 成功获取sin函数地址: %p\n", sin_func);
            
            // 测试函数调用
            double result = sin_func(3.14159 / 2);  // sin(π/2) ≈ 1
            printf("   ✓ sin(π/2) = %.6f\n", result);
        } else {
            printf("   ✗ 获取sin函数失败: %s\n", dlerror());
        }
    } else {
        printf("   ✗ 数学库加载失败: %s\n", dlerror());
    }
    
    // 3. 错误处理演示
    printf("\n3. 错误处理演示:\n");
    printf("   尝试加载不存在的库:\n");
    
    void *bad_handle = dlopen("/nonexistent/badlib.so", RTLD_LAZY);
    if (bad_handle) {
        printf("   ✗ 意外成功加载不存在的库\n");
        dlclose(bad_handle);
    } else {
        printf("   ✓ 正确处理不存在的库: %s\n", dlerror());
    }
    
    // 4. 符号查找演示
    printf("\n4. 符号查找演示:\n");
    
    // 在libc中查找各种函数
    const char *functions&#91;] = {"printf", "strlen", "memcpy", "memset", NULL};
    
    for (int i = 0; functions&#91;i]; i++) {
        void *func_addr = dlsym(libc_handle, functions&#91;i]);
        if (func_addr) {
            printf("   %s: %p\n", functions&#91;i], func_addr);
        } else {
            printf("   %s: 未找到 (%s)\n", functions&#91;i], dlerror());
        }
    }
    
    // 5. 库信息显示
    printf("\n5. 加载的库信息:\n");
    
    if (libc_handle) {
        // 获取库信息（注意：这不是标准的dlinfo）
        printf("   C库句柄: %p\n", libc_handle);
        
        // 显示库引用计数（伪代码，实际需要更复杂的实现）
        printf("   C库已加载\n");
    }
    
    if (libm_handle) {
        printf("   数学库句柄: %p\n", libm_handle);
        printf("   数学库已加载\n");
    }
    
    // 6. 清理资源
    printf("\n6. 清理资源:\n");
    
    if (libc_handle) {
        if (dlclose(libc_handle) == 0) {
            printf("   ✓ C库句柄关闭成功\n");
        } else {
            printf("   ✗ C库句柄关闭失败: %s\n", dlerror());
        }
    }
    
    if (libm_handle) {
        if (dlclose(libm_handle) == 0) {
            printf("   ✓ 数学库句柄关闭成功\n");
        } else {
            printf("   ✗ 数学库句柄关闭失败: %s\n", dlerror());
        }
    }
    
    // 7. 显示现代动态加载的优势
    printf("\n=== 现代动态加载优势 ===\n");
    printf("1. 功能完整:\n");
    printf("   ✓ 支持符号查找和调用\n");
    printf("   ✓ 支持引用计数管理\n");
    printf("   ✓ 支持错误处理和诊断\n");
    printf("   ✓ 支持多种加载模式\n");
    
    printf("\n2. 安全特性:\n");
    printf("   ✓ 支持版本检查\n");
    printf("   ✓ 支持依赖关系管理\n");
    printf("   ✓ 支持安全的库卸载\n");
    printf("   ✓ 支持插件隔离\n");
    
    printf("\n3. 灵活性:\n");
    printf("   ✓ 支持运行时库选择\n");
    printf("   ✓ 支持条件加载\n");
    printf("   ✓ 支持热插拔\n");
    printf("   ✓ 支持延迟加载\n");
    
    return 0;
}

int main() {
    return demo_modern_dl_loading();
}

示例3：插件系统架构演示

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <dlfcn.h>
#include <dirent.h>
#include <sys/stat.h>

/**
 * 插件接口定义
 */
typedef struct {
    const char *name;
    const char *version;
    const char *description;
    int (*initialize)(void);
    int (*execute)(const char *params);
    int (*finalize)(void);
} plugin_interface_t;

/**
 * 插件管理器
 */
typedef struct {
    plugin_interface_t *plugins&#91;32];
    int plugin_count;
    char plugin_directory&#91;256];
} plugin_manager_t;

/**
 * 初始化插件管理器
 */
int init_plugin_manager(plugin_manager_t *manager, const char *plugin_dir) {
    strncpy(manager->plugin_directory, plugin_dir, sizeof(manager->plugin_directory) - 1);
    manager->plugin_directory&#91;sizeof(manager->plugin_directory) - 1] = '\0';
    manager->plugin_count = 0;
    
    printf("插件管理器初始化:\n");
    printf("  插件目录: %s\n", manager->plugin_directory);
    
    // 检查目录是否存在
    struct stat st;
    if (stat(manager->plugin_directory, &st) == 0) {
        if (S_ISDIR(st.st_mode)) {
            printf("  ✓ 插件目录存在\n");
        } else {
            printf("  ✗ 路径不是目录\n");
            return -1;
        }
    } else {
        printf("  ℹ 插件目录不存在，将创建空目录\n");
        // 在实际应用中可能会创建目录
    }
    
    return 0;
}

/**
 * 扫描并加载插件
 */
int scan_and_load_plugins(plugin_manager_t *manager) {
    printf("扫描插件目录: %s\n", manager->plugin_directory);
    
    DIR *dir = opendir(manager->plugin_directory);
    if (!dir) {
        printf("  无法打开插件目录: %s\n", strerror(errno));
        return -1;
    }
    
    struct dirent *entry;
    int loaded_count = 0;
    
    printf("  发现的插件文件:\n");
    
    while ((entry = readdir(dir)) != NULL) {
        // 检查是否为.so文件
        if (strstr(entry->d_name, ".so")) {
            printf("    %s\n", entry->d_name);
            loaded_count++;
            
            // 构造完整路径
            char full_path&#91;512];
            snprintf(full_path, sizeof(full_path), "%s/%s", 
                     manager->plugin_directory, entry->d_name);
            
            // 演示加载过程（实际应用中会真正加载）
            printf("    模拟加载插件: %s\n", entry->d_name);
            
            // 在实际应用中，这里会使用dlopen加载库
            // 并获取插件接口函数
        }
    }
    
    closedir(dir);
    
    printf("  共发现 %d 个插件文件\n", loaded_count);
    manager->plugin_count = loaded_count;
    
    return 0;
}

/**
 * 插件调用演示
 */
void demonstrate_plugin_calls() {
    printf("=== 插件调用演示 ===\n");
    
    // 模拟插件接口
    printf("1. 插件接口定义:\n");
    printf("   typedef struct {\n");
    printf("       const char *name;\n");
    printf("       const char *version;\n");
    printf("       const char *description;\n");
    printf("       int (*initialize)(void);\n");
    printf("       int (*execute)(const char *params);\n");
    printf("       int (*finalize)(void);\n");
    printf("   } plugin_interface_t;\n");
    
    // 模拟插件实例
    printf("\n2. 插件实例演示:\n");
    
    struct {
        const char *name;
        const char *version;
        const char *description;
    } mock_plugins&#91;] = {
        {"数据库插件", "1.0.0", "提供数据库访问功能"},
        {"网络插件", "2.1.3", "提供网络通信功能"},
        {"图形插件", "1.5.2", "提供图形渲染功能"},
        {"音频插件", "3.0.1", "提供音频处理功能"},
        {NULL, NULL, NULL}
    };
    
    for (int i = 0; mock_plugins&#91;i].name; i++) {
        printf("  插件 %d:\n", i + 1);
        printf("    名称: %s\n", mock_plugins&#91;i].name);
        printf("    版本: %s\n", mock_plugins&#91;i].version);
        printf("    描述: %s\n", mock_plugins&#91;i].description);
        printf("    状态: 模拟加载成功\n");
    }
    
    // 模拟插件调用
    printf("\n3. 插件调用演示:\n");
    
    for (int i = 0; mock_plugins&#91;i].name; i++) {
        printf("  调用插件 %d (%s):\n", i + 1, mock_plugins&#91;i].name);
        printf("    initialize() -> 成功\n");
        printf("    execute(\"参数%d\") -> 执行成功\n", i + 1);
        printf("    finalize() -> 成功\n");
    }
}

/**
 * 演示插件系统架构
 */
int demo_plugin_system_architecture() {
    plugin_manager_t manager;
    
    printf("=== 插件系统架构演示 ===\n");
    
    // 初始化插件管理器
    printf("1. 初始化插件管理器:\n");
    if (init_plugin_manager(&manager, "/usr/lib/plugins") != 0) {
        printf("插件管理器初始化失败\n");
        return -1;
    }
    
    // 扫描插件
    printf("\n2. 扫描插件:\n");
    scan_and_load_plugins(&manager);
    
    // 演示插件调用
    printf("\n3. 插件调用演示:\n");
    demonstrate_plugin_calls();
    
    // 显示插件系统架构
    printf("\n=== 插件系统架构说明 ===\n");
    printf("1. 核心组件:\n");
    printf("   ✓ 插件管理器: 负责插件的加载、卸载和管理\n");
    printf("   ✓ 插件接口: 定义插件的标准接口\n");
    printf("   ✓ 插件加载器: 使用dlopen动态加载插件\n");
    printf("   ✓ 符号解析器: 使用dlsym获取插件函数\n");
    
    printf("\n2. 加载流程:\n");
    printf("   1. 扫描插件目录\n");
    printf("   2. 验证插件文件\n");
    printf("   3. 动态加载库文件\n");
    printf("   4. 获取插件接口\n");
    printf("   5. 调用初始化函数\n");
    printf("   6. 注册插件实例\n");
    
    printf("\n3. 调用流程:\n");
    printf("   1. 查找目标插件\n");
    printf("   2. 验证插件状态\n");
    printf("   3. 调用插件函数\n");
    printf("   4. 处理返回结果\n");
    printf("   5. 错误处理\n");
    
    printf("\n4. 安全考虑:\n");
    printf("   ✓ 插件签名验证\n");
    printf("   ✓ 沙箱环境隔离\n");
    printf("   ✓ 权限控制\n");
    printf("   ✓ 资源限制\n");
    printf("   ✓ 异常处理\n");
    
    return 0;
}

int main() {
    return demo_plugin_system_architecture();
}

示例4：动态库版本管理

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

/**
 * 库版本信息结构
 */
typedef struct {
    char name&#91;64];
    char version&#91;32];
    char filepath&#91;256];
    void *handle;
    int is_loaded;
    unsigned long load_time;
} library_version_t;

/**
 * 版本管理器
 */
typedef struct {
    library_version_t libraries&#91;16];
    int library_count;
    int max_libraries;
} version_manager_t;

/**
 * 初始化版本管理器
 */
int init_version_manager(version_manager_t *manager) {
    memset(manager, 0, sizeof(version_manager_t));
    manager->max_libraries = 16;
    manager->library_count = 0;
    
    printf("版本管理器初始化完成\n");
    printf("最大库数量: %d\n", manager->max_libraries);
    
    return 0;
}

/**
 * 添加库版本信息
 */
int add_library_version(version_manager_t *manager, 
                       const char *name, const char *version, const char *filepath) {
    if (manager->library_count >= manager->max_libraries) {
        printf("库数量已达上限\n");
        return -1;
    }
    
    library_version_t *lib = &manager->libraries&#91;manager->library_count];
    
    strncpy(lib->name, name, sizeof(lib->name) - 1);
    lib->name&#91;sizeof(lib->name) - 1] = '\0';
    
    strncpy(lib->version, version, sizeof(lib->version) - 1);
    lib->version&#91;sizeof(lib->version) - 1] = '\0';
    
    strncpy(lib->filepath, filepath, sizeof(lib->filepath) - 1);
    lib->filepath&#91;sizeof(lib->filepath) - 1] = '\0';
    
    lib->handle = NULL;
    lib->is_loaded = 0;
    lib->load_time = 0;
    
    manager->library_count++;
    
    printf("添加库版本信息:\n");
    printf("  名称: %s\n", lib->name);
    printf("  版本: %s\n", lib->version);
    printf("  路径: %s\n", lib->filepath);
    
    return 0;
}

/**
 * 显示系统库信息
 */
void show_system_library_info() {
    printf("=== 系统库信息 ===\n");
    
    // 显示系统信息
    struct utsname sys_info;
    if (uname(&sys_info) == 0) {
        printf("系统名称: %s\n", sys_info.sysname);
        printf("节点名称: %s\n", sys_info.nodename);
        printf("发行版本: %s\n", sys_info.release);
        printf("系统版本: %s\n", sys_info.version);
        printf("硬件架构: %s\n", sys_info.machine);
    }
    
    // 显示常见系统库
    printf("\n常见系统库路径:\n");
    
    const char *common_lib_paths&#91;] = {
        "/lib/x86_64-linux-gnu/libc.so.6",
        "/lib/x86_64-linux-gnu/libm.so.6",
        "/lib/x86_64-linux-gnu/libdl.so.2",
        "/lib/x86_64-linux-gnu/librt.so.1",
        "/lib/x86_64-linux-gnu/libpthread.so.0",
        NULL
    };
    
    for (int i = 0; common_lib_paths&#91;i]; i++) {
        struct stat st;
        if (stat(common_lib_paths&#91;i], &st) == 0) {
            printf("  %s (存在)\n", common_lib_paths&#91;i]);
        } else {
            printf("  %s (不存在)\n", common_lib_paths&#91;i]);
        }
    }
}

/**
 * 演示版本管理
 */
int demo_version_management() {
    version_manager_t manager;
    
    printf("=== 动态库版本管理演示 ===\n");
    
    // 初始化版本管理器
    printf("1. 初始化版本管理器:\n");
    if (init_version_manager(&manager) != 0) {
        return -1;
    }
    
    // 显示系统信息
    printf("\n2. 系统库信息:\n");
    show_system_library_info();
    
    // 添加库版本信息
    printf("\n3. 添加库版本信息:\n");
    
    add_library_version(&manager, "libc", "2.31", "/lib/x86_64-linux-gnu/libc.so.6");
    add_library_version(&manager, "libm", "2.31", "/lib/x86_64-linux-gnu/libm.so.6");
    add_library_version(&manager, "libdl", "2.31", "/lib/x86_64-linux-gnu/libdl.so.2");
    add_library_version(&manager, "librt", "2.31", "/lib/x86_64-linux-gnu/librt.so.1");
    add_library_version(&manager, "libpthread", "2.31", "/lib/x86_64-linux-gnu/libpthread.so.0");
    
    // 显示所有库信息
    printf("\n4. 所有库版本信息:\n");
    printf("%-15s %-10s %-40s %-10s\n", "名称", "版本", "路径", "状态");
    printf("%-15s %-10s %-40s %-10s\n", "----", "----", "----", "----");
    
    for (int i = 0; i < manager.library_count; i++) {
        library_version_t *lib = &manager.libraries&#91;i];
        printf("%-15s %-10s %-40s %-10s\n", 
               lib->name, lib->version, lib->filepath,
               lib->is_loaded ? "已加载" : "未加载");
    }
    
    // 演示版本比较
    printf("\n5. 版本比较演示:\n");
    
    struct {
        const char *version1;
        const char *version2;
        const char *description;
    } version_pairs&#91;] = {
        {"2.31", "2.30", "向前兼容"},
        {"2.29", "2.31", "向后兼容检查"},
        {"3.0.0", "2.9.9", "大版本升级"},
        {"2.31.1", "2.31.0", "补丁版本"},
        {NULL, NULL, NULL}
    };
    
    for (int i = 0; version_pairs&#91;i].version1; i++) {
        printf("  %s vs %s: %s\n", 
               version_pairs&#91;i].version1, version_pairs&#91;i].version2,
               version_pairs&#91;i].description);
    }
    
    // 显示版本管理策略
    printf("\n=== 版本管理策略 ===\n");
    printf("1. 版本兼容性:\n");
    printf("   ✓ 主版本号变化：可能不兼容\n");
    printf("   ✓ 次版本号变化：向后兼容\n");
    printf("   ✓ 修订版本号变化：完全兼容\n");
    
    printf("\n2. 加载策略:\n");
    printf("   ✓ 优先加载最新兼容版本\n");
    printf("   ✓ 支持版本回退\n");
    printf("   ✓ 支持并行版本加载\n");
    printf("   ✓ 支持版本冲突解决\n");
    
    printf("\n3. 安全策略:\n");
    printf("   ✓ 版本签名验证\n");
    printf("   ✓ 依赖关系检查\n");
    printf("   ✓ 兼容性测试\n");
    printf("   ✓ 回滚机制\n");
    
    return 0;
}

int main() {
    return demo_version_management();
}

示例5：现代动态加载最佳实践

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <dlfcn.h>
#include <sys/stat.h>
#include <time.h>

/**
 * 安全的动态加载器
 */
typedef struct {
    void *handle;
    char library_path&#91;256];
    time_t load_time;
    int reference_count;
    int is_valid;
} secure_loader_t;

/**
 * 初始化安全加载器
 */
int init_secure_loader(secure_loader_t *loader, const char *library_path) {
    // 验证库文件
    struct stat st;
    if (stat(library_path, &st) != 0) {
        printf("库文件不存在: %s\n", library_path);
        return -1;
    }
    
    if (!S_ISREG(st.st_mode)) {
        printf("路径不是常规文件: %s\n", library_path);
        return -1;
    }
    
    // 检查文件权限
    if (!(st.st_mode & S_IRUSR)) {
        printf("没有读取权限: %s\n", library_path);
        return -1;
    }
    
    // 初始化加载器
    loader->handle = NULL;
    strncpy(loader->library_path, library_path, sizeof(loader->library_path) - 1);
    loader->library_path&#91;sizeof(loader->library_path) - 1] = '\0';
    loader->load_time = 0;
    loader->reference_count = 0;
    loader->is_valid = 1;
    
    printf("安全加载器初始化:\n");
    printf("  库路径: %s\n", loader->library_path);
    printf("  文件大小: %ld 字节\n", st.st_size);
    printf("  修改时间: %s", ctime(&st.st_mtime));
    
    return 0;
}

/**
 * 安全加载库
 */
int secure_load_library(secure_loader_t *loader) {
    if (!loader->is_valid) {
        printf("加载器无效\n");
        return -1;
    }
    
    printf("安全加载库: %s\n", loader->library_path);
    
    // 使用RTLD_LAZY延迟加载
    loader->handle = dlopen(loader->library_path, RTLD_LAZY);
    if (!loader->handle) {
        printf("加载失败: %s\n", dlerror());
        return -1;
    }
    
    loader->load_time = time(NULL);
    loader->reference_count = 1;
    
    printf("  ✓ 加载成功\n");
    printf("  加载时间: %s", ctime(&loader->load_time));
    
    return 0;
}

/**
 * 获取符号地址
 */
void* secure_get_symbol(secure_loader_t *loader, const char *symbol_name) {
    if (!loader->handle) {
        printf("库未加载\n");
        return NULL;
    }
    
    void *symbol = dlsym(loader->handle, symbol_name);
    if (!symbol) {
        printf("符号未找到: %s (%s)\n", symbol_name, dlerror());
        return NULL;
    }
    
    printf("获取符号成功: %s -> %p\n", symbol_name, symbol);
    return symbol;
}

/**
 * 安全卸载库
 */
int secure_unload_library(secure_loader_t *loader) {
    if (!loader->handle) {
        printf("库未加载\n");
        return 0;
    }
    
    loader->reference_count--;
    if (loader->reference_count > 0) {
        printf("引用计数: %d，延迟卸载\n", loader->reference_count);
        return 0;
    }
    
    printf("卸载库: %s\n", loader->library_path);
    
    if (dlclose(loader->handle) != 0) {
        printf("卸载失败: %s\n", dlerror());
        return -1;
    }
    
    loader->handle = NULL;
    loader->load_time = 0;
    
    printf("  ✓ 卸载成功\n");
    return 0;
}

/**
 * 演示现代动态加载最佳实践
 */
int demo_modern_best_practices() {
    secure_loader_t loader;
    const char *system_lib = "/lib/x86_64-linux-gnu/libc.so.6";
    
    printf("=== 现代动态加载最佳实践演示 ===\n");
    
    // 1. 安全初始化
    printf("1. 安全初始化:\n");
    if (init_secure_loader(&loader, system_lib) != 0) {
        printf("安全加载器初始化失败\n");
        return -1;
    }
    
    // 2. 安全加载
    printf("\n2. 安全加载:\n");
    if (secure_load_library(&loader) != 0) {
        printf("安全加载失败\n");
        return -1;
    }
    
    // 3. 符号获取和使用
    printf("\n3. 符号获取和使用:\n");
    
    // 获取并使用malloc
    void* (*malloc_func)(size_t) = 
        (void* (*)(size_t))secure_get_symbol(&loader, "malloc");
    if (malloc_func) {
        printf("  测试malloc函数:\n");
        void *ptr = malloc_func(1024);
        if (ptr) {
            printf("    分配1024字节成功: %p\n", ptr);
            
            // 获取并使用free
            void (*free_func)(void*) = 
                (void (*)(void*))secure_get_symbol(&loader, "free");
            if (free_func) {
                free_func(ptr);
                printf("    释放内存成功\n");
            }
        }
    }
    
    // 获取并使用printf
    int (*printf_func)(const char*, ...) = 
        (int (*)(const char*, ...))secure_get_symbol(&loader, "printf");
    if (printf_func) {
        printf("  测试printf函数:\n");
        printf_func("    这是通过动态加载的printf输出\n");
    }
    
    // 4. 错误处理演示
    printf("\n4. 错误处理演示:\n");
    
    // 尝试获取不存在的符号
    void *nonexistent = secure_get_symbol(&loader, "nonexistent_function");
    if (!nonexistent) {
        printf("    ✓ 正确处理不存在的符号\n");
    }
    
    // 尝试加载不存在的库
    secure_loader_t bad_loader;
    if (init_secure_loader(&bad_loader, "/nonexistent/badlib.so") != 0) {
        printf("    ✓ 正确拒绝不存在的库文件\n");
    }
    
    // 5. 安全卸载
    printf("\n5. 安全卸载:\n");
    if (secure_unload_library(&loader) != 0) {
        printf("安全卸载失败\n");
        return -1;
    }
    
    printf("    ✓ 安全卸载完成\n");
    
    // 显示最佳实践总结
    printf("\n=== 现代动态加载最佳实践 ===\n");
    printf("1. 安全性最佳实践:\n");
    printf("   ✓ 文件完整性验证\n");
    printf("   ✓ 权限检查\n");
    printf("   ✓ 路径安全检查\n");
    printf("   ✓ 符号白名单\n");
    
    printf("\n2. 错误处理最佳实践:\n");
    printf("   ✓ 详细的错误信息\n");
    printf("   ✓ 优雅的降级处理\n");
    printf("   ✓ 资源清理\n");
    printf("   ✓ 日志记录\n");
    
    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() {
    return demo_modern_best_practices();
}

uselib 使用注意事项

历史背景：

早期Linux: 在早期Linux版本中用于动态加载共享库

现代状态: 在现代Linux系统中已被弃用

替代方案: 使用dlopen/dlsym等现代接口

系统要求：

内核版本: 早期支持uselib的Linux内核

权限要求: 通常需要适当的文件访问权限

架构支持: 历史上支持主流架构

安全考虑：

代码注入: 直接加载库文件可能存在安全风险

权限提升: 加载恶意库可能导致权限提升

内存安全: 直接内存操作可能影响系统稳定性

最佳实践：

使用现代接口: 优先使用dlopen/dlsym等现代动态加载接口

安全验证: 加载前验证库文件的完整性和来源

错误处理: 妥善处理加载和使用过程中的各种错误

资源管理: 及时释放加载的库资源

现代动态加载对比

uselib vs dlopen：

// uselib: 已过时的接口
uselib("/lib/libexample.so");

// dlopen: 现代标准接口
void *handle = dlopen("/lib/libexample.so", RTLD_LAZY);

功能对比：

特性uselibdlopen符号获取不支持支持错误处理有限完善引用计数无支持资源管理手动自动安全性较低较高

现代动态加载接口：

#include <dlfcn.h>

// 动态加载库
void *dlopen(const char *filename, int flag);

// 获取符号地址
void *dlsym(void *handle, const char *symbol);

// 卸载库
int dlclose(void *handle);

// 获取错误信息
char *dlerror(void);

编译选项：

# 链接动态加载库
gcc -o program program.c -ldl

# 位置无关代码
gcc -fPIC -shared -o libexample.so example.c

常见使用场景

1. 插件系统：

// 动态加载插件库
void *plugin = dlopen("plugin.so", RTLD_LAZY);
if (plugin) {
    // 获取插件接口
    plugin_interface_t *interface = dlsym(plugin, "plugin_interface");
    // 使用插件功能
}

2. 模块化应用：

// 根据配置动态加载不同模块
void *module = dlopen(config.module_path, RTLD_LAZY);
// 实现模块化架构

3. 热插拔功能：

// 运行时加载和卸载功能模块
void *feature = dlopen("feature.so", RTLD_LAZY);
// 使用完毕后卸载
dlclose(feature);

总结

uselib 是Linux历史上用于动态加载共享库的系统调用，但在现代Linux系统中已被弃用。开发者应该使用更现代、更安全的动态加载接口如 dlopen/dlsym/dlclose。

现代动态加载提供了：

完整的功能: 支持符号查找、引用计数、错误处理

更好的安全性: 完善的安全检查和错误处理机制

标准兼容: 符合POSIX标准，跨平台支持

丰富的特性: 支持多种加载模式和灵活的配置选项

通过合理使用现代动态加载技术，可以构建灵活、安全、高效的模块化应用程序。

2025-08-07

Linux系统编程

userfaultfd系统调用及示例

好的，我们继续按照您的要求学习 Linux 系统编程中的重要函数。这次我们介绍 userfaultfd。

1. 函数介绍

userfaultfd (User Fault File Descriptor) 是一个 Linux 系统调用（内核版本 >= 4.3），它提供了一种机制，允许用户态程序处理发生在其他进程（或同一进程的其他线程）中的页面错误（Page Fault）。

简单来说，它让你可以：

监控一块内存区域。

当这块内存被访问（读/写）但尚未分配物理页或被换出时，内核会暂停访问该内存的进程/线程。

内核通过一个特殊的文件描述符（userfaultfd）通知你的用户态程序。

你的程序可以读取这个通知，了解到哪个进程、哪个地址发生了缺页。

然后，你的程序可以自行决定如何处理这个缺页：

从磁盘加载数据。
从网络获取数据。
生成所需的数据。
映射另一块已存在的内存。
返回错误。

最后，你的程序通过 ioctl 调用告诉内核：“我已经处理好了，让那个进程继续运行吧”。

你可以把它想象成一个智能的内存管家：

你告诉管家（userfaultfd）：“监控客厅（某块内存）”。
当孩子（另一个进程）跑进客厅玩耍（访问内存），但客厅还没收拾好（页面未分配/换出），孩子会被卡住。
管家会立刻通知你：“孩子卡在客厅了！”。
你收到通知后，赶紧去把客厅收拾好（准备数据）。
然后你告诉管家：“客厅搞定了，让孩子进去玩吧”。
孩子就能继续开心地玩耍了。

这使得实现惰性加载（Lazy Loading）、内存快照、用户态垃圾回收、分布式共享内存等高级功能成为可能。

2. 函数原型

#include <sys/syscall.h> // 因为 glibc 可能未包装，常需 syscall
#include <unistd.h>
#include <fcntl.h>       // O_CLOEXEC, O_NONBLOCK
#include <linux/userfaultfd.h> // 核心定义

// 注意：glibc 可能没有直接包装，需要 syscall 或使用 liburing 等库
// 系统调用号在 x86_64 上通常是 323 (SYS_userfaultfd)
int userfaultfd(int flags);

3. 功能

创建 UFFD: 创建一个新的 userfaultfd 对象，并返回一个与之关联的文件描述符。
设置监听: 后续需要使用 ioctl (UFFDIO_API, UFFDIO_REGISTER) 来配置这个 userfaultfd，告诉它要监听哪些内存区域以及监听哪些类型的页面错误。
接收通知: 其他进程访问被监听的内存区域时发生页面错误，内核会将错误信息通过这个文件描述符发送给用户态程序。
处理错误: 用户态程序读取错误信息，进行处理，并通过 ioctl (UFFDIO_COPY, UFFDIO_ZEROPAGE, UFFDIO_WAKE) 等操作来解决页面错误，使被阻塞的进程恢复运行。

4. 参数

int flags: 控制 userfaultfd 行为的标志。可以是以下值的按位或组合：

0: 默认行为。
O_CLOEXEC: 在调用 exec() 时自动关闭该文件描述符。这是个好习惯，防止意外传递给新程序。
O_NONBLOCK: 使 userfaultfd 文件描述符变为非阻塞模式。对 userfaultfd 本身的读写操作（读取事件）会受到影响。

5. 返回值

成功时: 返回一个新的 userfaultfd 文件描述符（一个非负整数）。
失败时: 返回 -1，并设置全局变量 errno 来指示具体的错误原因（例如 EINVAL flags 无效，EMFILE 进程打开的文件描述符已达上限，ENOSYS 内核不支持 userfaultfd 等）。

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

mmap: 用于分配和映射内存区域，这些区域后续可以用 userfaultfd 来监控。
ioctl: 用于配置 userfaultfd（注册内存区域、处理页面错误）和与其交互的主要方式。
poll / select / epoll: 用于等待 userfaultfd 文件描述符变为可读（有事件到来）。
read: 用于从 userfaultfd 文件描述符读取页面错误事件。
fork / pthread: userfaultfd 通常与多进程或多线程结合使用，一个线程/进程负责监控和处理错误，其他线程/进程进行内存访问。

7. 示例代码

重要提示: userfaultfd 的使用非常复杂，涉及多线程/多进程、ioctl 操作、内存管理等。下面的示例是一个极度简化的概念演示，展示了核心流程。

示例 1：基本的 userfaultfd 设置和事件读取（概念性）

// userfaultfd_concept.c
#define _GNU_SOURCE
#include <sys/syscall.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <poll.h>
#include <linux/userfaultfd.h>
#include <sys/ioctl.h>

// 简化系统调用包装
static inline int sys_userfaultfd(int flags) {
    return syscall(__NR_userfaultfd, flags);
}

int main() {
    int uffd;
    struct uffdio_api api;
    struct uffdio_register reg;
    char *page;
    long page_size = sysconf(_SC_PAGESIZE);
    struct pollfd pollfd;
    struct uffd_msg msg;
    ssize_t nread;

    printf("Page size: %ld bytes\n", page_size);

    // 1. 检查内核支持
    printf("Checking for userfaultfd support...\n");
    uffd = sys_userfaultfd(O_CLOEXEC | O_NONBLOCK);
    if (uffd == -1) {
        if (errno == ENOSYS) {
            printf("userfaultfd is NOT supported on this kernel (need >= 4.3).\n");
        } else {
            perror("userfaultfd");
        }
        exit(EXIT_FAILURE);
    }
    printf("userfaultfd supported. File descriptor: %d\n", uffd);

    // 2. 启用 API (必须步骤)
    printf("\nEnabling UFFD API...\n");
    api.api = UFFD_API;
    api.features = 0; // 不请求任何额外特性
    if (ioctl(uffd, UFFDIO_API, &api) == -1) {
        perror("ioctl UFFDIO_API");
        close(uffd);
        exit(EXIT_FAILURE);
    }
    if (api.api != UFFD_API) {
        fprintf(stderr, "UFFD API version mismatch.\n");
        close(uffd);
        exit(EXIT_FAILURE);
    }
    printf("UFFD API enabled successfully.\n");

    // 3. 分配并映射内存
    printf("\nAllocating memory using mmap...\n");
    page = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (page == MAP_FAILED) {
        perror("mmap");
        close(uffd);
        exit(EXIT_FAILURE);
    }
    printf("Memory mapped at %p (size: %ld bytes)\n", (void*)page, page_size);

    // 4. 注册内存区域到 userfaultfd
    printf("\nRegistering memory region with userfaultfd...\n");
    reg.range.start = (unsigned long) page;
    reg.range.len = page_size;
    reg.mode = UFFDIO_REGISTER_MODE_MISSING; // 监听缺页错误
    if (ioctl(uffd, UFFDIO_REGISTER, &reg) == -1) {
        perror("ioctl UFFDIO_REGISTER");
        munmap(page, page_size);
        close(uffd);
        exit(EXIT_FAILURE);
    }
    printf("Memory region registered successfully.\n");

    // 5. 触发缺页错误 (在另一个线程/进程中通常发生)
    printf("\nTriggering a page fault by accessing the memory...\n");
    printf("  Accessing address %p...\n", (void*)page);
    *page = 'X'; // 这会触发缺页错误，并被 uffd 捕获
    printf("  Successfully wrote 'X' to %p.\n", (void*)page);

    // 6. 等待并读取事件 (通常在专用线程中)
    printf("\nPolling userfaultfd for events...\n");
    pollfd.fd = uffd;
    pollfd.events = POLLIN;
    int poll_res = poll(&pollfd, 1, 1000); // 1秒超时
    if (poll_res > 0 && (pollfd.revents & POLLIN)) {
        printf("Event detected on uffd.\n");
        nread = read(uffd, &msg, sizeof(msg));
        if (nread > 0) {
            if (msg.event == UFFD_EVENT_PAGEFAULT) {
                printf("  Received PAGEFAULT event:\n");
                printf("    Address: %p\n", (void*)msg.arg.pagefault.address);
                printf("    Flags: 0x%llx\n", (unsigned long long)msg.arg.pagefault.flags);
                if (msg.arg.pagefault.flags & UFFD_PAGEFAULT_FLAG_WRITE) {
                    printf("    (Fault was caused by a WRITE access)\n");
                } else {
                    printf("    (Fault was caused by a READ access)\n");
                }

                // --- 关键: 处理缺页错误 ---
                printf("\n--- Resolving page fault ---\n");
                struct uffdio_zeropage zeropage;
                zeropage.range.start = msg.arg.pagefault.address & ~(page_size - 1); // 对齐到页
                zeropage.range.len = page_size;
                zeropage.mode = 0;
                if (ioctl(uffd, UFFDIO_ZEROPAGE, &zeropage) == -1) {
                    perror("ioctl UFFDIO_ZEROPAGE");
                } else {
                    printf("  Page zeroed and resolved successfully.\n");
                    printf("  The faulting process/thread should now resume.\n");
                }
            } else {
                printf("  Received unexpected event type: %d\n", msg.event);
            }
        } else if (nread == 0) {
            printf("  Read 0 bytes from uffd (unexpected).\n");
        } else {
            perror("read from uffd");
        }
    } else if (poll_res == 0) {
        printf("  Timeout: No event received on uffd within 1 second.\n");
        printf("  (This might be because the page was already handled by the kernel\n");
        printf("   or the access didn't trigger a monitored fault.)\n");
    } else {
        perror("poll uffd");
    }

    // 7. 清理
    printf("\nCleaning up...\n");
    if (munmap(page, page_size) == -1) {
        perror("munmap");
    }
    if (close(uffd) == -1) {
        perror("close uffd");
    }
    printf("Cleanup completed.\n");

    return 0;
}

**代码解释 **(概念性):

定义 sys_userfaultfd 包装 syscall，因为 glibc 可能未直接提供。

调用 sys_userfaultfd(O_CLOEXEC | O_NONBLOCK) 创建 userfaultfd。

关键: 调用 ioctl(uffd, UFFDIO_API, &api) 启用 userfaultfd API。这是必需的初始化步骤。

使用 mmap 分配一个匿名私有内存页。

关键: 调用 ioctl(uffd, UFFDIO_REGISTER, &reg) 将 mmap 分配的内存区域注册到 userfaultfd 进行监控。UFFDIO_REGISTER_MODE_MISSING 表示监听缺页错误。

触发缺页: 程序直接访问 page 指向的内存。对于匿名私有映射，首次访问会触发内核分配一个“零页”并映射，这通常不会被 userfaultfd 捕获，因为内核自己处理了。为了让 userfaultfd 生效，通常需要更复杂的设置（如 mmap 一个未实际分配物理页的区域，或在另一个进程中访问）。

等待事件: 使用 poll 等待 userfaultfd 文件描述符变为可读。

读取事件: 如果 poll 检测到事件，调用 read(uffd, &msg, sizeof(msg)) 读取 struct uffd_msg。

检查事件类型: 检查 msg.event 是否为 UFFD_EVENT_PAGEFAULT。

处理事件: 打印缺页的地址和访问类型（读/写）。

关键: 调用 ioctl(uffd, UFFDIO_ZEROPAGE, &zeropage) 来解决缺页错误。这里使用 UFFDIO_ZEROPAGE 将缺页的地址范围映射为一个全零页。

清理资源。

注意: 这个例子为了简化，直接在主线程中触发并处理缺页，这在实际中可能不会按预期工作，因为内核通常会自己处理匿名页的首次分配。userfaultfd 的威力在于跨进程或更复杂的惰性加载场景。

重要提示与注意事项:

内核版本: 需要 Linux 内核 4.3 或更高版本。

glibc 支持: 标准 glibc 可能没有包装 userfaultfd，需要使用 syscall。

权限: 通常需要特殊权限（如 CAP_SYS_PTRACE）才能对其他进程使用 userfaultfd。同一进程内使用通常不需要。

复杂性: userfaultfd 的完整使用非常复杂，涉及多线程、事件循环、复杂的 ioctl 操作（如 UFFDIO_COPY 从用户态缓冲区复制数据到缺页地址）。

性能: 虽然功能强大，但处理页面错误涉及用户态和内核态的多次交互，可能带来开销。

应用场景: 主要用于实现高级内存管理功能，如用户态分页、惰性加载文件、内存快照、分布式内存等。

总结:

userfaultfd 是一个强大而独特的 Linux 系统调用，它将传统的、由内核全权处理的页面错误处理机制，部分地移交给了用户态程序。这为实现创新的内存管理和虚拟化技术提供了前所未有的灵活性和控制力。虽然使用起来相当复杂，但它是现代 Linux 系统编程中一个极具价值的工具。

2025-08-07

Linux系统编程

ustat 系统调用及示例

好的，我们来深入学习 ustat 系统调用

1. 函数介绍

ustat (Unix Status) 是一个非常古老的 Unix 系统调用，它的作用是获取已挂载文件系统的信息，特别是文件系统根节点（即设备）的一些基本统计信息，比如总空闲块数、总空闲 inode 数等。

你可以把它想象成一个远古版本的、功能非常有限的 statfs。在早期的 Unix 系统中，它被用来快速查看某个设备（代表一个文件系统）的健康状况和容量。

然而，对于现代的 Linux 系统（特别是基于 glibc 的系统），ustat 已经被弃用 (deprecated) 了。

简单来说，ustat 是一个过时的、不推荐在现代 Linux 编程中使用的系统调用。

https://www.calcguide.tech/2025/08/07/ustat-系统调用及示例/

为什么被弃用？

功能有限：它提供的信息远不如现代的 statfs 或 statvfs 丰富和准确。

设计陈旧：它基于设备号 (dev_t) 工作，而现代文件系统和挂载方式（如网络文件系统 NFS、伪文件系统 tmpfs 等）使得仅通过设备号获取信息变得不准确或不可能。

更好的替代品：statfs (或 POSIX 标准的 statvfs) 提供了更全面、更标准化的文件系统信息查询接口。

2. 函数原型

#include <ustat.h> // 包含 ustat 函数声明和 struct ustat

// 注意：在许多现代 Linux 系统上，这个头文件可能不存在或不推荐使用
int ustat(dev_t dev, struct ustat *ubuf);

3. 功能

获取指定设备号 (dev) 对应的文件系统的基本状态信息，并将结果存储在 ubuf 指向的 struct ustat 结构体中。

4. 参数

dev:

dev_t 类型。
指定要查询的文件系统的设备号。设备号通常可以通过 stat() 系统调用获取文件或目录的 st_dev 字段来得到。

ubuf:

struct ustat * 类型。
一个指向 struct ustat 结构体的指针。函数调用成功后，会将查询到的信息填充到这个结构体中。

5. struct ustat 结构体

// 这是 ustat.h 中定义的结构（概念性）
struct ustat {
    daddr_t f_tfree;  /* Total free blocks */
    ino_t   f_tinode; /* Number of free inodes */
    char    f_fname&#91;6]; /* Filsys name, optional */
    char    f_fpack&#91;6]; /* Filsys pack name, optional */
};

f_tfree: 文件系统中总的空闲块数。
f_tinode: 文件系统中总的空闲 inode 数。
f_fname 和 f_fpack: 可选的文件系统名称和卷标，但通常不被现代文件系统支持。

6. 返回值

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

7. 错误码 (errno)

EINVAL: dev 参数无效。
ENOSYS: 系统不支持 ustat 系统调用（在现代 Linux 上很常见）。

8. 相似函数或关联函数 (现代替代品)

statfs / fstatfs: 现代 Linux 中用于获取文件系统统计信息的标准系统调用。功能更强大，信息更丰富。
statvfs / fstatvfs: POSIX 标准定义的函数，与 statfs 功能类似，具有更好的可移植性。
stat: 获取文件或目录的状态信息，包括其所在的设备号 (st_dev)。

9. 为什么不推荐使用 ustat 以及现代替代方案

ustat 已经过时且不推荐使用。现代 Linux 编程应使用 statfs 或 statvfs。

现代替代方案示例 (statfs)

#define _GNU_SOURCE // 启用 GNU 扩展
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/vfs.h>    // 包含 statfs
#include <sys/stat.h>   // 包含 stat
#include <string.h>
#include <errno.h>

int main() {
    struct statfs sfs;
    struct stat statbuf;
    const char *path = "/"; // 查询根文件系统

    printf("--- Demonstrating modern alternative to ustat: statfs ---\n");

    // 方法 1: 使用 statfs 直接查询路径
    printf("1. Querying filesystem info for path '%s' using statfs():\n", path);
    if (statfs(path, &sfs) == 0) {
        printf("  Filesystem Type (Magic): 0x%lx\n", (unsigned long)sfs.f_type);
        printf("  Block Size:              %ld bytes\n", (long)sfs.f_bsize);
        printf("  Total Blocks:            %ld\n", (long)sfs.f_blocks);
        printf("  Free Blocks:             %ld\n", (long)sfs.f_bfree);
        printf("  Available Blocks:        %ld (for non-root users)\n", (long)sfs.f_bavail);
        printf("  Total Inodes:            %ld\n", (long)sfs.f_files);
        printf("  Free Inodes:             %ld\n", (long)sfs.f_ffree);
        printf("  Filesystem ID:           %d:%d\n", (int)sfs.f_fsid.__val&#91;0], (int)sfs.f_fsid.__val&#91;1]);
    } else {
        perror("statfs");
        exit(EXIT_FAILURE);
    }

    // 方法 2: 先用 stat 获取设备号，再用 statfs 查询 (模拟 ustat 的思路，但用 statfs)
    printf("\n2. Getting device number with stat() and querying with statfs():\n");
    if (stat(path, &statbuf) == 0) {
        printf("  Device ID for '%s': %ld\n", path, (long)statbuf.st_dev);
        // 注意：没有直接的 "statfs_by_dev" 函数。
        // 我们仍然需要一个路径。现代方法是直接用路径查询。
        // 如果真的需要基于设备号查询，需要遍历 /proc/mounts 等找到挂载点。
        // 这正是 ustat 设计上的局限性。
        printf("  Note: Modern statfs works with paths, not device IDs directly.\n");
        printf("        This is more robust than the old ustat approach.\n");
    } else {
        perror("stat");
    }

    printf("\n--- Summary ---\n");
    printf("1. ustat is obsolete and deprecated on modern Linux systems.\n");
    printf("2. Use statfs() or statvfs() instead for querying filesystem information.\n");
    printf("3. These modern functions provide more details and work correctly with all filesystem types.\n");

    return 0;
}

10. 编译和运行 (现代替代方案)

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

# 运行程序
./modern_statfs_example

11. 预期输出 (现代替代方案)

--- Demonstrating modern alternative to ustat: statfs ---
1. Querying filesystem info for path '/' using statfs():
  Filesystem Type (Magic): 0xef53
  Block Size:              4096 bytes
  Total Blocks:            123456789
  Free Blocks:             56789012
  Available Blocks:        50000000 (for non-root users)
  Total Inodes:            30000000
  Free Inodes:             25000000
  Filesystem ID:           12345:67890

2. Getting device number with stat() and querying with statfs():
  Device ID for '/': 64768
  Note: Modern statfs works with paths, not device IDs directly.
        This is more robust than the old ustat approach.

--- Summary ---
1. ustat is obsolete and deprecated on modern Linux systems.
2. Use statfs() or statvfs() instead for querying filesystem information.
3. These modern functions provide more details and work correctly with all filesystem types.

12. 总结

ustat 是一个历史遗留的、已被弃用的系统调用。

历史作用：在早期 Unix 系统中用于查询文件系统基本信息。

为何弃用：

功能有限且不准确。
基于设备号的设计不适用于现代复杂文件系统。

现代替代品：

statfs(path, &buf): 通过路径查询文件系统信息（推荐）。
statvfs(path, &buf): POSIX 标准接口，可移植性更好。

给 Linux 编程小白的建议：完全不需要学习 ustat。从一开始就应该学习和使用 statfs 或 statvfs 来获取文件系统信息。

2025-08-07

Linux系统编程

utimensat和futimens 系统调用及示例

好的，我们来深入学习 utimensat 和 futimens 系统调用

1. 函数介绍

在 Linux 系统中，每个文件都关联着一些重要的时间属性：

访问时间 (atime): 文件上一次被读取的时间。

修改时间 (mtime): 文件内容上一次被修改的时间。

状态改变时间 (ctime): 文件的元数据（如权限、所有者、链接数等）上一次被改变的时间。

我们之前学过 utimes 可以用来修改 atime 和 mtime。utimensat 和 futimens 是更现代、更强大的系统调用，用于完成相同的任务。

utimensat 和 futimens 的核心优势：

纳秒级精度：它们使用 struct timespec，可以精确到纳秒（虽然底层文件系统可能不支持这么高的精度，但接口提供了）。

更灵活的控制：它们引入了特殊的标记，允许你精确控制对每个时间戳的操作：

设置为当前时间。
保持不变。
设置为指定时间。

更灵活的路径解析：utimensat 可以像 openat 一样，相对于一个目录文件描述符解析路径，并且可以选择是否跟随符号链接。

简单来说，utimensat 和 futimens 是 utimes 的“升级版”，提供了更高的精度和更灵活的操作方式。

2. 函数原型

#include <fcntl.h>      // 包含 AT_FDCWD 等常量
#include <sys/stat.h>   // 包含 utimensat, futimens 函数声明和 timespec 结构体

// 通过路径名设置时间戳 (更灵活)
int utimensat(int dirfd, const char *pathname, const struct timespec times&#91;2], int flags);

// 通过文件描述符设置时间戳
int futimens(int fd, const struct timespec times&#91;2]);

3. 功能

两者都用于设置文件的访问时间 (atime) 和修改时间 (mtime)。

utimensat: 通过路径名指定文件，并提供额外的灵活性（相对路径解析、符号链接处理）。
futimens: 通过已打开的文件描述符 (fd) 指定文件。

4. 参数详解

futimens(int fd, const struct timespec times[2])

fd:

int 类型。
一个指向目标文件的已打开文件描述符。

times:

const struct timespec times[2] 类型。
一个包含两个 struct timespec 元素的数组。
times[0] 指定了新的访问时间 (atime)。
times[1] 指定了新的修改时间 (mtime)。

特殊值:

如果 times[0] 或 times[1] 的 tv_nsec 字段是 UTIME_NOW，则相应的时间戳会被设置为调用时的当前时间。
如果 times[0] 或 times[1] 的 tv_nsec 字段是 UTIME_OMIT，则相应的时间戳将保持不变。
否则，时间戳将被设置为 tv_sec 和 tv_nsec 指定的值。

utimensat(int dirfd, const char *pathname, const struct timespec times[2], int flags)

dirfd:

int 类型。
一个目录文件描述符，用作 pathname 的基础路径。
如果 pathname 是绝对路径，则 dirfd 被忽略。
特殊值 AT_FDCWD 表示使用当前工作目录作为基础路径。

pathname:

const char * 类型。
指向要修改时间戳的文件的路径名（可以是相对路径或绝对路径）。

times:

const struct timespec times[2] 类型。
含义与 futimens 相同。

flags:

int 类型。

用于修改 utimensat 行为的标志。目前主要支持一个标志：

AT_SYMLINK_NOFOLLOW: 如果 pathname 是一个符号链接，则修改符号链接本身的时间戳，而不是它指向的目标文件的时间戳。如果未设置此标志（默认），则会跟随符号链接。

struct timespec 结构体:

struct timespec {
    time_t tv_sec;  /* 秒数 (自 Unix 纪元以来) */
    long   tv_nsec; /* 纳秒数 (0-999,999,999) */
};

5. 返回值

两者返回值相同：

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

6. 错误码 (errno)

两者共享许多相同的错误码：

EACCES: 搜索 pathname 的路径组件时权限不足，或者没有写权限。
EBADF: (对于 futimens) fd 不是有效的文件描述符。
EBADF: (对于 utimensat) dirfd 不是有效的文件描述符，且不等于 AT_FDCWD。
EFAULT: pathname 或 times 指向了调用进程无法访问的内存地址。
EINVAL: times 数组中的时间值无效（例如，纳秒数超出范围或 flags 无效）。
EIO: I/O 错误。
ELOOP: 解析 pathname 时遇到符号链接循环。
ENAMETOOLONG: pathname 太长。
ENOENT: pathname 指定的文件或目录不存在。
ENOMEM: 内核内存不足。
ENOTDIR: (对于 utimensat) pathname 的某个前缀不是目录，或者 dirfd 是一个文件描述符但不是目录。
EPERM: times 中指定的时间早于文件的 ctime 和 mtime，且调用进程不拥有该文件（某些文件系统会阻止将时间戳设置得比 ctime/mtime 更早）。
EROFS: 文件系统是只读的。

7. 相似函数或关联函数

utimes: 旧版函数，使用 struct timeval（微秒精度）。
utime: 更老的函数，使用 struct utimbuf（秒精度）。
lutimes: 旧版函数，用于修改符号链接本身的时间戳。
stat / lstat: 用于获取文件的当前时间戳。

8. 示例代码

下面的示例演示了如何使用 utimensat 和 futimens 来修改文件时间戳，并展示它们的灵活性。

#define _GNU_SOURCE // 启用 GNU 扩展
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>      // 包含 open, O_* flags, AT_FDCWD, AT_SYMLINK_NOFOLLOW
#include <sys/stat.h>   // 包含 utimensat, futimens, timespec, stat
#include <string.h>
#include <errno.h>
#include <time.h>       // 包含 time, localtime, strftime

// 辅助函数：打印文件的时间信息
void print_file_times(const char *filename) {
    struct stat sb;
    if (stat(filename, &sb) == -1) {
        perror("stat");
        return;
    }

    printf("File: %s\n", filename);
    printf("  Last Status Change (ctime): %s", ctime(&sb.st_ctime)); // ctime 包含换行符
    printf("  Last Modification (mtime):  %s", ctime(&sb.st_mtime));
    printf("  Last Access (atime):        %s", ctime(&sb.st_atime));
    printf("\n");
}

// 辅助函数：创建一个测试文件
void create_test_file(const char *filename) {
    FILE *f = fopen(filename, "w");
    if (!f) {
        perror("fopen");
        exit(EXIT_FAILURE);
    }
    fprintf(f, "This is a test file for utimensat/futimens example.\n");
    fclose(f);
    printf("Created test file: %s\n\n", filename);
}

int main() {
    const char *test_file = "utimensat_test_file.txt";
    const char *test_symlink = "utimensat_test_symlink.txt";
    struct timespec new_times&#91;2];
    time_t fixed_time_sec;
    struct tm tm_tmp;

    printf("--- Demonstrating utimensat and futimens ---\n");

    // 1. 创建一个测试文件
    create_test_file(test_file);

    // 2. 创建一个指向测试文件的符号链接
    if (symlink(test_file, test_symlink) == -1) {
        perror("symlink");
        unlink(test_file);
        exit(EXIT_FAILURE);
    }
    printf("Created symlink: %s -> %s\n\n", test_symlink, test_file);

    // 3. 显示初始时间
    printf("1. Initial timestamps:\n");
    print_file_times(test_file);
    print_file_times(test_symlink); // 符号链接的时间通常和目标文件一样（除非文件系统特殊支持）

    // 4. 准备一个固定的时间
    printf("2. Preparing fixed time...\n");
    memset(&tm_tmp, 0, sizeof(tm_tmp));
    tm_tmp.tm_year = 2023 - 1900; // tm_year is years since 1900
    tm_tmp.tm_mon = 10 - 1;       // tm_mon is 0-11
    tm_tmp.tm_mday = 27;
    tm_tmp.tm_hour = 10;
    tm_tmp.tm_min = 0;
    tm_tmp.tm_sec = 0;
    tm_tmp.tm_isdst = 0;
    fixed_time_sec = timegm(&tm_tmp);
    if (fixed_time_sec == -1) {
        perror("timegm");
        unlink(test_file);
        unlink(test_symlink);
        exit(EXIT_FAILURE);
    }

    // 5. 使用 futimens 设置时间
    printf("3. --- Using futimens() ---\n");
    int fd = open(test_file, O_RDONLY);
    if (fd == -1) {
        perror("open test_file");
        unlink(test_file);
        unlink(test_symlink);
        exit(EXIT_FAILURE);
    }

    new_times&#91;0].tv_sec = fixed_time_sec; // atime
    new_times&#91;0].tv_nsec = 123456789;     // atime 纳秒
    new_times&#91;1].tv_sec = fixed_time_sec; // mtime
    new_times&#91;1].tv_nsec = 987654321;     // mtime 纳秒

    printf("Setting timestamps using futimens()...\n");
    if (futimens(fd, new_times) == -1) {
        perror("futimens");
    } else {
        printf("futimens() succeeded.\n");
    }
    close(fd);
    printf("Timestamps after futimens:\n");
    print_file_times(test_file);

    // 6. 使用 utimensat 设置时间 (相对路径)
    printf("4. --- Using utimensat() with relative path ---\n");
    // 等待几秒，让时间不同
    sleep(2);

    // 将 atime 设置为当前时间，mtime 保持不变
    new_times&#91;0].tv_sec = 0;        // 无关紧要
    new_times&#91;0].tv_nsec = UTIME_NOW; // 设置为当前时间
    new_times&#91;1].tv_sec = 0;        // 无关紧要
    new_times&#91;1].tv_nsec = UTIME_OMIT; // 保持 mtime 不变

    printf("Setting atime to NOW and mtime to OMIT using utimensat(AT_FDCWD, ...)...\n");
    // AT_FDCWD 表示相对于当前工作目录解析路径
    if (utimensat(AT_FDCWD, test_file, new_times, 0) == -1) {
        perror("utimensat");
    } else {
        printf("utimensat() succeeded.\n");
    }
    printf("Timestamps after utimensat (atime updated, mtime unchanged):\n");
    print_file_times(test_file);

    // 7. 使用 utimensat 处理符号链接
    printf("5. --- Using utimensat() with symlinks ---\n");
    // 准备新的时间
    new_times&#91;0].tv_sec = fixed_time_sec + 3600; // atime + 1 小时
    new_times&#91;0].tv_nsec = 111111111;
    new_times&#91;1].tv_sec = fixed_time_sec + 7200; // mtime + 2 小时
    new_times&#91;1].tv_nsec = 222222222;

    // 默认情况下，utimensat 会跟随符号链接，修改目标文件
    printf("Calling utimensat() on symlink WITHOUT AT_SYMLINK_NOFOLLOW...\n");
    printf("  This will modify the TARGET file's timestamps.\n");
    if (utimensat(AT_FDCWD, test_symlink, new_times, 0) == -1) {
        perror("utimensat (follow symlink)");
    } else {
        printf("utimensat() succeeded (followed symlink).\n");
    }
    printf("Target file timestamps after utimensat (followed symlink):\n");
    print_file_times(test_file);
    printf("Symlink file timestamps (should be unchanged or linked):\n");
    print_file_times(test_symlink);

    // 现在使用 AT_SYMLINK_NOFOLLOW 来修改符号链接本身
    new_times&#91;0].tv_sec = fixed_time_sec + 10800; // atime + 3 小时
    new_times&#91;0].tv_nsec = 333333333;
    new_times&#91;1].tv_sec = fixed_time_sec + 14400; // mtime + 4 小时
    new_times&#91;1].tv_nsec = 444444444;

    printf("\nCalling utimensat() on symlink WITH AT_SYMLINK_NOFOLLOW...\n");
    printf("  This will modify the SYMLINK's timestamps (if filesystem supports it).\n");
    if (utimensat(AT_FDCWD, test_symlink, new_times, AT_SYMLINK_NOFOLLOW) == -1) {
        if (errno == EOPNOTSUPP) {
            printf("utimensat with AT_SYMLINK_NOFOLLOW failed: %s\n", strerror(errno));
            printf("  This is expected on many filesystems (e.g., ext4).\n");
        } else {
            perror("utimensat (nofollow symlink)");
        }
    } else {
        printf("utimensat() succeeded (modified symlink itself).\n");
        print_file_times(test_symlink);
    }

    // 8. 清理
    printf("\n6. --- Cleaning up ---\n");
    if (unlink(test_file) == 0) {
        printf("Deleted test file '%s'.\n", test_file);
    } else {
        perror("unlink test_file");
    }
    if (unlink(test_symlink) == 0) {
        printf("Deleted symlink '%s'.\n", test_symlink);
    } else {
        perror("unlink test_symlink");
    }

    printf("\n--- Summary ---\n");
    printf("1. futimens(fd, times&#91;2]): Sets atime/mtime for a file via its file descriptor.\n");
    printf("2. utimensat(dirfd, pathname, times&#91;2], flags): Sets atime/mtime via pathname, with more options.\n");
    printf("3. Both use struct timespec, providing nanosecond precision.\n");
    printf("4. Special timespec values:\n");
    printf("   - tv_nsec = UTIME_NOW:  Set timestamp to current time.\n");
    printf("   - tv_nsec = UTIME_OMIT: Leave timestamp unchanged.\n");
    printf("5. utimensat flags:\n");
    printf("   - 0 (default): Follow symlinks.\n");
    printf("   - AT_SYMLINK_NOFOLLOW: Modify symlink itself (filesystem support varies).\n");
    printf("   - dirfd allows relative path resolution (like openat).\n");
    printf("6. These are the modern, preferred functions for changing file timestamps.\n");

    return 0;
}

9. 编译和运行

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

# 运行程序
./utimensat_futimens_example

10. 预期输出 (片段)

--- Demonstrating utimensat and futimens ---
Created test file: utimensat_test_file.txt

Created symlink: utimensat_test_symlink.txt -> utimensat_test_file.txt

1. Initial timestamps:
File: utimensat_test_file.txt
  Last Status Change (ctime): Fri Oct 27 11:00:00 2023
  Last Modification (mtime):  Fri Oct 27 11:00:00 2023
  Last Access (atime):        Fri Oct 27 11:00:00 2023

File: utimensat_test_symlink.txt
  Last Status Change (ctime): Fri Oct 27 11:00:00 2023
  Last Modification (mtime):  Fri Oct 27 11:00:00 2023
  Last Access (atime):        Fri Oct 27 11:00:00 2023

2. Preparing fixed time...
3. --- Using futimens() ---
Setting timestamps using futimens()...
futimens() succeeded.
Timestamps after futimens:
File: utimensat_test_file.txt
  Last Status Change (ctime): Fri Oct 27 11:00:00 2023
  Last Modification (mtime):  Fri Oct 27 10:00:00 2023
  Last Access (atime):        Fri Oct 27 10:00:00 2023

4. --- Using utimensat() with relative path ---
Setting atime to NOW and mtime to OMIT using utimensat(AT_FDCWD, ...)...
utimensat() succeeded.
Timestamps after utimensat (atime updated, mtime unchanged):
File: utimensat_test_file.txt
  Last Status Change (ctime): Fri Oct 27 11:00:02 2023
  Last Modification (mtime):  Fri Oct 27 10:00:00 2023
  Last Access (atime):        Fri Oct 27 11:00:02 2023

5. --- Using utimensat() with symlinks ---
Calling utimensat() on symlink WITHOUT AT_SYMLINK_NOFOLLOW...
  This will modify the TARGET file's timestamps.
utimensat() succeeded (followed symlink).
Target file timestamps after utimensat (followed symlink):
File: utimensat_test_file.txt
  Last Status Change (ctime): Fri Oct 27 11:00:02 2023
  Last Modification (mtime):  Fri Oct 27 12:00:00 2023
  Last Access (atime):        Fri Oct 27 11:00:00 2023
Symlink file timestamps (should be unchanged or linked):
File: utimensat_test_symlink.txt
  ... (same as target) ...

Calling utimensat() on symlink WITH AT_SYMLINK_NOFOLLOW...
  This will modify the SYMLINK's timestamps (if filesystem supports it).
utimensat with AT_SYMLINK_NOFOLLOW failed: Operation not supported
  This is expected on many filesystems (e.g., ext4).

6. --- Cleaning up ---
Deleted test file 'utimensat_test_file.txt'.
Deleted symlink 'utimensat_test_symlink.txt'.

--- Summary ---
1. futimens(fd, times&#91;2]): Sets atime/mtime for a file via its file descriptor.
2. utimensat(dirfd, pathname, times&#91;2], flags): Sets atime/mtime via pathname, with more options.
3. Both use struct timespec, providing nanosecond precision.
4. Special timespec values:
   - tv_nsec = UTIME_NOW:  Set timestamp to current time.
   - tv_nsec = UTIME_OMIT: Leave timestamp unchanged.
5. utimensat flags:
   - 0 (default): Follow symlinks.
   - AT_SYMLINK_NOFOLLOW: Modify symlink itself (filesystem support varies).
   - dirfd allows relative path resolution (like openat).
6. These are the modern, preferred functions for changing file timestamps.

11. 总结

utimensat 和 futimens 是 Linux 中用于修改文件时间戳的现代、强大的系统调用。

核心优势：

高精度：纳秒级时间戳设置。
灵活控制：通过 UTIME_NOW 和 UTIME_OMIT 精确控制每个时间戳的行为。
路径灵活性：utimensat 支持相对路径解析和符号链接处理。

futimens：通过已打开的文件描述符操作，简单直接。

utimensat：功能更全，可以处理相对路径、绝对路径，并控制符号链接行为。

与旧函数对比：

比 utimes (微秒) 和 utime (秒) 精度更高。
比 lutimes 功能更强大（lutimes 只是 utimensat 的一个特例）。

给 Linux 编程小白的建议：在需要修改文件时间戳的新代码中，优先使用 utimensat 或 futimens。它们是当前的标准，功能强大且设计良好。