搞定 Linux内存难题，Kasan 工具这样用

做 Linux 开发或运维的朋友，大概率都踩过内存问题的坑：明明代码逻辑看着没问题，系统却时不时崩溃；日志里只飘着 “Segmentation fault”，排查半天找不到具体位置；甚至遇到隐性越界，数据悄悄被篡改却毫无征兆 —— 这些 “幽灵般” 的内存错误，不仅拖慢开发进度，还可能埋下线上故障隐患。

你或许试过用 GDB 断点调试，却卡在复杂调用栈里绕不出来；也可能用 Valgrind 检测，却受限于性能无法在生产环境使用。其实 Linux 内核早就自带一款 “内存侦探”——Kasan，能精准揪出越界访问、使用已释放内存、内存泄漏等常见问题，甚至能定位到具体代码行。但不少人对 Kasan 停留在 “听说过” 的阶段：不知道怎么开启内核配置，不清楚如何解读检测日志，更不了解实战中如何结合场景使用。接下来这篇内容，就从基础配置讲起，带着你一步步实操 Kasan，教你用它快速定位内存 bug，彻底摆脱 “内存难题排查难” 的困境。

一、Linux 内存管理回顾

在深入探讨 Kasan 工具之前，先来了解一下 Linux 内存管理的基本概念。想象一下，你的 Linux 系统就像是一个繁忙的大仓库，而内存则是这个仓库中的存储空间，各个进程就如同在仓库中存放货物的客户。Linux 内存管理的职责，便是高效地分配这些存储空间，确保每个进程都能获得所需的内存，同时避免内存浪费和冲突。

1.1Linux内存管理概述

Linux 内存管理采用了虚拟内存技术，为每个进程提供了独立的地址空间。这就好比每个客户都有自己独立的存储区域，互不干扰。在实际分配内存时，Linux 使用了伙伴系统（Buddy System）和 Slab 分配器等机制。伙伴系统主要负责大块内存的分配，它将内存划分为不同大小的块，并且这些块总是 2 的幂次大小，当请求分配内存时，伙伴系统会查找与请求大小最匹配的块，并且如果需要，可以将较大的块分割成两个较小的块；

当内存被释放时，伙伴系统会检查相邻的伙伴块是否也空闲，如果是的话则合并成一个较大的块 ，这种方式能够有效减少内存碎片。而 Slab 分配器则专注于小块内存的分配，它针对内核中频繁使用的小对象（如进程描述符、文件描述符等）进行优化，通过缓存这些小对象，提高了内存分配的效率。

内存管理对 Linux 系统的稳定和性能至关重要。如果内存分配不合理，可能导致系统出现内存泄漏，就像仓库中某些货物存放混乱，找不到主人也无法清理，随着时间的推移，可用内存越来越少，最终导致系统运行缓慢甚至崩溃；内存碎片化问题也不容忽视，这就好比仓库中的空间被零散地分割，虽然总的空间足够，但却无法存放大型货物，使得系统在分配大块内存时变得困难重重。

1.2常见内存问题

在 Linux 系统中，内存问题可谓是 “隐藏的杀手”，它们常常在不经意间给系统带来各种麻烦。下面就来看看一些常见的内存问题及其危害。

①越界访问：内存越界访问就像是在没有交通规则的道路上 “越界驾驶”。当程序访问了不属于它的内存区域时，就发生了内存越界。这种情况通常发生在数组操作中，比如访问数组时使用了超出数组大小的索引。例如，定义一个数组int array[10];，正常情况下，数组的索引范围是从 0 到 9，如果程序中不小心写成了array[10] = 100;，这就访问了数组边界之外的内存，如同汽车驶出了规定的车道，进入了未知区域 。内存越界访问的危害极大。

它可能导致程序修改了其他重要数据，就像一辆失控的汽车撞到了路边的重要设施，使得系统出现莫名其妙的错误，而且这种错误很难调试，因为错误发生的位置可能与实际问题代码相距甚远，就像事故现场和肇事车辆起始点相隔很远，增加了排查问题的难度。严重时，内存越界访问会直接导致系统崩溃，使正在运行的服务中断，造成不可估量的损失。

#include <stdio.h>
#include <string.h>

void demonstrate_memory_corruption() {
    int array[10] = {0};
    int important_data = 100;

    printf("=== 内存越界访问示例 ===\n");
    printf("初始状态:\n");
    printf("  important_data = %d\n", important_data);

    // 模拟正常访问
    printf("\n正常访问 array[5] = 10:\n");
    array[5] = 10;
    printf("  array[5] = %d\n", array[5]);
    printf("  important_data = %d (未受影响)\n", important_data);

    // 模拟越界访问 - 这会覆盖 important_data
    printf("\n  越界访问 array[10] = 200:\n");
    array[10] = 200;  // 这里发生了越界！
    printf("  array[10] = %d (看似成功)\n", array[10]);
    printf("  important_data = %d (被意外修改！)\n", important_data);

    // 更严重的越界
    printf("\n 严重越界访问 array[20] = 999:\n");
    array[20] = 999;  // 这里访问了更远的内存
    printf("  可能导致程序崩溃或不可预测的行为...\n");
}

void demonstrate_array_overflow() {
    char buffer[16];
    char user_input[] = "This is a very long input that will overflow the buffer";

    printf("\n=== 缓冲区溢出示例 ===\n");
    printf("缓冲区大小: 16 字节\n");
    printf("输入大小: %zu 字节\n", strlen(user_input));

    printf("\n尝试复制输入到缓冲区...\n");
    strcpy(buffer, user_input);  // 危险！没有检查边界

    printf("缓冲区内容: %s\n", buffer);
    printf("注意: 内存已经被破坏，但程序可能仍然运行\n");
}

int main() {
    demonstrate_memory_corruption();
    demonstrate_array_overflow();

    return 0;
}

②使用已释放内存：使用已释放的内存，就好比拿着一张过期作废的车票试图再次乘车。当程序释放了一块内存后，这块内存就应该被视为 “公共资源”，不再属于原来的程序。然而，如果程序在释放内存后，又继续访问这块内存，就会出现使用已释放内存的问题。

例如，使用malloc分配内存后，用free释放了它，但后续代码中又不小心使用了指向这块已释放内存的指针 。这种错误同样会引发严重后果。由于已释放的内存可能被操作系统重新分配给其他程序使用，访问已释放内存可能导致读取到错误的数据，或者修改了其他程序正在使用的内存，就像用过期车票乘车，可能会误占他人座位，引发一系列混乱。这会导致程序出现不可预测的行为，从数据错误到程序崩溃，严重影响系统的稳定性。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void demonstrate_use_after_free() {
    printf("=== 使用已释放内存示例 ===\n");
    printf("就像拿着过期车票试图再次乘车\n\n");

    // 分配内存（购买车票）
    int *ticket = (int *)malloc(sizeof(int));
    *ticket = 2025; // 车票有效期

    printf("1. 分配内存 (购买车票):\n");
    printf("   内存地址: %p\n", ticket);
    printf("   车票有效期: %d\n\n", *ticket);

    // 释放内存（车票过期）
    free(ticket);
    printf("2. 释放内存 (车票过期作废):\n");
    printf("   内存已归还给系统\n\n");

    // 错误：使用已释放的内存（使用过期车票）
    printf("3.   错误：尝试使用已释放的内存 (使用过期车票):\n");
    printf("   访问已释放内存的地址: %p\n", ticket);

    // 这是危险的操作！结果不可预测
    printf("   内存中的垃圾值: %d (可能是随机数据)\n\n", *ticket);

    // 分配新内存，可能会覆盖之前释放的内存
    int *new_ticket = (int *)malloc(sizeof(int));
    *new_ticket = 2026;

    printf("4. 系统分配新内存 (新乘客购票):\n");
    printf("   新内存地址: %p\n", new_ticket);
    printf("   新车票有效期: %d\n\n", *new_ticket);

    // 现在访问原来的指针可能会看到新的数据
    printf("5.   访问原指针现在可能指向新数据:\n");
    printf("   原指针地址: %p\n", ticket);
    printf("   原指针现在的值: %d (可能是新数据)\n", *ticket);

    free(new_ticket);
}

void demonstrate_dangling_pointer() {
    printf("\n=== 悬空指针示例 ===\n");

    char *username = (char *)malloc(20);
    strcpy(username, "Alice");

    printf("1. 分配字符串内存:\n");
    printf("   用户名: %s\n", username);

    free(username);
    printf("2. 释放内存后:\n");

    // 悬空指针：指向已释放内存的指针
    printf("   悬空指针仍然指向: %p\n", username);

    // 危险：指针仍然存在，但指向的内存已无效
    printf("   尝试访问: %s (可能显示垃圾数据)\n", username);

    // 正确做法：释放后将指针置为NULL
    username = NULL;
    printf("3. 正确做法：释放后将指针置为NULL:\n");
    printf("   指针现在: %p\n", username);

    // 现在访问会导致明显的错误，而不是隐藏的问题
    // if (username != NULL) {
    //     printf("   安全访问: %s\n", username);
    // }
}

int main() {
    demonstrate_use_after_free();
    demonstrate_dangling_pointer();

    return 0;
}

③内存泄漏：内存泄漏则像是一个看不见的漏洞，让内存资源无声无息地流失。当程序动态分配了内存，却在不再需要时没有释放这些内存，就会发生内存泄漏。比如在 C 语言中，使用malloc分配了内存，但没有相应的free操作；在 C++ 中，使用new分配内存后，没有使用delete释放 。随着内存泄漏的不断积累，系统的可用内存会越来越少，就像一个水池，不断有水流入，但排水口却被堵住，水池里的水越来越少，无法满足后续的需求。

这会导致系统性能逐渐下降，程序运行变得缓慢，因为系统需要不断地进行内存交换操作，从磁盘中读取数据来补充内存的不足。最终，当内存被耗尽时，程序可能会崩溃，服务中断，给用户带来极差的体验，对于一些关键业务系统，甚至可能造成巨大的经济损失。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 模拟内存泄漏的函数
void leak_memory(int count) {
    printf("=== 内存泄漏示例 ===\n");
    printf("就像一个看不见不见的漏洞，让内存资源无声无息地流失\n\n");

    for (int i = 0; i < count; i++) {
        // 分配内存但不释放 - 内存泄漏发生
        char *data = (char *)malloc(1024 * 1024); // 每次分配1MB

        if (data != NULL) {
            // 写入一些数据
            memset(data, 0xAA, 1024 * 1024);

            // 模拟一些处理...
            // 但忘记释放内存！

            printf("泄漏第 %d 次: 分配了 1MB 内存\n", i + 1);
        } else {
            printf("内存分配失败！系统可能已经耗尽内存\n");
            break;
        }
    }

    printf("\n  警告：已经泄漏了 %d MB 内存，并且没有释放！\n", count);
    printf("这些内存将一直被占用，直到程序结束\n");
}

// 正确的内存管理示例
void proper_memory_management(int count) {
    printf("\n=== 正确的内存管理 ===\n");

    for (int i = 0; i < count; i++) {
        char *data = (char *)malloc(1024 * 1024);

        if (data != NULL) {
            // 使用内存
            memset(data, 0xBB, 1024 * 1024);

            // 重要：使用完后释放内存
            free(data);

            printf("正确处理第 %d 次: 分配并释放了 1MB 内存\n", i + 1);
        } else {
            printf("内存分配失败！\n");
            break;
        }
    }

    printf("\n 正确：所有分配的内存都已释放\n");
}

// 更复杂的内存泄漏场景
void complex_memory_leak() {
    printf("\n=== 复杂的内存泄漏场景 ===\n");

    // 模拟一个函数，在某些条件下忘记释放内存
    for (int i = 0; i < 5; i++) {
        int *numbers = (int *)malloc(100 * sizeof(int));

        if (numbers != NULL) {
            // 初始化数据
            for (int j = 0; j < 100; j++) {
                numbers[j] = j;
            }

            // 模拟条件判断，某些情况下忘记释放
            if (i % 2 == 0) {
                // 偶数次不释放 - 内存泄漏
                printf("条件成立，忘记释放内存 (泄漏)\n");
            } else {
                // 奇数次释放
                free(numbers);
                printf("条件不成立，正确释放内存\n");
            }
        }
    }

    printf("\n  这个函数泄漏了部分内存\n");
}

int main() {
    // 演示内存泄漏
    leak_memory(5); // 泄漏5MB内存

    // 演示正确的内存管理
    proper_memory_management(5);

    // 演示复杂的内存泄漏场景
    complex_memory_leak();

    printf("\n=== 内存泄漏的危害 ===\n");
    printf("1. 系统可用内存逐渐减少\n");
    printf("2. 程序运行越来越慢\n");
    printf("3. 可能导致系统崩溃\n");
    printf("4. 影响其他程序的正常运行\n");

    return 0;
}

二、认识 Kasan 这位 “内存侦探”

面对这些棘手的内存问题，有没有一种有效的工具能够帮助我们快速定位和解决问题呢？答案就是 Kasan。

2.1 Kasan 是什么？

在探寻如何有效检测内存错误的道路上，Kasan （全称为 Kernel Address Sanitizer）工具应运而生，它的出现为内存错误检测领域带来了新的曙光 。Kasan，全称为 Kernel Address Sanitizer，即内核地址清理器，它是 AddressSanitizer 针对 Linux 内核的一个分支，最初由 Google 的工程师开发，目的就是专门用于检测 Linux 内核中的内存错误。

AddressSanitizer 是一个广泛应用于用户空间程序内存错误检测的工具，凭借在检测堆缓冲区溢出、栈缓冲区溢出、使用已释放内存等方面的出色表现，深受开发者喜爱。而 Kasan 则是借鉴了 AddressSanitizer 的设计思想和关键技术，将其应用场景拓展到了 Linux 内核领域。

Kasan 的发展历程与 Linux 内核的发展紧密相连。在早期的 Linux 内核开发中，内存错误的检测和调试主要依赖于一些简单的工具和开发者的经验。随着 Linux 内核的不断发展壮大，功能日益丰富，代码量也急剧增加，传统的内存错误检测方法越来越难以满足需求。那些隐藏在复杂内核代码深处的内存错误，就像潜藏在黑暗中的 “暗流”，难以被发现和处理，给系统的稳定性和安全性带来了极大的威胁。

Kasan 的出现，成功地填补了这一空白。自它被引入 Linux 内核以来，就迅速成为内核开发者不可或缺的得力助手。它在 Linux 内核版本演进中不断优化和完善，功能也越来越强大。如今，Kasan 已经成为 Linux 内核开发和维护过程中检测内存错误的标准工具之一，为保障 Linux 系统的稳定运行发挥着重要作用。就像在 Linux 内核这片广阔的 “战场” 上，Kasan 就是那把锋利的 “宝剑”，帮助开发者披荆斩棘，战胜内存错误带来的种种挑战。

2.2 Kasan 工作原理与机制

Kasan 利用了一种巧妙的 “影子内存”（shadow memory）技术来实现内存错误检测。简单来说，影子内存是一块与实际内存相对应的额外内存区域，它就像是实际内存的 “影子”，如影随形。Kasan 为每 8 字节的实际内存分配 1 字节的影子内存 ，通过影子内存中的标记来记录对应实际内存区域的访问权限和状态。例如，当一段内存被分配且未被释放时，其对应的影子内存标记为可访问状态；当内存被释放后，影子内存会被标记为不可访问状态。

当程序尝试访问内存时，Kasan 会检查对应的影子内存标记。如果影子内存标记表明该访问是合法的，程序可以正常访问内存；如果影子内存标记显示该访问不合法，比如访问了已释放内存或越界访问，Kasan 就会立即捕获到这个错误，并输出详细的错误信息，包括出错的地址、访问的大小以及相关的调用栈信息，就像侦探在犯罪现场收集线索一样，帮助开发者快速定位到问题代码所在。

（1）影子内存：核心奥秘

Kasan 能够高效检测内存错误，其核心奥秘在于 “影子内存”。简单来说，影子内存就像是实际内存的 “孪生兄弟”，Kasan 会为每一块实际使用的内存分配一块与之对应的影子内存区域，二者大小相同 。影子内存的主要任务是存储对应实际内存区域的状态信息，这些信息就像是内存的 “健康档案”，详细记录着内存的各种情况。

在实际运行中，影子内存通过特殊的编码方式来标记内存的状态。例如，当影子内存中的某个位置的值为 0 时，就表示对应的实际内存区域是完全可以正常访问的，就像一个畅通无阻的道路，程序可以自由地读取和写入数据；而当影子内存的值为负数时，则代表对应的内存区域存在问题，比如可能是已经被释放的内存，或者是越界访问的区域，这就好比道路上设置了 “禁止通行” 的标志，程序如果试图访问，Kasan 就能立刻察觉并发出警报。

以一个简单的数组访问为例，假设我们定义了一个包含 10 个元素的整数数组int arr[10];，系统会为这个数组分配一块连续的内存空间来存储这 10 个整数。与此同时，Kasan 会为这块内存分配对应的影子内存。当程序执行arr[5] = 10;这样的操作时，Kasan 会先检查影子内存中对应arr[5]的位置，确认该位置标记为可访问状态（通常为 0），才会允许这次赋值操作顺利进行。但如果程序中出现了arr[15] = 20;这样的越界访问，Kasan 检查影子内存时，会发现对应arr[15]的位置标记并非可访问状态，于是马上判定这是一次非法访问，并及时报告错误，就像一个严格的交通警察，绝不允许任何违规的 “内存通行” 行为。

C 语言代码示例如下：

#include <stdio.h>
#include <stdlib.h>

// 简单模拟 Kasan 的影子内存检查
#define ARRAY_SIZE 10

// 模拟影子内存 (每个字节对应 8 个字节的应用内存)
unsigned char shadow_memory[ARRAY_SIZE / 8 + 1] = {0};

// 初始化影子内存
void init_shadow() {
    // 标记前 10 个整数（40 字节）为可访问
    for (int i = 0; i < 5; i++) {
        shadow_memory[i] = 0x00;  // 0 表示可访问
    }
    // 标记其余部分为不可访问
    for (int i = 5; i < sizeof(shadow_memory); i++) {
        shadow_memory[i] = 0xff;  // 非 0 表示不可访问
    }
}

// 检查内存访问是否合法
int check_memory_access(void *ptr, size_t size) {
    size_t addr = (size_t)ptr;
    size_t base = (size_t)malloc(ARRAY_SIZE * sizeof(int));
    size_t offset = addr - base;

    // 计算影子内存索引和位
    size_t shadow_index = offset / 8;
    size_t shadow_bit = offset % 8;

    // 检查影子内存
    if (shadow_index >= sizeof(shadow_memory)) {
        return 0;  // 越界
    }

    // 检查对应位是否为 0
    if ((shadow_memory[shadow_index] & (1 << shadow_bit)) != 0) {
        return 0;  // 不可访问
    }

    return 1;  // 合法访问
}

int main() {
    int *arr = (int *)malloc(ARRAY_SIZE * sizeof(int));
    init_shadow();

    printf("=== Kasan 内存检查示例 ===\n");

    // 合法访问
    printf("尝试访问 arr[5] = 10: ");
    if (check_memory_access(&arr[5], sizeof(int))) {
        arr[5] = 10;
        printf("访问成功\n");
    } else {
        printf("非法访问！\n");
    }

    // 越界访问
    printf("尝试访问 arr[15] = 20: ");
    if (check_memory_access(&arr[15], sizeof(int))) {
        arr[15] = 20;
        printf(" 访问成功\n");
    } else {
        printf(" 非法访问！\n");
    }

    free(arr);
    return 0;
}

• 影子内存初始化：为数组分配对应的影子内存，并标记可访问区域

• 内存访问检查：在每次内存访问前检查影子内存

• 越界检测：对于越界访问能够及时发现并报告

编译运行后，你会看到：

=== Kasan 内存检查示例 ===
尝试访问 arr[5] = 10: 访问成功
尝试访问 arr[15] = 20: 非法访问！

这就是 Kasan 如何像交通警察一样监控内存访问，防止越界等内存错误。

（2）编译时插桩：关键环节

除了影子内存这一核心技术，Kasan 还有一个关键的工作环节，那就是编译时插桩。在 Linux 内核编译的过程中，Kasan 会巧妙地插入一些额外的检查代码，这些代码就像是隐藏在程序中的 “小哨兵”，时刻监视着内存的访问情况。

这些检查代码会在内存访问指令之前被插入，比如在进行内存读取（load）或者写入（store）操作前，检查代码会先执行。它的主要职责是查询影子内存中对应位置的状态信息，以此来判断即将进行的内存访问是否合法。例如，当程序执行一条从内存中读取数据的指令时，编译时插入的检查代码会迅速查询影子内存，确认该内存区域是否允许被读取。如果影子内存标记该区域可访问，那么读取指令才能正常执行；反之，如果影子内存标记该区域不可访问，检查代码就会立即触发错误报告机制。

Kasan 还会接管内存管理函数，比如常见的内存分配函数malloc和内存释放函数free。当程序调用malloc分配内存时，Kasan 会在背后记录下分配的内存地址、大小等关键信息，并相应地在影子内存中做好标记；当调用free释放内存时，Kasan 同样会更新影子内存，将对应内存区域标记为已释放状态，禁止再次访问。这就好比一个图书馆管理员，对每一本书的借出（内存分配）和归还（内存释放）都了如指掌，并做好记录，防止出现混乱。

一旦 Kasan 检测到内存访问错误，它会迅速生成详细的错误报告。报告中会包含错误的类型，比如是越界访问还是使用已释放内存；还会明确指出错误发生的具体内存地址，以及相关的调用栈信息，这些信息就像是一张详细的 “错误地图”，能够帮助开发者快速定位到问题代码所在，准确找出内存错误的根源，从而高效地进行修复。

2.3 Kasan 集成配置

将 Kasan 集成到 Linux 内核中，是充分发挥其内存错误检测能力的关键一步 ，这一过程虽然需要开发者投入一定的精力，但却能为后续的开发和调试工作带来极大的便利。以 Linux 内核 5.10 版本为例，我们来详细了解一下具体的集成步骤。

首先，确保开发环境中安装了 Linux 内核 5.10 的源代码。你可以从官方的 Linux 内核镜像站点下载对应的源代码压缩包，下载完成后，使用解压命令将其解压到指定的目录，例如/usr/src/linux-5.10。

接着，进入解压后的内核源代码目录，使用make menuconfig命令打开内核配置界面。这就像是打开了一个庞大的 “功能超市”，在这里你可以对内核的各种功能进行选择和配置。在配置界面中，通过方向键和回车键，依次找到 “Kernel hacking” -> “Memory Debugging” 选项，然后在其中找到 “KASAN: runtime memory debugger” 选项，按下空格键将其选中，使其前面的括号内显示为 “*”，这表示启用 Kasan 功能。

对于一些追求极致性能和个性化配置的开发者来说，还可以进一步深入配置。比如，在 “KASAN: runtime memory debugger” 的子选项中，有 “KASAN: inline instrumentation (EXPERIMENTAL)” 选项。这个选项涉及到 Kasan 的检测模式，内联模式（inline instrumentation）会在编译时将检查代码直接插入到内存访问代码中，检测更加精细，但可能会对性能产生一定影响；而轮询模式（outline instrumentation）则是在运行时进行检查，对性能影响相对较小。你可以根据自己的需求和对性能的考量来选择合适的模式。

完成所有配置后，按下 “Esc” 键退出配置界面，并保存配置。接下来，就可以开始编译内核了。在终端中执行make -j$(nproc)命令，其中-j$(nproc)参数表示使用系统的所有 CPU 核心进行并行编译，这样可以大大加快编译速度。编译过程可能会持续一段时间，具体时长取决于你的硬件性能和内核代码的复杂程度，在这个过程中，你可以耐心等待，或者去做一些其他的事情。

编译完成后，还需要安装编译好的内核模块和内核。依次执行make modules_install和make install命令，这两个命令会将编译好的内核模块安装到系统的对应目录中，并更新系统的启动配置，使新的内核能够在下次启动时生效。最后，重启系统，在启动过程中，选择新安装的带有 Kasan 功能的内核，至此，Kasan 就成功集成到 Linux 内核中了。

Kasan 提供了一系列丰富的配置参数，这些参数就像是调节工具性能的 “旋钮”，通过合理调整它们，能够让 Kasan 在不同的应用场景中发挥出最佳的检测效果 。先来说说CONFIG_KASAN_RECORD这个参数，当它被启用时，Kasan 会记录更多关于内存访问的详细信息，包括内存的分配和释放历史等。这对于调试一些复杂的内存问题非常有帮助，比如在追踪一个难以捉摸的内存泄漏问题时，开启CONFIG_KASAN_RECORD，Kasan 记录的信息就像是一份详细的 “内存使用日志”，开发者可以从中清晰地看到内存是在哪些函数中被分配和释放的，从而更容易找到问题的根源。但需要注意的是，启用这个参数会增加一定的系统开销，因为记录这些信息需要占用额外的系统资源。

再看CONFIG_KASAN_HW_TAGS参数，它主要用于支持硬件标签的 Kasan 模式，这种模式仅在支持内存标记扩展（MTE）的 arm64 CPU 上运行 。在这种模式下，硬件会协助 Kasan 进行内存访问的检测，大大提高检测效率，并且内存和性能开销都相对较低，因此非常适合在对性能要求较高的生产环境中使用。例如，在一些基于 arm64 架构的服务器上，启用CONFIG_KASAN_HW_TAGS，既能保障系统的稳定运行，又能及时检测出潜在的内存错误。

对于一些对性能极为敏感的应用场景，CONFIG_KASAN_LOW_OVERHEAD模式就派上用场了。启用这个模式后，Kasan 会采用一些优化策略来降低对系统性能的影响，虽然可能会牺牲掉一部分检测的全面性，但在那些对性能要求苛刻，且内存错误风险相对较低的场景中，这是一个很好的平衡选择。比如在一些实时性要求很高的多媒体处理应用中，使用CONFIG_KASAN_LOW_OVERHEAD模式，既能保证应用的流畅运行，又能在一定程度上检测内存错误。

还有CONFIG_KASAN_CONCURRENT参数，它主要用于支持并发环境下的内存错误检测。在一些多线程、多进程并发执行的复杂应用中，内存访问的情况更加复杂，容易出现一些只有在并发环境下才会出现的内存错误。启用CONFIG_KASAN_CONCURRENT，Kasan 就能更好地捕捉这些并发相关的内存问题，保障系统在并发场景下的稳定性。

三、Kasan 实战：揪出内存问题 “元凶”

理论知识储备完成，接下来就进入实战环节，看看 Kasan 是如何在实际操作中发挥作用，揪出内存问题的 “元凶” 的。

3.1准备工作

在使用 Kasan 之前，需要确保内核已经开启了相关的配置选项。首先，要保证 CONFIG_HAVE_ARCH_KASAN 和 CONFIG_KASAN 这两个配置项被启用。CONFIG_HAVE_ARCH_KASAN 表示当前架构是否支持 Kasan ，而 CONFIG_KASAN 则是开启 Kasan 功能的关键配置。

开启这些配置选项的方式通常是通过内核配置工具，如 make menuconfig。在配置界面中，找到 “Kernel hacking” 选项，进入后找到 “Memory Debugging” 相关子菜单，在其中可以找到 Kasan 的配置项，将 CONFIG_KASAN 设置为 “y”，表示启用 Kasan 。如果希望获得更详细的调试信息，还可以开启 CONFIG_KASAN_EXTRA_INFO 等相关选项。

需要注意的是，开启 Kasan 可能会对系统性能产生一定的影响，因为它需要额外的内存和计算资源来维护影子内存和进行内存访问检查 。所以在生产环境中使用时，需要谨慎评估。同时，不同的内核版本和架构可能对 Kasan 的支持和配置方式略有差异，在实际操作时要参考对应的内核文档和资料。

3.2案例一：越界访问排查

我们来看一段简单的 C 语言代码示例，这段代码模拟了一个在 Linux 内核模块中可能出现的越界访问情况 。

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/slab.h>

static int __init kasan_demo_init(void) {
    char *buffer;
    size_t buffer_size = 10;

    buffer = kmalloc(buffer_size, GFP_KERNEL);
    if (!buffer) {
        printk(KERN_ERR "Memory allocation failed\n");
        return -ENOMEM;
    }

    // 故意越界访问，将数据写入超出分配内存的位置
    buffer[buffer_size + 1] = 'A'; 

    kfree(buffer);
    printk(KERN_INFO "Module initialized successfully\n");
    return 0;
}

static void __exit kasan_demo_exit(void) {
    printk(KERN_INFO "Module exited successfully\n");
}

module_init(kasan_demo_init);
module_exit(kasan_demo_exit);
MODULE_LICENSE("GPL");

当这段代码在内核中运行并启用 Kasan 后，Kasan 会迅速检测到越界访问错误，并生成详细的错误报告 。错误报告大致如下：

==================================================================
BUG: KASAN: slab-out-of-bounds in kasan_demo_init+0x74/0x98 at addr ffffffff88888888
Write of size 1 by task <your_task_name>/<pid>
CPU: <cpu_number> PID: <pid> Comm: <your_task_name> Tainted: <taint_info> <kernel_version> #<build_number>
Hardware name: <your_hardware_name>
Call trace:
[<ffffffff81000000>] dump_backtrace+0x0/0x358
[<ffffffff81000014>] show_stack+0x14/0x20
[<ffffffff810000a8>] dump_stack+0xa8/0xd0
[<ffffffff810003c4>] kasan_object_err+0x24/0x80
[<ffffffff81000654>] kasan_report.part.1+0x1dc/0x498
[<ffffffff81000b98>] qlist_move_cache+0x0/0xc0
[<ffffffff81000fe4>] __asan_store1+0x4c/0x58
[<ffffffffc0000074>] kasan_demo_init+0x74/0x98 [your_module_name]
Object at ffffffff88888880, in cache kmalloc-<size> size: <allocated_size>
Allocated:
[<ffffffffc0000000>] kasan_demo_init+0x30/0x98 [your_module_name]

在这份错误报告中，“BUG: KASAN: slab-out-of-bounds” 明确指出错误类型是越界访问 。“kasan_demo_init+0x74/0x98” 表示错误发生在kasan_demo_init函数中，偏移地址为 0x74，函数总大小为 0x98，这就像是在一个房子里（函数），告诉你错误发生在房子里的具体位置（偏移地址）。“at addr ffffffff88888888” 指出了越界访问的具体内存地址，这是定位问题的关键线索之一，就像给了你错误发生的 “门牌号”。“Write of size 1” 说明是一次写入操作，写入大小为 1 字节，让你清楚了解错误的操作类型和数据量。

根据这份报告，我们可以迅速定位到代码中buffer[buffer_size + 1] = 'A';这一行，这就是导致越界访问的罪魁祸首。要修复这个问题，只需确保内存访问不超出分配的范围，比如修改为buffer[buffer_size - 1] = 'A';，这样就保证了访问在合法的内存区间内。

3.3案例二：释放后使用问题解决

接下来看一个释放后使用内存的代码示例 。

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/slab.h>

static int __init kasan_use_after_free_init(void) {
    char *buffer;
    size_t buffer_size = 10;

    buffer = kmalloc(buffer_size, GFP_KERNEL);
    if (!buffer) {
        printk(KERN_ERR "Memory allocation failed\n");
        return -ENOMEM;
    }

    kfree(buffer);
    // 尝试访问已释放的内存
    buffer[5] = 'B'; 

    printk(KERN_INFO "Module initialized successfully\n");
    return 0;
}

static void __exit kasan_use_after_free_exit(void) {
    printk(KERN_INFO "Module exited successfully\n");
}

module_init(kasan_use_after_free_init);
module_exit(kasan_use_after_free_exit);
MODULE_LICENSE("GPL");

当启用 Kasan 运行这段代码时，Kasan 会检测到释放后使用内存的错误，并给出如下报告 ：

==================================================================
BUG: KASAN: use-after-free in kasan_use_after_free_init+0x6c/0x98 at addr ffffffff88888888
Write of size 1 by task <your_task_name>/<pid>
CPU: <cpu_number> PID: <pid> Comm: <your_task_name> Tainted: <taint_info> <kernel_version> #<build_number>
Hardware name: <your_hardware_name>
Call trace:
[<ffffffff81000000>] dump_backtrace+0x0/0x358
[<ffffffff81000014>] show_stack+0x14/0x20
[<ffffffff810000a8>] dump_stack+0xa8/0xd0
[<ffffffff810003c4>] kasan_object_err+0x24/0x80
[<ffffffff81000654>] kasan_report.part.1+0x1dc/0x498
[<ffffffff81000b98>] qlist_move_cache+0x0/0xc0
[<ffffffff81000fe4>] __asan_store1+0x4c/0x58
[<ffffffffc000006c>] kasan_use_after_free_init+0x6c/0x98 [your_module_name]
Freed by task <your_task_name>/<pid>; stack:
[<ffffffff81000000>] dump_backtrace+0x0/0x358
[<ffffffff81000014>] show_stack+0x14/0x20
[<ffffffff810000a8>] dump_stack+0xa8/0xd0
[<ffffffff810003c4>] kasan_object_err+0x24/0x80
[<ffffffff81000654>] kasan_report.part.1+0x1dc/0x498
[<ffffffff81000b98>] qlist_move_cache+0x0/0xc0
[<ffffffff81000fe4>] __asan_store1+0x4c/0x58
[<ffffffffc0000048>] kasan_use_after_free_init+0x48/0x98 [your_module_name]
Object at ffffffff88888880, in cache kmalloc-<size> size: <allocated_size>
Freed:
[<ffffffffc0000048>] kasan_use_after_free_init+0x48/0x98 [your_module_name]

从报告中 “BUG: KASAN: use-after-free” 可以得知这是一个释放后使用内存的错误 。“kasan_use_after_free_init+0x6c/0x98” 指出错误发生在kasan_use_after_free_init函数的特定位置。“at addr ffffffff88888888” 给出了错误发生的内存地址。报告中还特别指出 “Freed by task <your_task_name>/”，并列出了内存被释放时的堆栈信息，这对于追踪内存释放的源头非常有帮助，就像为你提供了一条从错误发生点回溯到内存释放点的 “线索链”。

根据这份报告，我们可以轻松定位到代码中kfree(buffer);之后的buffer[5] = 'B';这一行，这就是问题所在。要修复这个问题，需要确保在内存释放后不再访问该内存，比如可以将buffer指针设置为NULL，即kfree(buffer); buffer = NULL;，这样后续如果不小心再次访问buffer，就会因为buffer为NULL而触发空指针异常，从而更容易发现和解决问题 。