利用udev在/dev下动态生成/移除设备文件

用udev在/dev/下动态生成设备文件，这样用户就不用手工调用mknod了。

利用的kernel API：

class_create : 创建class
class_destroy : 销毁class
class_device_create : 创建device
class_device_destroy : 销毁device


注意，这些API是2.6.13开始有的，在2.6.13之前，应当使用

class_simple_create
class_simple_destroy
class_simple_device_add
class_simple_device_remove

这一系列，也就是ldd3第14章描述的。 详见:

https://lwn.net/Articles/128644/

Output:
===========================================
[root@localhost dynamic_dev_node]# insmod ./dummy_dev.ko
[root@localhost dynamic_dev_node]# file /dev/dummy_dev0
/dev/dummy_dev0: character special (250/0)
[root@localhost dynamic_dev_node]# rmmod dummy_dev.ko
[root@localhost dynamic_dev_node]# file /dev/dummy_dev0
/dev/dummy_dev0: ERROR: cannot open `/dev/dummy_dev0' (No such file or directory)




#include linux/kernel.h>
#include linux/module.h>
#include linux/init.h>
#include linux/mm.h>
#include linux/fs.h>
#include linux/types.h>
#include linux/delay.h>
#include linux/moduleparam.h>
#include linux/slab.h>
#include linux/errno.h>
#include linux/ioctl.h>
#include linux/cdev.h>
#include linux/string.h>
#include linux/list.h>
#include linux/pci.h>
#include asm/uaccess.h>
#include asm/atomic.h>
#include asm/unistd.h>



#define THIS_DESCRIPTION
This module is a dummy device driver, it registern
tta char device, and utilize udev to create/destroy n
ttdevice node under /dev/ dynamicallly.


MODULE_LICENSE(GPL);
MODULE_AUTHOR(albcamus albcamus@gmail.com>);
MODULE_DESCRIPTION(THIS_DESCRIPTION);



#define DUMMY_MAJOR 250
#define DUMMY_MINOR 0
#define DUMMY_NAME dummy_dev





/**
* the open routine of 'dummy_dev'
*/
static int dummy_open(struct inode *inode, struct file *file)
{
printk(Open OKn);
return 0;
}

/**
* the write routine of 'dummy_dev'
*/
static ssize_t dummy_write(struct file *filp, const char *bp, size_t count, loff_t *ppos)
{
printk(Don't Write!n);
return 0;
}

/**
* the read routine of 'dummy_dev'
*/
static ssize_t dummy_read(struct file *filp, char *bp, size_t count, loff_t *ppos)
{
return 0;
}

/**
* the ioctl routine of 'dummy_dev'
*/
static int dummy_ioctl(struct inode *inode, struct file *filep,
unsigned int cmd, unsigned long arg)
{

return 0;
}


/**
* file_operations of 'dummy_dev'
*/
static struct file_operations dummy_dev_ops = {
.owner = THIS_MODULE,
.open = dummy_open,
.read = dummy_read,
.write = dummy_write,
.ioctl = dummy_ioctl,
};


/**
* struct cdev of 'dummy_dev'
*/
struct cdev *my_cdev;
struct class *my_class;



static int __init my_init(void)
{
int err, devno = MKDEV(DUMMY_MAJOR, DUMMY_MINOR);


/* register the 'dummy_dev' char device */
my_cdev = cdev_alloc();
cdev_init(my_cdev, dummy_dev_ops);

my_cdev->owner = THIS_MODULE;

err = cdev_add(my_cdev, devno, 1);
if (err != 0)
printk(dummy pci device register failed!n);

/* creating your own class */
my_class = class_create(THIS_MODULE, dummy_class);
if(IS_ERR(my_class)) {
printk(Err: failed in creating class.n);
return -1;
}

/* register your own device in sysfs, and this will cause udevd to create corresponding device node */
class_device_create(my_class, NULL, MKDEV(DUMMY_MAJOR, DUMMY_MINOR), NULL, DUMMY_NAME %d, DUMMY_MINOR );



return 0;
}

static void __exit my_fini(void)
{
printk(byen);

cdev_del(my_cdev);
//kfree(my_cdev); no use. because that cdev_del() will call kfree if neccessary.


class_device_destroy(my_class, MKDEV(DUMMY_MAJOR, DUMMY_MINOR));
class_destroy(my_class);

}




module_init(my_init);
module_exit(my_fini);