// 优化前：临界区太大
spin_lock(&drv->lock);
data = drv->buffer[idx];       // 读数据
process_data(data);            // 处理数据（不需要锁）
drv->count++;                  // 更新计数
spin_unlock(&drv->lock);

// 优化后：只锁共享数据
spin_lock(&drv->lock);
data = drv->buffer[idx];
drv->count++;
spin_unlock(&drv->lock);
process_data(data);            // 移到锁外```

### 优化2：读写锁替代自旋。
读多写少的场景，用读写锁让多个读者并行：

```c
// 自旋锁：读者也互斥
spin_lock(&lock);
val = shared_data;    // 多个读者也要排队
spin_unlock(&lock);

// 读写锁：读者并发
rwlock_t rwlock;
DEFINE_RWLOCK(rwlock);

// 读端：多个读者可并行
read_lock(&rwlock);
val = shared_data;
read_unlock(&rwlock);

// 写端：独占
write_lock(&rwlock);
shared_data = new_val;
write_unlock(&rwlock);

// 定义per-cpu变量
static DEFINE_PER_CPU(struct stats, cpu_stats);

// 更新：不需要锁，操作本CPU副本
void update_stats(int delta)
{
    // 禁止抢占，确保不会被迁移到其他CPU
    preempt_disable();
    this_cpu_inc(cpu_stats.count);
    this_cpu_add(cpu_stats.total, delta);
    preempt_enable();
}

// 汇总：遍历所有CPU
u64 get_total_count(void)
{
    u64 total = 0;
    int cpu;
    for_each_possible_cpu(cpu)
        total += per_cpu(cpu_stats.count, cpu);
    return total;
}

// RCU保护的数据结构struct config {
    int mode;
    int threshold;
    struct rcu_head rcu;
};

static struct config __rcu *cur_config;

// 读端：无锁，极快
int get_mode(void)
{
    struct config *cfg;
    int mode;
    rcu_read_lock();
    cfg = rcu_dereference(cur_config);
    mode = cfg->mode;          // 读端完全不加载    rcu_read_unlock();
    return mode;
}

// 写端：分配新结构，原子替换，延迟释放旧结构
void set_mode(int new_mode)
{
    struct config *old, *new_cfg;
    new_cfg = kmalloc(sizeof(*new_cfg), GFP_KERNEL);
    *new_cfg = *rcu_dereference(cur_config);
    new_cfg->mode = new_mode;
    old = rcu_replace_pointer(cur_config, new_cfg, true);
    synchronize_rcu();          // 等待所有读者退。    kfree(old);
}

// 导出端：V4L2驱动导出DMA-BUF fd
int v4l2_export_buf(struct file *file, void *priv,
                    struct v4l2_exportbuffer *exp)
{
    // vb2核心层完成导。    return vb2_core_expbuf(&q->vb2_buf,
                exp->dmabuf_fd, exp->type,
                exp->index, exp->plane,
                exp->flags, exp->mem_offset);
}

// 导入端：GPU/DRM通过fd导入
struct dma_buf *dmabuf = dma_buf_get(fd);
struct dma_buf_attachment *attach;
attach = dma_buf_attach(dmabuf, dev);
sgt = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL);
// 拿到scatterlist，直接用DMA访问同一块物理内存```

**splice/sendfile**：文件到socket的零拷贝，内核内部直接搬运页缓存。
```c
// sendfile：文件→socket零拷贝
ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count);

// splice：任意两个fd之间零拷贝
ssize_t splice(int fd_in, off_t *off_in,
               int fd_out, off_t *off_out,
               size_t len, unsigned int flags);

// 差：每次拷贝4字节
for (i = 0; i < count; i++) {
    if (copy_to_user(&user_buf[i], &kern_buf[i], 4))
        return -EFAULT;
}

// 好：一次拷贝全部
if (copy_to_user(user_buf, kern_buf, count * 4))
    return -EFAULT;

// 分配scatter-gather列表
int nents = dma_map_sg(dev, sg_list, nents, DMA_TO_DEVICE);
// nents是硬件可用的DMA映射段数，可能少于原始段。// 因为相邻物理页可能被合并

// 遍历映射后的段
for_each_sg(sg_list, sg, nents, i) {
    dma_addr_t addr = sg_dma_address(sg);
    size_t len = sg_dma_len(sg);
    // 把addr/len填入硬件描述。}

// 上半部：只做最紧急的硬件应答
static irqreturn_t my_hardirq(int irq, void *dev_id)
{
    struct my_dev *dev = dev_id;
    u32 status = readl(dev->regs + IRQ_STATUS);
    if (!(status & IRQ_PENDING))
        return IRQ_NONE;
    writel(IRQ_ACK, dev->regs + IRQ_CLEAR);  // 应答硬件
    dev->irq_status = status;
    return IRQ_WAKE_THREAD;  // 唤醒线程化下半部
}

// 下半部：可以睡眠，做耗时处理
static irqreturn_t my_thread_fn(int irq, void *dev_id)
{
    struct my_dev *dev = dev_id;
    // 可以睡眠：互斥锁、内存分配、IO操作
    mutex_lock(&dev->mtx);
    process_interrupt(dev);
    mutex_unlock(&dev->mtx);
    return IRQ_HANDLED;
}

// 注册线程化中。int ret = request_threaded_irq(irq, my_hardirq, my_thread_fn,
                               IRQF_ONESHOT, "my_dev", dev);

// NAPI轮询函数
static int my_napi_poll(struct napi_struct *napi, int budget)
{
    struct my_dev *dev = container_of(napi, struct my_dev, napi);
    int rx_count = 0;

    while (rx_count < budget) {
        struct sk_buff *skb = receive_packet(dev);
        if (!skb)
            break;
        netif_receive_skb(skb);
        rx_count++;
    }

    if (rx_count < budget) {
        // 包收完了，切回中断模块        napi_complete_done(napi, rx_count);
        enable_interrupt(dev);  // 重新使能中断
    }
    return rx_count;
}

// 中断处理：调度NAPI轮询
static irqreturn_t my_net_irq(int irq, void *dev_id)
{
    struct my_dev *dev = dev_id;
    disable_interrupt(dev);     // 关中断，切轮。    napi_schedule(&dev->napi);  // 调度轮询
    return IRQ_HANDLED;
}

// 初始化NAPI
netif_napi_add(dev->netdev, &dev->napi, my_napi_poll);

// ethtool配置网卡中断合并
// ethtool -C eth0 rx-usecs 50 rx-frames 64
// 50微秒。4帧，哪个先到触发中断

// NVMe设置中断合并
struct nvme_completion_queue {
    u16 intr_vector;
    u16 intr_coal_thresh;  // 完成多少个命令后触发中断
};

# 查看当前中断亲和。cat /proc/irq/32/smp_affinity

# 把IRQ 32绑定到CPU 0。（位掩码b0101 = 5。echo 5 > /proc/irq/32/smp_affinity

# 驱动中设。irq_set_affinity_hint(irq, cpumask_of(cpu));

// 创建内存池：最少保护个对。mempool_t *pool = mempool_create(8, mempool_alloc_slab,
                                  mempool_free_slab, my_cachep);

// 从内存池分配：不会失。void *obj = mempool_alloc(pool, GFP_KERNEL);
if (!obj)  // 实际上不会走到这。    return -ENOMEM;

// 归还
mempool_free(obj, pool);

// 销。mempool_destroy(pool);

// 创建专用slab缓存
struct kmem_cache *my_cache = kmem_cache_create("my_driver_obj",
                                    sizeof(struct my_obj), 0,
                                    SLAB_HWCACHE_ALIGN, NULL);

// 从缓存分支struct my_obj *obj = kmem_cache_alloc(my_cache, GFP_KERNEL);

// 归还缓存
kmem_cache_free(my_cache, obj);

// 销毁缓。kmem_cache_destroy(my_cache);

// 分配4个连续页。6KB。struct page *pages = alloc_pages(GFP_KERNEL, 2);  // 2^2 = 4。if (!pages)
    return -ENOMEM;

void *vaddr = page_address(pages);
// 使用...

__free_pages(pages, 2);  // 释放，注意order要匹```

高阶分配在系统运行久了之后容易失败。如果必须用大块连续内存，在模块初始化时尽早分配，或者考虑用scatter-gather代替连续内存。
## 六、性能分析工具

### perf：采样分支
```bash
# 记录性能数据
perf record -g ./my_test          # -g记录调用。perf record -e cpu-clock -g -p 1234  # 追踪指定进程

# 分析热点
perf report                       # 交互式报。perf report --stdio               # 文本输出

# 实时热点
perf top                          # 类似top，但按函数采```

### ftrace：函数追。
```bash
# 追踪指定函数
echo my_driver_func > /sys/kernel/debug/tracing/set_ftrace_filter
echo function > /sys/kernel/debug/tracing/current_tracer
echo 1 > /sys/kernel/debug/tracing/tracing_on
# ... 运行测试 ...
cat /sys/kernel/debug/tracing/trace

# 函数耗时统计
echo function_graph > /sys/kernel/debug/tracing/current_tracer
echo my_driver_func > /sys/kernel/debug/tracing/set_graph_function

# 函数耗时直方图（6.8内核。echo 'hist:keys=func,latency:sort=latency' > \
    /sys/kernel/debug/tracing/events/my_driver/trigger

# 安装bcc工具
# apt install bpfcc-tools

# 追踪内核函数耗时
funclatency-bpfcc -p 1234 do_sys_open

# 追踪块设备IO延迟
biosnoop-bpfcc

# 追踪内存分配
memleak-bpfcc -p 1234

# 追踪锁竞。offcputime-bpfcc -p 1234

# 中断统计
cat /proc/interrupts            # 硬中断计数cat /proc/softirqs              # 软中断计数
# 查看哪个CPU处理哪个中断
watch -n1 "cat /proc/interrupts | grep my_dev"

// 危险：直接信任用户数。struct my_config cfg;
if (copy_from_user(&cfg, user_ptr, sizeof(cfg)))
    return -EFAULT;
buffer[cfg.index] = cfg.value;  // cfg.index可能越界。
// 安全：验证所有字。struct my_config cfg;
if (copy_from_user(&cfg, user_ptr, sizeof(cfg)))
    return -EFAULT;
if (cfg.index >= ARRAY_SIZE(buffer))  // 边界检。    return -EINVAL;
if (cfg.value > MAX_VALUE)            // 范围检。    return -ERANGE;
buffer[cfg.index] = cfg.value;

// 危险：整数溢。int count;
if (copy_from_user(&count, user_ptr, sizeof(count)))
    return -EFAULT;
// count = 0x40000001, count * 4 = 0x432位溢出）
buf = kmalloc(count * sizeof(u32), GFP_KERNEL);  // 分配4字节
// 但后续写入count个u32，越界！

// 安全：用kmalloc_array检查溢buf = kmalloc_array(count, sizeof(u32), GFP_KERNEL);
if (!buf)
    return -ENOMEM;
// kmalloc_array内部会检查count * sizeof(u32)是否溢出

static long my_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    struct my_dev *dev = file->private_data;
    void __user *uptr = (void __user *)arg;

    // 第一步：检查cmd合法。    if (_IOC_TYPE(cmd) != MY_IOC_MAGIC)
        return -ENOTTY;
    if (_IOC_NR(cmd) > MY_IOC_MAXNR)
        return -ENOTTY;

    switch (cmd) {
    case MY_IOCTL_SET_CONFIG: {
        struct my_config cfg;

        // 第二步：检查用户空间指针可访问
        if (!access_ok(uptr, sizeof(cfg)))
            return -EFAULT;

        // 第三步：拷贝并验。        if (copy_from_user(&cfg, uptr, sizeof(cfg)))
            return -EFAULT;

        // 第四步：边界检。        if (cfg.index >= MAX_INDEX)
            return -EINVAL;
        if (cfg.size == 0 || cfg.size > MAX_SIZE)
            return -EINVAL;

        // 第五步：权限检。        if (cfg.privileged && !capable(CAP_SYS_ADMIN))
            return -EPERM;

        // 第六步：加锁操作共享数据
        mutex_lock(&dev->mtx);
        dev->config = cfg;
        mutex_unlock(&dev->mtx);
        break;
    }
    default:
        return -ENOTTY;
    }
    return 0;
}

static long my_ioctl(struct file *file, unsigned int cmd,
                     unsigned long arg)
{
    // 危险操作必须检查权限    switch (cmd) {
    case MY_IOCTL_RESET:
    case MY_IOCTL_FLASH_FW:
    case MY_IOCTL_DEBUG:
        if (!capable(CAP_SYS_ADMIN))
            return -EPERM;
        break;
    default:
        break;
    }
    // ...
}

// 初始化时设置设备节点权限
static int my_dev_init(void)
{
    struct device *dev;

    dev = device_create(my_class, NULL, devt, NULL, "mydev");
    // 默认crw-rw----，属主root，组device
    // 修改权限：只允许root访问
    dev_set_mode(dev, 0600);  // crw-------

    // 或者用devtmpfs自动设置
    // 在class_create时指。}

# /etc/udev/rules.d/99-mydev.rules
KERNEL=="mydev", MODE="0660", GROUP="device"

// 用户空间设置seccomp过滤
#include <seccomp.h>

scmp_filter_ctx ctx = seccomp_init(SCMP_ACT_KILL);
// 只允许read/write/exit
seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(read), 0);
seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 0);
seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit), 0);
seccomp_load(ctx);

# SELinux策略示例：只允许特定域访问mydev
allow my_app_domain mydev_device_t:chr_file { read write ioctl };

// 驱动中使用IOMMU。.8内核自动处理。// dma_alloc_coherent内部会通过IOMMU映射
void *vaddr = dma_alloc_coherent(dev, size, &dma_handle, GFP_KERNEL);
// dma_handle是设备看到的IOVA（IO Virtual Address。// IOMMU把IOVA翻译成物理地址，设备只能访问这块内存
// 启用IOMMU：内核启动参数// intel_iommu=on    (x86)
// arm-smmu.enable=1 (ARM)

// 设置DMA地址掩码
int ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(64));
if (ret) {
    // 64位DMA不支持，尝试32。    ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32));
    if (ret)
        return ret;  // 设备不支持DMA
}

// 分配DMA缓冲区时多留一些guard空间
#define BUF_SIZE    4096
#define GUARD_SIZE  256

void *vaddr = dma_alloc_coherent(dev, BUF_SIZE + GUARD_SIZE,
                                  &dma_handle, GFP_KERNEL);

// 只告诉设备BUF_SIZE的大。// 设备写入超过BUF_SIZE的部分落入guard区域
// 驱动检查guard区域是否被改写，检测越界写。if (memcmp(vaddr + BUF_SIZE, guard_pattern, GUARD_SIZE) != 0) {
    dev_err(dev, "DMA buffer overflow detected!\n");
    // 触发安全告警
}

# 内核配置
CONFIG_STACKPROTECTOR=y
CONFIG_STACKPROTECTOR_STRONG=y   # 更强的保护，更多函数插入canary

# 驱动编译时自动启用，无需额外代码
# 如果栈溢出覆盖了canary，内核打印：
# stack-protector: Kernel stack is corrupted in: my_func+0x5c/0x60

# 内核配置
CONFIG_SLAB_FREELIST_HARDENED=y
CONFIG_SLAB_FREELIST_RANDOM=y    # 随机化空闲链表顺。CONFIG_HARDENED_USERCOPY=y       # 加强copy_to/from_user检```

### 用户空间访问：access_ok + copy_from_user

两步验证，缺一不可。
```c
// 第一步：检查用户空间地址范围是否合法
if (!access_ok(uptr, size))
    return -EFAULT;

// 第二步：安全拷贝（内部处理缺页等异常。if (copy_from_user(kbuf, uptr, size))
    return -EFAULT;

// 典型竞态：检查与使用分离(TOCTOU)
// 危险
if (dev->running) {        // 检。    // 另一个线程可能在这里把dev->running设为0并释放资。    writel(data, dev->regs);  // 使用——可能访问已释放的内存！
}

// 安全：加锁保护mutex_lock(&dev->mtx);
if (dev->running) {
    writel(data, dev->regs);
}
mutex_unlock(&dev->mtx);