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/bus和sys/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