cdev_add

初始化 cdev 后，需要把它添加到系统中去。为此可以调用 cdev_add()函数。传入cdev 结构的指针，起始设备编号，以及设备编号范围。

函数首先将分配的设备号与设备数目保存进cdev结构体中。然后再讲cdev结构体记录在一个 kobj_map 结构的 cdev_map 变量中。

 /**
  * cdev_add() - add a char device to the system
  * @p: the cdev structure for the device
  * @dev: the first device number for which this device is responsible
  * @count: the number of consecutive minor numbers corresponding to this
  *         device
  *
  * cdev_add() adds the device represented by @p to the system, making it
  * live immediately.  A negative error code is returned on failure.
  */
 int cdev_add(struct cdev *p, dev_t dev, unsigned count)
 {
     p->dev = dev;
     p->count = count;
     return kobj_map(cdev_map, dev, count, NULL, exact_match, exact_lock, p);
 }

内核中所有都字符设备都会记录在一个 kobj_map 结构的 cdev_map 变量中。这个结构的变量中包含一个散列表用来快速存取所有的对象。kobj_map() 函数就是用来把字符设备编号和 cdev 结构变量一起保存到 cdev_map 这个散列表里。当后续要打开一个字符设备文件时，通过调用 kobj_lookup() 函数，根据设备编号就可以找到 cdev 结构变量，从而取出其中的 ops 字段。

kobj_map函数中哈希表的实现原理和前面注册分配设备号中的几乎完全一样，通过要加入系统的设备的主设备号major（major=MAJOR(dev)）来获得probes数组的索引值i（i = major % 255），然后把一个类型为struct probe的节点对象加入到probes[i]所管理的链表中，如图2-6所示。其中struct probe所在的矩形块中的深色部分是我们重点关注的内容，记录了当前正在加入系统的字符设备对象的有关信息。其中，dev是它的设备号，range是从次设备号开始连续的设备数量，data是一void *变量，指向当前正要加入系统的设备对象指针p。图2-6展示了两个满足主设备号major % 255 = 2的字符设备通过调用cdev_add之后，cdev_map所展现出来的数据结构状态。

所以，简单地说，设备驱动程序通过调用cdev_add把它所管理的设备对象的指针嵌入到一个类型为struct probe的节点之中，然后再把该节点加入到cdev_map所实现的哈希链表中。对系统而言，当设备驱动程序成功调用了cdev_add之后，就意味着一个字符设备对象已经加入到了系统，在需要的时候，系统就可以找到它。对用户态的程序而言，cdev_add调用之后，就已经可以通过文件系统的接口呼叫到我们的驱动程序。

 static struct kobj_map *cdev_map;
 typedef struct kobject *kobj_probe_t(dev_t, int *, void *);
 struct kobj_map {
     struct probe {
         struct probe *next;
         dev_t dev;
         unsigned long range;
         struct module *owner;
         kobj_probe_t *get;
         int (*lock)(dev_t, void *);
         void *data;
     } *probes[];
     struct mutex *lock;
 };

 //cdev_add(struct cdev *p, dev_t dev, unsigned count)
 //                   设备号，  设备数目，         匹配函数，   锁定函数，    cdev指针
 //kobj_map(cdev_map,    dev,    count,    NULL,   exact_match, exact_lock,    p);
 int kobj_map(struct kobj_map *domain, dev_t dev, unsigned long range,
          struct module *module, kobj_probe_t *probe,
          int (*lock)(dev_t, void *), void *data)
 {
     unsigned n = MAJOR(dev + range - ) - MAJOR(dev) + ;//判断占用几个主设备号
     unsigned index = MAJOR(dev);
     unsigned i;
     struct probe *p;

     if (n > )
         n = ;

     p = kmalloc(sizeof(struct probe) * n, GFP_KERNEL);

     if (p == NULL)
         return -ENOMEM;

     for (i = ; i < n; i++, p++) {
         p->owner = module;
         p->get = probe;
         p->lock = lock;
         p->dev = dev;
         p->range = range;
         p->data = data;
     }
     mutex_lock(domain->lock);
     for (i = , p -= n; i < n; i++, p++, index++)
     {
         struct probe **s = &domain->probes[index % ];
         while (*s && (*s)->range < range)
             s = &(*s)->next;
         p->next = *s;
         *s = p;
     }
     mutex_unlock(domain->lock);
     return ;
 }

当一个字符设备驱动不再需要的时候（比如模块卸载），就可以用 cdev_del() 函数来释放 cdev 占用的内存。

 /**
  * cdev_del() - remove a cdev from the system
  * @p: the cdev structure to be removed
  *
  * cdev_del() removes @p from the system, possibly freeing the structure
  * itself.
  */
 void cdev_del(struct cdev *p)
 {
     cdev_unmap(p->dev, p->count);
     kobject_put(&p->kobj);
 }

kobj_unmap() 释放 cdev_map 散列表中的对象。

 //void cdev_del(struct cdev *p)
 //cdev_unmap(p->dev, p->count);
 static void cdev_unmap(dev_t dev, unsigned count)
 {
     kobj_unmap(cdev_map, dev, count);
 }
 void kobj_unmap(struct kobj_map *domain, dev_t dev, unsigned long range)
 {
     unsigned n = MAJOR(dev + range - ) - MAJOR(dev) + ;
     unsigned index = MAJOR(dev);
     unsigned i;
     struct probe *found = NULL;

     if (n > )
         n = ;

     mutex_lock(domain->lock);
     for (i = ; i < n; i++, index++) {
         struct probe **s;
         for (s = &domain->probes[index % ]; *s; s = &(*s)->next)
         {
             struct probe *p = *s;
             if (p->dev == dev && p->range == range)
             {
                 *s = p->next;
                 if (!found)
                     found = p;
                 break;
             }
         }
     }
     mutex_unlock(domain->lock);
     kfree(found);
 }

kobj_unmap()

kobject_put() 释放 cdev 结构本身。

 /**
  * kobject_put - decrement refcount for object.
  * @kobj: object.
  *
  * Decrement the refcount, and if 0, call kobject_cleanup().
  */
 void kobject_put(struct kobject *kobj)
 {
     if (kobj) {
         if (!kobj->state_initialized)
             WARN(, KERN_WARNING "kobject: '%s' (%p): is not "
                    "initialized, yet kobject_put() is being "
                    "called.\n", kobject_name(kobj), kobj);
         kref_put(&kobj->kref, kobject_release);
     }
 }

kobject_put()