字符設備驅(qū)動模型淺析

在linux系統(tǒng)中，很多驅(qū)動是字符型驅(qū)動，有些是直接編譯集成在內(nèi)核中，另一些是單獨編譯成“.ko”動態(tài)加載的。其實字符驅(qū)動只是個外殼，用于內(nèi)核與應用程序間通信，無非是調(diào)用open，release，read，write和ioctl等例程。所以根據(jù)應用不同，字符驅(qū)動能會調(diào)用其他驅(qū)動模塊，如i2c、spi和v4l2等，于是字符驅(qū)動還可分WDT驅(qū)動、RTC驅(qū)動和MTD驅(qū)動等。所以在分析其他驅(qū)動模塊之前有必要好好分析下字符設備驅(qū)動模型。本篇文章要講的就是字符設備驅(qū)動模型，也就是字符設備驅(qū)動是怎么注冊和注銷的，怎么生成設備節(jié)點的，怎么和應用程序關聯(lián)的，例程調(diào)用具體如何實現(xiàn)的等等。

一、字符設備驅(qū)動的注冊和注銷

對于寫過linux-2.6內(nèi)核(本文采用linux-2.6.18內(nèi)核)字符驅(qū)動的程序員來說，對下面這段程序的形式肯定不陌生。int result;

/*

* Register the driver in the kernel

* Dynmically get the major number for the driver using

* alloc_chrdev_region function

*/

result = alloc_chrdev_region(&dev, 0, 1, “testchar”);

/* if it fails return error */

if (result < 0) {

printk("Error registering test character device\n");

return -ENODEV;

}

printk(KERN_INFO " test major#: %d, minor# %d\n", MAJOR(dev), MINOR(dev));

/* initialize cdev with file operations */

cdev_init(&cdev, & test _fops);

cdev.owner = THIS_MODULE;

cdev.ops = &test_fops;

/* add cdev to the kernel */

result = cdev_add(&cdev, dev, 1);

if (result) {

unregister_chrdev_region(dev, 1);

printk("Error adding test char device: error no:%d\n", result);

return -EINVAL;

}

testchar _class = class_create(THIS_MODULE, "testchar");

if (!testchar _class) {

printk("Error creating test device class\n");

unregister_chrdev_region(dev, 1);

unregister_chrdev(MAJOR(dev), "testchar");

cdev_del(&cdev);

return -EINVAL;

}

class_device_create(testchar _class, NULL, dev, NULL, "testchar");

復制代碼通常這段程序會放在一個模塊初始化加載函數(shù)里，形式是這樣的，int __init testchar_init(void)

{

}

module_init(testchar_init);

復制代碼既然有注冊的函數(shù)，那必然有注銷的函數(shù)，這叫有進必有出，有公必有母…，總而言之，這是大自然的神奇被人類所利用。廢話少說，形式是這樣的，void __exit testchar _cleanup(void)

{

/* remove major number allocated to this driver */

unregister_chrdev_region(dev, 1);

/* remove simple class device */

class_device_destroy(testchar_class, dev);

/* destroy simple class */

class_destroy(testchar class);

cdev_del(&cdev);

/* unregistering the driver from the kernel */

unregister_chrdev(MAJOR(dev), "testchar");

}

module_exit(testchar_cleanup);

復制代碼這些注冊字符驅(qū)動的例程調(diào)用大都集中在文件fs/char_dev.c中。所以先來看看這個文件中都有些啥，這叫直搗黃龍。

這有個初始化函數(shù)，在模塊加載過程中會被調(diào)用到(動態(tài)insmod加載或在內(nèi)核中加載)，如下，void __init chrdev_init(void)

{

cdev_map = kobj_map_init(base_probe, &chrdevs_lock);

}。

復制代碼kobj_map_init()函數(shù)傳進去了兩個參數(shù)，base_probe函數(shù)和chrdevs_lock互斥變量，返回一個struct kobj_map類型的指針。

base_probe調(diào)用了request_module()函數(shù)，用于加載與字符驅(qū)動相關的驅(qū)動程序，被加載的驅(qū)動命名方式是char-major-主設備號-次設備號。request_module()函數(shù)，你可以看看該函數(shù)上頭的英文注釋，它最終會調(diào)用應用層空間的modprobe命令來加載驅(qū)動程序。實際上，沒有使用該項功能。

chrdevs_lock是一個全局的互斥變量，用于整個設備驅(qū)動模塊的關鍵區(qū)域保護，后面你會看到。

返回的是struct kobj_map類型指針，保存到cdev_map中，該結構體干嗎用的呢，顧名思義，用來做映射連通的，后面會慢慢說明。先來看看該結構體的定義，struct kobj_map {

struct probe {

struct probe *next; /* 被255整除后相同的設備號鏈成一個單向鏈表 */

dev_t dev; /* 字符設備驅(qū)動的設備號，包含主設備號(高12位)和次設備號(低20位) */

unsigned long range; /* 次設備號范圍 */

struct module *owner; /* 表明模塊的歸屬，是THIS_MODULE */

kobj_probe_t *get; /* 這里可以保存?zhèn)鬟M來的base_probe函數(shù)指針，可回調(diào) */

int (*lock)(dev_t, void *); /* 保存回調(diào)函數(shù)，具體是啥，后續(xù)會說到 */

void *data;

} *probes[255]; /* 雖然大小只有255，但采用了鏈表的形式，可以支持到4096個主設 */

struct mutex *lock; /* 保存全局互斥鎖，用于關鍵區(qū)域的保護 */

};

復制代碼我們再來看看kobj_map_init()函數(shù)里頭做了什么，該函數(shù)是這樣的，struct kobj_map *kobj_map_init(kobj_probe_t *base_probe, struct mutex *lock)

{

struct kobj_map *p = kmalloc(sizeof(struct kobj_map), GFP_KERNEL);

struct probe *base = kzalloc(sizeof(*base), GFP_KERNEL);

int i;

if ((p == NULL) || (base == NULL)) {

kfree(p);

kfree(base);

return NULL;

}

base->dev = 1;

base->range = ~0; /* 初始的范圍很大 */[!--empirenews.page--]

base->get = base_probe; /* 保存函數(shù)指針 */

for (i = 0; i < 255; i++)

p->probes[i] = base; /* 所有指針都指向同一個base */

p->lock = lock;

return p;

}。

復制代碼該函數(shù)只是分配了一個結構體struct kobj_map，并做了初始化，保存了函數(shù)指針base_probe和全局鎖lock。

下面就按照驅(qū)動注冊流程一個個解析這些例程調(diào)用吧。首先是alloc_chrdev_region()函數(shù)，解析它之前，先看看結構體(定義了255個結構體指針),static struct char_device_struct {

/*被255整除后相同的設備號鏈成一個單向鏈表*/

struct char_device_struct *next;

unsigned int major; /* 主設備號 */

unsigned int baseminor; /* 次設備起始號 */

int minorct; /* 次設備號范圍 */

char name[64]; /* 驅(qū)動的名字 */

struct file_operations *fops; /* 保存文件操作指針，目前沒有使用 */

struct cdev *cdev; /* will die */ /*目前沒有使用*/

} *chrdevs[CHRDEV_MAJOR_HASH_SIZE]; /* CHRDEV_MAJOR_HASH_SIZE = 255 */

復制代碼它的作用僅僅是用于注冊字符設備驅(qū)動，保存已經(jīng)注冊字符驅(qū)動的一些信息，如主次設備號，次設備號的數(shù)量，驅(qū)動的名字等，便于字符設備驅(qū)動注冊時索引查找。alloc_chrdev_region()函數(shù)很簡單，通過調(diào)用__register_chrdev_region()來實現(xiàn)，通過英語注釋你也可以明白，這個函數(shù)有兩個作用，一是，如果主設備號為0，則分配一個最近的主設備號，返回給調(diào)用者;二是，如果主設備號不為0，則占用好該主設備號對應的位置，返回給調(diào)用者。如下，static struct char_device_struct *

__register_chrdev_region(unsigned int major, unsigned int baseminor,

int minorct, const char *name)

{

struct char_device_struct *cd, **cp;

int ret = 0;

int i;

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

if (cd == NULL)

return ERR_PTR(-ENOMEM);

mutex_lock(&chrdevs_lock); /* 這下看到了吧，加鎖，就允許你一個人進來 */

/* temporary */

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;

strncpy(cd->name,name, 64);

i = major_to_index(major);

/* 如果主設備號不為0，則占用好該主設備號對應的位置 */

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

if ((*cp)->major > major ||

((*cp)->major == major && (*cp)->baseminor >= baseminor))

break;

if (*cp && (*cp)->major == major &&

(*cp)->baseminor < baseminor + minorct) {

ret = -EBUSY;

goto out;

}

cd->next = *cp;

*cp = cd;

mutex_unlock(&chrdevs_lock); /* 開鎖，隊列里的下一個人可以進來了 */

return cd;

out:

mutex_unlock(&chrdevs_lock);

kfree(cd);

return ERR_PTR(ret);

}

復制代碼接著是cdev_init()函數(shù)，先說說cdev的結構體，struct cdev {

struct kobject kobj; /* 不多解釋了，看看鄙人前面寫的文章吧 */

struct module *owner; /* 模塊鎖定和加載時用得著 */

const struct file_operations *ops; /* 保存文件操作例程結構體 */

struct list_head list; /* open時，會將其inode加到該鏈表中，方便判別是否空閑 */

dev_t dev; /* 設備號 */

unsigned int count;

};

復制代碼cdev結構體把字符設備驅(qū)動和文件系統(tǒng)相關聯(lián)，后面解析字符設備驅(qū)動怎樣運行的時候會詳談。

cdev_init()函數(shù)如下，void cdev_init(struct cdev *cdev, const struct file_operations *fops)

{

memset(cdev, 0, sizeof *cdev);

INIT_LIST_HEAD(&cdev->list);

cdev->kobj.ktype = &ktype_cdev_default; /* 卸載驅(qū)動時會用到，別急，后面詳講 */

kobject_init(&cdev->kobj);

cdev->ops = fops; /* 用戶寫的字符設備驅(qū)動fops就保存在這了 */

}。

復制代碼你也看到了，該函數(shù)就是對變量做了初始化，關于kobject的解析，建議你看看鄙人博客上寫的《Linux設備模型淺析之設備篇》和《Linux設備模型淺析之驅(qū)動篇》兩篇文章，這里就不詳談了。

用戶的fops，在本文中是test_fops，一般形式是這樣的，

static const struct file_operations test_fops = {

.owner = THIS_MODULE,

.open = test_fops_open,

.release = test_fops_release,

.ioctl = test_fops_ioctl,

.read = test_fops_read,

.write = test_fops_write,

};

復制代碼

接著又調(diào)用了函數(shù)cdev_add()，這個函數(shù)又調(diào)用了kobj_map()函數(shù)，其作用就是分配一個struct probe結構體，填充該結構體中的變量并將其加入到全局的cdev_map中，說白了，就是分個一畝三分田給該字符設備驅(qū)動，并做好標記，放到主設備號對應的地方，等主人下次來找的時候能找到(使用kobj_lookup()函數(shù)，后面會講到)。該函數(shù)是這樣的，int kobj_map(struct kobj_map *domain, dev_t dev, unsigned long range,

struct module *module, kobj_probe_t *probe,

[!--empirenews.page--]

int (*lock)(dev_t, void *), void *data)

{

unsigned n = MAJOR(dev + range - 1) - MAJOR(dev) + 1;

unsigned index = MAJOR(dev);

unsigned i;

struct probe *p;

if (n > 255)

n = 255;

/* 分配了一畝三分田 */

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

if (p == NULL)

return -ENOMEM;

/* 填充些私有的東西 */

for (i = 0; i < n; i++, p++) {

p->owner = module;

p->get = probe; /* 是exact_match ()函數(shù)，獲取cdev結構體的kobject指針 */

p->lock = lock; /* 是exact_lock()函數(shù)，增加引用*/

p->dev = dev;

p->range = range;

p->data = data; /* cdev保存到p->data中 */

}

mutex_lock(domain->lock);

/* 將這一畝三分田加到主設備號對應的位置上去 */

for (i = 0, p -= n; i < n; i++, p++, index++) {

struct probe **s = &domain->probes[index % 255];

while (*s && (*s)->range < range)

s = &(*s)->next;

p->next = *s;

*s = p;

}

mutex_unlock(domain->lock);

return 0;

}

復制代碼接下來有class_create()函數(shù)和class_device_create()函數(shù)，前者生成一個名字為"testchar"的class，后者作用就是在/dev目錄下生成設備節(jié)點，當然，需要uevent和UDEVD的支持，具體可見鄙人博客上的文章《Linux設備模型淺析之uevent篇》。

順帶說下register_chrdev()函數(shù)，其也是注冊字符設備驅(qū)動，只不過是封裝好的，包含了所有前面講的注冊步驟——分配一個設備號，由一個主設備號和255個次設備號組成。如下，int register_chrdev(unsigned int major, const char *name,

const struct file_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))

return PTR_ERR(cd);

cdev = cdev_alloc(); /* 這個有點不一樣，動態(tài)分配的，不是調(diào)用者提供 */

if (!cdev)

goto out2;

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)

goto out;

cd->cdev = cdev;

return major ? 0 : cd->major;

out:

kobject_put(&cdev->kobj);

out2:

kfree(__unregister_chrdev_region(cd->major, 0, 256));

return err;

}