Linux内核API device_unregister

函数device_unregister()在实现过程中调用了函数device_del()，用于从Linux内核系统设备驱动程序模型中移除一个设备，并删除/sys/devices/virtual目录下对应的设备目录及/dev目录下对应的设备文件。

device_unregister文件包含

#include <linux/device.h>

device_unregister函数定义

在内核源码中的位置：linux-3.19.3/drivers/base/core.c

函数定义格式：

void device_unregister(struct device *dev)

device_unregister输入参数说明

• 参数dev是struct device结构体类型的指针，代表函数即将被删除的逻辑设备，此结构体的定义在极客笔记函数device_create()分析中已有详细说明。

device_unregister返回参数说明

• 函数device_unregister()的返回结果都是void类型的变量，即不返回任何值。

device_unregister实例解析

实例说明：此实例不是简单地说明函数device_register()、device_unregister()的作用，而是通过编写一个完整的字符设备驱动程序，在驱动程序中说明函数的作用，并进一步体现函数在驱动程序实现中的作用。

编写测试文件：device_register_unregister.c

头文件引用、全局变量定义及相关函数声明：

/*头文件引用*/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>
#include <linux/types.h>
#include <linux/moduleparam.h>
#include <linux/pci.h>
#include <asm/unistd.h>
#include <linux/device.h>

MODULE_LICENSE("GPL");

/*宏定义及全局变量定义*/
#define MEM_MALLOC_SIZE   4096       //缓冲区大小
#define MEM_MAJOR         245        //主设备号
#define MEM_MINOR         0          //次设备号
char *mem_spvm;                     //缓冲区指针，指向内存区
struct class *mem_class;            //设备类指针
struct device *dev;                 //逻辑设备类指针

static int  __init  device_register_unregister_init(void);         //模块加载函数声明
static void  __exit device_register_unregister_exit(void);         //模块卸载函数声明
static int mem_open(struct inode *ind, struct file *filp);       //设备打开函数声明
static int mem_release(struct inode *ind, struct file *filp);    //设备关闭函数声明

/*设备读函数声明*/
static ssize_t mem_read(struct file *filp, char __user *buf, size_t size, loff_t *fpos);

/*设备写函数声明*/
static ssize_t mem_write(struct file *filp, const char __user *buf, size_t size,loff_t *fpos);
static void device_register_release(struct device *dev);     //逻辑设备释放处理函数

/*定义设备驱动文件结构体*/
struct file_operations mem_fops =
{
    .owner=THIS_MODULE,              //设备文件拥有者
    .open = mem_open,                //设备打开函数
    .release = mem_release,          //设备打开函数
    .read = mem_read,                //设备读函数
    .write = mem_write,            //设备写函数
};

模块加载函数定义：

int __init device_register_unregister_init(void)
{
    int res;
    printk("into device_initialize_add_del_init\n");
    mem_spvm = (char *)vmalloc(MEM_MALLOC_SIZE);                    //开辟内存缓冲区
    res=register_chrdev(MEM_MAJOR, "my_char_dev", &mem_fops); //注册字符设备
    if(res)                                                          //注册失败
    {
        unregister_chrdev(MEM_MAJOR, "my_char_dev");                 //删除字符设备
        printk("register char dev failed\n");
        return -1;
    }
    printk("register char dev success\n");
    mem_class = class_create(THIS_MODULE, "my_char_dev");            //创建设备类
    if(IS_ERR(mem_class))                                            //判断创建是否成功
    {
            printk("failed in creating class.\n");
            class_destroy(mem_class);                                //失败，则销毁设备类
            return -1;
    }
    printk("class create success\n");
    dev=kzalloc(sizeof(*dev), GFP_KERNEL);                      //为逻辑设备开辟内存空间
    dev->devt=MKDEV(MEM_MAJOR, MEM_MINOR);                       //初始化逻辑设备设备号
    dev->class=mem_class;                                        //初始化设备类
    dev->release = device_register_release;                      //初始化设备注销处理函数
    res= kobject_set_name(&dev->kobj, "my_char_dev");            //初始化设备引用计数器
    if(res)
    {
        printk("kobject_set_name_vargs failed\n");
        kfree(dev);                         //失败，释放逻辑设备占用的内存空间
        return -1;
    }
    res=device_register(dev);               //将新创建的逻辑设备加入Linux内核系统
    if(res)
    {
        printk("register device failed\n");
        device_unregister(dev);             //失败，则注销逻辑设备
        kfree(dev);                         //失败，释放逻辑设备的内存空间
        return -1;
    }
    printk("register device success\n");
    printk("out device_register_unregister_init\n");
    return 0;
}

模块退出函数定义：

void __exit device_register_unregister_exit (void)
{
    printk("into device_register_unregister_exit\n");
    unregister_chrdev(MEM_MAJOR, "my_char_dev");            //注销字符设备
    if (dev)
    {
        device_unregister(dev);                             //删除逻辑设备
    }
    printk("device unregister success\n");
    if (mem_class)
        class_destroy(mem_class);                           //删除设备类
    printk("class destroy success\n");
    if (mem_spvm ! = NULL)
        vfree(mem_spvm);                                    //释放内存缓冲区空间
    printk("vfree mem_spvm OK\n");
    printk("out device_register_unregister_exit\n");
}

相关函数定义：

/*设备打开函数定义*/
int mem_open(struct inode *ind, struct file *filp)
{
    printk("open vmalloc space\n");
    try_module_get(THIS_MODULE);                           //模块引用自加
    printk("open vmalloc space success\n");
    return 0;
}

/*设备读函数定义*/
ssize_t mem_read(struct file *filp, char *buf, size_t size, loff_t *lofp)
{
    int res = -1;
    char *tmp;
    printk("copy data to the user space\n");
    tmp = mem_spvm;
    if (size > MEM_MALLOC_SIZE)                            //判断读取数据的大小
        size = MEM_MALLOC_SIZE;
    if (tmp ! = NULL)
        res = copy_to_user(buf, tmp, size);                //将内核输入写入用户空间
    if (res == 0)
    {
        printk("copy data success and the data is:%s\n", tmp);     //显示读取的数据
        return size;
    }
    else
    {
        printk("copy data fail to the user space\n");
        return 0;
    }
}

/*设备写函数定义*/
ssize_t mem_write(struct file *filp, const char *buf, size_t size, loff_t *lofp)
{
    int res = -1;
    char *tmp;
    printk("read data from the user space\n");
    tmp = mem_spvm;
    if (size > MEM_MALLOC_SIZE)                               //判断输入数据的大小
        size = MEM_MALLOC_SIZE;
    if (tmp ! = NULL)
        res = copy_from_user(tmp, buf, size);                 //将用户输入数据写入内核空间
    if (res == 0)
    {
        printk("read data success and the data is:%s\n", tmp);     //显示写入的数据
        return size;
    }
    else
    {
        printk("read data from user space fail\n");
        return 0;
    }
}

/*设备关闭函数定义*/
int mem_release(struct inode *ind, struct file *filp)
{
    printk("close vmalloc space\n");
    module_put(THIS_MODULE);                                  //模块引用计数器自减
    printk("close vmalloc space success\n");
    return 0;
}

/*逻辑设备释放处理函数*/
static void device_register_release(struct device *dev)
{
    pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
    kfree(dev);                                               //释放设备占用的内存空间
}

模块加载、退出函数调用：

module_init(device_register_unregister_init);               //模块加载
module_exit(device_register_unregister_exit);               //模块卸载

用户态测试函数：

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <linux/fcntl.h>
int main(int argc, char **argv)
{
    int fd, cnt;
    char buf[256];
    printf("char device testing.\n");
    fd = open("/dev/my_char_dev", O_RDWR);                    //打开字符设备
    if (fd == 0)
    {
        printf("the char dev file cannot be opened.\n");
        return 1;
    }
    printf("input the data for kernel: ");
    scanf("%s", buf);                                         //输入数据
    cnt = write(fd, buf, 256);                                //将输入数据写入设备
    if (cnt == 0)
        printf("Write Error! \n");
    cnt = read(fd, buf, 256);                                 //从设备中读取数据
    if (cnt > 0)
        printf("read data from kernel is: %s\n", buf);
    else
        printf("read data error\n");
    close(fd);                                                //关闭设备
    printf("close the char dev file and test over\n");
    return 0;
}

实例运行结果及分析

首先编译模块，执行命令insmod device_register_unregister.ko插入内核模块，然后输入命令dmesg -c查看模块插入结果，会出现如图A所示的结果。

执行命令ls /dev查看当前系统的设备文件，出现如图B所示的结果。

执行命令ls /sys/devices/virtual/my_char_dev/my_char_dev查看逻辑设备目录，出现如图C所示的结果。

用gcc编译器编译用户驱动测试文件，运行编译之后的可执行文件，出现如图D所示的结果。

用户测试程序执行完之后，输入命令dmesg -c，出现如图E所示的执行结果。

删除内核模块，执行命令rmmod device_register_unregister.ko，然后输入命令dmesg -c，出现如图F所示的信息。

结果分析：

由图A至图C可以看出设备驱动添加成功，逻辑设备目录及设备文件的创建都成功，说明函数device_register()是成功执行的，并完成了其相应的作用。图D是用户态的测试程序显示的结果，与图E进行对比可以说明设备驱动程序的添加是成功的。图F是模块卸载之后的显示结果，当命令rmmod device_initialize_add_del.ko执行之后，重新执行命令ls /dev和命令ls /sys/devices/virtual/my_char_dev，可以看出不会出现和图B、图C相同的结果，/dev目录下的设备文件my_char_dev会消失，/sys/devices/virtual/my_char_dev目录下的目录my_char_dev也会消失。