2012年（15）
分类：
2012-07-10 22:09:06
Author: Eric Fang
Date: 2010-01-12
-----------------------------------------------------------------
本站分析linux内核源码，版本号为2.6.32.3
转载请注明出处：http://ericfang.cublog.cn/
-----------------------------------------------------------------
在清楚了kobject之后，就可以继续分析device、driver、bus了，这三者是设备驱动程序的基本数据结构。
我们可以这样理解，内核用device来表示各种设备，然后用driver来表示它的驱动，而设备有很多种，也属于相同类型或不同类型，而其对应的驱动可能同时也是另外一个设备的驱动，为了管理这些设备和驱动，就引入了总线bus_type，总线上有两个集合（也可以理解为两条链，如上图中的bus），分别用来存放该总线类型的设备和驱动，当添加一个设备时就将设备添加到总线的设备集合（图中操作2），同时可能会到驱动集合去匹配适合它的驱动（图中操作3，在此之前device和driver没有挂钩），如何找到了就会将它们联系起来（图中操作6）。同样注册一个驱动，就会把它挂到相应总线类型的驱动集合里（图中操作1），同时去设备集合中找出它锁驱动的设备（图中操作4，在此之前device和driver没有挂钩），如果找到就把设备链接到它支持的设备链表上（图中操作6）。
下面我们进入到代码中去：
struct bus_type结构定义如下：
struct bus_type {
const char *name;
struct bus_attribute *bus_attrs;
struct device_attribute *dev_attrs;
struct driver_attribute *drv_attrs;
int (*match)(struct device *dev, struct device_driver *drv);
int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
int (*probe)(struct device *dev);
int (*remove)(struct device *dev);
void (*shutdown)(struct device *dev);
int (*suspend)(struct device *dev, pm_message_t state);
int (*resume)(struct device *dev);
const struct dev_pm_ops *pm;
struct bus_type_private *p;
};
较之先前一些内核版本，bus_type把部分私有字段封装到bus_type_private类型结构里：
struct bus_type_private {
struct kset subsys;
struct kset *drivers_kset;
struct kset *devices_kset;
struct klist klist_devices;
struct klist klist_drivers;
struct blocking_notifier_head bus_notifier;
unsigned int drivers_autoprobe:1;
struct bus_type *bus;
};
字段klist_devices和klist_drivers分别表示挂在bus_type上的驱动和设备链表，bus_type的其他字段和函数指针将在分析过程中说明。
首先我们要为设备和驱动注册一个总线类型：
int bus_register(struct bus_type *bus)
{
int retval;
struct bus_type_private *priv;
priv = kzalloc(sizeof(struct bus_type_private), GFP_KERNEL);
if (!priv)
return -ENOMEM;
priv->bus = bus;
bus->p = priv;
分配私有区域的内存空间，并将其关联
BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier);
初始化回调函数
retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name);
if (retval)
goto out;
priv->subsys.kobj.kset = bus_kset;
priv->subsys.kobj.ktype = &bus_ktype;
priv->drivers_autoprobe = 1;
retval = kset_register(&priv->subsys);
if (retval)
goto out;
这里我们看到了subsys用来表示它的文件系统，可以回想上一节kset的注册。
这个bus_kset是系统启动是创建的，系统init进程kernel_init()中调用do_basic_setup()，其中调用driver_init(),其中调用的buses_init()，如下
int __init buses_init(void)
{
bus_kset = kset_create_and_add("bus", &bus_uevent_ops, NULL);
if (!bus_kset)
return -ENOMEM;
return 0;
}
从而知道创建的文件系统目录在/sys/bus下。
static struct kset_uevent_ops bus_uevent_ops = {
.filter = bus_uevent_filter,
};
static int bus_uevent_filter(struct kset *kset, struct kobject *kobj)
{
struct kobj_type *ktype = get_ktype(kobj);
if (ktype == &bus_ktype)
return 1;
return 0;
}
继续bus_register（）中的代码：
retval = bus_create_file(bus, &bus_attr_uevent);
if (retval)
goto bus_uevent_fail;
bus_create_file（）如下:
int bus_create_file(struct bus_type *bus, struct bus_attribute *attr)
{
int error;
if (bus_get(bus)) {
error = sysfs_create_file(&bus->p->subsys.kobj, &attr->attr);
bus_put(bus);
} else
error = -EINVAL;
return error;
}
用bus_attr_uevent创建了bus->p->subsys.kobj的属性文件，由上面的赋值知道其读写操作在bus_ktype的sysfs_ops，其定义如下：
static struct kobj_type bus_ktype = {
.sysfs_ops = &bus_sysfs_ops,
};
static struct sysfs_ops bus_sysfs_ops = {
.show = bus_attr_show,
.store = bus_attr_store,
};
static ssize_t bus_attr_show(struct kobject *kobj, struct attribute *attr,
char *buf)
{
struct bus_attribute *bus_attr = to_bus_attr(attr);
struct bus_type_private *bus_priv = to_bus(kobj);
ssize_t ret = 0;
if (bus_attr->show)
ret = bus_attr->show(bus_priv->bus, buf);
return ret;
}
static ssize_t bus_attr_store(struct kobject *kobj, struct attribute *attr,
const char *buf, size_t count)
{
struct bus_attribute *bus_attr = to_bus_attr(attr);
struct bus_type_private *bus_priv = to_bus(kobj);
ssize_t ret = 0;
if (bus_attr->store)
ret = bus_attr->store(bus_priv->bus, buf, count);
return ret;
}
由上面的程序可以看出文件的读写操作最终会回到struct bus_attribute &bus_attr_uevent的show和store方法。
bus_attr_uevent是通过宏定义的：
#define __ATTR(_name,_mode,_show,_store) { \
.attr = {.name = __stringify(_name), .mode = _mode }, \
.show = _show, \
.store = _store, \
}
#define BUS_ATTR(_name, _mode, _show, _store) \
struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store)
static BUS_ATTR(uevent, S_IWUSR, NULL, bus_uevent_store);
其show方法为NULL，说明不可读。
static ssize_t bus_uevent_store(struct bus_type *bus,
const char *buf, size_t count)
{
enum kobject_action action;
if (kobject_action_type(buf, count, &action) == 0)
kobject_uevent(&bus->p->subsys.kobj, action);
return count;
}
在用户空间可以控制事件的发生,如echo add > event将产生一个add的事件。
接着继续bus_register（）中的代码：
priv->devices_kset = kset_create_and_add("devices", NULL,
&priv->subsys.kobj);
if (!priv->devices_kset) {
retval = -ENOMEM;
goto bus_devices_fail;
}
priv->drivers_kset = kset_create_and_add("drivers", NULL,
&priv->subsys.kobj);
if (!priv->drivers_kset) {
retval = -ENOMEM;
goto bus_drivers_fail;
}
创建两个kset，其内嵌object的parent都指向priv->subsys.kobj，说明其文件系统在bus所在目录下。由上回分析中知道kset_create_and_add()时其内嵌kobj的ktype指向kset_ktype，而这里没有输入参数的uevent_ops为NULL，则会以priv->subsys.kobj->kset->uevent_ops来产生事件，我们上面分析中知道这个uevent_ops为bus_uevent_ops，其filter会比较kobj的ktype是不是&bus_ktype，而这里是&kset_ktype，所以这里是忽略了事件。
klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put);
klist_init(&priv->klist_drivers, NULL, NULL);
初始化总线上设备和驱动的链表。
retval = add_probe_files(bus);
if (retval)
goto bus_probe_files_fail;
add_probe_files()函数如下：
static int add_probe_files(struct bus_type *bus)
{
int retval;
retval = bus_create_file(bus, &bus_attr_drivers_probe);
if (retval)
goto out;
retval = bus_create_file(bus, &bus_attr_drivers_autoprobe);
if (retval)
bus_remove_file(bus, &bus_attr_drivers_probe);
out:
return retval;
}
同上面创建bus_attr_uevent属性一样创建bus_attr_drivers_probe和bus_attr_drivers_autoprobe属性文件。粘出属性的代码：
static BUS_ATTR(drivers_probe, S_IWUSR, NULL, store_drivers_probe);
static BUS_ATTR(drivers_autoprobe, S_IWUSR | S_IRUGO,
show_drivers_autoprobe, store_drivers_autoprobe);
bus_attr_drivers_autoprobe的show指向NULL，说明其改文件不可写。
static ssize_t store_drivers_probe(struct bus_type *bus,
const char *buf, size_t count)
{
struct device *dev;
dev = bus_find_device_by_name(bus, NULL, buf);
if (!dev)
return -ENODEV;
if (bus_rescan_devices_helper(dev, NULL) != 0)
return -EINVAL;
return count;
}
将用户输(在用户空间)和的设备名称对应的设备与驱动匹配一次。
static ssize_t show_drivers_autoprobe(struct bus_type *bus, char *buf)
{
return sprintf(buf, "%d\n", bus->p->drivers_autoprobe);
}
在用户空间可以打印drivers_autoprobe的值,如cat drivers_autoprobe
static ssize_t store_drivers_autoprobe(struct bus_type *bus,
const char *buf, size_t count)
{
if (buf[0] == '0')
bus->p->drivers_autoprobe = 0;
else
bus->p->drivers_autoprobe = 1;
return count;
}
在用户空间可以改变drivers_autoprobe的值,如echo 1 > drivers_autoprobe
继续分析bus_register（）中的代码：
retval = bus_add_attrs(bus);
if (retval)
goto bus_attrs_fail;
bus_add_attrs()如下：
static int bus_add_attrs(struct bus_type *bus)
{
int error = 0;
int i;
if (bus->bus_attrs) {
for (i = 0; attr_name(bus->bus_attrs[i]); i++) {
error = bus_create_file(bus, &bus->bus_attrs[i]);
if (error)
goto err;
}
}
done:
return error;
err:
while (--i >= 0)
bus_remove_file(bus, &bus->bus_attrs[i]);
goto done;
}
如果bus->bus_attrs存在，则同样为其创建属性文件。
pr_debug("bus: '%s': registered\n", bus->name);
return 0;
bus_attrs_fail:
remove_probe_files(bus);
bus_probe_files_fail:
kset_unregister(bus->p->drivers_kset);
bus_drivers_fail:
kset_unregister(bus->p->devices_kset);
bus_devices_fail:
bus_remove_file(bus, &bus_attr_uevent);
bus_uevent_fail:
kset_unregister(&bus->p->subsys);
kfree(bus->p);
out:
bus->p = NULL;
return retval;
}
bus_register()分析完了，总结一下，它注册了一个总线类型，创建对应的文件系统（包括目录和属性），初始化总线上的驱动和设备，这样我们就可以通过内核提供的函数往总线上注册设备和驱动了。
