register_chrdev_region()、alloc_chrdev_region() 和 register_chrdev()

1.字符设备结构体 

 内核中所有已分配的字符设备编号都记录在一个名为 chrdevs散列表里。该散列表中的每一个元素是一个 char_device_struct 结构，它的定义如下：

   staticstruct char_device_struct {
      structchar_device_struct*next;    //指向散列冲突链表中的下一个元素的指针
      unsigned intmajor;                // 主设备号
      unsigned intbaseminor;            // 起始次设备号
      intminorct;                       // 设备编号的范围大小
      charname[64];                     // 处理该设备编号范围内的设备驱动的名称
      structfile_operations*fops;      // 没有使用
      struct cdev*cdev;                 // 指向字符设备驱动程序描述符的指针
   } *chrdevs[CHRDEV_MAJOR_HASH_SIZE];

注意，内核并不是为每一个字符设备定义一个char_device_struct 结构，而是为一组（主设备号相同的设备）对应同一个字符设备驱动的设备编号范围定义一个char_device_struct 结构。chrdevs 散列表的大小是 255，散列算法是把每组字符设备编号范围的主设备号以255 取模插入相应的散列桶中。同一个散列桶中的字符设备编号范围是按起始次设备号递增排序的。

2.字符设备的注册
内核提供了三个函数来注册一组字符设备编号，这三个函数分别是register_chrdev_region()、alloc_chrdev_region() 和register_chrdev()。这三个函数都会调用一个共用的 __register_chrdev_region()函数来注册一组设备编号范围（即一个 char_device_struct 结构）。

register_chrdev_region(dev_tfirst,unsigned int count,char *name)
First :要分配的设备编号范围的初始值(次设备号常设为0);
Count:连续编号范围.
Name:编号相关联的设备名称. (/proc/devices);
动态分配:
Int alloc_chrdev_region(dev_t *dev,unsigned int firstminor,unsignedint count,char *name);
Firstminor : 通常为0;
*dev:存放返回的设备号;
释放:
Void unregist_chrdev_region(dev_t first,unsigned int count);
调用Documentation/devices.txt中能够找到已分配的设备号．

所以下面先来看一下__register_chrdev_region() 函数的实现代码。

__register_chrdev_region()
static struct char_device_struct *__register_chrdev_region(unsigned int major, unsigned intbaseminor, int minorct, const char *name){
   struct char_device_struct *cd,**cp;
   int ret = 0;
   int i;
   cd = kzalloc(sizeof(structchar_device_struct), GFP_KERNEL);
   if (cd == NULL)
      returnERR_PTR(-ENOMEM);
  mutex_lock(&chrdevs_lock);
   if (major == 0) {
       for (i =ARRAY_SIZE(chrdevs)-1; i > 0; i--)
         if(chrdevs[i] == NULL)
            break;
      if (i == 0){
         ret =-EBUSY;
         gotoout;
      }
      major =i;
      ret =major;
   }
   cd->major =major;
   cd->baseminor =baseminor;
   cd->minorct =minorct;
  strncpy(cd->name,name, 64);
   i =major_to_index(major);
   for (cp =&chrdevs[i]; *cp; cp =&(*cp)->next)
      if((*cp)->major > major ||
         ((*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;

     
      if (new_max>= old_min &&new_max <= old_max) {
         ret =-EBUSY;
         gotoout;
      }
     
      if (new_min<= old_max &&new_min >= old_min) {
         ret =-EBUSY;
         gotoout;
      }
   }
   cd->next =*cp;
   *cp = cd;
  mutex_unlock(&chrdevs_lock);
   return cd;
out:
  mutex_unlock(&chrdevs_lock);
   kfree(cd);
   return ERR_PTR(ret);
}
函数 __register_chrdev_region() 主要执行以下步骤：
1. 分配一个新的 char_device_struct 结构，并用 0 填充。
2. 如果申请的设备编号范围的主设备号为0，那么表示设备驱动程序请求动态分配一个主设备号。动态分配主设备号的原则是从散列表的最后一个桶向前寻找，那个桶是空的，主设备号就是相应散列桶的序号。所以动态分配的主设备号总是小于256，如果每个桶都有字符设备编号了，那动态分配就会失败。
3. 根据参数设置 char_device_struct 结构中的初始设备号，范围大小及设备驱动名称。
4. 计算出主设备号所对应的散列桶，为新的 char_device_struct结构寻找正确的位置。同时，如果设备编号范围有重复的话，则出错返回。
5. 将新的 char_device_struct 结构插入散列表中，并返回 char_device_struct结构的地址。

分析完 __register_chrdev_region()后，我们来一个个看那三个注册函数。

 register_chrdev_region()

intregister_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);
      if(IS_ERR(cd))
         gotofail;
   }
   return 0;
fail:
   to = n;
   for (n = from; n< to; n = next) {
      next =MKDEV(MAJOR(n)+1, 0);
     kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next -n));
   }
   return PTR_ERR(cd);
}

register_chrdev_region()函数用于分配指定的设备编号范围。如果申请的设备编号范围跨越了主设备号，它会把分配范围内的编号按主设备号分割成较小的子范围，并在每个子范围上调用__register_chrdev_region()。如果其中有一次分配失败的话，那会把之前成功分配的都全部退回。

alloc_chrdev_region
int alloc_chrdev_region(dev_t *dev, unsignedbaseminor, unsigned count, const char *name)
{
   struct char_device_struct*cd;
   cd =__register_chrdev_region(0, baseminor, count, name);
   if (IS_ERR(cd))
      returnPTR_ERR(cd);
   *dev =MKDEV(cd->major,cd->baseminor);
   return 0;
}
alloc_chrdev_region()函数用于动态申请设备编号范围，这个函数好像并没有检查范围过大的情况，不过动态分配总是找个空的散列桶，所以问题也不大。通过指针参数返回实际获得的起始设备编号。

register_chrdev

intregister_chrdev(unsigned int major, const char *name, const structfile_operations *fops)
{
   struct char_device_struct*cd;
   struct cdev *cdev;
   char *s;
   int err = -ENOMEM;

   cd =__register_chrdev_region(major, 0, 256, name);
   if (IS_ERR(cd))
      returnPTR_ERR(cd);

   cdev = cdev_alloc();
   if (!cdev)
      gotoout2;

   cdev->owner =fops->owner;
   cdev->ops =fops;
  kobject_set_name(&cdev->kobj, "%s",name);
   for (s =strchr(kobject_name(&cdev->kobj),'/');s; s = strchr(s, '/'))
      *s ='!';

   err = cdev_add(cdev,MKDEV(cd->major, 0), 256);
   if (err)
      gotoout;

   cd->cdev =cdev;

   return major ? 0 :cd->major;
out:
  kobject_put(&cdev->kobj);
out2:
  kfree(__unregister_chrdev_region(cd->major, 0,256));
   return err;
}
最后一个register_chrdev() 是一个老式分配设备编号范围的函数。它分配一个单独主设备号和 0 ~ 255的次设备号范围。如果申请的主设备号为 0 则动态分配一个。该函数还需传入一个 file_operations结构的指针，函数内部自动分配了一个新的 cdev 结构。

字符设备的注销
和注册分配字符设备编号范围类似，内核提供了两个注销字符设备编号范围的函数，分别是 unregister_chrdev_region()和 unregister_chrdev() 。它们都调用了 __unregister_chrdev_region()函数。由于比较简单，就不加说明了，只把代码贴出来。

static struct char_device_struct *__unregister_chrdev_region(unsigned major, unsigned baseminor, intminorct)
{
   struct char_device_struct *cd= NULL, **cp;
   int i =major_to_index(major);

  mutex_lock(&chrdevs_lock);
   for (cp =&chrdevs[i]; *cp; cp =&(*cp)->next)
      if((*cp)->major == major&&
        (*cp)->baseminor == baseminor&&
        (*cp)->minorct == minorct)
            break;
   if (*cp) {
      cd =*cp;
      *cp =cd->next;
   }
  mutex_unlock(&chrdevs_lock);
   return cd;
}

void unregister_chrdev_region(dev_t from, unsigned count)
{
   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;
     kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next -n));
   }
}

void unregister_chrdev(unsigned int major, const char *name)
{
   struct char_device_struct*cd;
   cd =__unregister_chrdev_region(major, 0, 256);
   if (cd&& cd->cdev)
     cdev_del(cd->cdev);
   kfree(cd);

}

使用他们注册字符设备都需要手动创建设备节点