首先我們在註冊函式裡面呼叫了register_chrdev(MEM_MAJOR,"mem",&memory_fops)，向核心註冊了一個字元裝置。

第一個引數是主裝置號，0代表動態分配，這裡的MEM_MAJOR是1。第二個引數是裝置的名字，第三個引數是檔案操作指標。

每個裝置檔案對應有兩個裝置號：一個是主裝置號，標識該裝置的種類，也標識了該裝置所使用的驅動程式；另一個是次裝置號，標識使用同一裝置驅動程式的不同硬體裝置。裝置檔案的主裝置號必須與裝置驅動程式在登入該裝置時申請的主裝置號一致，否則使用者程序將無法訪問到裝置驅動程式。 

一般說來，PCI卡通常都屬於字元裝置

完成註冊後，在/proc/devices中的第一個字元裝置我們就看到了：1 mem。

1.前面提到了註冊，那這個字元裝置到底註冊到哪裡去了呢？這是要弄明白的第一個問題。

其實是註冊到一個存放字元裝置的連結串列中了：

fs/char_dev.c

1. static struct char_device_struct {  
2.     struct char_device_struct *next;  
3.     unsigned int major;  
4.     unsigned int baseminor;  
5.     int minorct;  
6.     char name[64];  
7.     struct cdev *cdev;      /* will die */  
8. } *chrdevs[CHRDEV_MAJOR_HASH_SIZE];  

這裡的CHRDEV_MAJOR_HASH_SIZE的大小是255，也就是這裡最多能夠存放的主裝置號最多有255個。

這裡還是一點需要注意的是這裡分配的是一個指標陣列。

1. cd->next = *cp;  
2. *cp = cd;  

首先*cp代表的是當前相同的主裝置號中最後面的一個，當然這這裡的*cp是指向NULL的，然後把*cp更新為cd。

可以注意到這裡好像並沒有struct cdev什麼事情，下面就對其進行初始化。

2.cdev_add第二個任務,add a char device to the system,make it live immediately

先介紹兩個遇到的結構體：

include/linux/cdev.h

1. struct cdev {  
2.     struct kobject kobj;  
3.     struct module *owner;  
4.     const struct file_operations *ops;  
5.     struct list_head list;  
6.     dev_t dev;  
7.     unsigned int count;  
8. };  

可進行的操作有：

1. void cdev_init(struct cdev *, const struct file_operations *);  
2. struct cdev *cdev_alloc(void);  
3. void cdev_put(struct cdev *p);  
4. int cdev_add(struct cdev *, dev_t, unsigned);  
5. void cdev_del(struct cdev *);  
6. void cd_forget(struct inode *);  

在結構體cdev裡出現了另外一個極其重要的結構體struct kobject,include/linux/kobject.h

1. struct kobject {  
2.     const char      *name;  
3.     struct list_head    entry;  
4.     struct kobject      *parent;  
5.     struct kset     *kset;  
6.     struct kobj_type    *ktype;  
7.     struct sysfs_dirent *sd;  
8.     struct kref     kref;  
9.     unsigned int state_initialized:1;  
10.     unsigned int state_in_sysfs:1;  
11.     unsigned int state_add_uevent_sent:1;  
12.     unsigned int state_remove_uevent_sent:1;  
13.     unsigned int uevent_suppress:1;  
14. };  

主要的操作有：

1. extern void kobject_init(struct kobject *kobj, struct kobj_type *ktype);  
2. extern void kobject_del(struct kobject *kobj);  
3. extern struct kobject *kobject_get(struct kobject *kobj);  
4. extern void kobject_put(struct kobject *kobj);extern void kobject_put(struct kobject *kobj);  

cdev_add裡面只調用了一個函式：kobj_map(cdev_map, dev, count, NULL, exact_match, exact_lock, p);

cdev_map是fs/char_dev.h裡定義的一個結構體變數，而kobj_map的作用就是初始化它。

1. static struct kobj_map *cdev_map;  

1. struct kobj_map {  
2.     struct probe {  
3.         struct probe *next;  
4.         dev_t dev;  
5.         unsigned long range;  
6.         struct module *owner;  
7.         kobj_probe_t *get;  
8.         int (*lock)(dev_t, void *);  
9.         void *data;  
10.     } *probes[255];  
11.     struct mutex *lock;  
12. };  

kobj_map:

 核心中所有都字元裝置都會記錄在一個 kobj_map 結構的 cdev_map 變數中。這個結構的變數中包含一個散列表用來快速存取所有的物件。kobj_map() 函式就是用來把字元裝置編號和 cdev 結構變數一起儲存到 cdev_map 這個散列表裡。當後續要開啟一個字元裝置檔案時，通過呼叫 kobj_lookup() 函式，根據裝置編號就可以找到 cdev 結構變數，從而取出其中的 ops 欄位。

1. int kobj_map(struct kobj_map *domain, dev_t dev, unsigned long range,  
2.          struct module *module, kobj_probe_t *probe,  
3.          int (*lock)(dev_t, void *), void *data)  
4. {  
5.     unsigned n = MAJOR(dev + range - 1) - MAJOR(dev) + 1;  
6.     unsigned index = MAJOR(dev);  
7.     unsigned i;  
8.     struct probe *p;  
9.   
10.     if (n > 255)  
11.         n = 255;  
12.   
13.     p = kmalloc(sizeof(struct probe) * n, GFP_KERNEL);  
14.   
15.     if (p == NULL)  
16.         return -ENOMEM;  
17.   
18.     for (i = 0; i < n; i++, p++) {  
19.         p->owner = module;  
20.         p->get = probe;  
21.         p->lock = lock;  
22.         p->dev = dev;  
23.         p->range = range;  
24.         p->data = data;  
25.     }  
26.     mutex_lock(domain->lock);  
27.     for (i = 0, p -= n; i < n; i++, p++, index++) {  
28.         struct probe **s = &domain->probes[index % 255];  
29.         while (*s && (*s)->range < range)  
30.             s = &(*s)->next;  
31.         p->next = *s;  
32.         *s = p;  
33.     }  
34.     mutex_unlock(domain->lock);  
35.     return 0;  
36. }  

現在完成的僅僅是註冊，下面還有一些重要的事情需要完成。