// hello.c - 最简内核模块（Linux 6.8验证：#include <linux/module.h>
#include <linux/init.h>

/* 模块元信息*/
MODULE_LICENSE("GPL");
MODULE_AUTHOR("linuxros");
MODULE_DESCRIPTION("Hello World内核模块");
MODULE_VERSION("1.0");

/* 初始化函数：insmod时执行*/
static int __init hello_init(void)
{
    printk(KERN_INFO "hello: module loaded\n");
    return 0;
}

/* 退出函数：rmmod时执行*/
static void __exit hello_exit(void)
{
    printk(KERN_INFO "hello: module unloaded\n");
}

module_init(hello_init);
module_exit(hello_exit);

printk(KERN_EMERG   "系统不可用\n");   // 0 - 最高优先级
printk(KERN_ALERT   "必须立即处理\n"); // 1
printk(KERN_CRIT    "严重条件\n");     // 2
printk(KERN_ERR     "错误条件\n");     // 3
printk(KERN_WARNING "警告条件\n");     // 4
printk(KERN_NOTICE  "正常但值得注意\n"); // 5
printk(KERN_INFO    "信息\n");         // 6
printk(KERN_DEBUG   "调试信息\n");     // 7 - 最低优先级

# 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

sudo apt install linux-headers-$(uname -r) build-essential

// param_demo.c - 模块参数示例
#include <linux/module.h>
#include <linux/init.h>
#include <linux/moduleparam.h>

/* 定义参数 */
static int count = 1;
static char *name = "default";
static bool enable = false;
static int values[4] = {1, 2, 3, 4};
static int nvalues = 4;  // 数组实际元素个数

/* 声明参数 */
module_param(count, int, S_IRUGO);
module_param(name, charp, S_IRUGO);
module_param(enable, bool, S_IRUGO);
module_param_array(values, int, &nvalues, S_IRUGO);

MODULE_PARM_DESC(count, "迭代次数（默认。);
MODULE_PARM_DESC(name, "设备名称（默认default。);
MODULE_PARM_DESC(enable, "使能开关（默认false。);
MODULE_PARM_DESC(values, "数值数组);

static int __init param_init(void)
{
    int i;
    pr_info("param: count=%d name=%s enable=%d\n", count, name, enable);
    pr_info("param: values=");
    for (i = 0; i < nvalues; i++)
        pr_cont("%d ", values[i]);
    pr_cont("\n");
    return 0;
}

static void __exit param_exit(void)
{
    pr_info("param: module unloaded\n");
}

module_init(param_init);
module_exit(param_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("模块参数示例");

# insmod传参
sudo insmod param_demo.ko count=5 name="mydev" enable=1 values=10,20,30

# modprobe传参（写。etc/modprobe.d/下或命令行）
sudo modprobe param_demo count=5 name="mydev"

# sysfs运行时修改（需要S_IWUSR权限。echo 10 | sudo tee /sys/module/param_demo/parameters/count

// param_cb_demo.c - 参数回调示例
#include <linux/module.h>
#include <linux/init.h>
#include <linux/moduleparam.h>

static int threshold = 100;

/* 参数设置回调 */
static int threshold_set(const char *val, const struct kernel_param *kp)
{
    int ret;
    long new_val;

    ret = kstrtol(val, 10, &new_val);
    if (ret < 0)
        return ret;

    if (new_val < 0 || new_val > 1000) {
        pr_err("threshold: value %ld out of range [0, 1000]\n", new_val);
        return -EINVAL;
    }

    pr_info("threshold: changed from %d to %ld\n", *(int *)kp->arg, new_val);
    *(int *)kp->arg = (int)new_val;
    return 0;
}

/* 参数获取回调 */
static int threshold_get(char *buf, const struct kernel_param *kp)
{
    return scnprintf(buf, PAGE_SIZE, "%d\n", *(int *)kp->arg);
}

/* 定义kernel_param_ops */
static const struct kernel_param_ops threshold_ops = {
    .set = threshold_set,
    .get = threshold_get,
};

module_param_cb(threshold, &threshold_ops, &threshold, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(threshold, "阈值（0-1000，默认500）");

static int __init cb_init(void)
{
    pr_info("cb: threshold=%d\n", threshold);
    return 0;
}

static void __exit cb_exit(void)
{
    pr_info("cb: module unloaded, threshold=%d\n", threshold);
}

module_init(cb_init);
module_exit(cb_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("参数回调示例");

// module_a.c - 导出符号
#include <linux/module.h>
#include <linux/init.h>

static int add(int a, int b)
{
    return a + b;
}

/* 导出符号，其他模块可调用 */
EXPORT_SYMBOL(add);

static int __init mod_a_init(void)
{
    pr_info("mod_a: loaded, add() exported\n");
    return 0;
}

static void __exit mod_a_exit(void)
{
    pr_info("mod_a: unloaded\n");
}

module_init(mod_a_init);
module_exit(mod_a_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("符号导出模块A");

// module_b.c - 使用导出符号
#include <linux/module.h>
#include <linux/init.h>

/* 声明外部符号 */
extern int add(int a, int b);

static int __init mod_b_init(void)
{
    int result = add(3, 5);
    pr_info("mod_b: add(3, 5) = %d\n", result);
    return 0;
}

static void __exit mod_b_exit(void)
{
    pr_info("mod_b: unloaded\n");
}

module_init(mod_b_init);
module_exit(mod_b_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("符号调用模块B");

sudo insmod module_a.ko
sudo insmod module_b.ko
dmesg | tail -5
# 输出: mod_b: add(3, 5) = 8

# 查看所有内核导出符号cat /proc/kallsyms | grep add

# 查看模块导出的符号grep -E "EXPORT_SYMBOL" module_a.ko  # 不准确，应看Module.symvers

# 查看Module.symvers（编译后生成。cat Module.symvers

MODULE_LICENSE("Proprietary");  // 非GPL

Unknown symbol in module

MODULE_SOFTDEP("pre: module_a");    // 前置依赖：加载前先加载module_a
MODULE_SOFTDEP("post: module_c");   // 后置依赖：加载后再加载module_c

// req_mod_demo.c - 动态请求加载模块#include <linux/module.h>
#include <linux/init.h>

static int __init req_init(void)
{
    int ret;

    /* 请求内核加载指定模块 */
    ret = request_module("module_a");
    if (ret < 0) {
        pr_err("req: failed to load module_a, ret=%d\n", ret);
        return ret;
    }

    pr_info("req: module_a loaded on demand\n");
    return 0;
}

static void __exit req_exit(void)
{
    pr_info("req: module unloaded\n");
}

module_init(req_init);
module_exit(req_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("动态加载依赖模块示例);

// notifier_demo.c - 通知链示例#include <linux/module.h>
#include <linux/init.h>
#include <linux/notifier.h>

/* 自定义通知事件。*/
#define MY_EVENT_BASE 0x8000
#define MY_EVENT_DATA_READY  (MY_EVENT_BASE + 1)
#define MY_EVENT_STOP        (MY_EVENT_BASE + 2)

/* 定义通知链头 */
static BLOCKING_NOTIFIER_HEAD(my_notifier_list);

/* 注册/注销通知链的导出函数 */
int my_register_notifier(struct notifier_block *nb)
{
    return blocking_notifier_chain_register(&my_notifier_list, nb);
}
EXPORT_SYMBOL(my_register_notifier);

int my_unregister_notifier(struct notifier_block *nb)
{
    return blocking_notifier_chain_unregister(&my_notifier_list, nb);
}
EXPORT_SYMBOL(my_unregister_notifier);

/* 发送通知的导出函数*/
void my_notify_event(unsigned long event, void *data)
{
    blocking_notifier_call_chain(&my_notifier_list, event, data);
}
EXPORT_SYMBOL(my_notify_event);

static int __init notifier_init(void)
{
    pr_info("notifier: chain initialized\n");
    return 0;
}

static void __exit notifier_exit(void)
{
    pr_info("notifier: module unloaded\n");
}

module_init(notifier_init);
module_exit(notifier_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("通知链示例);

// notifier_client.c - 通知链客户端
#include <linux/module.h>
#include <linux/init.h>
#include <linux/notifier.h>

extern int my_register_notifier(struct notifier_block *nb);
extern int my_unregister_notifier(struct notifier_block *nb);

#define MY_EVENT_BASE 0x8000
#define MY_EVENT_DATA_READY  (MY_EVENT_BASE + 1)

static int my_event_handler(struct notifier_block *nb,
                            unsigned long event, void *data)
{
    switch (event) {
    case MY_EVENT_DATA_READY:
        pr_info("client: received DATA_READY event, data=%p\n", data);
        break;
    default:
        break;
    }
    return NOTIFY_DONE;
}

static struct notifier_block my_nb = {
    .notifier_call = my_event_handler,
    .priority = 0,
};

static int __init client_init(void)
{
    int ret = my_register_notifier(&my_nb);
    if (ret)
        pr_err("client: register failed, ret=%d\n", ret);
    else
        pr_info("client: registered\n");
    return ret;
}

static void __exit client_exit(void)
{
    my_unregister_notifier(&my_nb);
    pr_info("client: unregistered\n");
}

module_init(client_init);
module_exit(client_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("通知链客户端示例");

MODULE_VERSION("1.0.0");

#include <linux/version.h>

#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 8, 0)
    /* 6.8及以上使用新API */
    ret = new_api_call();
#else
    /* 旧版使用兼容API */
    ret = legacy_api_call();
#endif

0xabc12345  add  module_a  EXPORT_SYMBOL_GPL

/lib/modules/6.8.x-xx-generic/build/Module.symvers

// 引用计数操作
if (!try_module_get(THIS_MODULE)) {
    pr_err("failed to get module reference\n");
    return -ENODEV;
}

/* 使用模块功能... */

module_put(THIS_MODULE);

static const struct file_operations my_fops = {
    .owner   = THIS_MODULE,  // 内核自动管理引用计数
    .open    = my_open,
    .release = my_release,
    .read    = my_read,
};

#include <linux/module.h>

/* 查看模块状态*/
enum module_state {
    MODULE_STATE_LIVE,      // 正常运行
    MODULE_STATE_COMING,    // 正在加载
    MODULE_STATE_GOING,     // 正在卸载
    MODULE_STATE_UNFORMED,  // 尚未完成初始化};

sudo rmmod -f module_name

// 各级initcall宏（定义在include/linux/init.h）
pure_initcall(fn)       // 0 - 仅对内建代码有效
core_initcall(fn)       // 1 - 核心子系统（中断控制器、时钟）
postcore_initcall(fn)   // 2 - 总线注册（PCI、USB总线）
arch_initcall(fn)       // 3 - 架构相关初始化
subsys_initcall(fn)     // 4 - 子系统初始化（网络、块设备）
fs_initcall(fn)         // 5 - 文件系统初始化
device_initcall(fn)     // 6 - 设备驱动（大多数驱动的默认级别）
late_initcall(fn)       // 7 - 延迟初始化（依赖前面所有子系统就绪）

modinfo hello.ko | grep vermagic
uname -r

sudo cp hello.ko /lib/modules/$(uname -r)/extra/
sudo depmod -a
sudo modprobe hello

# 查看引用计数
cat /proc/modules | grep hello
# 输出: hello 16384 1 - Live 0x...

# 第三列就是引用计数lsmod | grep hello