struct cdev {
    struct kobject     kobj;       // 内嵌kobject，sysfs展示
    struct module     *owner;      // 模块所有者，通常设THIS_MODULE
    const struct file_operations *ops;  // 指向file_operations
    struct list_head   list;       // 同主设备号的cdev链表
    dev_t              dev;        // 设备。    unsigned int       count;      // 连续次设备号数量
};

// mychardev.c - 字符设备驱动（Linux 6.8，Ubuntu 24.04 LTS。#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/mutex.h>

#define DEVICE_NAME  "mychardev"
#define CLASS_NAME   "mychardev_class"
#define BUF_SIZE     4096

/* ioctl命令定义 */
#define MYCHAR_MAGIC  'k'
#define MYCHAR_RESET     _IO(MYCHAR_MAGIC, 0)
#define MYCHAR_GET_SIZE  _IOR(MYCHAR_MAGIC, 1, int)
#define MYCHAR_SET_SIZE  _IOW(MYCHAR_MAGIC, 2, int)
#define MYCHAR_EXCHANGE  _IOWR(MYCHAR_MAGIC, 3, int)

/* 设备私有数据 */
struct mychar_dev {
    struct cdev    cdev;
    char          *buf;
    size_t         buf_len;
    struct mutex   lock;
};

static struct mychar_dev mydev;
static dev_t devt;
static struct class *myclass;
static struct device *mydevice;

static int my_open(struct inode *inode, struct file *filp)
{
    /* 通过container_of从cdev获取设备私有数据 */
    struct mychar_dev *dev;

    dev = container_of(inode->i_cdev, struct mychar_dev, cdev);
    filp->private_data = dev;

    pr_info("mychardev: opened\n");
    return 0;
}

static int my_release(struct inode *inode, struct file *filp)
{
    pr_info("mychardev: closed\n");
    return 0;
}

static ssize_t my_read(struct file *filp, char __user *buf,
                       size_t count, loff_t *ppos)
{
    struct mychar_dev *dev = filp->private_data;
    ssize_t ret;

    mutex_lock(&dev->lock);

    /* 偏移超出缓冲区长度，返回EOF */
    if (*ppos >= dev->buf_len) {
        mutex_unlock(&dev->lock);
        return 0;
    }

    /* 限制读取长度不超过剩余数*/
    if (count > dev->buf_len - *ppos)
        count = dev->buf_len - *ppos;

    /* 拷贝数据到用户空*/
    if (copy_to_user(buf, dev->buf + *ppos, count)) {
        mutex_unlock(&dev->lock);
        return -EFAULT;
    }

    *ppos += count;
    ret = count;

    mutex_unlock(&dev->lock);
    pr_info("mychardev: read %zu bytes, pos=%lld\n", count, *ppos);
    return ret;
}

static ssize_t my_write(struct file *filp, const char __user *buf,
                        size_t count, loff_t *ppos)
{
    struct mychar_dev *dev = filp->private_data;
    ssize_t ret;

    mutex_lock(&dev->lock);

    /* 缓冲区已*/
    if (*ppos >= BUF_SIZE) {
        mutex_unlock(&dev->lock);
        return -ENOSPC;
    }

    /* 限制写入长度不超过缓冲区剩余空间 */
    if (count > BUF_SIZE - *ppos)
        count = BUF_SIZE - *ppos;

    /* 从用户空间拷贝数*/
    if (copy_from_user(dev->buf + *ppos, buf, count)) {
        mutex_unlock(&dev->lock);
        return -EFAULT;
    }

    *ppos += count;
    if (*ppos > dev->buf_len)
        dev->buf_len = *ppos;

    ret = count;

    mutex_unlock(&dev->lock);
    pr_info("mychardev: wrote %zu bytes, pos=%lld\n", count, *ppos);
    return ret;
}

static long my_ioctl(struct file *filp, unsigned int cmd,
                     unsigned long arg)
{
    struct mychar_dev *dev = filp->private_data;
    int val;

    /* 校验魔数*/
    if (_IOC_TYPE(cmd) != MYCHAR_MAGIC)
        return -ENOTTY;

    switch (cmd) {
    case MYCHAR_RESET:
        mutex_lock(&dev->lock);
        memset(dev->buf, 0, BUF_SIZE);
        dev->buf_len = 0;
        mutex_unlock(&dev->lock);
        pr_info("mychardev: buffer reset\n");
        break;

    case MYCHAR_GET_SIZE:
        mutex_lock(&dev->lock);
        val = (int)dev->buf_len;
        mutex_unlock(&dev->lock);
        if (copy_to_user((int __user *)arg, &val, sizeof(val)))
            return -EFAULT;
        break;

    case MYCHAR_SET_SIZE:
        if (copy_from_user(&val, (int __user *)arg, sizeof(val)))
            return -EFAULT;
        if (val < 0 || val > BUF_SIZE)
            return -EINVAL;
        mutex_lock(&dev->lock);
        dev->buf_len = val;
        mutex_unlock(&dev->lock);
        break;

    case MYCHAR_EXCHANGE:
        if (copy_from_user(&val, (int __user *)arg, sizeof(val)))
            return -EFAULT;
        mutex_lock(&dev->lock);
        /* 返回当前缓冲区长度，同时设置新*/
        {
            int old = (int)dev->buf_len;
            if (val >= 0 && val <= BUF_SIZE)
                dev->buf_len = val;
            mutex_unlock(&dev->lock);
            if (copy_to_user((int __user *)arg, &old, sizeof(old)))
                return -EFAULT;
        }
        break;

    default:
        return -ENOTTY;
    }

    return 0;
}

/* file_operations：驱动与VFS的接*/
static const struct file_operations my_fops = {
    .owner          = THIS_MODULE,
    .open           = my_open,
    .release        = my_release,
    .read           = my_read,
    .write          = my_write,
    .unlocked_ioctl = my_ioctl,
};

static int __init my_init(void)
{
    int ret;

    /* 1. 动态分配设备号 */
    ret = alloc_chrdev_region(&devt, 0, 1, DEVICE_NAME);
    if (ret < 0) {
        pr_err("mychardev: alloc_chrdev_region failed (%d)\n", ret);
        return ret;
    }
    pr_info("mychardev: major=%d minor=%d\n", MAJOR(devt), MINOR(devt));

    /* 2. 初始化cdev */
    cdev_init(&mydev.cdev, &my_fops);
    mydev.cdev.owner = THIS_MODULE;

    /* 3. 分配缓冲*/
    mydev.buf = kzalloc(BUF_SIZE, GFP_KERNEL);
    if (!mydev.buf) {
        ret = -ENOMEM;
        goto err_unregister;
    }
    mydev.buf_len = 0;
    mutex_init(&mydev.lock);

    /* 4. 添加cdev到内存*/
    ret = cdev_add(&mydev.cdev, devt, 1);
    if (ret < 0) {
        pr_err("mychardev: cdev_add failed (%d)\n", ret);
        goto err_free_buf;
    }

    /* 5. 创建设备类（Linux 6.4+ 不再需要THIS_MODULE参数）*/
    myclass = class_create(CLASS_NAME);
    if (IS_ERR(myclass)) {
        pr_err("mychardev: class_create failed\n");
        ret = PTR_ERR(myclass);
        goto err_cdev_del;
    }

    /* 6. 创建设备节点 */
    mydevice = device_create(myclass, NULL, devt, NULL, DEVICE_NAME);
    if (IS_ERR(mydevice)) {
        pr_err("mychardev: device_create failed\n");
        ret = PTR_ERR(mydevice);
        goto err_class_destroy;
    }

    pr_info("mychardev: loaded, /dev/%s ready\n", DEVICE_NAME);
    return 0;

err_class_destroy:
    class_destroy(myclass);
err_cdev_del:
    cdev_del(&mydev.cdev);
err_free_buf:
    kfree(mydev.buf);
err_unregister:
    unregister_chrdev_region(devt, 1);
    return ret;
}

static void __exit my_exit(void)
{
    device_destroy(myclass, devt);
    class_destroy(myclass);
    cdev_del(&mydev.cdev);
    kfree(mydev.buf);
    mutex_destroy(&mydev.lock);
    unregister_chrdev_region(devt, 1);
    pr_info("mychardev: unloaded\n");
}

module_init(my_init);
module_exit(my_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("linuxros");
MODULE_DESCRIPTION("Character device driver example for Linux 6.8");

obj-m += mychardev.o

KDIR ?= /lib/modules/$(shell uname -r)/build

all:
    make -C $(KDIR) M=$(PWD) modules

clean:
    make -C $(KDIR) M=$(PWD) clean

// test_mychardev.c - 用户空间测试程序
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>

#define DEVICE_PATH "/dev/mychardev"

#define MYCHAR_MAGIC  'k'
#define MYCHAR_RESET     _IO(MYCHAR_MAGIC, 0)
#define MYCHAR_GET_SIZE  _IOR(MYCHAR_MAGIC, 1, int)
#define MYCHAR_SET_SIZE  _IOW(MYCHAR_MAGIC, 2, int)
#define MYCHAR_EXCHANGE  _IOWR(MYCHAR_MAGIC, 3, int)

int main(void)
{
    int fd;
    char wbuf[] = "Hello from user space!";
    char rbuf[64] = {0};
    int val;

    fd = open(DEVICE_PATH, O_RDWR);
    if (fd < 0) {
        perror("open");
        return EXIT_FAILURE;
    }

    /* 写入测试 */
    if (write(fd, wbuf, strlen(wbuf)) < 0) {
        perror("write");
        close(fd);
        return EXIT_FAILURE;
    }
    printf("Written: %s\n", wbuf);

    /* ioctl: 获取缓冲区数据长*/
    if (ioctl(fd, MYCHAR_GET_SIZE, &val) < 0) {
        perror("ioctl GET_SIZE");
        close(fd);
        return EXIT_FAILURE;
    }
    printf("Buffer data length: %d\n", val);

    /* 回到起始位置读取 */
    lseek(fd, 0, SEEK_SET);
    if (read(fd, rbuf, sizeof(rbuf) - 1) < 0) {
        perror("read");
        close(fd);
        return EXIT_FAILURE;
    }
    printf("Read back: %s\n", rbuf);

    /* ioctl: 交换——传入新长度，返回旧长度 */
    val = 10;
    if (ioctl(fd, MYCHAR_EXCHANGE, &val) < 0) {
        perror("ioctl EXCHANGE");
        close(fd);
        return EXIT_FAILURE;
    }
    printf("Exchange: old_len=%d, set new_len=10\n", val);

    /* ioctl: 重置缓冲*/
    if (ioctl(fd, MYCHAR_RESET) < 0) {
        perror("ioctl RESET");
        close(fd);
        return EXIT_FAILURE;
    }
    printf("Buffer reset done\n");

    close(fd);
    return EXIT_SUCCESS;
}

# 编译驱动
make

# 加载模块
sudo insmod mychardev.ko

# 查看分配的设备号
dmesg | grep mychardev | tail -3

# 编译测试程序
gcc -o test_mychardev test_mychardev.c

# 运行测试
sudo ./test_mychardev

# 卸载模块
sudo rmmod mychardev

_IOC_TYPE(cmd)   // 提取魔数。_IOC_NR(cmd)     // 提取序号
_IOC_DIR(cmd)    // 提取方向
_IOC_SIZE(cmd)   // 提取数据大小

struct miscdevice {
    int              minor;      // 次设备号，MISC_DYNAMIC_MINOR表示自动分配
    const char      *name;       // 设备名，/dev/下的节点。    const struct file_operations *fops;  // file_operations
    struct list_head list;       // 内核内部链表
    struct device   *parent;     // 父设。    struct device   *this_device;// 内核创建的device指针
    const struct attribute_group **groups;
    const char      *nodir_name;
};

int misc_register(struct miscdevice *misc);    // 注册
void misc_deregister(struct miscdevice *misc); // 注销

// led_misc.c - LED控制杂项设备驱动（Linux 6.8。#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
#include <linux/uaccess.h>

#define DEVICE_NAME "myled"

/* 模拟LED状态*/
static int led_state = 0;

static int led_open(struct inode *inode, struct file *filp)
{
    pr_info("myled: opened\n");
    return 0;
}

static int led_release(struct inode *inode, struct file *filp)
{
    pr_info("myled: closed\n");
    return 0;
}

static ssize_t led_read(struct file *filp, char __user *buf,
                        size_t count, loff_t *ppos)
{
    char state_str[2];

    if (*ppos > 0)
        return 0;  /* 只读一*/

    state_str[0] = led_state ? '1' : '0';
    state_str[1] = '\n';

    if (count < 2)
        return -EINVAL;

    if (copy_to_user(buf, state_str, 2))
        return -EFAULT;

    *ppos = 2;
    return 2;
}

static ssize_t led_write(struct file *filp, const char __user *buf,
                         size_t count, loff_t *ppos)
{
    char kbuf[4] = {0};

    if (count > sizeof(kbuf) - 1)
        count = sizeof(kbuf) - 1;

    if (copy_from_user(kbuf, buf, count))
        return -EFAULT;

    if (kbuf[0] == '1') {
        led_state = 1;
        pr_info("myled: LED ON\n");
    } else if (kbuf[0] == '0') {
        led_state = 0;
        pr_info("myled: LED OFF\n");
    } else {
        return -EINVAL;
    }

    return count;
}

static long led_ioctl(struct file *filp, unsigned int cmd,
                      unsigned long arg)
{
    switch (cmd) {
    case 0:  /* 关灯 */
        led_state = 0;
        pr_info("myled: ioctl LED OFF\n");
        break;
    case 1:  /* 开销*/
        led_state = 1;
        pr_info("myled: ioctl LED ON\n");
        break;
    default:
        return -ENOTTY;
    }
    return 0;
}

static const struct file_operations led_fops = {
    .owner          = THIS_MODULE,
    .open           = led_open,
    .release        = led_release,
    .read           = led_read,
    .write          = led_write,
    .unlocked_ioctl = led_ioctl,
};

/* 杂项设备定义 */
static struct miscdevice led_misc = {
    .minor = MISC_DYNAMIC_MINOR,  /* 自动分配次设备号 */
    .name  = DEVICE_NAME,         /* /dev/myled */
    .fops  = &led_fops,
};

static int __init led_init(void)
{
    int ret;

    ret = misc_register(&led_misc);
    if (ret < 0) {
        pr_err("myled: misc_register failed (%d)\n", ret);
        return ret;
    }

    pr_info("myled: registered, /dev/%s ready\n", DEVICE_NAME);
    return 0;
}

static void __exit led_exit(void)
{
    misc_deregister(&led_misc);
    pr_info("myled: unregistered\n");
}

module_init(led_init);
module_exit(led_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("linuxros");
MODULE_DESCRIPTION("LED misc device driver example for Linux 6.8");

# 加载驱动
sudo insmod led_misc.ko

# 开销echo 1 | sudo tee /dev/myled

# 关灯
echo 0 | sudo tee /dev/myled

# 读取状态cat /dev/myled

# 卸载
sudo rmmod led_misc

/* 创建*/
struct class *cls = class_create("my_class");

/* 创建设备节点，自动触发udev */
struct device *dev = device_create(cls, NULL, devt, NULL, "mydev");

/* 销*/
device_destroy(cls, devt);
class_destroy(cls);

# 格式：mknod 设备路径 c 主设备号 次设备号
sudo mknod /dev/mychardev c 240 0

# 设置权限
sudo chmod 666 /dev/mychardev

# 删除节点
sudo rm /dev/mychardev

# 查看是否已挂载devtmpfs
mount | grep devtmpfs

# 手动挂载（嵌入式系统启动脚本中）
mount -t devtmpfs devtmpfs /dev

# /etc/udev/rules.d/99-mychardev.rules
# mychardev设备：所有用户可读写
KERNEL=="mychardev", MODE="0666"

# 指定用户。KERNEL=="mychardev", GROUP="dialout", MODE="0660"

sudo udevadm control --reload-rules
sudo udevadm trigger