Linux设备模型简单笔记

最近分析了下Linux设备管理相关的代码【linux/drivers】,本来想偷个懒，直接转一篇Linux设备模型的文章呢，结果找了半天发现还不如自己笔记呢。。哎。。越来越懒了。。

这里我们以Linux2.6.11的源码为基础，简单的分析下设备模型框架相关的代码和实现。由于代码比较多，这里只简单的笔记下主干流程代码。

bus 

Linux设备驱动模型是以总线bus为基础框架的， 各种设备和驱动均挂载到指定的bus上 。

bus的数据类型定义：

device.h: struct bus_type { char * name; struct subsystem	subsys; /* bus实际上是以subsys为基础构建的 */ struct kset		drivers;/* bus上可以挂载多个driver */ struct kset		devices;/* bus上可以挂载多个device */ 。。。。。 。。。。。 };

当添加一个新的bus时，调用函数bus_register

bus.c： /* 这里声明了bus管理子系统bus_subsys，用来管理所有的bus实例。*/ decl_subsys(bus, &ktype_bus, NULL); /* 注册一个bus到kernel中，这里可以搜索下，会发现有很多地方调用了该函数 */ int bus_register(struct bus_type * bus) { int retval; retval = kobject_set_name(&bus->subsys.kset.kobj, "%s", bus->name); if (retval) goto out; /* 将bus实例添加到bus_subsys中 */ subsys_set_kset(bus, bus_subsys); retval = subsystem_register(&bus->subsys); if (retval) goto out; /* bus实例下管理的devices，这里也放到subsys中 */ kobject_set_name(&bus->devices.kobj, "devices"); bus->devices.subsys = &bus->subsys; retval = kset_register(&bus->devices); if (retval) goto bus_devices_fail; /* bus实例下管理的drivers，这里也放到subsys中 */ kobject_set_name(&bus->drivers.kobj, "drivers"); bus->drivers.subsys = &bus->subsys; bus->drivers.ktype = &ktype_driver; retval = kset_register(&bus->drivers); if (retval) goto bus_drivers_fail; bus_add_attrs(bus); pr_debug("bus type '%s' registered\n", bus->name); return 0; bus_drivers_fail: kset_unregister(&bus->devices); bus_devices_fail: subsystem_unregister(&bus->subsys); out: return retval; }

简单的分析完bus_register函数，我们以PCI总线为例，看下Linux：

#/sys/bus目录代表了bus_subsys #/sys/bus/pci目录代表了pci目录注册实例 [root@MyCloudServer pci]# pwd /sys/bus/pci [root@MyCloudServer pci]# ls #devices  drivers为两个目录，对应于bus_register函数 devices  drivers  drivers_autoprobe  drivers_probe  rescan  resource_alignment  slots  uevent

device 

分析完bus，我们来看下device，device的数据类型定义：

device.h: struct device { 。。。。。 。。。。。 /*
device挂在bus上，一个device只能对应一个driver，
*/ struct bus_type * bus; /* type of bus device is on */ struct device_driver *driver; /* which driver has allocated this
					   device */ 。。。。。 。。。。。 };

当添加一个新的设备时，会调用函数device_register

core.c： /*
这里声明了device管理子系统devices_subsys，用来管理所有的devices实例。同时由于device有挂在bus上，
因此bus上也会有一个device实例，是以超链接的形式链接的。
*/ decl_subsys(devices, &ktype_device, &device_hotplug_ops); int device_register(struct device *dev) { device_initialize(dev); return device_add(dev); } void device_initialize(struct device *dev) { /* 将device放到devices_subsys中 */ kobj_set_kset_s(dev, devices_subsys); kobject_init(&dev->kobj); INIT_LIST_HEAD(&dev->node); INIT_LIST_HEAD(&dev->children); INIT_LIST_HEAD(&dev->driver_list); INIT_LIST_HEAD(&dev->bus_list); INIT_LIST_HEAD(&dev->dma_pools); } int device_add(struct device *dev) { struct device *parent = NULL; int error = -EINVAL; 。。。。。 。。。。。 goto Error; if ((error = device_pm_add(dev))) goto PMError; /* 将device挂到bus上 */ if ((error = bus_add_device(dev))) goto BusError; down_write(&devices_subsys.rwsem); 。。。。。 。。。。。 } bus.c: int bus_add_device(struct device * dev) { struct bus_type * bus = get_bus(dev->bus); int error = 0; if (bus) { down_write(&dev->bus->subsys.rwsem); pr_debug("bus %s: add device %s\n", bus->name, dev->bus_id); list_add_tail(&dev->bus_list, &dev->bus->devices.list); device_attach(dev); up_write(&dev->bus->subsys.rwsem); device_add_attrs(bus, dev); /* 通过超链接的形式，将device挂到bus上 */ sysfs_create_link(&bus->devices.kobj, &dev->kobj, dev->bus_id); } return error; }

在Linux上找个例子看下：

[root@MyCloudServer devices]# pwd /sys/bus/xen/devices [root@MyCloudServer devices]# ls -l
total 0 #可以看到，这里是超链接的形式 lrwxrwxrwx 1 root root 0 Dec 12 23:40 vbd-51712 -> ../../../devices/vbd-51712 lrwxrwxrwx 1 root root 0 Dec 12 23:40 vbd-51728 -> ../../../devices/vbd-51728 lrwxrwxrwx 1 root root 0 Dec 12 23:40 vif-0 -> ../../../devices/vif-0

driver 

接着分析driver，driver数据类型定义：

device.h: struct device_driver { char * name; /* driver也是挂在bus上 */ struct bus_type * bus; struct semaphore	unload_sem; struct kobject		kobj; /* 一个driver可以对应多个device，比如一个USB驱动可以同时对应多个USB设备 */ struct list_head	devices; struct module * owner; 。。。。。 。。。。。 };

当添加一个新的driver时，会调用函数driver_register

driver.c： int driver_register(struct device_driver * drv) { INIT_LIST_HEAD(&drv->devices); init_MUTEX_LOCKED(&drv->unload_sem); return bus_add_driver(drv); } bus.c: int bus_add_driver(struct device_driver * drv) { struct bus_type * bus = get_bus(drv->bus); int error = 0; if (bus) { pr_debug("bus %s: add driver %s\n", bus->name, drv->name); error = kobject_set_name(&drv->kobj, "%s", drv->name); if (error) { put_bus(bus); return error; } /* 将driver挂到bus上 */ drv->kobj.kset = &bus->drivers; if ((error = kobject_register(&drv->kobj))) { put_bus(bus); return error; } down_write(&bus->subsys.rwsem); driver_attach(drv); up_write(&bus->subsys.rwsem); module_add_driver(drv->owner, drv); driver_add_attrs(bus, drv); } return error; }

那么device和driver是如何相互绑定的呢？这里简单的笔记几个函数：

bus.c: /* 尝试将一个device和一个driver绑定 */ int driver_probe_device(struct device_driver * drv, struct device * dev) { /* 总线如果有前期方法，先过滤下看能不能绑定 */ if (drv->bus->match && !drv->bus->match(dev, drv)) return -ENODEV; dev->driver = drv; /* driver如果有自己的绑定方法，也尝试绑定下 */ if (drv->probe) { int error = drv->probe(dev); if (error) { dev->driver = NULL; return error; } } device_bind_driver(dev); return 0; } /* 绑定device实例对应的driver */ int device_attach(struct device * dev) { struct bus_type * bus = dev->bus; struct list_head * entry; int error; /* 如果device实例已经声明了要绑定的driver了，那就没啥好说的了。*/ if (dev->driver) { device_bind_driver(dev); return 1; } if (bus->match) { /* 遍历当前bus上所有的driver，一个个尝试和device绑定，有一个成功就OK */ list_for_each(entry, &bus->drivers.list) { struct device_driver * drv = to_drv(entry); error = driver_probe_device(drv, dev); if (!error) /* success, driver matched */ return 1; if (error != -ENODEV && error != -ENXIO) /* driver matched but the probe failed */ printk(KERN_WARNING "%s: probe of %s failed with error %d\n", drv->name, dev->bus_id, error); } } return 0; } /* 一个新的driver进来了，看下当前device有没有需要绑定的 */ void driver_attach(struct device_driver * drv) { struct bus_type * bus = drv->bus; struct list_head * entry; int error; if (!bus->match) return; list_for_each(entry, &bus->devices.list) { /* 遍历当前bus上的device，如果有device还没有绑定driver，就尝试和本driver绑定下，
当前bus上所有的device都要遍历一遍。
 */ struct device * dev = container_of(entry, struct device, bus_list); if (!dev->driver) { error = driver_probe_device(drv, dev); if (error && (error != -ENODEV)) /* driver matched but the probe failed */ printk(KERN_WARNING "%s: probe of %s failed with error %d\n", drv->name, dev->bus_id, error); } } } 

class 

除了bus，device，driver这种竖向结构，Linxu设备模型还有一种横向结构，class。class是将不同bus下的同一种类型的device管理起来，比如：

[root@MyCloudServer net]# pwd /sys/class/net [root@MyCloudServer net]# ls -l
total 0 lrwxrwxrwx 1 root root 0 Dec 12 23:53 eth0 -> ../../devices/vif-0/net/eth0
lrwxrwxrwx 1 root root 0 Dec 12 23:53 lo -> ../../devices/virtual/net/lo

class数据结构如下：

device.h: struct class { char * name; struct subsystem	subsys; struct list_head	children; struct list_head	interfaces; struct class_attribute * class_attrs; struct class_device_attribute * class_dev_attrs; int (*hotplug)(struct class_device *dev, char **envp, int num_envp, char *buffer, int buffer_size); void (*release)(struct class_device *dev); void (*class_release)(struct class *class); };

当添加一个新的class时，会调用函数class_register。

class.c： /* 这里声明了class管理子系统class_subsys，用来管理所有的class实例。*/ static decl_subsys(class, &ktype_class, NULL); int class_register(struct class * cls) { int error; pr_debug("device class '%s': registering\n", cls->name); INIT_LIST_HEAD(&cls->children); INIT_LIST_HEAD(&cls->interfaces); error = kobject_set_name(&cls->subsys.kset.kobj, "%s", cls->name); if (error) return error; subsys_set_kset(cls, class_subsys); /* 将class注册到class_subsys上 */ error = subsystem_register(&cls->subsys); if (!error) { error = add_class_attrs(class_get(cls)); class_put(cls); } return error; }

class和device通过class_device结构体产生联系。

device.h: struct class_device { struct list_head	node; struct kobject		kobj; struct class * class; /* required */ struct device * dev; /* not necessary, but nice to have */ void * class_data; /* class-specific data */ char class_id[BUS_ID_SIZE]; /* unique to this class */ };

如果要绑定一个class和一个device，调用函数class_device_register。

class.c： int class_device_register(struct class_device *class_dev) { class_device_initialize(class_dev); return class_device_add(class_dev); } int class_device_add(struct class_device *class_dev) { 。。。。。。 。。。。。。 /* now take care of our own registration */ if (parent) { down_write(&parent->subsys.rwsem); list_add_tail(&class_dev->node, &parent->children); /* 此处循环是在添加device到class前进行前期处理 */ list_for_each_entry(class_intf, &parent->interfaces, node) if (class_intf->add) class_intf->add(class_dev); up_write(&parent->subsys.rwsem); } class_device_add_attrs(class_dev); /* 在class目录下创建链接 */ class_device_dev_link(class_dev); class_device_driver_link(class_dev); register_done: if (error && parent) class_put(parent); class_device_put(class_dev); return error; }

在分析class_device_add时可以看到代码中有一个前期处理循环，这里是用class_interface来定义的。

device.h: struct class_interface { struct list_head	node; struct class *class; int (*add) (struct class_device *); void (*remove) (struct class_device *); };

假如我们需要在device加入class前需要额外处理下，就可以通过调用class_interface_register函数来注册一个回调函数。

class.c: int class_interface_register(struct class_interface *class_intf) { struct class * parent; struct class_device * class_dev; if (!class_intf || !class_intf->class) return -ENODEV; parent = class_get(class_intf->class); if (!parent) return -EINVAL; down_write(&parent->subsys.rwsem); list_add_tail(&class_intf->node, &parent->interfaces); if (class_intf->add) { list_for_each_entry(class_dev, &parent->children, node) class_intf->add(class_dev); } up_write(&parent->subsys.rwsem); return 0; }

platform_device 

最后在简单的笔记下platform_device结构体。

device.h: /*
个人认为platform_device就是一个device，不过多了一个resource管理功能。
*/ struct platform_device { char * name; u32		id; struct device	dev; u32		num_resources; struct resource * resource; };

不过platform_device有两个特点： 
1 platform_device全部挂在struct bus_type platform_bus_type总线上。 
2 platform_device实例在device目录下有一个共同的父设备（文件夹）struct device platform_bus 。

具体platform_device就不笔记了，可以参考platform.c代码。