浅析字符设备驱动程序__register_chrdev_region

  在 2.4 的内核我们使用 register_chrdev(0, "hello", &hello_fops) 来进行字符设备设备节点的分配，这种方式每一个主设备号只能存放一种设备，它们使用相同的 file_operation 结构体，也就是说内核最多支持 256
个字符设备驱动程序。

   在 2.6 的内核之后，新增了一个 register_chrdev_region 函数，它支持将同一个主设备号下的次设备号进行分段，每一段供给一个字符设备驱动程序使用，使得资源利用率大大提升，同时，2.6 的内核保留了原有的 register_chrdev 方法。在 2.6 的内核中这两种方法都会调用到 __register_chrdev_region 函数，本文将从它入手来分析内核是如何管理字符设备驱动程序的。

static struct char_device_struct {
struct char_device_struct *next;
unsigned int major;
unsigned int baseminor;
int minorct;
char name[64];
struct cdev *cdev;		/* will die */
} *chrdevs[CHRDEV_MAJOR_HASH_SIZE];

   内核中的每一个字符设备驱动程序都由一个 char_device_struct 结构体来描述，包含主设备号、起始次设备号、次设备号个数等信息。

   内核使用 chrdevs 这个指针数组来管理所有的字符设备驱动程序，数组范围 0-255 ，看上去好像还是只支持 256 个字符设备驱动程序，其实并不然，每一个 char_device_struct 结构都含有一个 next 指针，它可以指向与其主设备号相同的其它字符设备驱动程序，它们之间主设备号相同，各自的次设备号范围相互不重叠。




一、register_chrdev

static inline int register_chrdev(unsigned int major, const char *name,
const struct file_operations *fops)
{
return __register_chrdev(major, 0, 256, name, fops);
}

int __register_chrdev(unsigned int major, unsigned int baseminor,
unsigned int count, const char *name,
const struct file_operations *fops)
{
struct char_device_struct *cd;
struct cdev *cdev;

cd = __register_chrdev_region(major, baseminor, count, name);

cdev = cdev_alloc();

cdev->owner = fops->owner;
cdev->ops = fops;
kobject_set_name(&cdev->kobj, "%s", name);

err = cdev_add(cdev, MKDEV(cd->major, baseminor), count);

cd->cdev = cdev;

return major ? 0 : cd->major;
}

  它调用了 __register_chrdev_region 并强制指定了起始次设备号为0，256个，把一个主设备号下的所有次设备号都申请光了。同时它还封装了 cdev_init 和 cdev_add ，倒是很省事。

二、register_chrdev_region

int register_chrdev_region(dev_t from, unsigned count, const char *name)
{
struct char_device_struct *cd;
dev_t to = from + count;
dev_t n, next;

for (n = from; n < to; n = next) {
next = MKDEV(MAJOR(n)+1, 0);
if (next > to)
next = to;
cd = __register_chrdev_region(MAJOR(n), MINOR(n),
next - n, name);
}
return 0;
}

  register_chrdev_region 则是根据要求的范围进行申请，同时我们需要手动 cdev_init cdev_add 。

三、__register_chrdev_region

static struct char_device_struct *
__register_chrdev_region(unsigned int major, unsigned int baseminor,
int minorct, const char *name)
{
// **p 是 char_device_struct 类型实例
//  *p 是 char_device_struct 实例的指针
//   p 是 char_device_struct 实例的指针的指针
struct char_device_struct *cd, **cp;
int ret = 0;
int i;

cd = kzalloc(sizeof(struct char_device_struct), GFP_KERNEL);

mutex_lock(&chrdevs_lock);

/*
* 如果major为0则分配一个没有使用的主设备号
* 注意，从 chrdevs[255] 开始向下查找
*/
if (major == 0) {
for (i = ARRAY_SIZE(chrdevs)-1; i > 0; i--) {
if (chrdevs[i] == NULL)
break;
}

if (i == 0) {
ret = -EBUSY;
goto out;
}
major = i;
ret = major;
}

cd->major = major;
cd->baseminor = baseminor;
cd->minorct = minorct;
strlcpy(cd->name, name, sizeof(cd->name));

// return major % CHRDEV_MAJOR_HASH_SIZE;
i = major_to_index(major);

/*
*  不要分析直接分析 for 循环
*  拿实例来分析不容易晕
*
*/
// *(a.next) 是 next 实例
// *(a->next)
// *((*a)->next) 是 next 实例
// (*cp)->next 是 next 实例的指针，这个指针存在于 **cp 中
// cp 是 chrdevs[i] 的指针,chrdevs[i]本身就是个指针
// cp == &chrdevs[i].next
for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next)
if ((*cp)->major > major || 	// 正常情况下 If 语句不成立
((*cp)->major == major &&
(((*cp)->baseminor >= baseminor) || ((*cp)->baseminor + (*cp)->minorct > baseminor))) )
break;

/* 如果有重叠部分，正常情况下应该不重叠  */
if (*cp && (*cp)->major == major) {
int old_min = (*cp)->baseminor;
int old_max = (*cp)->baseminor + (*cp)->minorct - 1;
int new_min = baseminor;
int new_max = baseminor + minorct - 1;

/* New driver overlaps from the left.  */
if (new_max >= old_min && new_max <= old_max) {
ret = -EBUSY;
goto out;
}

/* New driver overlaps from the right.  */
if (new_min <= old_max && new_min >= old_min) {
ret = -EBUSY;
goto out;
}
}
// 第一次时 *cp == chrdevs[i] == null
cd->next = *cp;
*cp = cd;	// 第一次时，*cp == chrdevs[i] 指向 新分配的 char_device_struct 结构
mutex_unlock(&chrdevs_lock);
return cd;
}

  直接分析代码有些吃力，拿个例子来分析。

alloc_chrdev_region(&devid, 0, HELLO_CNT, "hello");
major = MAJOR(devid);
devid = MKDEV(major, 2);
register_chrdev_region(devid, 1, "hello2");

int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,
const char *name)
{
struct char_device_struct *cd;
cd = __register_chrdev_region(0, baseminor, count, name);
if (IS_ERR(cd))
return PTR_ERR(cd);
*dev = MKDEV(cd->major, cd->baseminor);
return 0;
}

第一次 

  alloc_chrdev_region(&devid, 0, 2, "hello"); 

  major = MAJOR(devid); 

  __register_chrdev_region(unsigned int major = 0, unsigned int baseminor = 0,int minorct = 2, const char *name)

  chrdevs[i] == null

  cp = &chrdevs[i] -> *cp == chrdevs[i] == null

  cd->next = *cp == null (*cp 内容是空的，它的内容是别人的地址)

  cp == chrdevs[i] = cd (指针和指针赋值，将cd指向的实体的地址赋给 *cp 也就是 chrdevs[i])

第二次

  register_chrdev_region(devid, 1, "hello2");

  __register_chrdev_region(unsigned int major = 0, unsigned int baseminor = 2,int minorct = 1, const char *name)

  if 语句条件不成立，因此,cp = &(*cp)->next ,*cp == (*cp)->next == chrdevs[i]->next == null 跳出 for 循环

  cp = &chrdevs[i] -> (*cp) == chrdevs[i] -> (*cp)->next == chrdevs[i]->next == null

  cd->next = *cp; cd->next 指向了上一次分配的实例

  cp = cd -> chrdevs[i] = cd 指针和指针之间的赋值，chrdevs[i] 就指向了新分配的实例，新分配的实例.next 指向上一次分配的实例

  相当于从链表头部插入了一个节点，此时，再来看这个图应该更清晰了。



四、字符设备驱动程序模板

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <asm/arch/regs-gpio.h>
#include <asm/hardware.h>
#include <linux/poll.h>
#include <linux/cdev.h>

/* 1. 确定主设备号 */
static int major;

static int hello_open(struct inode *inode, struct file *file)
{
printk("hello_open\n");
return 0;
}

static int hello2_open(struct inode *inode, struct file *file)
{
printk("hello2_open\n");
return 0;
}

/* 2. 构造file_operations */
static struct file_operations hello_fops = {
.owner = THIS_MODULE,
.open  = hello_open,
};

static struct file_operations hello2_fops = {
.owner = THIS_MODULE,
.open  = hello2_open,
};

#define HELLO_CNT   2

static struct cdev hello_cdev;
static struct cdev hello2_cdev;
static struct class *cls;

static int hello_init(void)
{
dev_t devid;

/* 3. 告诉内核 */
#if 0 // 老方法
/* (major,  0), (major, 1), ..., (major, 255)都对应hello_fops */
major = register_chrdev(0, "hello", &hello_fops);
#else // 新方法
if (major) {
devid = MKDEV(major, 0);
/* (major,0~1) 对应 hello_fops, (major, 2~255)都不对应hello_fops */
register_chrdev_region(devid, HELLO_CNT, "hello");
} else {
/* (major,0~1) 对应 hello_fops, (major, 2~255)都不对应hello_fops */
alloc_chrdev_region(&devid, 0, HELLO_CNT, "hello");
major = MAJOR(devid);
}

cdev_init(&hello_cdev, &hello_fops);
cdev_add(&hello_cdev, devid, HELLO_CNT);

devid = MKDEV(major, 2);
register_chrdev_region(devid, 1, "hello2");
cdev_init(&hello2_cdev, &hello2_fops);
cdev_add(&hello2_cdev, devid, 1);

#endif

cls = class_create(THIS_MODULE, "hello");
class_device_create(cls, NULL, MKDEV(major, 0), NULL, "hello0"); /* /dev/hello0 */
class_device_create(cls, NULL, MKDEV(major, 1), NULL, "hello1"); /* /dev/hello1 */
class_device_create(cls, NULL, MKDEV(major, 2), NULL, "hello2"); /* /dev/hello2 */
class_device_create(cls, NULL, MKDEV(major, 3), NULL, "hello3"); /* /dev/hello3 */

return 0;
}

static void hello_exit(void)
{
class_device_destroy(cls, MKDEV(major, 0));
class_device_destroy(cls, MKDEV(major, 1));
class_device_destroy(cls, MKDEV(major, 2));
class_device_destroy(cls, MKDEV(major, 3));
class_destroy(cls);

cdev_del(&hello_cdev);
unregister_chrdev_region(MKDEV(major, 0), HELLO_CNT);

cdev_del(&hello2_cdev);
unregister_chrdev_region(MKDEV(major, 2), 1);
}

module_init(hello_init);
module_exit(hello_exit);

MODULE_LICENSE("GPL");