567次阅读 | 发布于2年以前

概述

本程序在谢宝友老师[1]所提供的高负载处理模块的代码[2]基础上，根据5.15版内核的变化，修改出的。本程序是一个内核模块，用于监控系统负载，在平均负载超过4时，打印所有进程的调用栈。

本程序分为三个文件：main.c、load.h、Makefile。其中，main.c是本内核模块的主程序；load.h中是该内核模块的扩展代码，这里放了一个获取内核中未被导出符号（变量或函数）的一个函数；Makefile用来编译该内核模块。完整代码在文章的最下面。

模块的主要实现方式为：设置一个定时器，以固定的间隔访问系统给出的1分钟内平均负载，如果超过负载阈值，则输出运行队列全部进程栈信息，并使程序休眠一段较长的时间。流程图如下：

定时器

本模块采用了hrtimer——高精度定时器，由linux/hrtimer.h引入，可精确到ns级。

平均负载

这里有所改动，原文中是通过kallsyms_lookup_name函数获取的，但我在浏览头文件时发现了linux/sched/loadavg.h头文件，里面已经定义好了一些有关平均负载——loadavg的宏，并导出了avenrun——平均负载数组——1、5、15分钟内的平均负载，所以我这里直接引用了该头文件、直接使用了相关符号

输出进程栈

这里改动很大，在5.15版中，没有了save_stack_trace_tsk，通过查看linux/stacktrace.h文件，发现这个函数被用于未配置CONFIG_ARCH_STACKWALK的系统，而配置了CONFIG_ARCH_STACKWALK的系统中，有新的函数：unsigned int stack_trace_save_tsk(struct task_struct *task, unsigned long *store, unsigned int size, unsigned int skipnr)，定义于kernel/stacktrace.c中，与旧函数相比变化很大，好在在源代码中有详细的接口说明，根据这我成功的修改了栈的输出部分。

与此同时我发现了功能类似的另一个函数show_stack，定义于arch/x86/kernel/dumpstack.c

然而，这两个函数的符号都没有导出，也就无法通过引入相关头文件来使用，原文章来获取内核中未导出符号的kallsyms_lookup_name函数也未被导出，这就要求我寻找一种新的方法来获取未导出符号，我找到了kprobe技术。

kprobes技术[3]是内核开发者们专门为了便于跟踪内核函数执行状态所设计的一种轻量级内核调试技术。利用kprobes技术，内核开发人员可以在内核的绝大多数指定函数中动态的插入探测点来收集所需的调试状态信息而基本不影响内核原有的执行流程。我们可以通过注册一个指定了函数名的kprobe来获取函数的地址。

main.c


#include <linux/stacktrace.h> /* for stack_trace_print */
#include <linux/module.h> /* for module_*, MODULE_*, printk */
#include <linux/hrtimer.h> /* for hrtimer_*, ktime_* */
#include <linux/sched/loadavg.h> /* for avenrun, LOAD_* */
#include <linux/sched.h> /* for struct task_struct */
#include <linux/sched/signal.h> /* for do_each_thread, while_each_thread */
#include "load.h" /* for find_kallsyms_lookup_name */
#define BACKTRACE_DEPTH 20 /* 最大栈深度 */
void (*ShowStack)(struct task_struct *task, unsigned long *sp, const char *loglvl); /* 将要指向stack_show函数，可以直接输出进程控制块的调用栈 */
unsigned int (*StackTraceSaveTask)(struct task_struct *tsk, unsigned long *store, unsigned int size, unsigned int skipnr); /* 将要指向stack_trace_save_tsk */
static void print_all_task_stack(void) { /* 打印全部进程调用栈 */
    struct task_struct *g, *p; /* 用于遍历进程 */
    unsigned long backtrace[BACKTRACE_DEPTH]; /* 用于存储调用栈的函数地址 */
    unsigned int nr_bt; /* 用于存储调用栈的层数 */
    printk("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
    printk("Load: %lu.%02lu, %lu.%02lu, %lu.%02lu\n", /* 输出近期平均负载 */
        LOAD_INT(avenrun[0]), LOAD_FRAC(avenrun[0]),
        LOAD_INT(avenrun[1]), LOAD_FRAC(avenrun[1]),
        LOAD_INT(avenrun[2]), LOAD_FRAC(avenrun[2]));
    rcu_read_lock(); /* 为运行队列上锁 */
    printk("dump running task.\n");
    do_each_thread(g, p) { /* 遍历运行队列 */
        if(p->__state == TASK_RUNNING) {
            printk("running task, comm: %s, pid %d\n", p->comm, p->pid);
            // show_stack(p, NULL, ""); /* 可以取代下面两个语句 */
            nr_bt = StackTraceSaveTask(p, backtrace, BACKTRACE_DEPTH, 0); /* 保存栈 */ // 和下面一个语句一起可以取代上面一条语句
            stack_trace_print(backtrace, nr_bt, 0); /* 打印栈 */
        }
    } while_each_thread(g, p);
    printk("dump uninterrupted task.\n");
    do_each_thread(g, p) { /* 和上面的遍历类似 */
        if(p->__state & TASK_UNINTERRUPTIBLE) {
            printk("uninterrupted task, comm: %s, pid %d\n", p->comm, p->pid);
            // show_stack(p, NULL, ""); /* 可以取代下面两个语句 */
            nr_bt = StackTraceSaveTask(p, backtrace, BACKTRACE_DEPTH, 0); /* 保存栈 */ // 和下面一个语句一起可以取代上面一条语句
            stack_trace_print(backtrace, nr_bt, 0); /* 打印栈 */
        }
    } while_each_thread(g, p);
    rcu_read_unlock(); /* 为运行队列解锁 */
}
struct hrtimer timer; /* 创建一个计时器 */
static void check_load(void) { /* 主要的计时器触发后的程序 */
    static ktime_t last; /* 默认值是0 */
    u64 ms;
    int load = LOAD_INT(avenrun[0]);
    if(load < 4) /* 近1分钟内平均负载不超过4，没问题 */
        return;
    ms = ktime_to_ms(ktime_sub(ktime_get(), last)); /* 计算打印栈时间间隔 */
    if(ms < 20*1000) /* 打印栈的时间间隔小于20s,不打印 */
        return;
    last = ktime_get(); /* 获取当前时间 */
    print_all_task_stack(); /* 打印全部进程调用栈 */
}
static enum hrtimer_restart monitor_handler(struct hrtimer *hrtimer) { /* 计时器到期后调用的程序 */
    enum hrtimer_restart ret = HRTIMER_RESTART;
    check_load();
    hrtimer_forward_now(hrtimer, ms_to_ktime(10)); /* 延期10ms后到期 */
    return ret;
}
static void start_timer(void) {
    hrtimer_init(&timer, CLOCK_MONOTONIC, HRTIMER_MODE_PINNED); /* 初始化计时器为绑定cpu的自开机以来的恒定时钟 */
    timer.function = monitor_handler; /* 设定回调函数 */
    hrtimer_start_range_ns(&timer, ms_to_ktime(10), 0, HRTIMER_MODE_REL_PINNED); /* 启动计时器并设定计时模式为绑定cpu的相对时间，计时10ms，松弛范围为0 */
}
static int load_monitor_init(void) { /* 模块初始化 */
    // ShowStack = find_kallsyms_lookup_name("show_stack"); /* 使用show_stack时将此三行取消注释 */
    // if(!ShowStack)
    //     return -EINVAL;
    StackTraceSaveTask = find_kallsyms_lookup_name("stack_trace_save_tsk"); /* 使用stack_trace_save_tsk时将此三行取消注释 */
    if(!StackTraceSaveTask)
        return -EINVAL;
    start_timer();
    printk("load-monitor loaded.\n");
    return 0;
}
static void load_monitor_exit(void) { /* 模块退出 */
    hrtimer_cancel(&timer); /* 取消计时器 */
    printk("load-monitor unloaded.\n");
}
module_init(load_monitor_init);
module_exit(load_monitor_exit);
MODULE_DESCRIPTION("load monitor module");
MODULE_AUTHOR("Baoyou Xie <baoyou.xie@gmail.com>");
MODULE_LICENSE("GPL");

load.h


#include <linux/kprobes.h> /* for *kprobe* */
/* 调用kprobe找到kallsyms_lookup_name的地址位置 */
int noop_pre(struct kprobe *p, struct pt_regs *regs) { return 0; } /* 定义探针前置程序 */
void *find_kallsyms_lookup_name(char *sym) { /* 通过kprobe找到函数入口地址 */
    int ret;
    void *p; /* 用于保存要返回的函数入口地址 */
    struct kprobe kp = { /* 初始化探针 */
        .symbol_name = sym, /* 设置要跟踪的内核函数名 */
        .pre_handler = noop_pre /* 放置前置程序 */
    };
    if ((ret = register_kprobe(&kp)) < 0) { /* 探针注册失败就报告错误信息并返回空指针 */
        printk(KERN_INFO "register_kprobe failed, error\n", ret);
        return NULL;
    }
    /* 保存探针跟踪地址,即函数入口;输出注册成功信息,注销探针,返回地址 */
    p = kp.addr;
    printk(KERN_INFO "%s addr: %lx\n", sym, (unsigned long)p);
    unregister_kprobe(&kp);
    return p;
}

Makefile


OS_VER := UNKOWN
UNAME := $(shell uname -r)
ifneq ($(findstring 4.15.0-39-generic,$(UNAME)),)
    OS_VER := UBUNTU_1604
endif

ifneq ($(KERNELRELEASE),)
    obj-m += $(MODNAME).o
    $(MODNAME)-y := main.o
    ccflags-y := -I$(PWD)/
else
    export PWD=`pwd`
endif

ifeq ($(KERNEL_BUILD_PATH),)
    KERNEL_BUILD_PATH := /lib/modules/`uname -r`/build
endif

ifeq ($(MODNAME),)
    export MODNAME=load_monitor
endif

all:
    make CFLAGS_MODULE=-D$(OS_VER) -C /lib/modules/`uname -r`/build M=`pwd` modules
clean:
    make -C $(KERNEL_BUILD_PATH) M=$(PWD) clean

运行结果

将三个文件放入一个单独的文件夹中，运行make命令，编译出可插入内核的程序。编译好后，运行sudo insmod load_monitor.ko命令将其插入内核。

接下来是测试，运行stress -c 8命令（stress需要另外安装），使平均负载快速到达4以上，这里可以在新的虚拟终端通过top命令实时观测负载。当负载到达4之后，在运行着stress命令的窗口中按下ctrl+c终止程序，运行sudo dmesg命令就可以查看到内核栈的输出信息。

利用可挂载内核模块进行高负载处理