第9周：内核模块开发入门

字数统计: 3.2k字   |   阅读时长≈ 16分

第9周：内核模块开发入门

目标：能够编写、编译、加载和卸载 Linux 内核模块，理解内核空间与用户空间的交互机制。

1. 内核模块基础

1.1 Hello World 模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// hello.c
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>

// 模块加载时调用
static int __init hello_init(void) {
    printk(KERN_INFO "Hello: Module loaded!\n");
    return 0;  // 返回 0 表示成功
}

// 模块卸载时调用
static void __exit hello_exit(void) {
    printk(KERN_INFO "Hello: Module unloaded!\n");
}

// 注册入口/出口函数
module_init(hello_init);
module_exit(hello_exit);

// 模块信息
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("A simple Hello World kernel module");
MODULE_VERSION("1.0");

1.2 编译系统（Kbuild）

1
2
3
4
5
6
7
8
9
10
11
# Makefile
obj-m += hello.o

# 内核源码路径（根据实际修改）
KDIR := /lib/modules/$(shell uname -r)/build

all:
	$(MAKE) -C $(KDIR) M=$(PWD) modules

clean:
	$(MAKE) -C $(KDIR) M=$(PWD) clean
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# 编译
make

# 加载模块（需要 root）
sudo insmod hello.ko

# 查看内核日志
dmesg | tail
# [12345.678] Hello: Module loaded!

# 查看已加载模块
lsmod | grep hello

# 卸载模块
sudo rmmod hello

# 查看卸载日志
dmesg | tail
# [12345.789] Hello: Module unloaded!

# 模块信息
modinfo hello.ko
# filename:       hello.ko
# license:        GPL
# author:         Your Name
# description:    A simple Hello World kernel module
# srcversion:     ...

1.3 模块参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <linux/moduleparam.h>

static int port = 8080;
static char *iface = "eth0";
static int debug = 0;

// 注册模块参数
module_param(port, int, 0660);       // 0660 = root 可读写
module_param(iface, charp, 0644);    // charp = 字符串指针
module_param(debug, bool, 0644);     // bool = 布尔值

MODULE_PARM_DESC(port, "Listen port");
MODULE_PARM_DESC(iface, "Network interface");
MODULE_PARM_DESC(debug, "Enable debug output");
1
2
3
4
5
6
7
8
9
# 带参数加载
sudo insmod mymodule.ko port=9090 iface="ens33" debug=1

# 查看参数
sudo modinfo -p mymodule.ko

# 运行时修改（如果权限允许）
echo 1 | sudo tee /sys/module/mymodule/parameters/debug
cat /sys/module/mymodule/parameters/port

1.4 模块依赖

1
2
3
4
5
6
7
8
9
// 声明依赖
MODULE_DEPENDS("some_other_module");

// 导出符号供其他模块使用
EXPORT_SYMBOL(my_function);
EXPORT_SYMBOL_GPL(my_gpl_function);  // 仅 GPL 模块可用

// 在另一个模块中使用
extern int my_function(void);

2. printk 与日志系统

2.1 printk 日志级别

1
2
3
4
5
6
7
8
9
10
11
printk(KERN_EMERG   "System unusable\n");   // 0，紧急
printk(KERN_ALERT   "Action required\n");   // 1，告警
printk(KERN_CRIT    "Critical\n");          // 2，严重
printk(KERN_ERR     "Error\n");             // 3，错误（常用）
printk(KERN_WARNING "Warning\n");           // 4，警告
printk(KERN_NOTICE  "Notice\n");            // 5，通知
printk(KERN_INFO    "Info\n");              // 6，信息（常用）
printk(KERN_DEBUG   "Debug\n");             // 7，调试

// 等价写法（KERN_INFO 是宏，自动拼接）
printk("Hello: %s\n", KERN_INFO "message");

日志级别控制：

1
2
3
4
5
6
7
8
9
10
11
# 查看当前控制台日志级别
cat /proc/sys/kernel/printk
# 输出: 4       4       1       7
#       当前    默认   启动    控制台

# 设置控制台最低显示级别（只显示 ERROR 及以上）
echo 3 | sudo tee /proc/sys/kernel/printk

# 动态调整（仅调试用）
# 在 /etc/sysctl.conf 中永久设置
kernel.printk = 4 4 1 7

dmesg 过滤：

1
2
3
4
5
6
7
8
9
10
# 按级别过滤
dmesg -l err,warn        # 只显示 ERROR 和 WARNING
dmesg -l info            # 显示 INFO 及以上
dmesg -d                 # 显示时间戳

# 按模块过滤
dmesg | grep hello

# 实时监控
dmesg -w

2.2 printk vs printf

特性 printk printf
运行环境 内核空间 用户空间
输出目标 内核日志缓冲区 stdout
格式支持 受限（无浮点） 完整
安全性 不能睡眠/阻塞 可以
性能 较慢（缓冲区+调度） 快

⚠️ printk 限制：

1
2
3
4
5
6
7
8
9
10
11
// ❌ 不能使用浮点（内核无 FPU 上下文）
printk("%f\n", 3.14);

// ❌ 不能睡眠/阻塞
// 不能调用 schedule()、mutex_lock()、copy_from_user() 等

// ❌ 不能调用用户空间函数
// 不能调用 malloc（用 kmalloc）、printf 等

// ✅ 使用内核 API
printk(KERN_INFO "Value: %d, %s\n", count, buf);

3. /proc 文件系统

3.1 创建 /proc 文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
// proc_demo.c
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/slab.h>

#define PROC_NAME "netstat"

// 数据
static int g_connection_count = 0;
static int g_packet_count = 0;

// === 方法 1：使用 seq_file（推荐，处理大数据）===

static void *seq_start(struct seq_file *m, loff_t *pos) {
    return *pos == 0 ? &g_connection_count : NULL;
}

static void *seq_next(struct seq_file *m, void *v, loff_t *pos) {
    (*pos)++;
    return NULL;
}

static void seq_stop(struct seq_file *m, void *v) {
    // 无需清理
}

static int seq_show(struct seq_file *m, void *v) {
    seq_printf(m, "Connections: %d\n", g_connection_count);
    seq_printf(m, "Packets: %d\n", g_packet_count);
    seq_printf(m, "Uptime: %lu seconds\n", jiffies / HZ);
    return 0;
}

static const struct seq_operations seq_ops = {
    .start = seq_start,
    .next  = seq_next,
    .stop  = seq_stop,
    .show  = seq_show,
};

static int proc_open(struct inode *inode, struct file *file) {
    return seq_open(file, &seq_ops);
}

// === 方法 2：直接 read/write（适合小数据）===

static ssize_t proc_read(struct file *file, char __user *buf,
                         size_t count, loff_t *ppos) {
    char buffer[256];
    int len;

    // 只读一次（支持重复 read）
    if (*ppos > 0) return 0;

    len = snprintf(buffer, sizeof(buffer),
        "Connections: %d\n"
        "Packets: %d\n"
        "Status: active\n",
        g_connection_count, g_packet_count);

    // 拷贝到用户空间
    if (copy_to_user(buf, buffer, len)) return -EFAULT;

    *ppos += len;
    return len;
}

static ssize_t proc_write(struct file *file, const char __user *buf,
                          size_t count, loff_t *ppos) {
    char kbuffer[32];

    if (count >= sizeof(kbuffer)) return -EINVAL;

    if (copy_from_user(kbuffer, buf, count)) return -EFAULT;
    kbuffer[count] = '\0';

    // 解析写入的值
    if (sscanf(kbuffer, "%d", &g_connection_count) == 1) {
        printk(KERN_INFO "Connections updated to %d\n", g_connection_count);
    }

    return count;
}

// 文件操作
static const struct proc_ops proc_fops = {
    .proc_read  = proc_read,
    .proc_write = proc_write,
    .proc_open  = proc_open,
    .proc_lseek = seq_lseek,  // seq_file 专用
};

static int __init proc_init(void) {
    // 创建 /proc/netstat 文件
    struct proc_dir_entry *entry;

    entry = proc_create(PROC_NAME, 0666, NULL, &proc_fops);
    if (!entry) {
        printk(KERN_ERR "Failed to create /proc/%s\n", PROC_NAME);
        return -ENOMEM;
    }

    printk(KERN_INFO "Created /proc/%s\n", PROC_NAME);
    return 0;
}

static void __exit proc_exit(void) {
    remove_proc_entry(PROC_NAME, NULL);
    printk(KERN_INFO "Removed /proc/%s\n", PROC_NAME);
}

module_init(proc_init);
module_exit(proc_exit);
MODULE_LICENSE("GPL");
1
2
3
4
5
6
7
8
9
10
11
12
# 测试
sudo insmod proc_demo.ko
cat /proc/netstat
# Connections: 0
# Packets: 0

echo "42" | sudo tee /proc/netstat
cat /proc/netstat
# Connections: 42
# Packets: 0

sudo rmmod proc_demo

3.2 /proc 目录结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/proc/
├── version          # 内核版本
├── meminfo          # 内存信息
├── cpuinfo          # CPU 信息
├── mounts           # 挂载点
├── net/             # 网络子系统
│   ├── dev          # 网络接口统计
│   ├── tcp          # TCP 连接表（内部格式）
│   ├── tcp6         # TCP6 连接表
│   ├── udp          # UDP 连接表
│   ├── sockstat     # Socket 统计
│   ├── snmp         # SNMP 协议统计
│   ├── netstat      # 网络统计
│   └── softnet_stat # 软中断统计
├── sys/             # 可调内核参数
│   └── net/
│       └── core/
│       └── ipv4/
│       └── ipv6/
└── [pid]/           # 进程信息
    ├── cmdline      # 命令行
    ├── status       # 进程状态
    ├── fd/          # 文件描述符
    └── net/         # 进程的网络连接
        └── tcp
        └── udp

4. 内核数据结构与内存管理

4.1 常用内核数据结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#include <linux/list.h>      // 链表
#include <linux/hashtable.h> // 哈希表
#include <linux/rbtree.h>    // 红黑树
#include <linux/spinlock.h>  // 自旋锁

// === 链表 ===
struct my_data {
    int value;
    struct list_head list;  // 链表节点
};

// 定义链表头
LIST_HEAD(my_list);

// 遍历链表
struct my_data *pos;
list_for_each_entry(pos, &my_list, list) {
    printk("value=%d\n", pos->value);
}

// === 哈希表 ===
DEFINE_HASHTABLE(my_hash, 8);  // 2^8 = 256 个桶

struct hash_node {
    int key;
    int data;
    struct hlist_node node;  // 哈希节点
};

// 添加
hash_add(my_hash, &node->node, key);

// 查找
struct hash_node *found;
hash_for_each_possible(my_hash, found, node, key) {
    if (found->key == key) break;
}

// === 红黑树 ===
struct rb_root my_tree = RB_ROOT;

struct tree_node {
    int key;
    int data;
    struct rb_node node;
};

// 插入
struct tree_node *node = kmalloc(sizeof(*node), GFP_KERNEL);
node->key = key;
struct rb_node **link = &my_tree.rb_node;
struct rb_node *parent = NULL;
while (*link) {
    parent = *link;
    struct tree_node *cur = rb_entry(parent, struct tree_node, node);
    if (key < cur->key)
        link = &(*link)->rb_left;
    else
        link = &(*link)->rb_right;
}
rb_link_node(&node->node, parent, link);
rb_insert_color(&node->node, &my_tree);

4.2 内核内存分配

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <linux/slab.h>

// === kmalloc（类似 malloc）===
void *p = kmalloc(size, GFP_KERNEL);
// GFP_KERNEL = 可能睡眠，可被信号中断（进程上下文）
// GFP_ATOMIC = 不睡眠（中断上下文、原子上下文）
// GFP_NOWAIT = 不睡眠，不排队

if (!p) return -ENOMEM;

// 释放
kfree(p);

// === kzalloc（分配并清零）===
void *p = kzalloc(sizeof(struct my_data), GFP_KERNEL);
// 等价于 kmalloc + memset(0)

// === vmalloc（大块虚拟连续内存）===
// 适合大内存（页级分配），但性能较低
void *p = vmalloc(65536);
vfree(p);

// === kmem_cache（对象缓存/Slab 分配器）===
// 适合频繁分配/释放的固定大小对象

struct kmem_cache *cache;
cache = kmem_cache_create("my_cache", sizeof(struct my_data),
                          0, 0, NULL);

struct my_data *obj = kmem_cache_alloc(cache, GFP_KERNEL);
// 使用...
kmem_cache_free(cache, obj);

// 销毁
kmem_cache_destroy(cache);

kmalloc vs vmalloc 对比：

特性 kmalloc vmalloc
物理连续性 物理连续 仅虚拟连续
最大大小 通常 ≤ 128KB 几乎无限制
速度 快（DMA 友好） 慢（TLB 抖动）
DMA 使用 可直接用 需要映射
适用场景 小对象、DMA 大缓冲区

5. 实践：/proc 网络连接统计

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
// net_counter.c
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/list.h>
#include <linux/spinlock.h>

#define PROC_DIR   "net_monitor"
#define PROC_FILE  "connections"

// 连接记录
struct conn_entry {
    __be32  saddr;        // 源 IP
    __be32  daddr;        // 目的 IP
    __u16   sport;        // 源端口
    __u16   dport;        // 目的端口
    __u8    state;        // TCP 状态
    __u32   bytes;        // 传输字节数
    unsigned long ts;     // 时间戳
    struct list_head list;
};

static LIST_HEAD(conn_list);
static DEFINE_SPINLOCK(conn_lock);  // 自旋锁保护链表
static atomic_t total_conn = ATOMIC_INIT(0);
static atomic_t total_bytes = ATOMIC_INIT(0);

// seq_file 输出
static int show_connections(struct seq_file *m, void *v) {
    struct conn_entry *entry;
    unsigned long flags;

    spin_lock_irqsave(&conn_lock, flags);

    seq_printf(m, "=== Network Connection Monitor ===\n");
    seq_printf(m, "Total connections: %d\n", atomic_read(&total_conn));
    seq_printf(m, "Total bytes: %u\n", atomic_read(&total_bytes));
    seq_printf(m, "\n%-20s %-20s %-8s %-8s %-6s %-10s\n",
               "Source", "Dest", "Sport", "Dport", "State", "Bytes");

    list_for_each_entry(entry, &conn_list, list) {
        __be32 sa = entry->saddr;
        __be32 da = entry->daddr;

        seq_printf(m, "%pI4 %pI4 %-8u %-8u %-6u %-10u\n",
                   &sa, &da,
                   ntohs(entry->sport),
                   ntohs(entry->dport),
                   entry->state,
                   entry->bytes);
    }

    spin_unlock_irqrestore(&conn_lock, flags);
    return 0;
}

static int proc_open(struct inode *inode, struct file *file) {
    return single_open(file, show_connections, NULL);
}

// 写接口：添加测试数据
static ssize_t proc_write(struct file *file, const char __user *buf,
                          size_t count, loff_t *ppos) {
    char kbuf[32];
    __be32 saddr, daddr;
    __u16 sport, dport;

    if (count >= sizeof(kbuf)) return -EINVAL;
    if (copy_from_user(kbuf, buf, count)) return -EFAULT;
    kbuf[count] = '\0';

    // 解析格式: "saddr daddr sport dport"
    if (sscanf(kbuf, "%u %u %hu %hu",
               &saddr, &daddr, &sport, &dport) == 4) {
        struct conn_entry *entry = kmalloc(sizeof(*entry), GFP_KERNEL);
        if (entry) {
            entry->saddr = saddr;
            entry->daddr = daddr;
            entry->sport = sport;
            entry->dport = dport;
            entry->state = 1;  // ESTABLISHED
            entry->bytes = 0;
            entry->ts = jiffies;

            spin_lock(&conn_lock);
            list_add(&entry->list, &conn_list);
            atomic_inc(&total_conn);
            spin_unlock(&conn_lock);

            printk(KERN_INFO "Added connection: %pI4:%u -> %pI4:%u\n",
                   &saddr, sport, &daddr, dport);
        }
    }

    return count;
}

static const struct proc_ops proc_fops = {
    .proc_read  = seq_read,
    .proc_write = proc_write,
    .proc_open  = proc_open,
    .proc_lseek = seq_lseek,
    .proc_release = single_release,
};

static int __init net_counter_init(void) {
    proc_create(PROC_FILE, 0666,
                proc_mkdir(PROC_DIR, NULL), &proc_fops);
    printk(KERN_INFO "net_monitor: loaded. /proc/%s/%s\n",
           PROC_DIR, PROC_FILE);
    return 0;
}

static void __exit net_counter_exit(void) {
    remove_proc_entry(PROC_FILE, proc_mkdir(PROC_DIR, NULL));
    remove_proc_entry(PROC_DIR, NULL);

    // 清理链表
    struct conn_entry *entry, *tmp;
    list_for_each_entry_safe(entry, tmp, &conn_list, list) {
        list_del(&entry->list);
        kfree(entry);
    }

    printk(KERN_INFO "net_monitor: unloaded\n");
}

module_init(net_counter_init);
module_exit(net_counter_exit);
MODULE_LICENSE("GPL");
1
2
3
4
5
6
7
8
9
10
11
12
13
# 编译加载
make
sudo insmod net_counter.ko

# 添加测试连接
echo "3232235777 3232235788 8080 80" | sudo tee /proc/net_monitor/connections
# 192.168.1.1 = 3232235777, 192.168.1.2 = 3232235788

# 查看连接
cat /proc/net_monitor/connections

# 删除
sudo rmmod net_counter

6. 内核调试技巧

6.1 常用调试方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# === 日志 ===
dmesg                          # 查看内核日志
dmesg -w                       # 实时监控
journalctl -k                  # systemd 日志中的内核消息
journalctl -kf                 # 实时跟踪

# === 内核打印 ===
# 在代码中：
printk(KERN_INFO "debug: x=%d y=%p\n", x, y);

# === 动态调试（printk 变体）===
dev_dbg(&dev->dev, "message %d\n", val);     // 受 DYNAMIC_DEBUG 控制
dev_info(&dev->dev, "info %d\n", val);        // 始终打印
dev_err(&dev->dev, "error %d\n", val);        // 始终打印

# === /proc/sys/debug/ ===
cat /proc/sys/debug/exception-trace    # 异常跟踪

# === /sys/kernel/debug/ (debugfs) ===
mount -t debugfs none /sys/kernel/debug
ls /sys/kernel/debug/
# tracing/       # ftrace
# dynamic_debug/ # 动态调试
# tracing/       # 跟踪

6.2 内核 Oops / Panic 分析

1
2
3
4
5
6
7
8
9
10
11
12
13
# 内核 Oops 信息解读
# BUG: unable to handle kernel NULL pointer dereference
# 地址: [<ffffffff81234567>] 函数名+0xXX/0xYY
# RIP: 0010:[<ffffffff81234567>]  [<模块名>] 函数+0xXX/0xYY

# 分析步骤：
# 1. 找到 fault 地址（NULL 指针）
# 2. 找到调用栈（RIP, RSP）
# 3. 分析哪个函数访问了空指针
# 4. 检查是否缺少 NULL 检查

# 工具
crash /usr/lib/debug/boot/vmlinux-$(uname -r) /proc/kcore

7. 开发环境搭建

7.1 安装内核头文件

1
2
3
4
5
6
7
8
9
10
11
# Ubuntu/Debian
sudo apt install linux-headers-$(uname -r)
sudo apt install build-essential

# CentOS/RHEL
sudo yum install kernel-devel-$(uname -r)
sudo yum install gcc make

# 验证
ls /lib/modules/$(uname -r)/build
# 应该是软链接到内核源码

7.2 内核源码阅读

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# 下载源码
apt source linux-image-$(uname -r)
# 或
git clone --depth 1 https://github.com/torvalds/linux.git

# 关键文件目录
net/
├── core/             # 网络核心（sk_buff, netlink 等）
│   ├── skbuff.c      # sk_buff 管理
│   ├── dev.c         # 网络设备管理
│   ├── sock.c        # Socket 层
│   ├── netlink.c     # netlink 通信
│   └── flow.c        # 流过滤
├── ipv4/             # IPv4 实现
│   ├── route.c       # 路由
│   ├── tcp.c         # TCP 核心
│   ├── tcp_input.c   # TCP 输入处理
│   ├── tcp_output.c  # TCP 输出处理
│   ├── udp.c         # UDP
│   ├── icmp.c        # ICMP
│   └── netfilter/    # Netfilter IPv4
│       ├── ip_tables.c
│       ├── nf_conntrack_*.c
│       └── nf_nat_*.c
├── netfilter/        # Netfilter 核心
│   ├── nf_log.c
│   ├── nf_queue.c
│   └── nf_socket.c
├── ethernet/         # 以太网驱动
├── bridge/           # 网桥
└── kernel/           # 通用网络

7.3 cscope / ctags 配置

1
2
3
4
5
6
7
8
9
10
# 生成标签
cd /path/to/linux/source
make tags    # 生成 tags 文件
make cscope  # 生成 cscope 数据库

# vim 中使用
:set tags=tags
:tag sk_buff       # 跳转到 sk_buff 定义
Ctrl-]             # 跳转到光标处符号定义
Ctrl-t             # 跳转回上一个位置

8. 安全注意事项

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// === 必须检查的参数 ===
// 从用户空间传入的数据不能信任！

static long my_ioctl(struct file *f, unsigned int cmd, unsigned long arg) {
    // 检查权限
    if (!capable(CAP_NET_ADMIN)) return -EPERM;

    // 验证参数
    if (_IOC_TYPE(cmd) != MY_MAGIC) return -ENOTTY;
    if (_IOC_NR(cmd) >= MY_CMD_MAX) return -ENOTTY;

    // 复制数据时要检查指针有效性
    if (copy_from_user(&kern_data, user_ptr, sizeof(kern_data)))
        return -EFAULT;

    return 0;
}

// === 常用能力检查 ===
capable(CAP_NET_ADMIN)   // 网络管理
capable(CAP_SYS_ADMIN)   // 系统管理
capable(CAP_NET_RAW)     // 原始 socket

// === 禁止的操作 ===
// - 直接访问用户空间指针（必须用 copy_from_user/copy_to_user）
// - 在中断上下文睡眠（用 GFP_ATOMIC）
// - 持有自旋锁时睡眠
// - 不持有任何锁时访问共享数据
// - 浮点运算
// - 调用用户空间函数
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发、Linux开发、
公众号开发、开源爱好者、Linux

联系QQ:562054870