linux内核调试，模块中使用内核未导出接口

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

提示：这里可以添加本文要记录的大概内容：
内核版本：5.10

内核模块调试时候会遇到当前编译的linux内核没有导出一个函数而不能使用这个函数，比如删除文件的 do_unlinkat 函数，如何在模块中使用内核没有导出的函数呢，下面介绍下模块中使用内核没有导出的函数的方法。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、模块中使用内核没有导出的函数

1，查看内核函数在当前内核的地址
可以通过查看 /proc/kallsyms 节点找内核函数地址
cat /proc/kallsyms | grep do_unlinkat

或者内核编译完后会生成System.map文件，这个文件包含也是函数的地址，也可以使用，需要注意使用和当前系统配套的system.map
2，查看内核的这个函数定义，将这个地址转成函数指针然后使用
内核定义：
struct filename *
getname_kernel(const char * filename)

long do_unlinkat(int dfd, struct filename *name)

模块定义示例：
typedef struct filename* (getname_kernel_func_t)(char);
getname_kernel_func_t getname_kernel_ptr = (getname_kernel_func_t)0xffffffffb534f7a0;

typedef long (do_unlinkat_func_t)(int , struct filename);
do_unlinkat_func_t do_unlinkat_ptr = (do_unlinkat_func_t)0xffffffffb5351760;

内核中有函数可以通过地址或者函数名相互获取，但是通过函数名称获取地址的函数没有导出
int lookup_symbol_name(unsigned long addr, char *symname) //未导出
int sprint_symbol(char *buffer, unsigned long address)
{
return __sprint_symbol(buffer, address, 0, 1);
}
EXPORT_SYMBOL_GPL(sprint_symbol);

二、代码示例

使用代码前，需要将定义大的函数地址换成 当前电脑上的函数的内核地址（章节一有说明），否则可能出现异常

#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/sysfs.h>

#include <linux/fs.h>
#include <linux/namei.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/binfmts.h>
#include <linux/kallsyms.h>

#define DEVICE_NAME "mychardev"
#define CLASS_NAME "mychardev_class"

static dev_t dev_num; // 设备号
static struct cdev my_cdev; // cdev 结构体
static struct class *my_class; // 设备类
static struct device * my_device;


#define BUFFER_SIZE 1024 // 定义缓冲区大小

ssize_t open_read_close_file(const char *path)
{
    struct file *filp;
    char *buffer;
    ssize_t bytes_read;
    int err;

    // 分配缓冲区以存储读取的数据
    buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL);
    if (!buffer) {
        return -ENOMEM; // 内存分配失败
    }

    // 使用 vfs_open 打开文件
    filp = filp_open(path, O_RDWR | O_CREAT, 0644);

    if (IS_ERR(filp)) {
        kfree(buffer); // 释放缓冲区
        return -1;
    }

    // 从文件读取数据
    bytes_read = kernel_read(filp, buffer, BUFFER_SIZE - 1, &filp->f_pos);
    if (bytes_read >= 0) {
        buffer[bytes_read] = '\0'; // 确保字符串结束符
        printk(KERN_INFO "Read from file: %s\n", buffer); // 打印读取的内容
    } else {
        printk(KERN_ERR "Failed to read from file: %ld\n", bytes_read);
    }
    
    // 关闭文件
    filp_close(filp, NULL);

    return bytes_read; // 返回读取的字节数
    
}

typedef int (*kernel_execve_func_t)(
    const char *kernel_filename,
    const char *const *argv,
    const char *const *envp
);

kernel_execve_func_t kernel_execve_ptr;

#define KERNEL_EXECVE ((int (*)(const char *, const char *const *, const char *const *))0xffffffffb5346ad0)


// ffffffffb5193190 T kallsyms_lookup_name
// ffffffffb5193620 T lookup_symbol_name
typedef unsigned long (*kallsyms_lookup_name_func_t)(const char *);
kallsyms_lookup_name_func_t kallsyms_ptr = (kallsyms_lookup_name_func_t)0xffffffffb5193190;

typedef unsigned int (*lookup_symbol_name_func_t)(unsigned long ,char *);
lookup_symbol_name_func_t symbol_name_ptr = (lookup_symbol_name_func_t)0xffffffffb5193620;

// 定义函数指针类型
typedef int (*printk_func_t)(const char *, ...);

// 创建指向 printk 函数的函数指针
printk_func_t printk_ptr = (printk_func_t)0xffffffffb5b24bf5;

int my_kernel_exec(void)
{
    int ret;
    char symname[128];
    unsigned long addr = 0;
    const char *argv[32+2] = { "/usr/bin/touch", NULL, };
    const char *envp[32+2] = { "-l", ">", "/dev/stdout",NULL, };
    const char *envp1[32+2] = { "/root/k_file_test/myfiletest",NULL, };
  
    kernel_execve_ptr = (kernel_execve_func_t)0xffffffffb5346ad0;

    //kernel_execve_ptr = (kernel_execve_func_t)kallsyms_lookup_name("kernel_execve");
    printk("kernel_execve_ptr = %lx\n", kernel_execve_ptr);

    ret = kernel_execve_ptr("/usr/bin/ls", argv, envp1);
    printk_ptr("kernel_execve ret = %d, ret = %d\n", ret, 111);
    //ret = KERNEL_EXECVE("ls", argv, envp);
    addr = kallsyms_ptr("kernel_execve");
    if(addr != 0)
    {
        printk("kallsyms_ptr kernel_execve = %lx\n", addr);
    }else
    {
        printk("kallsyms_ptr addr = 0\n");
    }
    
    ret = symbol_name_ptr(addr, symname);
    printk("symbol_name_ptr ret = %d, symname = %s\n",ret , symname);
    
    return ret;
}

// ffffffffb534f7a0 T getname_kernel
// ffffffffb5351760 T do_unlinkat
//long do_unlinkat(int dfd, struct filename *name)
typedef struct filename* (*getname_kernel_func_t)(char*);
getname_kernel_func_t getname_kernel_ptr = (getname_kernel_func_t)0xffffffffb534f7a0;

typedef long (*do_unlinkat_func_t)(int , struct filename*);
do_unlinkat_func_t do_unlinkat_ptr = (do_unlinkat_func_t)0xffffffffb5351760;

int my_kernel_rmfile(char* name)
{
    int ret = 0;

    ret = do_unlinkat_ptr(AT_FDCWD, getname_kernel_ptr(name));
    printk("do_unlinkat_ptr ret = %d\n", ret);
    return 0;
}



// 设备打开操作
static int my_open(struct inode *inode, struct file *file)
{
    // 在这里执行打开设备的操作
    return 0;
}

// 设备关闭操作
static int my_release(struct inode *inode, struct file *file)
{
    // 在这里执行关闭设备的操作
    return 0;
}

// 设备读取操作
static ssize_t my_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
    // 在这里执行读取数据的操作
    return count;
}

// 设备写入操作
static ssize_t my_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
    // 在这里执行写入数据的操作
    char command[256];
    int cmd = 0;
    int ret = 0;
    
    if (count > sizeof(command) - 1) {
        return -EINVAL;
    }
    
    ret = copy_from_user(command, buf, count);
    if (ret) {
        return -EFAULT;
    }

    // 终止字符串
    command[count] = '\0';
    
    sscanf(command, "%d", &cmd);
    printk("cmd = %d\n", cmd);

    switch(cmd)
    {
        case 1:
            open_read_close_file("./test_file");
            break;
    
        case 2:
            //my_kernel_exec();
            break;

        case 3:
            my_kernel_rmfile("/root/k_file_test/testfile");
            break;

        default:
            break;
    }

    return count;
}

// 设备 ioctl 操作
static long my_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    // 在这里执行 ioctl 操作
    return 0;
}


// 设备操作函数表
static const struct file_operations fops = {
    .owner          = THIS_MODULE,
    .open           = my_open,
    .release        = my_release,
    .read           = my_read,
    .write          = my_write,
    .unlocked_ioctl          = my_ioctl,
};



static ssize_t show_my_sysfs_node(struct device *dev, struct device_attribute *attr, char *buf)
{
    /* 这里实现读取 sysfs 文件的内容 */
    return sprintf(buf, "Hello from the kernel!\n");
}

static ssize_t store_my_sysfs_node(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
    /* 这里实现写入 sysfs 文件的行为 */
    pr_info("Received '%.*s'\n", (int)count, buf);
    return count;
}

static DEVICE_ATTR(my_sysfs_node, 0644, show_my_sysfs_node, store_my_sysfs_node);

// 模块加载时的初始化函数
static int __init my_init(void)
{
    int result;

    // 动态分配设备号
    result = alloc_chrdev_region(&dev_num, 0, 1, DEVICE_NAME);
    if (result < 0) {
        printk(KERN_ERR "Failed to allocate character device region.\n");
        return result;
    }

    // 初始化 cdev 结构体
    cdev_init(&my_cdev, &fops);

    // 注册 cdev
    result = cdev_add(&my_cdev, dev_num, 1);
    if (result) {
        unregister_chrdev_region(dev_num, 1);
        printk(KERN_ERR "Failed to add cdev.\n");
        return result;
    }

    // 创建设备类
    my_class = class_create(THIS_MODULE, CLASS_NAME);
    if (IS_ERR(my_class)) {
        cdev_del(&my_cdev);
        unregister_chrdev_region(dev_num, 1);
        printk(KERN_ERR "Failed to create device class.\n");
        return PTR_ERR(my_class);
    }

    // 创建设备节点
    my_device = device_create(my_class, NULL, dev_num, NULL, DEVICE_NAME);

    printk(KERN_INFO "Character device '%s' created with major number %d.\n", DEVICE_NAME, MAJOR(dev_num));

    // 创建 sysfs 文件节点
    device_create_file(my_device, &dev_attr_my_sysfs_node);

    return 0;
}

// 模块卸载时的清理函数
static void __exit my_exit(void)
{
    // 删除 sysfs 文件节点
    device_remove_file(my_device, &dev_attr_my_sysfs_node);
    // 删除设备节点
    device_destroy(my_class, dev_num);

    // 删除设备类
    class_destroy(my_class);

    // 删除 cdev
    cdev_del(&my_cdev);

    // 释放设备号
    unregister_chrdev_region(dev_num, 1);

    printk(KERN_INFO "Character device '%s' removed.\n", DEVICE_NAME);
}

module_init(my_init);
module_exit(my_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("A simple character device driver.");

Makefile

obj-m += module_char_test.o

all:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

---

总结

linux内核调试，模块中使用内核未导出接口，通过函数指针访问内核没有导出接口，可以调试使用