Linux字符驱动框架中错误标签的处理问题理解

话说在前面，错误标签的处理遵循先定义后处理的原则

以上是标签的一些使用方法以及定义

#include <linux/module.h>
#include <linux/kernel.h>
#include<linux/init.h>
#include<linux/moduleparam.h>
#include<linux/types.h>
#include<linux/kdev_t.h>
#include<linux/fs.h>
#include<linux/cdev.h>
#include<linux/device.h>
#include<linux/uaccess.h>
#include<linux/errno.h>

   struct device_test={
        struct cdev cdev_test;
        dev_t dev_num;
        struct class *class;
        struct device *device;
        int major;
        int minor;
        char kbuf[32];
    };

struct device_test dev1;
struct device_test dev2;

static int cdev_test_open(struct inode *inode,struct file *file)
{
    dev1.minor=0;
    dev2.minor=1;
    file->private_data=container_of(inode->i_cdev,struct device_test,cdev_test);
    printk("This is cdev_test_open\n");
    return 0;
}
static ssize_t cdev_test_write(struct file *file,const char __user *buf,size_t size,loff_t *off)
{
    struct device_test *test_dev=(struct device_test*)file->private_data;
    
    if (size > sizeof(test_dev->kbuf)) {
        printk(KERN_ERR "Write size exceeds buffer\n");
        return -EINVAL;
    }
    if (test_dev->minor==0)
    {
          if(copy_from_user(test_dev->kbuf,buf,size)!=0)
    {

        printk("copy_from_user error\n");
        return -1;
    }
    printk("copy_from_user test_dev->kbuff %s\n",test_dev->kbuf);
  
    }
    else if (test_dev->minor==1)
    {
        if(copy_from_user(test_dev->kbuf,buf,size)!=0)
    {

        printk("copy_from_user error\n");
        return -1;
    }
    printk("copy_from_user test_dev->kbuf %s\n",test_dev->kbuf);
       
        
    }
    
   
    return 0;
}
static ssize_t cdev_test_read(struct file *file,char __user *buf,size_t size,loff_t *off)
{
    struct device_test *test_dev=(struct device_test*)file->private_data;
    
    if(copy_to_user(buf,test_dev->kbuf,strlen(test_dev->kbuf))!=0)
    {

        printk("copy_to_user error\n");
        return -1;
    }
    
    printk("This is cdev_test_read\n");
    return 0;
}
static int cdev_test_release(struct inode *inode,struct file *file)
{

    printk("This is cdev_test_release\n");
    return 0;
}
static struct file_operations cdev_test_ops={
    .owner=THIS_MODULE,
    .open=cdev_test_open,
    .read=cdev_test_read,
    .write=cdev_test_write,
    .release=cdev_test_release,
};
//驱动入口函数
static int __init modulecdev_init(void)
{
  
    int ret;
    

   //自动申请设备节点
   ret=alloc_chrdev_region(&dev1.dev_num,0,2,"alloc_name");
   if(ret<0){
     goto err_chrdev1;
      
          } 
          printk("alloc_chrdev_region is ok\n");
          dev1.major=MAJOR(dev1.dev_num);
          dev1.minor=MINOR(dev1.dev_num);
          printk("major is %d\n",dev1.major); 
          printk("minor is %d\n",dev1.minor);

    dev1.cdev_test.owner=THIS_MODULE;//初始化cdev

    cdev_init(&dev1.cdev_test,&cdev_test_ops);

    cdev_add(&dev.cdev_test,dev1.dev_num,1);//添加一个cdev结构构体，完成设备注册到内核
    if(ret<0){
        goto err_chr_add1;
         
             } 

    dev1.class=class_create(THIS_MODULE,"test1");//创建类
    if(IS_ERR(dev1.class))
    {
        ret=PTR_ERR(dev1.class);
        goto err_class_create1;
    }

    dev1.device=device_create(dev1.class,NULL,dev1.dev_num,NULL,"test1");//创建设备
    if(IS_ERR(dev1.device))
    {
        ret=PTR_ERR(dev1.device);
        goto err_device_create1;
    }




    dev2.major=MAJOR(dev1.dev_num+1);
    dev2.minor=MINOR(dev1.dev_num+1);
    printk("major is %d\n",dev2.major); 
    printk("minor is %d\n",dev2.minor);
    dev2.cdev_test.owner=THIS_MODULE;//初始化cdev
    cdev_init(&dev2.cdev_test,&cdev_test_ops);

    cdev_add(&dev2.cdev_test,dev1.dev_num+1,1);//添加一个cdev结构构体，完成设备注册到内核
    if(ret<0){
        goto err_chr_add2;
         
             } 
    dev2.class=class_create(THIS_MODULE,"test2");//创建类
    if(IS_ERR(dev2.class))
    {
        ret=PTR_ERR(dev2.class);
        goto err_class_create1;
    }

    dev2.device=device_create(dev2.class,NULL,dev1.dev_num+1,NULL,"test2");
    if(IS_ERR(dev2.device))
    {
        ret=PTR_ERR(dev2.device);
        goto err_device_create2;
    }
    return 0;
    err_device_create2:
        class_destroy(dev2.class,dev1.dev_num+1);//2删除类
     
    err_class_create2:
        cdev_del(&dev2.cdev_test);//2删除cdev

    err_chr_add2:
        unregister_chrdev_region(dev1.dev_num+1,1);//2注销设备号

    err_device_create1:
        class_destroy(dev1.class,dev1.dev_num+1);//1删除类
     
    err_class_create1:
        cdev_del(&dev1.cdev_test);//1删除cdev

    err_chr_add1:
        unregister_chrdev_region(dev1.dev_num+1,1);//1注销设备号
    
    err_chrdev:
        return ret;
}
static void __exit modulecdev_exit(void)
{
    unregister_chrdev_region(dev1.dev_num,1);
    cdev_del(&dev1.cdev_test);
    device_destroy(dev1.class,dev1.dev_num);
    class_destroy(dev1.class);


    unregister_chrdev_region(dev1.dev_num+1,1);
    cdev_del(&dev2.cdev_test);
    device_destroy(dev2.class,dev1.dev_num+1);
    class_destroy(dev2.class);
    printk(KERN_EMERG "Goodbye, cruel world\r\n");
}
module_init(modulecdev_init);
module_exit(modulecdev_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("zhangsan");
MODULE_DESCRIPTION("A simple Hello World module");
MODULE_ALIAS("A simple module");
MODULE_VERSION("V1.0");

// 初始化顺序
ret = alloc_chrdev_region(...);                 // [1]
cdev_add(&dev1.cdev_test, ...);                 // [2]
dev1.class = class_create(...);                 // [3]
dev1.device = device_create(...);               // [4]
cdev_add(&dev2.cdev_test, ...);                 // [5]
dev2.class = class_create(...);                 // [6]
dev2.device = device_create(...);               // [7]

// 错误处理标签（逆序）
err_device2:
    device_destroy(dev2.class, dev2.dev_num);   // [7]
err_class2:
    class_destroy(dev2.class);                  // [6]
err_cdev2:
    cdev_del(&dev2.cdev_test);                  // [5]
err_device1:
    device_destroy(dev1.class, dev1.dev_num);   // [4]
err_class1:
    class_destroy(dev1.class);                  // [3]
err_cdev1:
    cdev_del(&dev1.cdev_test);                  // [2]
err_alloc:
    unregister_chrdev_region(dev1.dev_num, 2); // [1]

对于代码还有还可以进一步优化，使用两次 unregister_chrdev_region 分别释放 dev1 和 dev2 的设备号，但 alloc_chrdev_region 一次性分配了两个连续设备号，必须统一释放整个区间。推荐统一释放：无论设备号是否连续，建议在模块退出时统一释放所有设备号，避免因遗漏或参数错误导致内核不稳定。

可以两个设备共享一个设备类，

共享设备类
优化为共享一个 class（dev1.class），简化资源管理

设备号分配逻辑问题

1. ​次设备号计算错误
   alloc_chrdev_region(&dev1.dev_num, 0, 2, "alloc_name")会分配连续的设备号（主设备号相同，次设备号从0开始）。

   • 错误代码：dev2.minor = MINOR(dev1.dev_num + 1)
   • 正确做法：直接通过dev2.dev_num = dev1.dev_num + 1获取第二个设备号，然后提取次设备号​设备号范围越界若主设备号已达最大值（通常为2^12-1），
   • dev1.dev_num + 1可能导致主设备号递增。
   • 建议通过MKDEV(MAJOR(dev1.dev_num), MINOR(dev1.dev_num) + 1)生成第二个设

优化的代码为：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include <linux/err.h>

static int __init modulecdev_init(void) {
    int ret;
    dev_t base_dev;

    // 分配设备号（连续两个）
    ret = alloc_chrdev_region(&base_dev, 0, 2, "test_devices");
    if (ret < 0) goto err_alloc;

    // 初始化 dev1
    dev1.dev_num = base_dev;
    cdev_init(&dev1.cdev_test, &cdev_test_ops);
    ret = cdev_add(&dev1.cdev_test, dev1.dev_num, 1);
    if (ret < 0) goto err_cdev1;

    // 创建共享的 class
    dev1.class = class_create(THIS_MODULE, "test_class");
    if (IS_ERR(dev1.class)) {
        ret = PTR_ERR(dev1.class);
        goto err_class1;
    }

    // 创建设备 dev1
    dev1.device = device_create(dev1.class, NULL, dev1.dev_num, NULL, "test1");
    if (IS_ERR(dev1.device)) {
        ret = PTR_ERR(dev1.device);
        goto err_device1;
    }

    // 初始化 dev2
    dev2.dev_num = MKDEV(MAJOR(base_dev), MINOR(base_dev) + 1);
    cdev_init(&dev2.cdev_test, &cdev_test_ops);
    ret = cdev_add(&dev2.cdev_test, dev2.dev_num, 1);
    if (ret < 0) goto err_cdev2;

    // 创建设备 dev2（使用共享的 class）
    dev2.device = device_create(dev1.class, NULL, dev2.dev_num, NULL, "test2");
    if (IS_ERR(dev2.device)) {
        ret = PTR_ERR(dev2.device);
        goto err_device2;
    }

    return 0;

//------------------------- 错误处理（严格逆序） -------------------------//
err_device2:
    cdev_del(&dev2.cdev_test);     // 删除 dev2 的 cdev
err_cdev2:
    device_destroy(dev1.class, dev1.dev_num); // 销毁 dev1 的设备
err_device1:
    class_destroy(dev1.class);     // 销毁共享的 class
err_class1:
    cdev_del(&dev1.cdev_test);     // 删除 dev1 的 cdev
err_cdev1:
    unregister_chrdev_region(base_dev, 2); // 释放整个设备号区间
err_alloc:
    return ret;
}

static void __exit modulecdev_exit(void) {
    //------------------------- 逆序释放所有资源 -------------------------//
    device_destroy(dev1.class, dev2.dev_num); // 销毁 dev2 的设备
    device_destroy(dev1.class, dev1.dev_num); // 销毁 dev1 的设备
    class_destroy(dev1.class);                // 销毁共享的 class
    cdev_del(&dev2.cdev_test);                // 删除 dev2 的 cdev
    cdev_del(&dev1.cdev_test);                // 删除 dev1 的 cdev
    unregister_chrdev_region(dev1.dev_num, 2); // 释放设备号
    printk(KERN_EMERG "Driver unloaded\n");
}