如何在Linux系统下自动创建设备节点

　　第一：自动创建设备节点方法

　　1、使用 class_create 函数创建一个类。

　　2、使用 device_create 函数在我们创建的类下面创建一个设备。

　　第二：自动创建设备节点简介

　　Linux驱动实验中，通过使用insmod命令加载模块后，需要通过mknod命令手动创建设备节点，这样使用起来比较麻烦，并且不可能每个设备都这样操作， Linux 系统的存在就是为了方便使用， 所以我们来看一下如何实现自动创建设备节点， 当加载模块时， 在/dev 目录下自动创建相应的设备文件。怎么自动创建一个设备节点呢?在嵌入式 Linux 中使用 mdev 来实现设备节点文件的自动创建和删除。

　　udev 是一种工具， 它能够根据系统中的硬件设备的状态动态更新设备文件， 包括设备文件的创建， 删除等。设备文件通常放在/dev 目录下。使用 udev 后， 在/dev 目录下就只包含系统中真正存在的设备。而mdev 是 udev 的简化版本,是 busybox 中所带的程序,最适合用在嵌入式系统,而 udev 一般用在 PC 上的linux 中,相对 mdev 来说要复杂些， 所以在嵌入式 Linux 中使用 mdev 来实现设备节点文件的自动创建和删除。

　　第三：创建和删除类函数

　　内核中定义了struct class结构体，一个struct class结构体类型变量对应一个类，内核同时提供了class_create用来创建一个类，这个类存放于 sysfs 下面， 一旦创建好了这个类， 再调用 device_create来在/dev 目录下创建相应的设备节点。这样， 加载模块的时候， 用户空间中的 udev 会自动响应 device_create，去/sysfs 下寻找对应的类从而创建设备节点。

　　在 Linux 驱动程序中一般通过 class_create 和 class_destroy 来完成设备节点的创建和删除。首先要创建一个 class 类结构体， class 结构体定义在 include/linux/device.h 里面。class_create 是个宏， 宏定义如下：#define class_create(owner, name) 

({ 
static struct lock_class_key __key; 
__class_create(owner, name, &__key); 
})
 
struct class *__class_create(struct module *owner, const char *name,struct lock_class_key *key)

    class_create一共有两个参数，参数 owner 一般为 THIS_MODULE， 参数 name 是类名字。返回值是个指向结构体 class 的指针， 也就是创建的类。

void class_destroy(struct class *cls);//参数 cls 就是要删除的类。

     当使用上节的函数创建完成一个类后，使用device_create 函数在这个类下创建一个设备。

struct device *device_create(struct class *class,
struct device *parent,
dev_t devt,
void *drvdata,
const char *fmt, ...)

device_create是个可变参数函数，参数class就是设备要创建哪个类下面；参数parent是父设备，一般为NULL，也就是没有父设备；参数devt是设备号；参数drvdata是设备可能会使用的一些数据，一般为NULL；参数fmt是设备名字，如果设置fmt=xxx的话，就会生成/dev/xxx这个设备文件。返回值就是创建好的设备。同样的， 卸载驱动的时候需要删除掉创建的设备， 设备删除函数为 device_destroy， 函数原型如下：

void device_destroy(struct class *class, dev_t devt)

第五：创建类函数

chrdev.c文件完整代码如下所示：

#include  //初始化头文件
#include  //最基本的文件， 支持动态添加和卸载模块。
#include  //包含了文件操作相关 struct 的定义， 例如大名鼎鼎的struct file_operations
#include 
#include  //对字符设备结构 cdev 以及一系列的操作函数的定义。 
                        //包含了 cdev 结构及相关函数的定义。
 
#define DEVICE_NUMBER 1 //定义次设备号的个数
#define DEVICE_SNAME "schrdev" //定义静态注册设备的名称
#define DEVICE_ANAME "achrdev" //定义动态注册设备的名称
#define DEVICE_MINOR_NUMBER 0 //定义次设备号的起始地址
 
#include  //包含了 device、 class 等结构的定义
 
#define DEVICE_CLASS_NAME "chrdev_class" //宏定义类名
 
static int major_num, minor_num; //定义主设备号和次设备号
struct class *class; //定义类
struct cdev cdev;//定义一个 cdev 结构体
 
module_param(major_num, int, S_IRUSR); //驱动模块传入普通参数 major_num
module_param(minor_num, int, S_IRUSR); //驱动模块传入普通参数 minor_num
 
dev_t dev_num;
 
int chrdev_open(struct inode *inode, struct file *file)
{
    printk("chrdev_open
");
    return 0;
} 
 
struct file_operations chrdev_ops = {
.owner = THIS_MODULE,
.open = chrdev_open
};
 
static int hello_init(void)
{
    int ret; //函数返回值
    if (major_num)
    {
         /*静态注册设备号*/
         printk("major_num = %d
", major_num); //打印传入进来的主设备号
         printk("minor_num = %d
", minor_num); //打印传入进来的次设备号
         //MKDEV 将主设备号和次设备号合并为一个设备号
         dev_num = MKDEV(major_num, minor_num);
         ret = register_chrdev_region(dev_num, DEVICE_NUMBER, DEVICE_SNAME); //注册设备号
         if (ret < 0)
         {
              printk("register_chrdev_region error
");
         } 
         printk("register_chrdev_region ok
"); //静态注册设备号成功
    } 
    else
    {
         /*动态注册设备号*/
         ret = alloc_chrdev_region(&dev_num, DEVICE_MINOR_NUMBER, 1, DEVICE_ANAME);
         if (ret < 0)
         {
             printk("alloc_chrdev_region error
");
         } 
         printk("alloc_chrdev_region ok
"); //动态注册设备号成功
         major_num = MAJOR(dev_num); //将主设备号取出来
         minor_num = MINOR(dev_num); //将次设备号取出来
         printk("major_num = %d
", major_num); //打印传入进来的主设备号
         printk("minor_num = %d
", minor_num); //打印传入进来的次设备号
    } 
    cdev.owner = THIS_MODULE;
    //cdev_init 函数初始化 cdev 结构体成员变量
    cdev_init(&cdev, &chrdev_ops);
    //完成字符设备注册到内核
    cdev_add(&cdev, dev_num, DEVICE_NUMBER);
    //创建类
    class = class_create(THIS_MODULE, DEVICE_CLASS_NAME);
    return 0;
}
 
static void hello_exit(void)
{
    unregister_chrdev_region(MKDEV(major_num, minor_num), DEVICE_NUMBER);
    //注销设备号
    cdev_del(&cdev);
    //删除类
    class_destroy(class);
   printk("gooodbye! 
");
}
 
module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");

　　将代码编译成模块，利用驱动程序里面的Makefile文件。

　　编译并加载，如果创建类成功以后，会在开发板的/sys/class/下面生成一个名为“chrdev_class”的类。现在没有加载驱动的情况，如下图所示：ls /sys/class

　　第六：创建设备函数

　　在前面代码的基础上添加创建设备的代码，如下所示：

#include  //初始化头文件
#include  //最基本的文件， 支持动态添加和卸载模块。
#include  //包含了文件操作相关 struct 的定义， 例如struct file_operations
#include 
 
#include  //对字符设备结构 cdev 以及一系列的操作函数的定义。
                        //包含了 cdev 结构及相关函数的定义。
 
#define DEVICE_NUMBER 1 //定义次设备号的个数
#define DEVICE_SNAME "schrdev" //定义静态注册设备的名称
#define DEVICE_ANAME "achrdev" //定义动态注册设备的名称
#define DEVICE_MINOR_NUMBER 0 //定义次设备号的起始地址
 
#include  //包含了 device、 class 等结构的定义
 
#define DEVICE_CLASS_NAME "chrdev_class"
#define DEVICE_NODE_NAME "chrdev_test" //宏定义设备节点的名字
 
static int major_num, minor_num; //定义主设备号和次设备号
struct class *class; /* 类 */
struct device *device; /* 设备 */
struct cdev cdev; //定义一个 cdev 结构体
 
module_param(major_num, int, S_IRUSR); //驱动模块传入普通参数 major_num
module_param(minor_num, int, S_IRUSR); //驱动模块传入普通参数 minor_num
dev_t dev_num; /* 设备号 */
 
/***
* @description: 打开设备
* @param {structinode} *inode：传递给驱动的 inode
* @param {structfile} *file：设备文件， file 结构体有个叫做 private_data 的成员变量，
* 一般在 open 的时候将 private_data 指向设备结构体。
* @return: 0 成功;其他 失败
*/
int chrdev_open(struct inode *inode, struct file *file)
{
    printk("chrdev_open
");
    return 0;
}
 
// 设备操作函数结构体
struct file_operations chrdev_ops = {
.owner = THIS_MODULE,
.open = chrdev_open
};
 
/**
* @description: 驱动入口函数
* @param {*}无
* @return {*} 0 成功;其他 失败
*/
static int hello_init(void)
{
    int ret; //函数返回值
    if (major_num)
    {
        /*静态注册设备号*/
        printk("major_num = %d
", major_num); //打印传入进来的主设备号
        printk("minor_num = %d
", minor_num); //打印传入进来的次设备号
        dev_num = MKDEV(major_num, minor_num); 
        //MKDEV 将主设备号和次设备号合并为一个设备号
        ret = register_chrdev_region(dev_num, DEVICE_NUMBER, DEVICE_SNAME); //注册设备号
        if (ret < 0)
        {
            printk("register_chrdev_region error
");
        } 
        printk("register_chrdev_region ok
"); //静态注册设备号成功
    } 
    else
    {
        /*动态注册设备号*/
        ret = alloc_chrdev_region(&dev_num, DEVICE_MINOR_NUMBER, 1, DEVICE_ANAME);
        if (ret < 0)
        {
            printk("alloc_chrdev_region error
");
        }
        printk("alloc_chrdev_region ok
"); //动态注册设备号成功
        major_num = MAJOR(dev_num); //将主设备号取出来
        minor_num = MINOR(dev_num); //将次设备号取出来
        printk("major_num = %d
", major_num); //打印传入进来的主设备号
        printk("minor_num = %d
", minor_num); //打印传入进来的次设备号
    } 
    // 初始化 cdev
    cdev.owner = THIS_MODULE;
    cdev_init(&cdev, &chrdev_ops);
    // 向系统注册设备
    cdev_add(&cdev, dev_num, DEVICE_NUMBER);
    // 创建 class 类
    class = class_create(THIS_MODULE, DEVICE_CLASS_NAME);
    // 在 class 类下创建设备
    device = device_create(class, NULL, dev_num, NULL, DEVICE_NODE_NAME);
    return 0;
} 
 
/**
* @description: 驱动出口函数
* @param {*}无
* @return {*}无
*/
static void hello_exit(void)
{
    //注销设备号
    unregister_chrdev_region(MKDEV(major_num, minor_num), DEVICE_NUMBER);
    //删除设备
    cdev_del(&cdev);
    //注销设备
    device_destroy(class, dev_num);
    //删除类
    class_destroy(class);
    printk("gooodbye! 
");
} 
 
// 将上面两个函数指定为驱动的入口和出口函数
module_init(hello_init);
module_exit(hello_exit);
// LICENSE 和作者信息
MODULE_LICENSE("GPL");
MODULE_AUTHOR("zuomu");

    编写应用测试程序如下所示：

#include 
#include 
#include 
#include 
#include 
int main(int argc,char *argv[])
{
    int fd;
    char buf[64] = {0};
    fd = open("/dev/chrdev_test",O_RDWR); //打开设备节点
    if(fd < 0)
    {
         perror("open error 
");
         return fd;
    } 
    close(fd);
    return 0;
}

输入命令编译app.c ，利用驱动里面的Makefile文件实现。

第七：具体效果如下：

将前面加载的驱动卸载掉，再加载新编译好的的驱动， 如下图所示：
rmmod chrdev
insmod chrdev.ko

输入以下命令查看/sys/class 下面是否生成类， 如下图所示：ls /sys/class/chrdev_class/

输入以下命令查看下是否生成了设备节点ls /dev/chrdev_test

总结：利用标准字符驱动模型，自动生成设备节点，在开发过程具有重要意义。

审核编辑：郭婷