#include <pthread.h>

pthread_t           // 线程标识符（类似进程的 pid）
pthread_attr_t      // 线程属性结构体
pthread_mutex_t     // 互斥锁
pthread_cond_t      // 条件变量
pthread_rwlock_t    // 读写锁

int pthread_create(pthread_t *thread, 
                   const pthread_attr_t *attr,
                   void *(*start_routine)(void*), 
                   void *arg);

int pthread_join(pthread_t thread, void **retval);

int pthread_detach(pthread_t thread);

pthread_t pthread_self(void);

int pthread_equal(pthread_t t1, pthread_t t2);

void pthread_exit(void *retval);

int pthread_attr_init(pthread_attr_t *attr);
int pthread_attr_destroy(pthread_attr_t *attr);

// 设置分离状态
int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
// detachstate: PTHREAD_CREATE_JOINABLE / PTHREAD_CREATE_DETACHED

// 设置栈大小
int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize);

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; // 静态初始化

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex); // 非阻塞
int pthread_mutex_unlock(pthread_mutex_t *mutex);
int pthread_mutex_destroy(pthread_mutex_t *mutex);

pthread_mutex_lock(&mutex);
// 临界区代码
pthread_mutex_unlock(&mutex);

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); // 阻塞等待
int pthread_cond_timedwait(...); // 带超时
int pthread_cond_signal(pthread_cond_t *cond); // 唤醒一个等待线程
int pthread_cond_broadcast(pthread_cond_t *cond); // 唤醒所有等待线程
int pthread_cond_destroy(pthread_cond_t *cond);

pthread_mutex_lock(&mutex);
while (condition_is_false) {
    pthread_cond_wait(&cond, &mutex); // 自动释放锁，被唤醒后重新加锁
}
// 执行操作
pthread_mutex_unlock(&mutex);

pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;

int pthread_rwlock_init(...);
int pthread_rwlock_rdlock(...);    // 读锁
int pthread_rwlock_wrlock(...);    // 写锁
int pthread_rwlock_unlock(...);
int pthread_rwlock_destroy(...);

pthread_spinlock_t spinlock;

int pthread_spin_init(...);
int pthread_spin_lock(...);
int pthread_spin_unlock(...);
int pthread_spin_destroy(...);

pthread_key_t key;

int pthread_key_create(pthread_key_t *key, void (*destructor)(void*));
int pthread_setspecific(pthread_key_t key, const void *value);
void *pthread_getspecific(pthread_key_t key);
int pthread_key_delete(pthread_key_t key);

int pthread_cancel(pthread_t thread); // 发送取消请求

// 设置取消状态和类型
int pthread_setcancelstate(int state, int *oldstate);
// state: PTHREAD_CANCEL_ENABLE / PTHREAD_CANCEL_DISABLE

int pthread_setcanceltype(int type, int *oldtype);
// type: PTHREAD_CANCEL_DEFERRED（默认，到取消点） / PTHREAD_CANCEL_ASYNCHRONOUS

void pthread_testcancel(void); // 显式设置取消点

pthread_once_t once_control = PTHREAD_ONCE_INIT;

int pthread_once(pthread_once_t *once_control, void (*init_routine)(void));

int ret = pthread_create(...);
if (ret != 0) {
    fprintf(stderr, "Error: %s\n", strerror(ret));
}

errno = ret;
perror("pthread_create");

gcc -o program program.c -lpthread
# 或推荐使用：
gcc -o program program.c -pthread   # 自动定义宏、链接库

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

void* thread_func(void* arg) {
    int id = *(int*)arg;
    printf("Thread %d running\n", id);
    sleep(1);
    pthread_exit((void*)(long)id);
}

int main() {
    pthread_t t1, t2;
    int id1 = 1, id2 = 2;

    pthread_create(&t1, NULL, thread_func, &id1);
    pthread_create(&t2, NULL, thread_func, &id2);

    void* retval;
    pthread_join(t1, &retval);
    printf("Thread 1 returned: %ld\n", (long)retval);

    pthread_join(t2, &retval);
    printf("Thread 2 returned: %ld\n", (long)retval);

    return 0;
}

[User Input]
     ↓
🟢 Node 1: Intent Detection (LLM) — What does the user want?
     ↓
🟡 Node 2: Condition — Should we check weather?
     ↓ Yes                 ↓ No
🔵 Node 3: Tool Call       🔵 Node 4: Simple Reply
     ↓
🟢 Node 5: Final Response (with reminder logic)
     ↓
[Output to User]

You are a task analyzer. Analyze the user input and decide if weather check is needed.

User input: {{input}}

Return JSON format:
{
  "need_check": true or false,
  "city": "city name, e.g. Beijing"
}

intent.need_check == true

{
  "type": "object",
  "properties": {
    "city": {
      "type": "string",
      "description": "City name, e.g. Shanghai"
    }
  },
  "required": ["city"]
}

from fastapi import FastAPI
import requests

app = FastAPI()

@app.post("/weather")
def get_weather(data: dict):
    city = data.get("city")
    api_key = "YOUR_OPENWEATHER_KEY"
    url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}"
    response = requests.get(url).json()
    return {
        "temp": f"{response['main']['temp'] - 273.15:.1f}°C",
        "condition": response['weather'][0]['description']
    }

You are a helpful assistant. Based on the weather info, decide if a reminder is needed.

Weather info:
{{weather_info}}

Reply in natural language. If it's raining, remind the user to bring an umbrella.

The user didn’t ask about weather. Just reply politely:
{{input}}

Will it rain in Hangzhou tomorrow? If yes, remind me.

It will rain in Hangzhou tomorrow. Don’t forget your umbrella!

POST https://demo-agent-tools.example.com/weather
Body: {"city": "Beijing"}
→ Returns: {"temp": "22°C", "condition": "Sunny"}

{
  "nodes": [
    {
      "id": "intent",
      "type": "llm",
      "config": {
        "prompt": "You are a task analyzer...\nReturn JSON..."
      },
      "output_var": "intent"
    },
    {
      "id": "condition",
      "type": "condition",
      "expression": "intent.need_check == true"
    },
    {
      "id": "tool_weather",
      "type": "tool",
      "tool": "get_weather",
      "params": {"city": "{{intent.city}}"},
      "output_var": "weather_info"
    },
    {
      "id": "final_reply",
      "type": "llm",
      "config": {
        "prompt": "Based on {{weather_info}}, generate a reply..."
      }
    }
  ]
}

# 从官方站点下载
wget https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.x.x.tar.xz

# 从镜像站点下载（以清华为例）
wget https://mirrors.tuna.tsinghua.edu.cn/kernel/v6.x/linux-6.x.x.tar.xz

# 克隆官方Git仓库
git clone https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

# 从镜像克隆（以清华为例）
git clone https://mirrors.tuna.tsinghua.edu.cn/git/linux.git

# 测试不同镜像的下载速度
time wget -O /dev/null https://mirrors.tuna.tsinghua.edu.cn/kernel/HEADER.html
time wget -O /dev/null https://mirrors.edge.kernel.org/pub/linux/kernel/HEADER.html

# 验证SHA256校验和
sha256sum linux-6.x.x.tar.xz

# 验证PGP签名
wget https://www.kernel.org/signature.asc
gpg --verify signature.asc linux-6.x.x.tar.sign

#include <sys/quota.h>

int quotactl(int cmd, const char *special, int id, caddr_t addr);

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

int main() {
    // 假设我们要查询 /home 文件系统的用户配额
    const char *mount_point = "/home";
    // 假设我们要查询 UID 为 1001 的用户的配额
    int user_id = 1001;
    struct dqblk quota_info;
    int result;

    // 使用 QCMD 宏构造 cmd 参数：操作是 Q_GETQUOTA，类型是 USRQUOTA (用户配额)
    result = quotactl(QCMD(Q_GETQUOTA, USRQUOTA), mount_point, user_id, (caddr_t)&quota_info);

    if (result == -1) {
        perror("quotactl"); // 打印错误信息
        fprintf(stderr, "Failed to get quota info for user %d on %s\n", user_id, mount_point);
        return 1;
    }

    // 打印获取到的配额信息
    // 注意: 数值通常以 1KB 块为单位
    printf("User ID: %d\n", user_id);
    printf("Block Hard Limit: %llu KB\n", (unsigned long long)quota_info.dqb_bhardlimit);
    printf("Block Soft Limit: %llu KB\n", (unsigned long long)quota_info.dqb_bsoftlimit);
    printf("Current Blocks Used: %llu KB\n", (unsigned long long)quota_info.dqb_curblocks);
    printf("Inode Hard Limit: %llu\n", (unsigned long long)quota_info.dqb_ihardlimit);
    printf("Inode Soft Limit: %llu\n", (unsigned long long)quota_info.dqb_isoftlimit);
    printf("Current Inodes Used: %llu\n", (unsigned long long)quota_info.dqb_curinodes);
    // dqb_btime 和 dqb_itime 是宽限时间，当超过软限制时才相关
    // printf("Block Grace Time Expiry: %lu\n", quota_info.dqb_btime);
    // printf("Inode Grace Time Expiry: %lu\n", quota_info.dqb_itime);

    return 0;
}

#include <stdio.h>
#include <unistd.h>
#include <sys/quota.h>
#include <errno.h>
#include <string.h>
#include <time.h> // 需要设置宽限时间

int main() {
    // 假设我们要设置 /home 文件系统的用户配额
    const char *mount_point = "/home";
    // 假设我们要设置 UID 为 1002 的用户的配额
    int user_id = 1002;
    struct dqblk new_quota_limits;
    int result;

    // 初始化结构体
    memset(&new_quota_limits, 0, sizeof(new_quota_limits));

    // 设置块（磁盘空间）限制 (单位通常是 1KB 块)
    new_quota_limits.dqb_bhardlimit = 500000; // 硬限制 500MB
    new_quota_limits.dqb_bsoftlimit = 400000; // 软限制 400MB

    // 设置 inode（文件数量）限制
    new_quota_limits.dqb_ihardlimit = 5000;  // 硬限制 5000 个文件
    new_quota_limits.dqb_isoftlimit = 4000;  // 软限制 4000 个文件

    // 设置宽限时间 (秒) - 当超过软限制时，用户还有这段时间可以清理，之后硬限制生效
    // 如果不设置或设置为0，可能会使用默认值或导致软限制行为异常
    new_quota_limits.dqb_btime = time(NULL) + 7 * 24 * 60 * 60; // 7天后
    new_quota_limits.dqb_itime = time(NULL) + 7 * 24 * 60 * 60; // 7天后
    // 设置有效的字段标志，告诉内核我们要设置哪些字段
    new_quota_limits.dqb_valid = QIF_LIMITS | QIF_TIMES; // 设置限制和时间

    // 使用 QCMD 宏构造 cmd 参数：操作是 Q_SETQUOTA，类型是 USRQUOTA (用户配额)
    result = quotactl(QCMD(Q_SETQUOTA, USRQUOTA), mount_point, user_id, (caddr_t)&new_quota_limits);

    if (result == -1) {
        perror("quotactl"); // 打印错误信息
        fprintf(stderr, "Failed to set quota limits for user %d on %s\n", user_id, mount_point);
        return 1;
    }

    printf("Successfully set quota limits for user %d on %s\n", user_id, mount_point);
    printf("Block Hard Limit: %llu KB, Soft Limit: %llu KB\n",
           (unsigned long long)new_quota_limits.dqb_bhardlimit,
           (unsigned long long)new_quota_limits.dqb_bsoftlimit);
    printf("Inode Hard Limit: %llu, Soft Limit: %llu\n",
           (unsigned long long)new_quota_limits.dqb_ihardlimit,
           (unsigned long long)new_quota_limits.dqb_isoftlimit);

    return 0;
}

# 假设代码保存在 get_quota.c 和 set_quota.c 中
# 需要 root 权限编译和运行
sudo gcc -o get_quota get_quota.c
sudo gcc -o set_quota set_quota.c

# 运行前确保 /home 文件系统启用了用户配额
# 运行示例 (需要 root 权限)
sudo ./get_quota
sudo ./set_quota

#include <linux/module.h>

int query_module(const char *name, int which, void *buf, 
                 size_t bufsize, size_t *ret);

struct module_info {
    unsigned long   addr;          /* 模块地址 */
    unsigned long   size;          /* 模块大小 */
    unsigned long   flags;         /* 模块标志 */
    long            refcnt;        /* 引用计数 */
    unsigned char   usecount;      /* 使用计数 */
};

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

// 注意：query_module 在现代 Linux 系统中可能不可用
// 这里提供概念性示例和现代替代方案

int main() {
    printf("=== query_module 基础示例 ===\n\n");
    
    printf("注意: query_module 是已废弃的系统调用\n");
    printf("在现代 Linux 系统中通常不可用\n\n");
    
    printf("功能说明:\n");
    printf("query_module 用于查询内核模块信息:\n");
    printf("1. QM_MODULES: 获取模块名称列表\n");
    printf("2. QM_REFS: 获取模块引用计数\n");
    printf("3. QM_SYMBOLS: 获取模块符号信息\n");
    printf("4. QM_INFO: 获取模块详细信息\n");
    printf("5. QM_MODINFO: 获取模块信息（新版本）\n");
    
    printf("\n=== 现代替代方案 ===\n");
    printf("1. 使用 /proc/modules 文件\n");
    printf("2. 使用 lsmod 命令\n");
    printf("3. 使用 modinfo 命令\n");
    printf("4. 使用 /sys/module/ 接口\n");
    
    return 0;
}

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

// 通过 /proc/modules 获取模块信息
int get_modules_via_proc() {
    printf("=== 通过 /proc/modules 获取模块信息 ===\n");
    
    FILE *fp = fopen("/proc/modules", "r");
    if (!fp) {
        perror("打开 /proc/modules 失败");
        return -1;
    }
    
    printf("%-25s %-10s %-8s %-15s %s\n", 
           "模块名称", "大小", "使用数", "被谁使用", "状态");
    printf("%-25s %-10s %-8s %-15s %s\n", 
           "--------", "----", "----", "------", "----");
    
    char line&#91;512];
    int count = 0;
    
    while (fgets(line, sizeof(line), fp) && count < 20) {
        char module_name&#91;64];
        unsigned long size;
        int use_count;
        char used_by&#91;256];
        char status&#91;32];
        char address&#91;32];
        
        // 解析 /proc/modules 格式
        int parsed = sscanf(line, "%63s %lu %d %255s %31s %31s",
                           module_name, &size, &use_count, used_by, status, address);
        
        if (parsed >= 4) {
            printf("%-25s %-10lu %-8d %-15s %s\n", 
                   module_name, size, use_count, used_by, 
                   parsed >= 5 ? status : "-");
            count++;
        }
    }
    
    fclose(fp);
    
    if (count == 0) {
        printf("没有模块信息\n");
    } else {
        printf("\n显示了前 %d 个模块\n", count);
    }
    
    return 0;
}

// 通过 /sys/module/ 获取模块详细信息
int get_module_details_via_sysfs() {
    printf("\n=== 通过 /sys/module/ 获取模块详细信息 ===\n");
    
    // 检查 /sys/module/ 目录
    if (access("/sys/module", F_OK) != 0) {
        printf("系统不支持 /sys/module/ 接口\n");
        return -1;
    }
    
    // 列出几个模块的详细信息
    const char *modules&#91;] = {"usbcore", "tcp", "ext4", "loop", NULL};
    
    for (int i = 0; modules&#91;i]; i++) {
        char module_path&#91;256];
        snprintf(module_path, sizeof(module_path), "/sys/module/%s", modules&#91;i]);
        
        if (access(module_path, F_OK) == 0) {
            printf("\n模块: %s\n", modules&#91;i]);
            
            // 检查模块参数
            char param_path&#91;256];
            snprintf(param_path, sizeof(param_path), "%s/parameters", module_path);
            if (access(param_path, F_OK) == 0) {
                printf("  ✓ 支持参数配置\n");
            }
            
            // 检查模块引用
            char refcnt_path&#91;256];
            snprintf(refcnt_path, sizeof(refcnt_path), "%s/refcnt", module_path);
            FILE *refcnt_fp = fopen(refcnt_path, "r");
            if (refcnt_fp) {
                char refcnt&#91;32];
                if (fgets(refcnt, sizeof(refcnt), refcnt_fp)) {
                    printf("  引用计数: %s", refcnt);
                }
                fclose(refcnt_fp);
            }
            
            // 检查模块状态
            char initstate_path&#91;256];
            snprintf(initstate_path, sizeof(initstate_path), "%s/initstate", module_path);
            FILE *initstate_fp = fopen(initstate_path, "r");
            if (initstate_fp) {
                char initstate&#91;32];
                if (fgets(initstate, sizeof(initstate), initstate_fp)) {
                    printf("  初始化状态: %s", initstate);
                }
                fclose(initstate_fp);
            }
        }
    }
    
    return 0;
}

// 模拟 query_module 功能
void simulate_query_module() {
    printf("\n=== 模拟 query_module 功能 ===\n");
    
    printf("QM_MODULES (获取模块列表):\n");
    printf("  模块1: usbcore\n");
    printf("  模块2: tcp\n");
    printf("  模块3: ext4\n");
    printf("  模块4: loop\n");
    printf("  模块5: sd_mod\n");
    
    printf("\nQM_INFO (获取模块详细信息):\n");
    printf("  模块名称: usbcore\n");
    printf("  地址: 0xffffffffc0000000\n");
    printf("  大小: 123456 字节\n");
    printf("  引用计数: 5\n");
    printf("  状态: Live\n");
    
    printf("\nQM_REFS (获取引用计数):\n");
    printf("  usbcore: 5\n");
    printf("  tcp: 3\n");
    printf("  ext4: 2\n");
    printf("  loop: 1\n");
    
    printf("\nQM_SYMBOLS (获取符号信息):\n");
    printf("  usb_register: 0xffffffffc0001000\n");
    printf("  usb_deregister: 0xffffffffc0002000\n");
    printf("  usb_submit_urb: 0xffffffffc0003000\n");
}

int main() {
    printf("=== 内核模块查询系统 ===\n\n");
    
    // 显示系统信息
    printf("系统信息:\n");
    printf("  用户 ID: %d\n", getuid());
    printf("  进程 ID: %d\n", getpid());
    
    // 检查权限
    if (getuid() != 0) {
        printf("  注意: 某些模块信息需要 root 权限\n");
    }
    printf("\n");
    
    // 通过 /proc/modules 获取信息
    get_modules_via_proc();
    
    // 通过 /sys/module/ 获取详细信息
    get_module_details_via_sysfs();
    
    // 模拟 query_module 功能
    simulate_query_module();
    
    printf("\n=== 现代模块管理工具 ===\n");
    printf("常用的模块管理命令:\n");
    printf("1. lsmod              # 列出已加载模块\n");
    printf("2. modinfo module     # 显示模块信息\n");
    printf("3. insmod module.ko   # 加载模块\n");
    printf("4. rmmod module       # 卸载模块\n");
    printf("5. modprobe module    # 智能加载模块\n");
    printf("6. depmod             # 生成模块依赖\n");
    printf("\n");
    
    printf("模块信息文件:\n");
    printf("1. /proc/modules      # 已加载模块列表\n");
    printf("2. /proc/devices      # 设备号信息\n");
    printf("3. /sys/module/       # 模块 sysfs 接口\n");
    printf("4. /lib/modules/       # 模块文件目录\n");
    
    return 0;
}

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

// 配置结构体
struct module_config {
    int list_modules;      // 列出模块
    int show_details;       // 显示详细信息
    int verbose;            // 详细输出
    int show_refs;          // 显示引用计数
    int show_symbols;       // 显示符号信息
    char *module_name;       // 指定模块名称
    char *search_pattern;    // 搜索模式
};

// 模块信息结构体
struct module_info {
    char name&#91;256];
    unsigned long size;
    int ref_count;
    char used_by&#91;512];
    char status&#91;32];
    unsigned long address;
};

// 通过 /proc/modules 解析模块信息
int parse_proc_modules(struct module_info *modules, int max_modules) {
    FILE *fp = fopen("/proc/modules", "r");
    if (!fp) {
        return -1;
    }
    
    int count = 0;
    char line&#91;1024];
    
    while (fgets(line, sizeof(line), fp) && count < max_modules) {
        struct module_info *mod = &modules&#91;count];
        char extra&#91;512];
        
        // 解析 /proc/modules 格式
        int parsed = sscanf(line, "%255s %lu %d %511s %31s %31s",
                           mod->name, &mod->size, &mod->ref_count, 
                           mod->used_by, mod->status, extra);
        
        if (parsed >= 4) {
            count++;
        }
    }
    
    fclose(fp);
    return count;
}

// 显示模块列表
void show_module_list(struct module_info *modules, int count, 
                     const struct module_config *config) {
    printf("=== 内核模块列表 ===\n");
    printf("%-25s %-12s %-8s %-20s %s\n", 
           "模块名称", "大小", "引用数", "被谁使用", "状态");
    printf("%-25s %-12s %-8s %-20s %s\n", 
           "--------", "----", "----", "------", "----");
    
    int displayed = 0;
    for (int i = 0; i < count && displayed < 50; i++) {
        struct module_info *mod = &modules&#91;i];
        
        // 如果指定了搜索模式，进行过滤
        if (config->search_pattern) {
            if (strstr(mod->name, config->search_pattern) == NULL) {
                continue;
            }
        }
        
        // 如果指定了模块名称，精确匹配
        if (config->module_name) {
            if (strcmp(mod->name, config->module_name) != 0) {
                continue;
            }
        }
        
        printf("%-25s %-12lu %-8d %-20s %s\n", 
               mod->name, mod->size, mod->ref_count, 
               mod->used_by, mod->status);
        displayed++;
    }
    
    if (displayed == 0) {
        printf("没有找到匹配的模块\n");
    } else if (displayed < count) {
        printf("\n显示了 %d 个匹配模块 (总共 %d 个)\n", displayed, count);
    }
}

// 显示模块详细信息
void show_module_details(struct module_info *modules, int count, 
                        const struct module_config *config) {
    printf("\n=== 模块详细信息 ===\n");
    
    int found = 0;
    for (int i = 0; i < count; i++) {
        struct module_info *mod = &modules&#91;i];
        
        // 检查是否匹配
        if (config->module_name) {
            if (strcmp(mod->name, config->module_name) != 0) {
                continue;
            }
        } else if (config->search_pattern) {
            if (strstr(mod->name, config->search_pattern) == NULL) {
                continue;
            }
        }
        
        printf("\n模块: %s\n", mod->name);
        printf("  大小: %lu 字节 (%.2f KB)\n", mod->size, (double)mod->size / 1024);
        printf("  引用计数: %d\n", mod->ref_count);
        printf("  被谁使用: %s\n", mod->used_by);
        printf("  状态: %s\n", mod->status);
        
        // 显示 sysfs 信息
        char sysfs_path&#91;256];
        snprintf(sysfs_path, sizeof(sysfs_path), "/sys/module/%s", mod->name);
        
        if (access(sysfs_path, F_OK) == 0) {
            printf("  Sysfs 路径: %s\n", sysfs_path);
            
            // 检查参数
            char param_path&#91;256];
            snprintf(param_path, sizeof(param_path), "%s/parameters", sysfs_path);
            if (access(param_path, F_OK) == 0) {
                printf("  ✓ 支持运行时参数配置\n");
            }
            
            // 检查引用计数
            char refcnt_path&#91;256];
            snprintf(refcnt_path, sizeof(refcnt_path), "%s/refcnt", sysfs_path);
            FILE *refcnt_fp = fopen(refcnt_path, "r");
            if (refcnt_fp) {
                char refcnt&#91;32];
                if (fgets(refcnt, sizeof(refcnt), refcnt_fp)) {
                    printf("  当前引用计数: %s", refcnt);
                }
                fclose(refcnt_fp);
            }
        }
        
        found++;
        if (config->module_name) {
            break;  // 只显示指定模块
        }
        
        if (found >= 5) {
            printf("\n只显示前 5 个匹配模块的详细信息\n");
            break;
        }
    }
    
    if (found == 0) {
        if (config->module_name) {
            printf("未找到模块: %s\n", config->module_name);
        } else if (config->search_pattern) {
            printf("未找到匹配模式 '%s' 的模块\n", config->search_pattern);
        } else {
            printf("没有模块信息\n");
        }
    }
}

// 显示系统模块统计
void show_module_statistics(struct module_info *modules, int count) {
    printf("\n=== 模块统计信息 ===\n");
    printf("总模块数: %d\n", count);
    
    if (count > 0) {
        // 统计引用计数
        int total_refs = 0;
        int max_refs = 0;
        int zero_refs = 0;
        unsigned long total_size = 0;
        
        for (int i = 0; i < count; i++) {
            total_refs += modules&#91;i].ref_count;
            total_size += modules&#91;i].size;
            
            if (modules&#91;i].ref_count > max_refs) {
                max_refs = modules&#91;i].ref_count;
            }
            
            if (modules&#91;i].ref_count == 0) {
                zero_refs++;
            }
        }
        
        printf("总大小: %.2f MB\n", (double)total_size / (1024 * 1024));
        printf("平均引用计数: %.2f\n", (double)total_refs / count);
        printf("最大引用计数: %d\n", max_refs);
        printf("零引用模块数: %d\n", zero_refs);
        
        // 显示最常见的模块
        printf("\n最常用的模块:\n");
        int shown = 0;
        for (int i = 0; i < count && shown < 5; i++) {
            if (modules&#91;i].ref_count > 0) {
                printf("  %s (%d 引用)\n", modules&#91;i].name, modules&#91;i].ref_count);
                shown++;
            }
        }
    }
}

// 显示帮助信息
void show_help(const char *program_name) {
    printf("用法: %s &#91;选项]\n", program_name);
    printf("\n选项:\n");
    printf("  -l, --list              列出所有模块\n");
    printf("  -d, --details           显示模块详细信息\n");
    printf("  -r, --refs              显示引用计数\n");
    printf("  -n, --name=MODULE       指定模块名称\n");
    printf("  -s, --search=PATTERN    搜索模块名称\n");
    printf("  -v, --verbose           详细输出\n");
    printf("  -S, --statistics         显示统计信息\n");
    printf("  -h, --help              显示此帮助信息\n");
    printf("\n示例:\n");
    printf("  %s -l                          # 列出所有模块\n", program_name);
    printf("  %s -d -n usbcore               # 显示 usbcore 模块详细信息\n", program_name);
    printf("  %s -l -s usb                   # 列出包含 usb 的模块\n", program_name);
    printf("  %s -S                          # 显示模块统计信息\n", program_name);
    printf("  %s -d -s network                # 显示网络相关模块详情\n", program_name);
}

int main(int argc, char *argv&#91;]) {
    struct module_config config = {
        .list_modules = 0,
        .show_details = 0,
        .verbose = 0,
        .show_refs = 0,
        .show_symbols = 0,
        .module_name = NULL,
        .search_pattern = NULL
    };
    
    printf("=== 内核模块查询工具 ===\n\n");
    
    // 解析命令行参数
    static struct option long_options&#91;] = {
        {"list",        no_argument,       0, 'l'},
        {"details",     no_argument,       0, 'd'},
        {"refs",        no_argument,       0, 'r'},
        {"symbols",     no_argument,       0, 'y'},
        {"name",        required_argument, 0, 'n'},
        {"search",      required_argument, 0, 's'},
        {"verbose",     no_argument,       0, 'v'},
        {"statistics",  no_argument,       0, 'S'},
        {"help",        no_argument,       0, 'h'},
        {0, 0, 0, 0}
    };
    
    int opt;
    while ((opt = getopt_long(argc, argv, "ldryn:s:vSh", long_options, NULL)) != -1) {
        switch (opt) {
            case 'l':
                config.list_modules = 1;
                break;
            case 'd':
                config.show_details = 1;
                break;
            case 'r':
                config.show_refs = 1;
                break;
            case 'y':
                config.show_symbols = 1;
                break;
            case 'n':
                config.module_name = optarg;
                break;
            case 's':
                config.search_pattern = optarg;
                break;
            case 'v':
                config.verbose = 1;
                break;
            case 'S':
                config.list_modules = 1;
                break;
            case 'h':
                show_help(argv&#91;0]);
                return 0;
            default:
                fprintf(stderr, "使用 '%s --help' 查看帮助信息\n", argv&#91;0]);
                return 1;
        }
    }
    
    // 如果没有指定操作，默认列出模块
    if (!config.list_modules && !config.show_details && 
        !config.show_refs && !config.show_symbols) {
        config.list_modules = 1;
    }
    
    // 显示系统信息
    if (config.verbose) {
        printf("系统信息:\n");
        printf("  用户 ID: %d\n", getuid());
        printf("  进程 ID: %d\n", getpid());
        printf("  当前目录: %s\n", getcwd(NULL, 0));
        printf("\n");
    }
    
    // 读取模块信息
    struct module_info modules&#91;500];
    int module_count = parse_proc_modules(modules, 500);
    
    if (module_count == -1) {
        printf("错误: 无法读取模块信息\n");
        printf("可能的原因:\n");
        printf("1. 系统不支持 /proc/modules\n");
        printf("2. 权限不足\n");
        printf("3. 内核不支持模块\n");
        return 1;
    }
    
    if (config.verbose) {
        printf("读取到 %d 个模块\n\n", module_count);
    }
    
    // 执行相应操作
    if (config.list_modules) {
        show_module_list(modules, module_count, &config);
    }
    
    if (config.show_details) {
        show_module_details(modules, module_count, &config);
    }
    
    if (optind == 1) {  // 如果没有指定参数，显示统计信息
        show_module_statistics(modules, module_count);
    }
    
    printf("\n=== 模块管理最佳实践 ===\n");
    printf("模块安全建议:\n");
    printf("1. 只加载可信的模块\n");
    printf("2. 定期更新模块\n");
    printf("3. 监控模块加载活动\n");
    printf("4. 限制模块加载权限\n");
    printf("5. 使用签名验证模块\n");
    printf("\n");
    
    printf("模块性能优化:\n");
    printf("1. 卸载不用的模块\n");
    printf("2. 优化模块参数\n");
    printf("3. 监控模块内存使用\n");
    printf("4. 使用模块黑名单\n");
    printf("5. 合理配置模块依赖\n");
    printf("\n");
    
    printf("现代替代方案:\n");
    printf("1. /proc/modules: 模块列表信息\n");
    printf("2. /sys/module/: 模块 sysfs 接口\n");
    printf("3. modinfo: 模块详细信息\n");
    printf("4. lsmod: 列出模块\n");
    printf("5. modprobe: 智能模块加载\n");
    printf("6. rmmod: 卸载模块\n");
    
    return 0;
}

# 编译示例程序
gcc -o query_module_example1 example1.c
gcc -o query_module_example2 example2.c
gcc -o query_module_example3 example3.c

# 运行示例
./query_module_example1
./query_module_example2
./query_module_example3 --help
./query_module_example3 -l
./query_module_example3 -d -n usbcore
./query_module_example3 -l -s usb
./query_module_example3 -S

# 检查模块支持
ls /proc/modules
ls /sys/module/

# 检查模块工具
which lsmod
which modinfo
which modprobe
which rmmod

# 查看内核模块目录
ls /lib/modules/$(uname -r)/kernel/

# 检查内核配置
grep -i module /boot/config-$(uname -r)

// 读取模块列表
int read_module_list() {
    FILE *fp = fopen("/proc/modules", "r");
    if (!fp) return -1;
    
    char line[1024];
    while (fgets(line, sizeof(line), fp)) {
        char name[256], used_by[256], status[32];
        unsigned long size;
        int ref_count;
        
        if (sscanf(line, "%255s %lu %d %255s %31s", 
                  name, &size, &ref_count, used_by, status) >= 4) {
            printf("%-20s %8lu %3d %s\n", name, size, ref_count, used_by);
        }
    }
    
    fclose(fp);
    return 0;
}

// 读取模块详细信息
int read_module_details(const char *module_name) {
    char path[256];
    
    // 读取引用计数
    snprintf(path, sizeof(path), "/sys/module/%s/refcnt", module_name);
    FILE *fp = fopen(path, "r");
    if (fp) {
        char refcnt[32];
        if (fgets(refcnt, sizeof(refcnt), fp)) {
            printf("引用计数: %s", refcnt);
        }
        fclose(fp);
    }
    
    return 0;
}

# 列出模块
lsmod

# 显示模块信息
modinfo module_name

# 加载模块
sudo modprobe module_name

# 卸载模块
sudo rmmod module_name

# 生成依赖关系
sudo depmod

// 安全的模块信息查询函数
int safe_query_modules(struct module_info *modules, int max_count) {
    // 验证参数
    if (!modules || max_count <= 0) {
        errno = EINVAL;
        return -1;
    }
    
    // 检查文件存在性
    if (access("/proc/modules", F_OK) != 0) {
        errno = ENOENT;
        return -1;
    }
    
    // 读取模块信息
    return parse_proc_modules(modules, max_count);
}

// 模块安全检查
int validate_module_security(const char *module_name) {
    // 检查模块名称合法性
    if (!module_name || strlen(module_name) == 0) {
        return -1;
    }
    
    // 检查是否在黑名单中
    // 这里简化处理，实际应用中可以检查 /etc/modprobe.d/blacklist.conf
    const char *blacklisted&#91;] = {"firewire-sbp2", "usbmouse", NULL};
    for (int i = 0; blacklisted&#91;i]; i++) {
        if (strcmp(module_name, blacklisted&#91;i]) == 0) {
            printf("警告: 模块 '%s' 在黑名单中\n", module_name);
            return -1;
        }
    }
    
    return 0;
}

#define _GNU_SOURCE
#include <fcntl.h>
ssize_t readahead(int fd, off64_t offset, size_t count);

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

/**
 * 创建大文件用于测试
 */
int create_test_file(const char *filename, size_t size) {
    int fd;
    char *buffer;
    size_t chunk_size = 1024 * 1024;  // 1MB chunks
    size_t written = 0;
    
    fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd == -1) {
        perror("创建测试文件失败");
        return -1;
    }
    
    buffer = malloc(chunk_size);
    if (!buffer) {
        perror("分配缓冲区失败");
        close(fd);
        return -1;
    }
    
    // 填充测试数据
    for (size_t i = 0; i < chunk_size; i++) {
        buffer&#91;i] = 'A' + (i % 26);
    }
    
    printf("正在创建 %zu MB 的测试文件...\n", size / (1024 * 1024));
    
    while (written < size) {
        size_t to_write = (size - written < chunk_size) ? size - written : chunk_size;
        ssize_t result = write(fd, buffer, to_write);
        if (result == -1) {
            perror("写入文件失败");
            free(buffer);
            close(fd);
            return -1;
        }
        written += result;
    }
    
    free(buffer);
    close(fd);
    printf("测试文件创建完成\n");
    return 0;
}

/**
 * 测量读取时间
 */
double time_read_operation(int fd, void *buffer, size_t size) {
    struct timespec start, end;
    ssize_t total_read = 0;
    off_t offset = 0;
    
    clock_gettime(CLOCK_MONOTONIC, &start);
    
    while (total_read < (ssize_t)size) {
        ssize_t to_read = (size - total_read < 1024 * 1024) ? size - total_read : 1024 * 1024;
        ssize_t result = pread(fd, (char*)buffer + total_read, to_read, offset);
        if (result == -1) {
            perror("读取文件失败");
            return -1;
        }
        if (result == 0) break;  // 文件结束
        
        total_read += result;
        offset += result;
    }
    
    clock_gettime(CLOCK_MONOTONIC, &end);
    
    return (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9;
}

/**
 * 演示readahead的基本使用
 */
int demo_readahead_basic() {
    const char *filename = "test_readahead.dat";
    const size_t file_size = 50 * 1024 * 1024;  // 50MB
    int fd;
    char *buffer;
    double time_without, time_with;
    
    printf("=== readahead 基本使用示例 ===\n");
    
    // 创建测试文件
    if (create_test_file(filename, file_size) != 0) {
        return -1;
    }
    
    // 分配读取缓冲区
    buffer = malloc(file_size);
    if (!buffer) {
        perror("分配读取缓冲区失败");
        unlink(filename);
        return -1;
    }
    
    // 测试不使用readahead的读取性能
    fd = open(filename, O_RDONLY);
    if (fd == -1) {
        perror("打开文件失败");
        free(buffer);
        unlink(filename);
        return -1;
    }
    
    printf("第一次读取（无预读）...\n");
    time_without = time_read_operation(fd, buffer, file_size);
    if (time_without > 0) {
        printf("无预读读取时间: %.3f 秒\n", time_without);
    }
    
    close(fd);
    
    // 测试使用readahead的读取性能
    fd = open(filename, O_RDONLY);
    if (fd == -1) {
        perror("打开文件失败");
        free(buffer);
        unlink(filename);
        return -1;
    }
    
    // 使用readahead预读整个文件
    printf("执行预读操作...\n");
    if (readahead(fd, 0, file_size) == 0) {
        printf("预读请求提交成功\n");
    } else {
        printf("预读请求失败: %s\n", strerror(errno));
    }
    
    // 等待一小段时间让预读完成
    sleep(1);
    
    printf("第二次读取（有预读）...\n");
    time_with = time_read_operation(fd, buffer, file_size);
    if (time_with > 0) {
        printf("有预读读取时间: %.3f 秒\n", time_with);
        if (time_without > 0) {
            printf("性能提升: %.1f%%\n", 
                   (time_without - time_with) / time_without * 100);
        }
    }
    
    close(fd);
    free(buffer);
    unlink(filename);
    
    return 0;
}

int main() {
    return demo_readahead_basic();
}

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

/**
 * 演示分段预读的使用
 */
int demo_readahead_segmented() {
    const char *filename = "segmented_test.dat";
    const size_t file_size = 100 * 1024 * 1024;  // 100MB
    const size_t segment_size = 10 * 1024 * 1024;  // 10MB per segment
    int fd;
    char *buffer;
    struct timespec start, end;
    double total_time = 0;
    
    printf("=== readahead 分段预读示例 ===\n");
    
    // 创建测试文件
    int test_fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (test_fd == -1) {
        perror("创建测试文件失败");
        return -1;
    }
    
    buffer = malloc(segment_size);
    if (!buffer) {
        perror("分配缓冲区失败");
        close(test_fd);
        unlink(filename);
        return -1;
    }
    
    // 填充测试数据
    for (size_t i = 0; i < segment_size; i++) {
        buffer&#91;i] = 'A' + (i % 26);
    }
    
    // 写入文件数据
    for (size_t offset = 0; offset < file_size; offset += segment_size) {
        write(test_fd, buffer, segment_size);
    }
    
    close(test_fd);
    printf("创建了 %zu MB 的测试文件\n", file_size / (1024 * 1024));
    
    // 打开文件进行测试
    fd = open(filename, O_RDONLY);
    if (fd == -1) {
        perror("打开文件失败");
        free(buffer);
        unlink(filename);
        return -1;
    }
    
    printf("开始分段读取测试...\n");
    
    // 分段预读和读取
    for (size_t offset = 0; offset < file_size; offset += segment_size) {
        printf("处理段 %zu/%zu MB\n", 
               (offset + segment_size) / (1024 * 1024),
               file_size / (1024 * 1024));
        
        // 预读当前段
        clock_gettime(CLOCK_MONOTONIC, &start);
        if (readahead(fd, offset, segment_size) == 0) {
            // printf("  预读段 %zu 完成\n", offset / segment_size);
        } else {
            printf("  预读段 %zu 失败: %s\n", offset / segment_size, strerror(errno));
        }
        
        // 等待预读完成（实际应用中可能不需要）
        usleep(100000);  // 100ms
        
        // 读取当前段
        ssize_t bytes_read = pread(fd, buffer, segment_size, offset);
        if (bytes_read == -1) {
            perror("读取段失败");
            break;
        }
        
        clock_gettime(CLOCK_MONOTONIC, &end);
        double segment_time = (end.tv_sec - start.tv_sec) + 
                             (end.tv_nsec - start.tv_nsec) / 1e9;
        total_time += segment_time;
        
        printf("  段处理时间: %.3f 秒\n", segment_time);
    }
    
    printf("\n总处理时间: %.3f 秒\n", total_time);
    printf("平均段处理时间: %.3f 秒\n", total_time / (file_size / segment_size));
    
    close(fd);
    free(buffer);
    unlink(filename);
    
    return 0;
}

int main() {
    return demo_readahead_segmented();
}

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

/**
 * 创建测试文件
 */
int create_large_file(const char *filename, size_t size) {
    int fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd == -1) {
        perror("创建文件失败");
        return -1;
    }
    
    char *buffer = malloc(1024 * 1024);
    if (!buffer) {
        perror("分配缓冲区失败");
        close(fd);
        return -1;
    }
    
    // 填充数据
    for (int i = 0; i < 1024 * 1024; i++) {
        buffer&#91;i] = 'A' + (i % 26);
    }
    
    size_t written = 0;
    while (written < size) {
        size_t to_write = (size - written < 1024 * 1024) ? size - written : 1024 * 1024;
        ssize_t result = write(fd, buffer, to_write);
        if (result == -1) {
            perror("写入文件失败");
            free(buffer);
            close(fd);
            return -1;
        }
        written += result;
    }
    
    free(buffer);
    close(fd);
    return 0;
}

/**
 * 使用readahead进行预读
 */
int test_readahead_method(const char *filename) {
    int fd = open(filename, O_RDONLY);
    if (fd == -1) {
        perror("打开文件失败");
        return -1;
    }
    
    struct stat sb;
    if (fstat(fd, &sb) == -1) {
        perror("获取文件状态失败");
        close(fd);
        return -1;
    }
    
    // 使用readahead预读
    if (readahead(fd, 0, sb.st_size) == 0) {
        printf("使用readahead预读成功\n");
    } else {
        printf("使用readahead预读失败: %s\n", strerror(errno));
    }
    
    close(fd);
    return 0;
}

/**
 * 使用posix_fadvise进行预读
 */
int test_fadvise_method(const char *filename) {
    int fd = open(filename, O_RDONLY);
    if (fd == -1) {
        perror("打开文件失败");
        return -1;
    }
    
    struct stat sb;
    if (fstat(fd, &sb) == -1) {
        perror("获取文件状态失败");
        close(fd);
        return -1;
    }
    
    // 使用posix_fadvise预读
    if (posix_fadvise(fd, 0, sb.st_size, POSIX_FADV_WILLNEED) == 0) {
        printf("使用posix_fadvise预读成功\n");
    } else {
        printf("使用posix_fadvise预读失败: %s\n", strerror(errno));
    }
    
    close(fd);
    return 0;
}

/**
 * 演示readahead与posix_fadvise的对比
 */
int demo_readahead_vs_fadvise() {
    const char *filename = "comparison_test.dat";
    const size_t file_size = 50 * 1024 * 1024;  // 50MB
    
    printf("=== readahead vs posix_fadvise 对比示例 ===\n");
    
    // 创建测试文件
    if (create_large_file(filename, file_size) != 0) {
        return -1;
    }
    
    printf("创建了 %zu MB 的测试文件\n", file_size / (1024 * 1024));
    
    printf("\n1. 测试readahead方法:\n");
    test_readahead_method(filename);
    
    printf("\n2. 测试posix_fadvise方法:\n");
    test_fadvise_method(filename);
    
    printf("\n3. 功能对比:\n");
    printf("   readahead:\n");
    printf("     - 专门的预读系统调用\n");
    printf("     - 直接控制预读字节数\n");
    printf("     - 更精确的控制\n");
    printf("   posix_fadvise:\n");
    printf("     - 通用的文件访问建议接口\n");
    printf("     - 支持多种访问模式\n");
    printf("     - 更好的可移植性\n");
    
    unlink(filename);
    return 0;
}

int main() {
    return demo_readahead_vs_fadvise();
}