2025年linux设备模型七(device_driver细节)

linux设备模型七(device_driver细节)阅读这篇之前 建议先阅读我的下面这篇博客了解 device driver 的数据结构和大概作用 https blog csdn net article details 了解我的下面这篇博客可以对 device 部分了解清晰 同时 下面用到了 device 中相同的接口分析 也会略过 https

大家好,我是讯享网,很高兴认识大家。

阅读这篇之前,建议先阅读我的下面这篇博客了解device_driver的数据结构和大概作用。

https://blog.csdn.net/_/article/details/

了解我的下面这篇博客可以对device部分了解清晰。同时,下面用到了device中相同的接口分析,也会略过。

https://blog.csdn.net/_/article/details/

1.driver的注册过程

 / * driver_register - register driver with bus * @drv: driver to register * * We pass off most of the work to the bus_add_driver() call, * since most of the things we have to do deal with the bus * structures. */ int driver_register(struct device_driver *drv) { int ret; struct device_driver *other; BUG_ON(!drv->bus->p); /* driver的总线必须要有自己的subsys,因为这个才是整个bus连接device和driver的核心 */ /* driver和bus两种都实现了下面函数,而实际最只能执行一个,所以告警说重复 */ if ((drv->bus->probe && drv->probe) || (drv->bus->remove && drv->remove) || (drv->bus->shutdown && drv->shutdown)) printk(KERN_WARNING "Driver '%s' needs updating - please use " "bus_type methods\n", drv->name); /* 查找驱动是否已经装载,已经装载的则直接 */ other = driver_find(drv->name, drv->bus); if (other) { put_driver(other); printk(KERN_ERR "Error: Driver '%s' is already registered, " "aborting...\n", drv->name); return -EBUSY; } /* 把驱动加入总线的驱动链表 */ ret = bus_add_driver(drv); if (ret) return ret; /* 驱动加组 */ ret = driver_add_groups(drv, drv->groups); if (ret) { bus_remove_driver(drv); return ret; } kobject_uevent(&drv->p->kobj, KOBJ_ADD); /* 向上增报告一个增加事件 */ return ret; }

讯享网

1.1 查找总线bus下的driver链表有没有名为name的driver

讯享网 / * driver_find - locate driver on a bus by its name. * @name: name of the driver. * @bus: bus to scan for the driver. * * Call kset_find_obj() to iterate over list of drivers on * a bus to find driver by name. Return driver if found. * * This routine provides no locking to prevent the driver it returns * from being unregistered or unloaded while the caller is using it. * The caller is responsible for preventing this. */ struct device_driver *driver_find(const char *name, struct bus_type *bus) { struct kobject *k = kset_find_obj(bus->p->drivers_kset, name); /* 在bus所管理的driver链表中,查找有没有name这个driver */ struct driver_private *priv; if (k) { /* Drop reference added by kset_find_obj() */ kobject_put(k); /* 把该driver的kobject引用计数减1,kset_find_obj函数对其+1了 */ priv = to_driver(k); /* 通过driver里面的kobject返回driver */ return priv->driver; } return NULL; }

1.1.1  遍历kset的kobject链表中有没有名为name的kobject

 / * kset_find_obj - search for object in kset. * @kset: kset we're looking in. * @name: object's name. * * Lock kset via @kset->subsys, and iterate over @kset->list, * looking for a matching kobject. If matching object is found * take a reference and return the object. */ struct kobject *kset_find_obj(struct kset *kset, const char *name) { struct kobject *k; struct kobject *ret = NULL; spin_lock(&kset->list_lock); /* 查找方法很简单,依次遍历bus的driver链表每个driver的kobject的name,如果有相同的返回对应的kobject */ list_for_each_entry(k, &kset->list, entry) { if (kobject_name(k) && !strcmp(kobject_name(k), name)) { ret = kobject_get(k); /* 记住,找到的话,这里对其引用计数+1了 */ break; } } spin_unlock(&kset->list_lock); return ret; }

上面步骤很简单,我在网上找到了一个图,可以更形象的描述上面的过程


讯享网

 

1.2 把driver放入bus的driver链表中去

讯享网 / * bus_add_driver - Add a driver to the bus. * @drv: driver. */ int bus_add_driver(struct device_driver *drv) { struct bus_type *bus; struct driver_private *priv; int error = 0; bus = bus_get(drv->bus); /* 得到bus */ if (!bus) return -EINVAL; pr_debug("bus: '%s': add driver %s\n", bus->name, drv->name); /* bus有自己的private,device有自己的private,driver也必须有自己的啊,他们的功能就是负责连接对方 */ priv = kzalloc(sizeof(*priv), GFP_KERNEL); if (!priv) { error = -ENOMEM; goto out_put_bus; } /* 初始化klist,以及填充dricer的private里面的内容 */ klist_init(&priv->klist_devices, NULL, NULL); priv->driver = drv; drv->p = priv; priv->kobj.kset = bus->p->drivers_kset; /* driver绑定bus(通过各自里面的privte) */ error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL, "%s", drv->name); if (error) goto out_unregister; /* 把driver在bus的节点,加入到bus的driver链表的最后一个 */ klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers); /* 前面算是已经把driver注册到对应的bus里面了 */ /* 默认所有的bus都是开启autoprobe的,除非应用层给写0,关闭了 */ if (drv->bus->p->drivers_autoprobe) { if (driver_allows_async_probing(drv)) { /* 查看driver的probe_type支不支持异步匹配 */ pr_debug("bus: '%s': probing driver %s asynchronously\n", drv->bus->name, drv->name); async_schedule(driver_attach_async, drv); /* 支持异步匹配,则重开一个线程,执行driver_attach_async函数,在那个线程中执行匹配 */ } else { error = driver_attach(drv); /* 不支持异步匹配,则直接在这个函数中匹配 */ if (error) goto out_unregister; } } module_add_driver(drv->owner, drv); error = driver_create_file(drv, &driver_attr_uevent); if (error) { printk(KERN_ERR "%s: uevent attr (%s) failed\n", __func__, drv->name); } error = driver_add_groups(drv, bus->drv_groups); if (error) { /* How the hell do we get out of this pickle? Give up */ printk(KERN_ERR "%s: driver_create_groups(%s) failed\n", __func__, drv->name); } if (!drv->suppress_bind_attrs) { error = add_bind_files(drv); if (error) { /* Ditto */ printk(KERN_ERR "%s: add_bind_files(%s) failed\n", __func__, drv->name); } } return 0; out_unregister: kobject_put(&priv->kobj); /* drv->p is freed in driver_release() */ drv->p = NULL; out_put_bus: bus_put(bus); return error; }

1.2.1 可以看一下下面的,异步匹配和同步匹配是完全一样的代码,只不过异步匹配是多开一个线程(多核cpu有效),在里面指行匹配(这样可以不影响本cpu的效率,因为一般同一个bus上的device还是很多的,一个一个匹配要很久的。)

static void driver_attach_async(void *_drv, async_cookie_t cookie) { struct device_driver *drv = _drv; int ret; ret = driver_attach(drv); pr_debug("bus: '%s': driver %s async attach completed: %d\n", drv->bus->name, drv->name, ret); }

1.2.2 通过driver匹配同一bus上的device

讯享网/ * driver_attach - try to bind driver to devices. * @drv: driver. * * Walk the list of devices that the bus has on it and try to * match the driver with each one. If driver_probe_device() * returns 0 and the @dev->driver is set, we've found a * compatible pair. */ int driver_attach(struct device_driver *drv) { return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach); }

1.2.2.1 给出匹配函数,driver匹配同一总线下的device。注意对比上篇的bus_for_each_drv,比较异同。

 / * bus_for_each_dev - device iterator. * @bus: bus type. * @start: device to start iterating from. * @data: data for the callback. * @fn: function to be called for each device. * * Iterate over @bus's list of devices, and call @fn for each, * passing it @data. If @start is not NULL, we use that device to * begin iterating from. * * We check the return of @fn each time. If it returns anything * other than 0, we break out and return that value. * * NOTE: The device that returns a non-zero value is not retained * in any way, nor is its refcount incremented. If the caller needs * to retain this data, it should do so, and increment the reference * count in the supplied callback. */ int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data, int (*fn)(struct device *, void *)) { struct klist_iter i; struct device *dev; int error = 0; if (!bus || !bus->p) return -EINVAL; /* 把总线上的device链表的头节点给i(注意头节点是不带有效信息的) */ klist_iter_init_node(&bus->p->klist_devices, &i, (start ? &start->p->knode_bus : NULL)); while ((dev = next_device(&i)) && !error) /* 从第一个device开始,调用fn函数,匹配driver和device */ error = fn(dev, data); klist_iter_exit(&i); /* 结束使用klist */ return error; }

注意:一个驱动可能匹配到多个device,所以上面的匹配除非发生错误,否则就要匹配整个链表的device.

1.2.2.2 drivace匹配device函数,对比上篇的__device_attach_driver函数,结构个功能都是一样的。

讯享网static inline int driver_match_device(struct device_driver *drv, struct device *dev) { /* 调用bus的match函数匹配,bus的match函数不存在,则返回1 */ return drv->bus->match ? drv->bus->match(dev, drv) : 1; } static int __driver_attach(struct device *dev, void *data) { struct device_driver *drv = data; int ret; /* * Lock device and try to bind to it. We drop the error * here and always return 0, because we need to keep trying * to bind to devices and some drivers will return an error * simply if it didn't support the device. * * driver_probe_device() will spit a warning if there * is an error. */ ret = driver_match_device(drv, dev); /* 在本函数上面,使用bus的match函数匹配 */ if (ret == 0) { /* 为0,没匹配到 */ /* no match */ return 0; } else if (ret == -EPROBE_DEFER) { dev_dbg(dev, "Device match requests probe deferral\n"); driver_deferred_probe_add(dev); /* 重新匹配 */ } else if (ret < 0) { dev_dbg(dev, "Bus failed to match device: %d", ret); /* 总线错误 */ return ret; } /* ret > 0 means positive match */ /* 大于0,标明正在匹配(配上了,但还有一些操作要执行) */ /* 到这里以及匹配到了,接下来就是要真正连接device和driver,以及执行probe函数了 */ if (dev->parent) /* Needed for USB */ device_lock(dev->parent); /* 设备的parent锁定,不能执行睡眠,卸载之类的操作,否则下面driver_probe_device函数如果匹配上指行probe函数,就没parent了 */ device_lock(dev); /* 要用device了,device肯定不能出乱子啊,否则删除了,这里的device接下来的操作就成野指针了 */ if (!dev->driver) /* 该device没driver,执行下句函数-----device有driver,还能匹配再到一个driver也是神了 */ driver_probe_device(drv, dev); /* 绑定device和driver,调用probe函数, */ device_unlock(dev); /* 注册好后,device就可以随意了 */ if (dev->parent) device_unlock(dev->parent); /* */ return 0; }

1.2.2.3 device和driver绑定,并指向probe函数

我的上一篇博客的后面有分析到,这里就不重复了。

https://blog.csdn.net/_/article/details/

 

总结:

1.为什么device匹配一次driver,又driver匹配一次divice?

比如:先注册的device,device在初始化的时候也绑定了bus,之后就可以主动联系自己所属bus,进一步可以通过自己所属的bus的private找到bus的driver链表,,逐个匹配同一bus上的driver。(这里我们举例是先注册的drvice,所以肯定匹配不到)

接下来注册driver,如driver,初始化的时候也绑定了bus,之后就主动联系自己所属bus,进一步可以通过自己所属的bus的private找到bus的device链表,逐个匹配同一bus上的driver。(上面device已经先于driver注册,这次肯定可以匹配到)

相反:先注册driver(driver匹配不到device),后注册device(也能匹配到driver)。

这就是为什么要即在device注册的时候匹配driver,又要在driver注册的时候匹配device的原因,因为不能确定到底驱动工程师是先注册driver还是先注册device。

2. bus有自己的subsys_private ,device有自己的device_private ,driver也有自己的driver_private,他们的功能就是负责连接对方。(下面我放出来了他们的数据结构,可以看一下,他们之间是通过klist_node 强化版的链表,互相连接起来的)

struct driver_private { struct kobject kobj; struct klist klist_devices; /* 一个driver可以支持多个device,所以这里用链表连接它所支持的device */ struct klist_node knode_bus; /* bus下所有driver组成一个链表,表头是bus的klist_drivers */ struct module_kobject *mkobj; struct device_driver *driver; }; / * struct device_private - structure to hold the private to the driver core portions of the device structure. * * @klist_children - klist containing all children of this device * @knode_parent - node in sibling list * @knode_driver - node in driver list * @knode_bus - node in bus list * @deferred_probe - entry in deferred_probe_list which is used to retry the * binding of drivers which were unable to get all the resources needed by * the device; typically because it depends on another driver getting * probed first. * @device - pointer back to the struct device that this structure is * associated with. * * Nothing outside of the driver core should ever touch these fields. */ struct device_private { struct klist klist_children; struct klist_node knode_parent; struct klist_node knode_driver; /* 一个driver可以支持多个device,该device就是靠这个节点加入到匹配到的driver的链表的 */ struct klist_node knode_bus; /* bus下所有device组成一个链表,表头是bus的klist_devices */ struct list_head deferred_probe; struct device *device; }; / * struct subsys_private - structure to hold the private to the driver core portions of the bus_type/class structure. * * @subsys - the struct kset that defines this subsystem * @devices_kset - the subsystem's 'devices' directory * @interfaces - list of subsystem interfaces associated * @mutex - protect the devices, and interfaces lists. * * @drivers_kset - the list of drivers associated * @klist_devices - the klist to iterate over the @devices_kset * @klist_drivers - the klist to iterate over the @drivers_kset * @bus_notifier - the bus notifier list for anything that cares about things * on this bus. * @bus - pointer back to the struct bus_type that this structure is associated * with. * * @glue_dirs - "glue" directory to put in-between the parent device to * avoid namespace conflicts * @class - pointer back to the struct class that this structure is associated * with. * * This structure is the one that is the actual kobject allowing struct * bus_type/class to be statically allocated safely. Nothing outside of the * driver core should ever touch these fields. */ struct subsys_private { struct kset subsys; struct kset *devices_kset; /* 负责连接它下面的所有device的目录 */ struct list_head interfaces; struct mutex mutex; struct kset *drivers_kset; /* 负责连接它下面的所有driver的目录 */ struct klist klist_devices; /* 负责连接它下面的所有device的链表 */ struct klist klist_drivers; /* 负责连接它下面的所有driver的链表 */ struct blocking_notifier_head bus_notifier; unsigned int drivers_autoprobe:1; struct bus_type *bus; struct kset glue_dirs; struct class *class; }; 

 

小讯
上一篇 2025-04-03 08:02
下一篇 2025-01-17 23:19

相关推荐

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容,请联系我们,一经查实,本站将立刻删除。
如需转载请保留出处:https://51itzy.com/kjqy/114172.html