xref: /DragonOS/kernel/src/driver/base/device/bus.rs (revision 52da9a59374752b4d01907b052135a0d317781dd)
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().map(|bus| bus.upgrade()).flatten();
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             .map(|bus| bus.upgrade())
298             .flatten()
299             .ok_or(SystemError::EINVAL)?;
300         kdebug!("bus '{}' add driver '{}'", bus.name(), driver.name());
301 
302         driver.set_kobj_type(Some(&BusDriverKType));
303         let kobj = driver.clone() as Arc<dyn KObject>;
304         KObjectManager::add_kobj(kobj, bus.subsystem().drivers_kset())?;
305 
306         bus.subsystem().add_driver_to_vec(driver)?;
307         if bus.subsystem().drivers_autoprobe() {
308             let r = driver_manager().driver_attach(driver);
309             if let Err(e) = r {
310                 bus.subsystem().remove_driver_from_vec(driver);
311                 return Err(e);
312             }
313         }
314 
315         driver_manager()
316             .add_groups(driver, bus.drv_groups())
317             .or_else(|e| {
318                 kerror!(
319                     "BusManager::add_driver: driver '{:?}' add_groups failed, err: '{:?}",
320                     driver.name(),
321                     e
322                 );
323                 Err(e)
324             })
325             .ok();
326 
327         if !driver.suppress_bind_attrs() {
328             self.add_bind_files(driver)
329                 .or_else(|e| {
330                     kerror!(
331                         "BusManager::add_driver: driver '{:?}' add_bind_files failed, err: '{:?}",
332                         driver.name(),
333                         e
334                     );
335                     Err(e)
336                 })
337                 .ok();
338         }
339 
340         return Ok(());
341     }
342 
343     ///
344     /// bus_register - register a driver-core subsystem
345     ///
346     /// ## 参数
347     /// - `bus` - bus to register
348     ///
349     /// Once we have that, we register the bus with the kobject
350     /// infrastructure, then register the children subsystems it has:
351     /// the devices and drivers that belong to the subsystem.
352     ///
353     /// 参考: https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/bus.c?fi=bus_register#783
354     ///
355     /// todo: 增加错误处理逻辑
356     pub fn register(&self, bus: Arc<dyn Bus>) -> Result<(), SystemError> {
357         bus.subsystem().set_bus(Some(Arc::downgrade(&bus)));
358 
359         let subsys_kset = bus.subsystem().subsys();
360         subsys_kset.set_name(bus.name());
361         bus.subsystem().set_drivers_autoprobe(true);
362 
363         subsys_kset.register(Some(sys_bus_kset()))?;
364 
365         let devices_kset =
366             KSet::new_and_add("devices".to_string(), None, Some(subsys_kset.clone()))?;
367         bus.subsystem().set_devices_kset(devices_kset);
368         let drivers_kset =
369             KSet::new_and_add("drivers".to_string(), None, Some(subsys_kset.clone()))?;
370         bus.subsystem().set_drivers_kset(drivers_kset);
371 
372         self.add_probe_files(&bus)?;
373         let bus_groups = bus.bus_groups();
374         self.add_groups(&bus, bus_groups)?;
375         // 把bus实例添加到总线管理器中(方便在sysfs callback的时候,根据kset找到bus实例)
376         self.kset_bus_map.write().insert(subsys_kset, bus.clone());
377         return Ok(());
378     }
379 
380     pub fn unregister(&self, _bus: Arc<dyn Bus>) -> Result<(), SystemError> {
381         todo!("bus_unregister")
382     }
383 
384     fn add_probe_files(&self, bus: &Arc<dyn Bus>) -> Result<(), SystemError> {
385         self.create_file(bus, &BusAttrDriversProbe)?;
386         let r = self.create_file(bus, &BusAttrDriversAutoprobe);
387 
388         if r.is_err() {
389             self.remove_file(bus, &BusAttrDriversProbe);
390         }
391         return r;
392     }
393 
394     #[allow(dead_code)]
395     fn remove_probe_files(&self, bus: &Arc<dyn Bus>) {
396         self.remove_file(bus, &BusAttrDriversAutoprobe);
397         self.remove_file(bus, &BusAttrDriversProbe);
398     }
399 
400     fn create_file(
401         &self,
402         bus: &Arc<dyn Bus>,
403         attr: &'static dyn Attribute,
404     ) -> Result<(), SystemError> {
405         let bus_kobj = bus.subsystem().subsys() as Arc<dyn KObject>;
406         return sysfs_instance().create_file(&bus_kobj, attr);
407     }
408 
409     fn remove_file(&self, bus: &Arc<dyn Bus>, attr: &'static dyn Attribute) {
410         let bus_kobj = bus.subsystem().subsys() as Arc<dyn KObject>;
411         sysfs_instance().remove_file(&bus_kobj, attr);
412     }
413 
414     #[inline]
415     fn add_groups(
416         &self,
417         bus: &Arc<dyn Bus>,
418         groups: &[&'static dyn AttributeGroup],
419     ) -> Result<(), SystemError> {
420         let bus_kobj = bus.subsystem().subsys() as Arc<dyn KObject>;
421         return sysfs_instance().create_groups(&bus_kobj, groups);
422     }
423 
424     /// 根据bus的kset找到bus实例
425     fn get_bus_by_kset(&self, kset: &Arc<KSet>) -> Option<Arc<dyn Bus>> {
426         return self.kset_bus_map.read().get(kset).map(|bus| bus.clone());
427     }
428 
429     /// 为bus上的设备选择可能的驱动程序
430     ///
431     /// 这个函数会扫描总线上的所有没有驱动的设备,然后为它们选择可能的驱动程序。
432     ///
433     /// ## 参数
434     ///
435     /// - `bus` - bus实例
436     #[allow(dead_code)]
437     pub fn rescan_devices(&self, bus: &Arc<dyn Bus>) -> Result<(), SystemError> {
438         for dev in bus.subsystem().devices().iter() {
439             rescan_devices_helper(dev)?;
440         }
441         return Ok(());
442     }
443 
444     /// 为新设备探测驱动
445     ///
446     /// Automatically probe for a driver if the bus allows it.
447     pub fn probe_device(&self, dev: &Arc<dyn Device>) {
448         let bus = dev.bus().map(|bus| bus.upgrade()).flatten();
449         if bus.is_none() {
450             return;
451         }
452         let bus = bus.unwrap();
453         if bus.subsystem().drivers_autoprobe() {
454             device_manager().device_initial_probe(dev).ok();
455         }
456         for interface in bus.subsystem().interfaces() {
457             interface.add_device(dev).ok();
458         }
459     }
460 
461     /// 从总线上移除一个驱动
462     ///
463     /// Detach the driver from the devices it controls, and remove
464     /// it from its bus's list of drivers. Finally, we drop the reference
465     /// to the bus.
466     ///
467     /// ## 参数
468     ///
469     /// - `driver` - 驱动实例
470     ///
471     /// 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/bus.c?fi=bus_remove_driver#666
472     pub fn remove_driver(&self, _driver: &Arc<dyn Driver>) {
473         todo!("BusManager::remove_driver")
474     }
475 
476     fn add_bind_files(&self, driver: &Arc<dyn Driver>) -> Result<(), SystemError> {
477         driver_manager().create_attr_file(driver, &DriverAttrUnbind)?;
478 
479         driver_manager()
480             .create_attr_file(driver, &DriverAttrBind)
481             .map_err(|e| {
482                 driver_manager().remove_attr_file(driver, &DriverAttrUnbind);
483                 e
484             })?;
485 
486         return Ok(());
487     }
488 }
489 
490 /// 参考: https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/bus.c?r=&mo=5649&fi=241#684
491 fn rescan_devices_helper(dev: &Arc<dyn Device>) -> Result<(), SystemError> {
492     if dev.driver().is_none() {
493         let need_parent_lock = dev
494             .bus()
495             .map(|bus| bus.upgrade().unwrap().need_parent_lock())
496             .unwrap_or(false);
497         if unlikely(need_parent_lock) {
498             // todo: lock device parent
499             unimplemented!()
500         }
501         device_manager().device_attach(&dev)?;
502     }
503     return Ok(());
504 }
505 
506 ///
507 /// bus_register - register a driver-core subsystem
508 ///
509 /// ## 参数
510 /// - `bus` - bus to register
511 ///
512 /// Once we have that, we register the bus with the kobject
513 /// infrastructure, then register the children subsystems it has:
514 /// the devices and drivers that belong to the subsystem.
515 pub fn bus_register(bus: Arc<dyn Bus>) -> Result<(), SystemError> {
516     return bus_manager().register(bus);
517 }
518 
519 /// @brief: 总线注销,并在sys/bussys/devices下删除文件夹
520 /// @parameter bus: Bus设备实体
521 /// @return: 成功:()   失败:SystemError
522 #[allow(dead_code)]
523 pub fn bus_unregister(bus: Arc<dyn Bus>) -> Result<(), SystemError> {
524     return bus_manager().unregister(bus);
525 }
526 
527 pub fn buses_init() -> Result<(), SystemError> {
528     let bus_kset = KSet::new("bus".to_string());
529     bus_kset.register(None).expect("bus kset register failed");
530     unsafe {
531         BUS_KSET_INSTANCE = Some(bus_kset);
532     }
533 
534     // 初始化 /sys/devices/system
535     {
536         let devices_system_kset = KSet::new("system".to_string());
537         let parent = sys_devices_kset() as Arc<dyn KObject>;
538         devices_system_kset.set_parent(Some(Arc::downgrade(&parent)));
539         devices_system_kset
540             .register(Some(sys_devices_kset()))
541             .expect("devices system kset register failed");
542         unsafe {
543             DEVICES_SYSTEM_KSET_INSTANCE = Some(devices_system_kset);
544         }
545     }
546 
547     // 初始化总线管理器
548     {
549         let bus_manager = BusManager::new();
550         unsafe {
551             BUS_MANAGER_INSTANCE = Some(bus_manager);
552         }
553     }
554     return Ok(());
555 }
556 
557 /// 把一个设备添加到总线上
558 ///
559 /// ## 描述
560 ///
561 /// - 添加一个设备的与bus相关的属性
562 /// - 在bus和设备文件夹下,创建软链接
563 /// - 把设备添加到它的总线的设备列表中
564 ///
565 /// 参考: https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/bus.c?fi=bus_add_device#441
566 ///
567 /// ## 参数
568 ///
569 /// - `dev` - 要被添加的设备
570 pub fn bus_add_device(dev: &Arc<dyn Device>) -> Result<(), SystemError> {
571     return bus_manager().add_device(dev);
572 }
573 
574 /// 自动为设备在总线上寻找可用的驱动程序
575 ///
576 /// Automatically probe for a driver if the bus allows it.
577 ///
578 /// ## 参数
579 ///
580 /// - `dev` - 要被添加的设备
581 ///
582 /// 参考: https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/bus.c?fi=bus_probe_device#478
583 pub fn bus_probe_device(dev: &Arc<dyn Device>) {
584     kinfo!("bus_probe_device: dev: {:?}", dev.name());
585     bus_manager().probe_device(dev);
586 }
587 
588 #[derive(Debug)]
589 struct BusAttrDriversProbe;
590 
591 impl Attribute for BusAttrDriversProbe {
592     fn mode(&self) -> ModeType {
593         return ModeType::S_IWUSR;
594     }
595 
596     fn name(&self) -> &str {
597         return "drivers_probe";
598     }
599 
600     fn support(&self) -> SysFSOpsSupport {
601         return SysFSOpsSupport::ATTR_STORE;
602     }
603 
604     /// 参考: https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/bus.c?r=&mo=5649&fi=241#241
605     fn store(&self, kobj: Arc<dyn KObject>, buf: &[u8]) -> Result<usize, SystemError> {
606         let kset: Arc<KSet> = kobj.arc_any().downcast().map_err(|_| SystemError::EINVAL)?;
607         let bus = bus_manager()
608             .get_bus_by_kset(&kset)
609             .ok_or(SystemError::EINVAL)?;
610 
611         let name = CStr::from_bytes_with_nul(buf)
612             .map_err(|_| SystemError::EINVAL)?
613             .to_str()
614             .map_err(|_| SystemError::EINVAL)?;
615 
616         let device = bus.find_device_by_name(name).ok_or(SystemError::ENODEV)?;
617 
618         if rescan_devices_helper(&device).is_ok() {
619             return Ok(buf.len());
620         }
621 
622         return Err(SystemError::EINVAL);
623     }
624 }
625 
626 #[derive(Debug)]
627 struct BusAttrDriversAutoprobe;
628 
629 impl Attribute for BusAttrDriversAutoprobe {
630     fn mode(&self) -> ModeType {
631         SYSFS_ATTR_MODE_RW
632     }
633 
634     fn name(&self) -> &str {
635         return "drivers_autoprobe";
636     }
637 
638     fn support(&self) -> SysFSOpsSupport {
639         return SysFSOpsSupport::ATTR_STORE | SysFSOpsSupport::ATTR_SHOW;
640     }
641 
642     /// 参考: https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/bus.c?r=&mo=5649&fi=241#231
643     fn store(&self, kobj: Arc<dyn KObject>, buf: &[u8]) -> Result<usize, SystemError> {
644         if buf.len() == 0 {
645             return Ok(0);
646         }
647 
648         let kset: Arc<KSet> = kobj.arc_any().downcast().map_err(|_| SystemError::EINVAL)?;
649         let bus = bus_manager()
650             .get_bus_by_kset(&kset)
651             .ok_or(SystemError::EINVAL)?;
652 
653         if buf[0] == '0' as u8 {
654             bus.subsystem().set_drivers_autoprobe(false);
655         } else {
656             bus.subsystem().set_drivers_autoprobe(true);
657         }
658 
659         return Ok(buf.len());
660     }
661 
662     /// 参考: https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/bus.c?r=&mo=5649&fi=241#226
663     fn show(&self, kobj: Arc<dyn KObject>, buf: &mut [u8]) -> Result<usize, SystemError> {
664         let kset: Arc<KSet> = kobj.arc_any().downcast().map_err(|_| SystemError::EINVAL)?;
665         let bus = bus_manager()
666             .get_bus_by_kset(&kset)
667             .ok_or(SystemError::EINVAL)?;
668         let val = if bus.subsystem().drivers_autoprobe() {
669             1
670         } else {
671             0
672         };
673         return sysfs_emit_str(buf, format!("{val}\n").as_str());
674     }
675 }
676 
677 #[allow(dead_code)]
678 #[derive(Debug, Clone, Copy)]
679 pub enum BusNotifyEvent {
680     /// 一个设备被添加到总线上
681     AddDevice,
682     /// 一个设备将要被移除
683     DelDevice,
684     /// 一个设备已经被移除
685     RemovedDevice,
686     /// 一个驱动将要被绑定
687     BindDriver,
688     /// 一个驱动已经被绑定
689     BoundDriver,
690     /// 一个驱动将要被解绑
691     UnbindDriver,
692     /// 一个驱动已经被解绑
693     UnboundDriver,
694     /// 驱动绑定失败
695     DriverNotBound,
696 }
697 
698 #[derive(Debug)]
699 struct BusDriverKType;
700 
701 impl KObjType for BusDriverKType {
702     fn sysfs_ops(&self) -> Option<&dyn SysFSOps> {
703         Some(&BusDriverSysFSOps)
704     }
705 
706     fn attribute_groups(&self) -> Option<&'static [&'static dyn AttributeGroup]> {
707         None
708     }
709 }
710 
711 #[derive(Debug)]
712 struct BusDriverSysFSOps;
713 
714 impl SysFSOps for BusDriverSysFSOps {
715     #[inline]
716     fn show(
717         &self,
718         kobj: Arc<dyn KObject>,
719         attr: &dyn Attribute,
720         buf: &mut [u8],
721     ) -> Result<usize, SystemError> {
722         attr.show(kobj, buf)
723     }
724 
725     #[inline]
726     fn store(
727         &self,
728         kobj: Arc<dyn KObject>,
729         attr: &dyn Attribute,
730         buf: &[u8],
731     ) -> Result<usize, SystemError> {
732         attr.store(kobj, buf)
733     }
734 }
735 
736 #[derive(Debug)]
737 struct DriverAttrUnbind;
738 
739 impl Attribute for DriverAttrUnbind {
740     fn mode(&self) -> ModeType {
741         SYSFS_ATTR_MODE_WO
742     }
743 
744     fn name(&self) -> &str {
745         "unbind"
746     }
747 
748     fn store(&self, kobj: Arc<dyn KObject>, buf: &[u8]) -> Result<usize, SystemError> {
749         let driver = kobj.cast::<dyn Driver>().map_err(|kobj| {
750             kerror!(
751                 "Intertrait casting not implemented for kobj: {}",
752                 kobj.name()
753             );
754             SystemError::EOPNOTSUPP_OR_ENOTSUP
755         })?;
756 
757         let bus = driver
758             .bus()
759             .map(|bus| bus.upgrade())
760             .flatten()
761             .ok_or(SystemError::ENODEV)?;
762 
763         let s = CStr::from_bytes_with_nul(buf)
764             .map_err(|_| SystemError::EINVAL)?
765             .to_str()
766             .map_err(|_| SystemError::EINVAL)?;
767         let dev = bus.find_device_by_name(s).ok_or(SystemError::ENODEV)?;
768         let p = dev.driver().ok_or(SystemError::ENODEV)?;
769         if Arc::ptr_eq(&p, &driver) {
770             device_manager().device_driver_detach(&dev);
771             return Ok(buf.len());
772         }
773         return Err(SystemError::ENODEV);
774     }
775 
776     fn support(&self) -> SysFSOpsSupport {
777         SysFSOpsSupport::ATTR_STORE
778     }
779 }
780 
781 #[derive(Debug)]
782 struct DriverAttrBind;
783 
784 impl Attribute for DriverAttrBind {
785     fn name(&self) -> &str {
786         "bind"
787     }
788 
789     fn mode(&self) -> ModeType {
790         SYSFS_ATTR_MODE_WO
791     }
792 
793     /*
794      * Manually attach a device to a driver.
795      * Note: the driver must want to bind to the device,
796      * it is not possible to override the driver's id table.
797      */
798     fn store(&self, kobj: Arc<dyn KObject>, buf: &[u8]) -> Result<usize, SystemError> {
799         let driver = kobj.cast::<dyn Driver>().map_err(|kobj| {
800             kerror!(
801                 "Intertrait casting not implemented for kobj: {}",
802                 kobj.name()
803             );
804             SystemError::EOPNOTSUPP_OR_ENOTSUP
805         })?;
806 
807         let bus = driver
808             .bus()
809             .map(|bus| bus.upgrade())
810             .flatten()
811             .ok_or(SystemError::ENODEV)?;
812         let device = bus
813             .find_device_by_name(
814                 CStr::from_bytes_with_nul(buf)
815                     .map_err(|_| SystemError::EINVAL)?
816                     .to_str()
817                     .map_err(|_| SystemError::EINVAL)?,
818             )
819             .ok_or(SystemError::ENODEV)?;
820 
821         if driver_manager().match_device(&driver, &device)? {
822             device_manager().device_driver_attach(&driver, &device)?;
823             return Ok(buf.len());
824         }
825         return Err(SystemError::ENODEV);
826     }
827     fn support(&self) -> SysFSOpsSupport {
828         SysFSOpsSupport::ATTR_STORE
829     }
830 }
831 
832 #[derive(Debug)]
833 pub struct SubSystemManager;
834 
835 impl SubSystemManager {
836     /// 注册一个子系统,并在`/sys/bus`和指定的父级文件夹下创建子文件夹
837     ///
838     /// ## 参数
839     ///
840     /// - `subsys` - 子系统实例
841     /// - `fake_root_dev` - 该子系统的伪根设备
842     /// - `parent_of_root` - 该子系统的伪根设备的父级节点
843     ///
844     /// 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/bus.c?fi=subsys_system_register#1078
845     pub fn subsys_register(
846         &self,
847         subsys: &Arc<dyn Bus>,
848         fake_root_dev: &Arc<dyn Device>,
849         parent_of_root: &Arc<dyn KObject>,
850     ) -> Result<(), SystemError> {
851         bus_manager().register(subsys.clone())?;
852         fake_root_dev.set_name(subsys.name());
853         fake_root_dev.set_parent(Some(Arc::downgrade(parent_of_root)));
854 
855         device_manager().register(fake_root_dev.clone())?;
856 
857         subsys.set_root_device(Some(Arc::downgrade(fake_root_dev)));
858         return Ok(());
859     }
860 
861     /// register a subsystem at /sys/devices/system/
862     /// 并且在/sys/bus和/sys/devices下创建文件夹
863     ///
864     /// All 'system' subsystems have a /sys/devices/system/<name> root device
865     /// with the name of the subsystem. The root device can carry subsystem-
866     /// wide attributes. All registered devices are below this single root
867     /// device and are named after the subsystem with a simple enumeration
868     /// number appended. The registered devices are not explicitly named;
869     /// only 'id' in the device needs to be set.
870     pub fn subsys_system_register(
871         &self,
872         subsys: &Arc<dyn Bus>,
873         fake_root_dev: &Arc<dyn Device>,
874     ) -> Result<(), SystemError> {
875         return self.subsys_register(
876             subsys,
877             fake_root_dev,
878             &(sys_devices_system_kset() as Arc<dyn KObject>),
879         );
880     }
881 }
882