xref: /DragonOS/kernel/src/driver/base/device/bus.rs (revision 4b0170bd6bb374d0e9699a0076cc23b976ad6db7)
1 use super::{
2     driver::{Driver, DriverMatchName, DriverMatcher},
3     sys_devices_kset, Device, DeviceMatchName, DeviceMatcher, DeviceState,
4 };
5 use crate::{
6     driver::base::{
7         device::{device_manager, driver::driver_manager},
8         kobject::{KObjType, KObject, KObjectManager},
9         kset::KSet,
10         subsys::SubSysPrivate,
11     },
12     filesystem::{
13         sysfs::{
14             file::sysfs_emit_str, sysfs_instance, Attribute, AttributeGroup, SysFSOps,
15             SysFSOpsSupport, SYSFS_ATTR_MODE_RW, SYSFS_ATTR_MODE_WO,
16         },
17         vfs::syscall::ModeType,
18     },
19     libs::rwlock::RwLock,
20 };
21 use alloc::{
22     string::{String, ToString},
23     sync::{Arc, Weak},
24 };
25 use core::{ffi::CStr, fmt::Debug, intrinsics::unlikely};
26 use hashbrown::HashMap;
27 use intertrait::cast::CastArc;
28 use system_error::SystemError;
29 
30 /// `/sys/bus`的kset
31 static mut BUS_KSET_INSTANCE: Option<Arc<KSet>> = None;
32 /// `/sys/devices/system`的kset
33 static mut DEVICES_SYSTEM_KSET_INSTANCE: Option<Arc<KSet>> = None;
34 
35 static mut BUS_MANAGER_INSTANCE: Option<BusManager> = None;
36 
37 #[inline(always)]
38 pub fn sys_bus_kset() -> Arc<KSet> {
39     unsafe { BUS_KSET_INSTANCE.clone().unwrap() }
40 }
41 
42 #[inline(always)]
43 #[allow(dead_code)]
44 pub fn sys_devices_system_kset() -> Arc<KSet> {
45     unsafe { DEVICES_SYSTEM_KSET_INSTANCE.clone().unwrap() }
46 }
47 
48 #[inline(always)]
49 pub fn bus_manager() -> &'static BusManager {
50     unsafe { BUS_MANAGER_INSTANCE.as_ref().unwrap() }
51 }
52 
53 #[inline(always)]
54 pub fn subsystem_manager() -> &'static SubSystemManager {
55     &SubSystemManager
56 }
57 
58 /// @brief: 总线状态
59 #[derive(Debug, Copy, Clone)]
60 pub enum BusState {
61     NotInitialized = 0, // 未初始化
62     Initialized = 1,    // 已初始化
63     UnDefined = 2,      // 未定义的
64 }
65 
66 /// @brief: 将u32类型转换为总线状态类型
67 impl From<u32> for BusState {
68     fn from(state: u32) -> Self {
69         match state {
70             0 => BusState::NotInitialized,
71             1 => BusState::Initialized,
72             _ => BusState::UnDefined,
73         }
74     }
75 }
76 
77 /// @brief: 将总线状态类型转换为u32类型
78 impl From<DeviceState> for BusState {
79     fn from(state: DeviceState) -> Self {
80         match state {
81             DeviceState::Initialized => BusState::Initialized,
82             DeviceState::NotInitialized => BusState::NotInitialized,
83             DeviceState::UnDefined => BusState::UnDefined,
84         }
85     }
86 }
87 
88 /// @brief: 将总线状态类型转换为设备状态类型
89 impl From<BusState> for DeviceState {
90     fn from(state: BusState) -> Self {
91         match state {
92             BusState::Initialized => DeviceState::Initialized,
93             BusState::NotInitialized => DeviceState::NotInitialized,
94             BusState::UnDefined => DeviceState::UnDefined,
95         }
96     }
97 }
98 
99 /// 总线子系统的trait,所有总线都应实现该trait
100 ///
101 /// 请注意,这个trait是用于实现总线子系统的,而不是总线驱动/总线设备。
102 /// https://code.dragonos.org.cn/xref/linux-6.1.9/include/linux/device/bus.h#84
103 pub trait Bus: Debug + Send + Sync {
104     fn name(&self) -> String;
105     /// Used for subsystems to enumerate devices like ("foo%u", dev->id).
106     fn dev_name(&self) -> String;
107     fn root_device(&self) -> Option<Weak<dyn Device>> {
108         None
109     }
110 
111     fn set_root_device(&self, _dev: Option<Weak<dyn Device>>) {}
112 
113     /// 总线上的设备的默认属性组
114     fn dev_groups(&self) -> &'static [&'static dyn AttributeGroup] {
115         &[]
116     }
117 
118     /// 总线的默认属性组
119     fn bus_groups(&self) -> &'static [&'static dyn AttributeGroup] {
120         &[]
121     }
122 
123     /// 总线上的驱动的默认属性组
124     fn drv_groups(&self) -> &'static [&'static dyn AttributeGroup] {
125         &[]
126     }
127 
128     /// 检查设备是否可以被总线绑定,如果可以,就绑定它们。
129     /// 绑定之后,device的driver字段会被设置为驱动实例。
130     ///
131     /// ## 参数
132     ///
133     /// - `device` - 设备实例
134     ///
135     /// ## 默认实现
136     ///
137     /// 如果总线不支持该操作,返回`SystemError::EOPNOTSUPP_OR_ENOTSUP`
138     fn probe(&self, _device: &Arc<dyn Device>) -> Result<(), SystemError> {
139         return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
140     }
141     fn remove(&self, _device: &Arc<dyn Device>) -> Result<(), SystemError>;
142     fn sync_state(&self, _device: &Arc<dyn Device>) {}
143     fn shutdown(&self, _device: &Arc<dyn Device>);
144     fn suspend(&self, _device: &Arc<dyn Device>) {
145         // todo: implement suspend
146     }
147 
148     fn resume(&self, device: &Arc<dyn Device>) -> Result<(), SystemError>;
149 
150     /// match platform device to platform driver.
151     ///
152     /// ## 参数
153     ///
154     /// * `device` - platform device
155     /// * `driver` - platform driver
156     ///
157     /// ## 返回
158     ///
159     /// - `Ok(true)` - 匹配成功
160     /// - `Ok(false)` - 匹配失败
161     /// - `Err(_)` - 由于内部错误导致匹配失败
162     /// - `Err(SystemError::ENOSYS)` - 该总线不支持该操作
163     fn match_device(
164         &self,
165         _device: &Arc<dyn Device>,
166         _driver: &Arc<dyn Driver>,
167     ) -> Result<bool, SystemError> {
168         return Err(SystemError::ENOSYS);
169     }
170 
171     fn subsystem(&self) -> &SubSysPrivate;
172 
173     /// 对当前总线操作的时候需要获取父级总线的锁
174     fn need_parent_lock(&self) -> bool {
175         false
176     }
177 }
178 
179 impl dyn Bus {
180     /// 在bus上,根据条件寻找一个特定的设备
181     ///
182     /// ## 参数
183     ///
184     /// - `matcher` - 匹配器
185     /// - `data` - 传给匹配器的数据
186     pub fn find_device<T: Copy>(
187         &self,
188         matcher: &dyn DeviceMatcher<T>,
189         data: T,
190     ) -> Option<Arc<dyn Device>> {
191         let subsys = self.subsystem();
192         let guard = subsys.devices();
193         for dev in guard.iter() {
194             if matcher.match_device(dev, data) {
195                 return Some(dev.clone());
196             }
197         }
198         return None;
199     }
200 
201     /// 根据名称匹配设备
202     ///
203     /// ## 参数
204     ///
205     /// - name 设备名称
206     pub fn find_device_by_name(&self, name: &str) -> Option<Arc<dyn Device>> {
207         return self.find_device(&DeviceMatchName, name);
208     }
209 
210     /// 在bus上,根据条件寻找一个特定的驱动
211     ///
212     /// ## 参数
213     ///
214     /// - `matcher` - 匹配器
215     /// - `data` - 传给匹配器的数据
216     pub fn find_driver<T: Copy>(
217         &self,
218         matcher: &dyn DriverMatcher<T>,
219         data: T,
220     ) -> Option<Arc<dyn Driver>> {
221         let subsys = self.subsystem();
222         let guard = subsys.drivers();
223         for drv in guard.iter() {
224             if matcher.match_driver(drv, data) {
225                 return Some(drv.clone());
226             }
227         }
228         return None;
229     }
230 
231     /// 根据名称在bus上匹配驱动
232     pub fn find_driver_by_name(&self, name: &str) -> Option<Arc<dyn Driver>> {
233         return self.find_driver(&DriverMatchName, name);
234     }
235 }
236 
237 /// @brief: 总线管理结构体
238 #[derive(Debug)]
239 pub struct BusManager {
240     /// 存储总线bus的kset结构体与bus实例的映射(用于在sysfs callback的时候,根据kset找到bus实例)
241     kset_bus_map: RwLock<HashMap<Arc<KSet>, Arc<dyn Bus>>>,
242 }
243 
244 impl BusManager {
245     pub fn new() -> Self {
246         return Self {
247             kset_bus_map: RwLock::new(HashMap::new()),
248         };
249     }
250 
251     /// 把一个设备添加到总线上
252     ///
253     /// ## 描述
254     ///
255     /// - 添加一个设备的与bus相关的属性
256     /// - 在bus和设备文件夹下,创建软链接
257     /// - 把设备添加到它的总线的设备列表中
258     ///
259     /// 参考: https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/bus.c?fi=bus_add_device#441
260     ///
261     /// ## 参数
262     ///
263     /// - `dev` - 要被添加的设备
264     pub fn add_device(&self, dev: &Arc<dyn Device>) -> Result<(), SystemError> {
265         let bus = dev.bus().and_then(|bus| bus.upgrade());
266         if let Some(bus) = bus {
267             device_manager().add_groups(dev, bus.dev_groups())?;
268 
269             // 增加符号链接
270             let bus_devices_kset = bus
271                 .subsystem()
272                 .devices_kset()
273                 .expect("bus devices kset is none, maybe bus is not registered");
274             let dev_kobj = dev.clone() as Arc<dyn KObject>;
275 
276             sysfs_instance().create_link(
277                 Some(&bus_devices_kset.as_kobject()),
278                 &dev_kobj,
279                 dev.name(),
280             )?;
281             sysfs_instance().create_link(
282                 Some(&dev_kobj),
283                 &bus.subsystem().subsys().as_kobject(),
284                 "subsystem".to_string(),
285             )?;
286             bus.subsystem().add_device_to_vec(dev)?;
287         }
288         return Ok(());
289     }
290 
291     /// 在总线上添加一个驱动
292     ///
293     /// 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/bus.c?fi=bus_add_driver#590
294     pub fn add_driver(&self, driver: &Arc<dyn Driver>) -> Result<(), SystemError> {
295         let bus = driver
296             .bus()
297             .and_then(|bus| bus.upgrade())
298             .ok_or(SystemError::EINVAL)?;
299         kdebug!("bus '{}' add driver '{}'", bus.name(), driver.name());
300 
301         driver.set_kobj_type(Some(&BusDriverKType));
302         let kobj = driver.clone() as Arc<dyn KObject>;
303         KObjectManager::add_kobj(kobj, bus.subsystem().drivers_kset())?;
304 
305         bus.subsystem().add_driver_to_vec(driver)?;
306         if bus.subsystem().drivers_autoprobe() {
307             let r = driver_manager().driver_attach(driver);
308             if let Err(e) = r {
309                 bus.subsystem().remove_driver_from_vec(driver);
310                 return Err(e);
311             }
312         }
313 
314         driver_manager()
315             .add_groups(driver, bus.drv_groups())
316             .map_err(|e| {
317                 kerror!(
318                     "BusManager::add_driver: driver '{:?}' add_groups failed, err: '{:?}",
319                     driver.name(),
320                     e
321                 );
322                 e
323             })
324             .ok();
325 
326         if !driver.suppress_bind_attrs() {
327             self.add_bind_files(driver)
328                 .map_err(|e| {
329                     kerror!(
330                         "BusManager::add_driver: driver '{:?}' add_bind_files failed, err: '{:?}",
331                         driver.name(),
332                         e
333                     );
334                     e
335                 })
336                 .ok();
337         }
338 
339         return Ok(());
340     }
341 
342     ///
343     /// bus_register - register a driver-core subsystem
344     ///
345     /// ## 参数
346     /// - `bus` - bus to register
347     ///
348     /// Once we have that, we register the bus with the kobject
349     /// infrastructure, then register the children subsystems it has:
350     /// the devices and drivers that belong to the subsystem.
351     ///
352     /// 参考: https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/bus.c?fi=bus_register#783
353     ///
354     /// todo: 增加错误处理逻辑
355     pub fn register(&self, bus: Arc<dyn Bus>) -> Result<(), SystemError> {
356         bus.subsystem().set_bus(Some(Arc::downgrade(&bus)));
357 
358         let subsys_kset = bus.subsystem().subsys();
359         subsys_kset.set_name(bus.name());
360         bus.subsystem().set_drivers_autoprobe(true);
361 
362         subsys_kset.register(Some(sys_bus_kset()))?;
363 
364         let devices_kset =
365             KSet::new_and_add("devices".to_string(), None, Some(subsys_kset.clone()))?;
366         bus.subsystem().set_devices_kset(devices_kset);
367         let drivers_kset =
368             KSet::new_and_add("drivers".to_string(), None, Some(subsys_kset.clone()))?;
369         bus.subsystem().set_drivers_kset(drivers_kset);
370 
371         self.add_probe_files(&bus)?;
372         let bus_groups = bus.bus_groups();
373         self.add_groups(&bus, bus_groups)?;
374         // 把bus实例添加到总线管理器中(方便在sysfs callback的时候,根据kset找到bus实例)
375         self.kset_bus_map.write().insert(subsys_kset, bus.clone());
376         return Ok(());
377     }
378 
379     pub fn unregister(&self, _bus: Arc<dyn Bus>) -> Result<(), SystemError> {
380         todo!("bus_unregister")
381     }
382 
383     fn add_probe_files(&self, bus: &Arc<dyn Bus>) -> Result<(), SystemError> {
384         self.create_file(bus, &BusAttrDriversProbe)?;
385         let r = self.create_file(bus, &BusAttrDriversAutoprobe);
386 
387         if r.is_err() {
388             self.remove_file(bus, &BusAttrDriversProbe);
389         }
390         return r;
391     }
392 
393     #[allow(dead_code)]
394     fn remove_probe_files(&self, bus: &Arc<dyn Bus>) {
395         self.remove_file(bus, &BusAttrDriversAutoprobe);
396         self.remove_file(bus, &BusAttrDriversProbe);
397     }
398 
399     fn create_file(
400         &self,
401         bus: &Arc<dyn Bus>,
402         attr: &'static dyn Attribute,
403     ) -> Result<(), SystemError> {
404         let bus_kobj = bus.subsystem().subsys() as Arc<dyn KObject>;
405         return sysfs_instance().create_file(&bus_kobj, attr);
406     }
407 
408     fn remove_file(&self, bus: &Arc<dyn Bus>, attr: &'static dyn Attribute) {
409         let bus_kobj = bus.subsystem().subsys() as Arc<dyn KObject>;
410         sysfs_instance().remove_file(&bus_kobj, attr);
411     }
412 
413     #[inline]
414     fn add_groups(
415         &self,
416         bus: &Arc<dyn Bus>,
417         groups: &[&'static dyn AttributeGroup],
418     ) -> Result<(), SystemError> {
419         let bus_kobj = bus.subsystem().subsys() as Arc<dyn KObject>;
420         return sysfs_instance().create_groups(&bus_kobj, groups);
421     }
422 
423     /// 根据bus的kset找到bus实例
424     fn get_bus_by_kset(&self, kset: &Arc<KSet>) -> Option<Arc<dyn Bus>> {
425         return self.kset_bus_map.read().get(kset).cloned();
426     }
427 
428     /// 为bus上的设备选择可能的驱动程序
429     ///
430     /// 这个函数会扫描总线上的所有没有驱动的设备,然后为它们选择可能的驱动程序。
431     ///
432     /// ## 参数
433     ///
434     /// - `bus` - bus实例
435     #[allow(dead_code)]
436     pub fn rescan_devices(&self, bus: &Arc<dyn Bus>) -> Result<(), SystemError> {
437         for dev in bus.subsystem().devices().iter() {
438             rescan_devices_helper(dev)?;
439         }
440         return Ok(());
441     }
442 
443     /// 为新设备探测驱动
444     ///
445     /// Automatically probe for a driver if the bus allows it.
446     pub fn probe_device(&self, dev: &Arc<dyn Device>) {
447         let bus = dev.bus().and_then(|bus| bus.upgrade());
448         if bus.is_none() {
449             return;
450         }
451         let bus = bus.unwrap();
452         if bus.subsystem().drivers_autoprobe() {
453             device_manager().device_initial_probe(dev).ok();
454         }
455         for interface in bus.subsystem().interfaces() {
456             interface.add_device(dev).ok();
457         }
458     }
459 
460     /// 从总线上移除一个驱动
461     ///
462     /// Detach the driver from the devices it controls, and remove
463     /// it from its bus's list of drivers. Finally, we drop the reference
464     /// to the bus.
465     ///
466     /// ## 参数
467     ///
468     /// - `driver` - 驱动实例
469     ///
470     /// 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/bus.c?fi=bus_remove_driver#666
471     pub fn remove_driver(&self, _driver: &Arc<dyn Driver>) {
472         todo!("BusManager::remove_driver")
473     }
474 
475     fn add_bind_files(&self, driver: &Arc<dyn Driver>) -> Result<(), SystemError> {
476         driver_manager().create_attr_file(driver, &DriverAttrUnbind)?;
477 
478         driver_manager()
479             .create_attr_file(driver, &DriverAttrBind)
480             .map_err(|e| {
481                 driver_manager().remove_attr_file(driver, &DriverAttrUnbind);
482                 e
483             })?;
484 
485         return Ok(());
486     }
487 }
488 
489 /// 参考: https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/bus.c?r=&mo=5649&fi=241#684
490 fn rescan_devices_helper(dev: &Arc<dyn Device>) -> Result<(), SystemError> {
491     if dev.driver().is_none() {
492         let need_parent_lock = dev
493             .bus()
494             .map(|bus| bus.upgrade().unwrap().need_parent_lock())
495             .unwrap_or(false);
496         if unlikely(need_parent_lock) {
497             // todo: lock device parent
498             unimplemented!()
499         }
500         device_manager().device_attach(dev)?;
501     }
502     return Ok(());
503 }
504 
505 ///
506 /// bus_register - register a driver-core subsystem
507 ///
508 /// ## 参数
509 /// - `bus` - bus to register
510 ///
511 /// Once we have that, we register the bus with the kobject
512 /// infrastructure, then register the children subsystems it has:
513 /// the devices and drivers that belong to the subsystem.
514 pub fn bus_register(bus: Arc<dyn Bus>) -> Result<(), SystemError> {
515     return bus_manager().register(bus);
516 }
517 
518 /// @brief: 总线注销,并在sys/bussys/devices下删除文件夹
519 /// @parameter bus: Bus设备实体
520 /// @return: 成功:()   失败:SystemError
521 #[allow(dead_code)]
522 pub fn bus_unregister(bus: Arc<dyn Bus>) -> Result<(), SystemError> {
523     return bus_manager().unregister(bus);
524 }
525 
526 pub fn buses_init() -> Result<(), SystemError> {
527     let bus_kset = KSet::new("bus".to_string());
528     bus_kset.register(None).expect("bus kset register failed");
529     unsafe {
530         BUS_KSET_INSTANCE = Some(bus_kset);
531     }
532 
533     // 初始化 /sys/devices/system
534     {
535         let devices_system_kset = KSet::new("system".to_string());
536         let parent = sys_devices_kset() as Arc<dyn KObject>;
537         devices_system_kset.set_parent(Some(Arc::downgrade(&parent)));
538         devices_system_kset
539             .register(Some(sys_devices_kset()))
540             .expect("devices system kset register failed");
541         unsafe {
542             DEVICES_SYSTEM_KSET_INSTANCE = Some(devices_system_kset);
543         }
544     }
545 
546     // 初始化总线管理器
547     {
548         let bus_manager = BusManager::new();
549         unsafe {
550             BUS_MANAGER_INSTANCE = Some(bus_manager);
551         }
552     }
553     return Ok(());
554 }
555 
556 /// 把一个设备添加到总线上
557 ///
558 /// ## 描述
559 ///
560 /// - 添加一个设备的与bus相关的属性
561 /// - 在bus和设备文件夹下,创建软链接
562 /// - 把设备添加到它的总线的设备列表中
563 ///
564 /// 参考: https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/bus.c?fi=bus_add_device#441
565 ///
566 /// ## 参数
567 ///
568 /// - `dev` - 要被添加的设备
569 pub fn bus_add_device(dev: &Arc<dyn Device>) -> Result<(), SystemError> {
570     return bus_manager().add_device(dev);
571 }
572 
573 /// 自动为设备在总线上寻找可用的驱动程序
574 ///
575 /// Automatically probe for a driver if the bus allows it.
576 ///
577 /// ## 参数
578 ///
579 /// - `dev` - 要被添加的设备
580 ///
581 /// 参考: https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/bus.c?fi=bus_probe_device#478
582 pub fn bus_probe_device(dev: &Arc<dyn Device>) {
583     kinfo!("bus_probe_device: dev: {:?}", dev.name());
584     bus_manager().probe_device(dev);
585 }
586 
587 #[derive(Debug)]
588 struct BusAttrDriversProbe;
589 
590 impl Attribute for BusAttrDriversProbe {
591     fn mode(&self) -> ModeType {
592         return ModeType::S_IWUSR;
593     }
594 
595     fn name(&self) -> &str {
596         return "drivers_probe";
597     }
598 
599     fn support(&self) -> SysFSOpsSupport {
600         return SysFSOpsSupport::ATTR_STORE;
601     }
602 
603     /// 参考: https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/bus.c?r=&mo=5649&fi=241#241
604     fn store(&self, kobj: Arc<dyn KObject>, buf: &[u8]) -> Result<usize, SystemError> {
605         let kset: Arc<KSet> = kobj.arc_any().downcast().map_err(|_| SystemError::EINVAL)?;
606         let bus = bus_manager()
607             .get_bus_by_kset(&kset)
608             .ok_or(SystemError::EINVAL)?;
609 
610         let name = CStr::from_bytes_with_nul(buf)
611             .map_err(|_| SystemError::EINVAL)?
612             .to_str()
613             .map_err(|_| SystemError::EINVAL)?;
614 
615         let device = bus.find_device_by_name(name).ok_or(SystemError::ENODEV)?;
616 
617         if rescan_devices_helper(&device).is_ok() {
618             return Ok(buf.len());
619         }
620 
621         return Err(SystemError::EINVAL);
622     }
623 }
624 
625 #[derive(Debug)]
626 struct BusAttrDriversAutoprobe;
627 
628 impl Attribute for BusAttrDriversAutoprobe {
629     fn mode(&self) -> ModeType {
630         SYSFS_ATTR_MODE_RW
631     }
632 
633     fn name(&self) -> &str {
634         return "drivers_autoprobe";
635     }
636 
637     fn support(&self) -> SysFSOpsSupport {
638         return SysFSOpsSupport::ATTR_STORE | SysFSOpsSupport::ATTR_SHOW;
639     }
640 
641     /// 参考: https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/bus.c?r=&mo=5649&fi=241#231
642     fn store(&self, kobj: Arc<dyn KObject>, buf: &[u8]) -> Result<usize, SystemError> {
643         if buf.is_empty() {
644             return Ok(0);
645         }
646 
647         let kset: Arc<KSet> = kobj.arc_any().downcast().map_err(|_| SystemError::EINVAL)?;
648         let bus = bus_manager()
649             .get_bus_by_kset(&kset)
650             .ok_or(SystemError::EINVAL)?;
651 
652         if buf[0] == b'0' {
653             bus.subsystem().set_drivers_autoprobe(false);
654         } else {
655             bus.subsystem().set_drivers_autoprobe(true);
656         }
657 
658         return Ok(buf.len());
659     }
660 
661     /// 参考: https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/bus.c?r=&mo=5649&fi=241#226
662     fn show(&self, kobj: Arc<dyn KObject>, buf: &mut [u8]) -> Result<usize, SystemError> {
663         let kset: Arc<KSet> = kobj.arc_any().downcast().map_err(|_| SystemError::EINVAL)?;
664         let bus = bus_manager()
665             .get_bus_by_kset(&kset)
666             .ok_or(SystemError::EINVAL)?;
667         let val = if bus.subsystem().drivers_autoprobe() {
668             1
669         } else {
670             0
671         };
672         return sysfs_emit_str(buf, format!("{val}\n").as_str());
673     }
674 }
675 
676 #[allow(dead_code)]
677 #[derive(Debug, Clone, Copy)]
678 pub enum BusNotifyEvent {
679     /// 一个设备被添加到总线上
680     AddDevice,
681     /// 一个设备将要被移除
682     DelDevice,
683     /// 一个设备已经被移除
684     RemovedDevice,
685     /// 一个驱动将要被绑定
686     BindDriver,
687     /// 一个驱动已经被绑定
688     BoundDriver,
689     /// 一个驱动将要被解绑
690     UnbindDriver,
691     /// 一个驱动已经被解绑
692     UnboundDriver,
693     /// 驱动绑定失败
694     DriverNotBound,
695 }
696 
697 #[derive(Debug)]
698 struct BusDriverKType;
699 
700 impl KObjType for BusDriverKType {
701     fn sysfs_ops(&self) -> Option<&dyn SysFSOps> {
702         Some(&BusDriverSysFSOps)
703     }
704 
705     fn attribute_groups(&self) -> Option<&'static [&'static dyn AttributeGroup]> {
706         None
707     }
708 }
709 
710 #[derive(Debug)]
711 struct BusDriverSysFSOps;
712 
713 impl SysFSOps for BusDriverSysFSOps {
714     #[inline]
715     fn show(
716         &self,
717         kobj: Arc<dyn KObject>,
718         attr: &dyn Attribute,
719         buf: &mut [u8],
720     ) -> Result<usize, SystemError> {
721         attr.show(kobj, buf)
722     }
723 
724     #[inline]
725     fn store(
726         &self,
727         kobj: Arc<dyn KObject>,
728         attr: &dyn Attribute,
729         buf: &[u8],
730     ) -> Result<usize, SystemError> {
731         attr.store(kobj, buf)
732     }
733 }
734 
735 #[derive(Debug)]
736 struct DriverAttrUnbind;
737 
738 impl Attribute for DriverAttrUnbind {
739     fn mode(&self) -> ModeType {
740         SYSFS_ATTR_MODE_WO
741     }
742 
743     fn name(&self) -> &str {
744         "unbind"
745     }
746 
747     fn store(&self, kobj: Arc<dyn KObject>, buf: &[u8]) -> Result<usize, SystemError> {
748         let driver = kobj.cast::<dyn Driver>().map_err(|kobj| {
749             kerror!(
750                 "Intertrait casting not implemented for kobj: {}",
751                 kobj.name()
752             );
753             SystemError::EOPNOTSUPP_OR_ENOTSUP
754         })?;
755 
756         let bus = driver
757             .bus()
758             .and_then(|bus| bus.upgrade())
759             .ok_or(SystemError::ENODEV)?;
760 
761         let s = CStr::from_bytes_with_nul(buf)
762             .map_err(|_| SystemError::EINVAL)?
763             .to_str()
764             .map_err(|_| SystemError::EINVAL)?;
765         let dev = bus.find_device_by_name(s).ok_or(SystemError::ENODEV)?;
766         let p = dev.driver().ok_or(SystemError::ENODEV)?;
767         if Arc::ptr_eq(&p, &driver) {
768             device_manager().device_driver_detach(&dev);
769             return Ok(buf.len());
770         }
771         return Err(SystemError::ENODEV);
772     }
773 
774     fn support(&self) -> SysFSOpsSupport {
775         SysFSOpsSupport::ATTR_STORE
776     }
777 }
778 
779 #[derive(Debug)]
780 struct DriverAttrBind;
781 
782 impl Attribute for DriverAttrBind {
783     fn name(&self) -> &str {
784         "bind"
785     }
786 
787     fn mode(&self) -> ModeType {
788         SYSFS_ATTR_MODE_WO
789     }
790 
791     /*
792      * Manually attach a device to a driver.
793      * Note: the driver must want to bind to the device,
794      * it is not possible to override the driver's id table.
795      */
796     fn store(&self, kobj: Arc<dyn KObject>, buf: &[u8]) -> Result<usize, SystemError> {
797         let driver = kobj.cast::<dyn Driver>().map_err(|kobj| {
798             kerror!(
799                 "Intertrait casting not implemented for kobj: {}",
800                 kobj.name()
801             );
802             SystemError::EOPNOTSUPP_OR_ENOTSUP
803         })?;
804 
805         let bus = driver
806             .bus()
807             .and_then(|bus| bus.upgrade())
808             .ok_or(SystemError::ENODEV)?;
809         let device = bus
810             .find_device_by_name(
811                 CStr::from_bytes_with_nul(buf)
812                     .map_err(|_| SystemError::EINVAL)?
813                     .to_str()
814                     .map_err(|_| SystemError::EINVAL)?,
815             )
816             .ok_or(SystemError::ENODEV)?;
817 
818         if driver_manager().match_device(&driver, &device)? {
819             device_manager().device_driver_attach(&driver, &device)?;
820             return Ok(buf.len());
821         }
822         return Err(SystemError::ENODEV);
823     }
824     fn support(&self) -> SysFSOpsSupport {
825         SysFSOpsSupport::ATTR_STORE
826     }
827 }
828 
829 #[derive(Debug)]
830 pub struct SubSystemManager;
831 
832 impl SubSystemManager {
833     /// 注册一个子系统,并在`/sys/bus`和指定的父级文件夹下创建子文件夹
834     ///
835     /// ## 参数
836     ///
837     /// - `subsys` - 子系统实例
838     /// - `fake_root_dev` - 该子系统的伪根设备
839     /// - `parent_of_root` - 该子系统的伪根设备的父级节点
840     ///
841     /// 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/bus.c?fi=subsys_system_register#1078
842     pub fn subsys_register(
843         &self,
844         subsys: &Arc<dyn Bus>,
845         fake_root_dev: &Arc<dyn Device>,
846         parent_of_root: &Arc<dyn KObject>,
847     ) -> Result<(), SystemError> {
848         bus_manager().register(subsys.clone())?;
849         fake_root_dev.set_name(subsys.name());
850         fake_root_dev.set_parent(Some(Arc::downgrade(parent_of_root)));
851 
852         device_manager().register(fake_root_dev.clone())?;
853 
854         subsys.set_root_device(Some(Arc::downgrade(fake_root_dev)));
855         return Ok(());
856     }
857 
858     /// register a subsystem at /sys/devices/system/
859     /// 并且在/sys/bus和/sys/devices下创建文件夹
860     ///
861     /// All 'system' subsystems have a /sys/devices/system/<name> root device
862     /// with the name of the subsystem. The root device can carry subsystem-
863     /// wide attributes. All registered devices are below this single root
864     /// device and are named after the subsystem with a simple enumeration
865     /// number appended. The registered devices are not explicitly named;
866     /// only 'id' in the device needs to be set.
867     pub fn subsys_system_register(
868         &self,
869         subsys: &Arc<dyn Bus>,
870         fake_root_dev: &Arc<dyn Device>,
871     ) -> Result<(), SystemError> {
872         return self.subsys_register(
873             subsys,
874             fake_root_dev,
875             &(sys_devices_system_kset() as Arc<dyn KObject>),
876         );
877     }
878 }
879