virtio_blk.rs 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762
  1. use core::{
  2. any::Any,
  3. fmt::{Debug, Formatter},
  4. };
  5. use alloc::{
  6. string::{String, ToString},
  7. sync::{Arc, Weak},
  8. vec::Vec,
  9. };
  10. use bitmap::{static_bitmap, traits::BitMapOps};
  11. use log::error;
  12. use system_error::SystemError;
  13. use unified_init::macros::unified_init;
  14. use virtio_drivers::device::blk::{VirtIOBlk, SECTOR_SIZE};
  15. use crate::{
  16. driver::{
  17. base::{
  18. block::{
  19. block_device::{BlockDevice, BlockId, GeneralBlockRange, LBA_SIZE},
  20. disk_info::Partition,
  21. manager::{block_dev_manager, BlockDevMeta},
  22. },
  23. class::Class,
  24. device::{
  25. bus::Bus,
  26. device_number::Major,
  27. driver::{Driver, DriverCommonData},
  28. DevName, Device, DeviceCommonData, DeviceId, DeviceType, IdTable,
  29. },
  30. kobject::{KObjType, KObject, KObjectCommonData, KObjectState, LockedKObjectState},
  31. kset::KSet,
  32. },
  33. virtio::{
  34. sysfs::{virtio_bus, virtio_device_manager, virtio_driver_manager},
  35. transport::VirtIOTransport,
  36. virtio_impl::HalImpl,
  37. VirtIODevice, VirtIODeviceIndex, VirtIODriver, VirtIODriverCommonData, VirtioDeviceId,
  38. VIRTIO_VENDOR_ID,
  39. },
  40. },
  41. exception::{irqdesc::IrqReturn, IrqNumber},
  42. filesystem::{
  43. devfs::{DevFS, DeviceINode, LockedDevFSInode},
  44. kernfs::KernFSInode,
  45. mbr::MbrDiskPartionTable,
  46. vfs::{syscall::ModeType, utils::DName, IndexNode, Metadata},
  47. },
  48. init::initcall::INITCALL_POSTCORE,
  49. libs::{
  50. rwlock::{RwLock, RwLockReadGuard, RwLockWriteGuard},
  51. spinlock::{SpinLock, SpinLockGuard},
  52. },
  53. };
  54. const VIRTIO_BLK_BASENAME: &str = "virtio_blk";
  55. static mut VIRTIO_BLK_DRIVER: Option<Arc<VirtIOBlkDriver>> = None;
  56. #[inline(always)]
  57. #[allow(dead_code)]
  58. fn virtio_blk_driver() -> Arc<VirtIOBlkDriver> {
  59. unsafe { VIRTIO_BLK_DRIVER.as_ref().unwrap().clone() }
  60. }
  61. /// Get the first virtio block device
  62. #[allow(dead_code)]
  63. pub fn virtio_blk_0() -> Option<Arc<VirtIOBlkDevice>> {
  64. virtio_blk_driver()
  65. .devices()
  66. .first()
  67. .cloned()
  68. .map(|dev| dev.arc_any().downcast().unwrap())
  69. }
  70. pub fn virtio_blk(
  71. transport: VirtIOTransport,
  72. dev_id: Arc<DeviceId>,
  73. dev_parent: Option<Arc<dyn Device>>,
  74. ) {
  75. let device = VirtIOBlkDevice::new(transport, dev_id);
  76. if let Some(device) = device {
  77. if let Some(dev_parent) = dev_parent {
  78. device.set_dev_parent(Some(Arc::downgrade(&dev_parent)));
  79. }
  80. virtio_device_manager()
  81. .device_add(device.clone() as Arc<dyn VirtIODevice>)
  82. .expect("Add virtio blk failed");
  83. }
  84. }
  85. static mut VIRTIOBLK_MANAGER: Option<VirtIOBlkManager> = None;
  86. #[inline]
  87. fn virtioblk_manager() -> &'static VirtIOBlkManager {
  88. unsafe { VIRTIOBLK_MANAGER.as_ref().unwrap() }
  89. }
  90. #[unified_init(INITCALL_POSTCORE)]
  91. fn virtioblk_manager_init() -> Result<(), SystemError> {
  92. unsafe {
  93. VIRTIOBLK_MANAGER = Some(VirtIOBlkManager::new());
  94. }
  95. Ok(())
  96. }
  97. pub struct VirtIOBlkManager {
  98. inner: SpinLock<InnerVirtIOBlkManager>,
  99. }
  100. struct InnerVirtIOBlkManager {
  101. id_bmp: static_bitmap!(VirtIOBlkManager::MAX_DEVICES),
  102. devname: [Option<DevName>; VirtIOBlkManager::MAX_DEVICES],
  103. }
  104. impl VirtIOBlkManager {
  105. pub const MAX_DEVICES: usize = 25;
  106. pub fn new() -> Self {
  107. Self {
  108. inner: SpinLock::new(InnerVirtIOBlkManager {
  109. id_bmp: bitmap::StaticBitmap::new(),
  110. devname: [const { None }; Self::MAX_DEVICES],
  111. }),
  112. }
  113. }
  114. fn inner(&self) -> SpinLockGuard<'_, InnerVirtIOBlkManager> {
  115. self.inner.lock()
  116. }
  117. pub fn alloc_id(&self) -> Option<DevName> {
  118. let mut inner = self.inner();
  119. let idx = inner.id_bmp.first_false_index()?;
  120. inner.id_bmp.set(idx, true);
  121. let name = Self::format_name(idx);
  122. inner.devname[idx] = Some(name.clone());
  123. Some(name)
  124. }
  125. /// Generate a new block device name like 'vda', 'vdb', etc.
  126. fn format_name(id: usize) -> DevName {
  127. let x = (b'a' + id as u8) as char;
  128. DevName::new(format!("vd{}", x), id)
  129. }
  130. #[allow(dead_code)]
  131. pub fn free_id(&self, id: usize) {
  132. if id >= Self::MAX_DEVICES {
  133. return;
  134. }
  135. self.inner().id_bmp.set(id, false);
  136. self.inner().devname[id] = None;
  137. }
  138. }
  139. /// virtio block device
  140. #[cast_to([sync] VirtIODevice)]
  141. #[cast_to([sync] Device)]
  142. pub struct VirtIOBlkDevice {
  143. blkdev_meta: BlockDevMeta,
  144. dev_id: Arc<DeviceId>,
  145. inner: SpinLock<InnerVirtIOBlkDevice>,
  146. locked_kobj_state: LockedKObjectState,
  147. self_ref: Weak<Self>,
  148. parent: RwLock<Weak<LockedDevFSInode>>,
  149. fs: RwLock<Weak<DevFS>>,
  150. metadata: Metadata,
  151. }
  152. impl Debug for VirtIOBlkDevice {
  153. fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
  154. f.debug_struct("VirtIOBlkDevice")
  155. .field("devname", &self.blkdev_meta.devname)
  156. .field("dev_id", &self.dev_id.id())
  157. .finish()
  158. }
  159. }
  160. unsafe impl Send for VirtIOBlkDevice {}
  161. unsafe impl Sync for VirtIOBlkDevice {}
  162. impl VirtIOBlkDevice {
  163. pub fn new(transport: VirtIOTransport, dev_id: Arc<DeviceId>) -> Option<Arc<Self>> {
  164. // 设置中断
  165. if let Err(err) = transport.setup_irq(dev_id.clone()) {
  166. error!("VirtIOBlkDevice '{dev_id:?}' setup_irq failed: {:?}", err);
  167. return None;
  168. }
  169. let devname = virtioblk_manager().alloc_id()?;
  170. let irq = Some(transport.irq());
  171. let device_inner = VirtIOBlk::<HalImpl, VirtIOTransport>::new(transport);
  172. if let Err(e) = device_inner {
  173. error!("VirtIOBlkDevice '{dev_id:?}' create failed: {:?}", e);
  174. return None;
  175. }
  176. let mut device_inner: VirtIOBlk<HalImpl, VirtIOTransport> = device_inner.unwrap();
  177. device_inner.enable_interrupts();
  178. let dev = Arc::new_cyclic(|self_ref| Self {
  179. blkdev_meta: BlockDevMeta::new(devname, Major::VIRTIO_BLK_MAJOR),
  180. self_ref: self_ref.clone(),
  181. dev_id,
  182. locked_kobj_state: LockedKObjectState::default(),
  183. inner: SpinLock::new(InnerVirtIOBlkDevice {
  184. device_inner,
  185. name: None,
  186. virtio_index: None,
  187. device_common: DeviceCommonData::default(),
  188. kobject_common: KObjectCommonData::default(),
  189. irq,
  190. }),
  191. parent: RwLock::new(Weak::default()),
  192. fs: RwLock::new(Weak::default()),
  193. metadata: Metadata::new(
  194. crate::filesystem::vfs::FileType::BlockDevice,
  195. ModeType::from_bits_truncate(0o755),
  196. ),
  197. });
  198. Some(dev)
  199. }
  200. fn inner(&self) -> SpinLockGuard<'_, InnerVirtIOBlkDevice> {
  201. self.inner.lock()
  202. }
  203. }
  204. impl IndexNode for VirtIOBlkDevice {
  205. fn fs(&self) -> Arc<dyn crate::filesystem::vfs::FileSystem> {
  206. self.fs
  207. .read()
  208. .upgrade()
  209. .expect("VirtIOBlkDevice fs is not set")
  210. }
  211. fn as_any_ref(&self) -> &dyn core::any::Any {
  212. self
  213. }
  214. fn read_at(
  215. &self,
  216. _offset: usize,
  217. _len: usize,
  218. _buf: &mut [u8],
  219. _data: SpinLockGuard<crate::filesystem::vfs::FilePrivateData>,
  220. ) -> Result<usize, SystemError> {
  221. Err(SystemError::ENOSYS)
  222. }
  223. fn write_at(
  224. &self,
  225. _offset: usize,
  226. _len: usize,
  227. _buf: &[u8],
  228. _data: SpinLockGuard<crate::filesystem::vfs::FilePrivateData>,
  229. ) -> Result<usize, SystemError> {
  230. Err(SystemError::ENOSYS)
  231. }
  232. fn list(&self) -> Result<alloc::vec::Vec<alloc::string::String>, system_error::SystemError> {
  233. Err(SystemError::ENOSYS)
  234. }
  235. fn metadata(&self) -> Result<crate::filesystem::vfs::Metadata, SystemError> {
  236. Ok(self.metadata.clone())
  237. }
  238. fn parent(&self) -> Result<Arc<dyn IndexNode>, SystemError> {
  239. let parent = self.parent.read();
  240. if let Some(parent) = parent.upgrade() {
  241. return Ok(parent as Arc<dyn IndexNode>);
  242. }
  243. Err(SystemError::ENOENT)
  244. }
  245. fn close(
  246. &self,
  247. _data: SpinLockGuard<crate::filesystem::vfs::FilePrivateData>,
  248. ) -> Result<(), SystemError> {
  249. Ok(())
  250. }
  251. fn dname(&self) -> Result<DName, SystemError> {
  252. let dname = DName::from(self.blkdev_meta.devname.clone().as_ref());
  253. Ok(dname)
  254. }
  255. fn open(
  256. &self,
  257. _data: SpinLockGuard<crate::filesystem::vfs::FilePrivateData>,
  258. _mode: &crate::filesystem::vfs::file::FileMode,
  259. ) -> Result<(), SystemError> {
  260. Ok(())
  261. }
  262. }
  263. impl DeviceINode for VirtIOBlkDevice {
  264. fn set_fs(&self, fs: alloc::sync::Weak<crate::filesystem::devfs::DevFS>) {
  265. *self.fs.write() = fs;
  266. }
  267. fn set_parent(&self, parent: Weak<crate::filesystem::devfs::LockedDevFSInode>) {
  268. *self.parent.write() = parent;
  269. }
  270. }
  271. impl BlockDevice for VirtIOBlkDevice {
  272. fn dev_name(&self) -> &DevName {
  273. &self.blkdev_meta.devname
  274. }
  275. fn blkdev_meta(&self) -> &BlockDevMeta {
  276. &self.blkdev_meta
  277. }
  278. fn disk_range(&self) -> GeneralBlockRange {
  279. let inner = self.inner();
  280. let blocks = inner.device_inner.capacity() as usize * SECTOR_SIZE / LBA_SIZE;
  281. drop(inner);
  282. log::debug!(
  283. "VirtIOBlkDevice '{:?}' disk_range: 0..{}",
  284. self.dev_name(),
  285. blocks
  286. );
  287. GeneralBlockRange::new(0, blocks).unwrap()
  288. }
  289. fn read_at_sync(
  290. &self,
  291. lba_id_start: BlockId,
  292. count: usize,
  293. buf: &mut [u8],
  294. ) -> Result<usize, SystemError> {
  295. let mut inner = self.inner();
  296. inner
  297. .device_inner
  298. .read_blocks(lba_id_start, &mut buf[..count * LBA_SIZE])
  299. .map_err(|e| {
  300. error!(
  301. "VirtIOBlkDevice '{:?}' read_at_sync failed: {:?}",
  302. self.dev_id, e
  303. );
  304. SystemError::EIO
  305. })?;
  306. Ok(count)
  307. }
  308. fn write_at_sync(
  309. &self,
  310. lba_id_start: BlockId,
  311. count: usize,
  312. buf: &[u8],
  313. ) -> Result<usize, SystemError> {
  314. self.inner()
  315. .device_inner
  316. .write_blocks(lba_id_start, &buf[..count * LBA_SIZE])
  317. .map_err(|_| SystemError::EIO)?;
  318. Ok(count)
  319. }
  320. fn sync(&self) -> Result<(), SystemError> {
  321. Ok(())
  322. }
  323. fn blk_size_log2(&self) -> u8 {
  324. 9
  325. }
  326. fn as_any_ref(&self) -> &dyn Any {
  327. self
  328. }
  329. fn device(&self) -> Arc<dyn Device> {
  330. self.self_ref.upgrade().unwrap()
  331. }
  332. fn block_size(&self) -> usize {
  333. todo!()
  334. }
  335. fn partitions(&self) -> Vec<Arc<Partition>> {
  336. let device = self.self_ref.upgrade().unwrap() as Arc<dyn BlockDevice>;
  337. let mbr_table = MbrDiskPartionTable::from_disk(device.clone())
  338. .expect("Failed to get MBR partition table");
  339. mbr_table.partitions(Arc::downgrade(&device))
  340. }
  341. }
  342. struct InnerVirtIOBlkDevice {
  343. device_inner: VirtIOBlk<HalImpl, VirtIOTransport>,
  344. name: Option<String>,
  345. virtio_index: Option<VirtIODeviceIndex>,
  346. device_common: DeviceCommonData,
  347. kobject_common: KObjectCommonData,
  348. irq: Option<IrqNumber>,
  349. }
  350. impl Debug for InnerVirtIOBlkDevice {
  351. fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  352. f.debug_struct("InnerVirtIOBlkDevice").finish()
  353. }
  354. }
  355. impl VirtIODevice for VirtIOBlkDevice {
  356. fn irq(&self) -> Option<IrqNumber> {
  357. self.inner().irq
  358. }
  359. fn handle_irq(
  360. &self,
  361. _irq: crate::exception::IrqNumber,
  362. ) -> Result<IrqReturn, system_error::SystemError> {
  363. // todo: handle virtio blk irq
  364. Ok(crate::exception::irqdesc::IrqReturn::Handled)
  365. }
  366. fn dev_id(&self) -> &Arc<DeviceId> {
  367. &self.dev_id
  368. }
  369. fn set_device_name(&self, name: String) {
  370. self.inner().name = Some(name);
  371. }
  372. fn device_name(&self) -> String {
  373. self.inner()
  374. .name
  375. .clone()
  376. .unwrap_or_else(|| VIRTIO_BLK_BASENAME.to_string())
  377. }
  378. fn set_virtio_device_index(&self, index: VirtIODeviceIndex) {
  379. self.inner().virtio_index = Some(index);
  380. self.blkdev_meta.inner().dev_idx = index.into();
  381. }
  382. fn virtio_device_index(&self) -> Option<VirtIODeviceIndex> {
  383. self.inner().virtio_index
  384. }
  385. fn device_type_id(&self) -> u32 {
  386. virtio_drivers::transport::DeviceType::Block as u32
  387. }
  388. fn vendor(&self) -> u32 {
  389. VIRTIO_VENDOR_ID.into()
  390. }
  391. }
  392. impl Device for VirtIOBlkDevice {
  393. fn dev_type(&self) -> DeviceType {
  394. DeviceType::Block
  395. }
  396. fn id_table(&self) -> IdTable {
  397. IdTable::new(VIRTIO_BLK_BASENAME.to_string(), None)
  398. }
  399. fn bus(&self) -> Option<Weak<dyn Bus>> {
  400. self.inner().device_common.bus.clone()
  401. }
  402. fn set_bus(&self, bus: Option<Weak<dyn Bus>>) {
  403. self.inner().device_common.bus = bus;
  404. }
  405. fn class(&self) -> Option<Arc<dyn Class>> {
  406. let mut guard = self.inner();
  407. let r = guard.device_common.class.clone()?.upgrade();
  408. if r.is_none() {
  409. guard.device_common.class = None;
  410. }
  411. return r;
  412. }
  413. fn set_class(&self, class: Option<Weak<dyn Class>>) {
  414. self.inner().device_common.class = class;
  415. }
  416. fn driver(&self) -> Option<Arc<dyn Driver>> {
  417. let r = self.inner().device_common.driver.clone()?.upgrade();
  418. if r.is_none() {
  419. self.inner().device_common.driver = None;
  420. }
  421. return r;
  422. }
  423. fn set_driver(&self, driver: Option<Weak<dyn Driver>>) {
  424. self.inner().device_common.driver = driver;
  425. }
  426. fn is_dead(&self) -> bool {
  427. false
  428. }
  429. fn can_match(&self) -> bool {
  430. self.inner().device_common.can_match
  431. }
  432. fn set_can_match(&self, can_match: bool) {
  433. self.inner().device_common.can_match = can_match;
  434. }
  435. fn state_synced(&self) -> bool {
  436. true
  437. }
  438. fn dev_parent(&self) -> Option<Weak<dyn Device>> {
  439. self.inner().device_common.get_parent_weak_or_clear()
  440. }
  441. fn set_dev_parent(&self, parent: Option<Weak<dyn Device>>) {
  442. self.inner().device_common.parent = parent;
  443. }
  444. }
  445. impl KObject for VirtIOBlkDevice {
  446. fn as_any_ref(&self) -> &dyn Any {
  447. self
  448. }
  449. fn set_inode(&self, inode: Option<Arc<KernFSInode>>) {
  450. self.inner().kobject_common.kern_inode = inode;
  451. }
  452. fn inode(&self) -> Option<Arc<KernFSInode>> {
  453. self.inner().kobject_common.kern_inode.clone()
  454. }
  455. fn parent(&self) -> Option<Weak<dyn KObject>> {
  456. self.inner().kobject_common.parent.clone()
  457. }
  458. fn set_parent(&self, parent: Option<Weak<dyn KObject>>) {
  459. self.inner().kobject_common.parent = parent;
  460. }
  461. fn kset(&self) -> Option<Arc<KSet>> {
  462. self.inner().kobject_common.kset.clone()
  463. }
  464. fn set_kset(&self, kset: Option<Arc<KSet>>) {
  465. self.inner().kobject_common.kset = kset;
  466. }
  467. fn kobj_type(&self) -> Option<&'static dyn KObjType> {
  468. self.inner().kobject_common.kobj_type
  469. }
  470. fn name(&self) -> String {
  471. self.device_name()
  472. }
  473. fn set_name(&self, _name: String) {
  474. // do nothing
  475. }
  476. fn kobj_state(&self) -> RwLockReadGuard<'_, KObjectState> {
  477. self.locked_kobj_state.read()
  478. }
  479. fn kobj_state_mut(&self) -> RwLockWriteGuard<'_, KObjectState> {
  480. self.locked_kobj_state.write()
  481. }
  482. fn set_kobj_state(&self, state: KObjectState) {
  483. *self.locked_kobj_state.write() = state;
  484. }
  485. fn set_kobj_type(&self, ktype: Option<&'static dyn KObjType>) {
  486. self.inner().kobject_common.kobj_type = ktype;
  487. }
  488. }
  489. #[unified_init(INITCALL_POSTCORE)]
  490. fn virtio_blk_driver_init() -> Result<(), SystemError> {
  491. let driver = VirtIOBlkDriver::new();
  492. virtio_driver_manager()
  493. .register(driver.clone() as Arc<dyn VirtIODriver>)
  494. .expect("Add virtio blk driver failed");
  495. unsafe {
  496. VIRTIO_BLK_DRIVER = Some(driver);
  497. }
  498. return Ok(());
  499. }
  500. #[derive(Debug)]
  501. #[cast_to([sync] VirtIODriver)]
  502. #[cast_to([sync] Driver)]
  503. struct VirtIOBlkDriver {
  504. inner: SpinLock<InnerVirtIOBlkDriver>,
  505. kobj_state: LockedKObjectState,
  506. }
  507. impl VirtIOBlkDriver {
  508. pub fn new() -> Arc<Self> {
  509. let inner = InnerVirtIOBlkDriver {
  510. virtio_driver_common: VirtIODriverCommonData::default(),
  511. driver_common: DriverCommonData::default(),
  512. kobj_common: KObjectCommonData::default(),
  513. };
  514. let id_table = VirtioDeviceId::new(
  515. virtio_drivers::transport::DeviceType::Block as u32,
  516. VIRTIO_VENDOR_ID.into(),
  517. );
  518. let result = VirtIOBlkDriver {
  519. inner: SpinLock::new(inner),
  520. kobj_state: LockedKObjectState::default(),
  521. };
  522. result.add_virtio_id(id_table);
  523. return Arc::new(result);
  524. }
  525. fn inner(&self) -> SpinLockGuard<'_, InnerVirtIOBlkDriver> {
  526. return self.inner.lock();
  527. }
  528. }
  529. #[derive(Debug)]
  530. struct InnerVirtIOBlkDriver {
  531. virtio_driver_common: VirtIODriverCommonData,
  532. driver_common: DriverCommonData,
  533. kobj_common: KObjectCommonData,
  534. }
  535. impl VirtIODriver for VirtIOBlkDriver {
  536. fn probe(&self, device: &Arc<dyn VirtIODevice>) -> Result<(), SystemError> {
  537. let dev = device
  538. .clone()
  539. .arc_any()
  540. .downcast::<VirtIOBlkDevice>()
  541. .map_err(|_| {
  542. error!(
  543. "VirtIOBlkDriver::probe() failed: device is not a VirtIO block device. Device: '{:?}'",
  544. device.name()
  545. );
  546. SystemError::EINVAL
  547. })?;
  548. block_dev_manager().register(dev as Arc<dyn BlockDevice>)?;
  549. return Ok(());
  550. }
  551. fn virtio_id_table(&self) -> Vec<crate::driver::virtio::VirtioDeviceId> {
  552. self.inner().virtio_driver_common.id_table.clone()
  553. }
  554. fn add_virtio_id(&self, id: VirtioDeviceId) {
  555. self.inner().virtio_driver_common.id_table.push(id);
  556. }
  557. }
  558. impl Driver for VirtIOBlkDriver {
  559. fn id_table(&self) -> Option<IdTable> {
  560. Some(IdTable::new(VIRTIO_BLK_BASENAME.to_string(), None))
  561. }
  562. fn add_device(&self, device: Arc<dyn Device>) {
  563. let iface = device
  564. .arc_any()
  565. .downcast::<VirtIOBlkDevice>()
  566. .expect("VirtIOBlkDriver::add_device() failed: device is not a VirtIOBlkDevice");
  567. self.inner()
  568. .driver_common
  569. .devices
  570. .push(iface as Arc<dyn Device>);
  571. }
  572. fn delete_device(&self, device: &Arc<dyn Device>) {
  573. let _iface = device
  574. .clone()
  575. .arc_any()
  576. .downcast::<VirtIOBlkDevice>()
  577. .expect("VirtIOBlkDriver::delete_device() failed: device is not a VirtIOBlkDevice");
  578. let mut guard = self.inner();
  579. let index = guard
  580. .driver_common
  581. .devices
  582. .iter()
  583. .position(|dev| Arc::ptr_eq(device, dev))
  584. .expect("VirtIOBlkDriver::delete_device() failed: device not found");
  585. guard.driver_common.devices.remove(index);
  586. }
  587. fn devices(&self) -> Vec<Arc<dyn Device>> {
  588. self.inner().driver_common.devices.clone()
  589. }
  590. fn bus(&self) -> Option<Weak<dyn Bus>> {
  591. Some(Arc::downgrade(&virtio_bus()) as Weak<dyn Bus>)
  592. }
  593. fn set_bus(&self, _bus: Option<Weak<dyn Bus>>) {
  594. // do nothing
  595. }
  596. }
  597. impl KObject for VirtIOBlkDriver {
  598. fn as_any_ref(&self) -> &dyn Any {
  599. self
  600. }
  601. fn set_inode(&self, inode: Option<Arc<KernFSInode>>) {
  602. self.inner().kobj_common.kern_inode = inode;
  603. }
  604. fn inode(&self) -> Option<Arc<KernFSInode>> {
  605. self.inner().kobj_common.kern_inode.clone()
  606. }
  607. fn parent(&self) -> Option<Weak<dyn KObject>> {
  608. self.inner().kobj_common.parent.clone()
  609. }
  610. fn set_parent(&self, parent: Option<Weak<dyn KObject>>) {
  611. self.inner().kobj_common.parent = parent;
  612. }
  613. fn kset(&self) -> Option<Arc<KSet>> {
  614. self.inner().kobj_common.kset.clone()
  615. }
  616. fn set_kset(&self, kset: Option<Arc<KSet>>) {
  617. self.inner().kobj_common.kset = kset;
  618. }
  619. fn kobj_type(&self) -> Option<&'static dyn KObjType> {
  620. self.inner().kobj_common.kobj_type
  621. }
  622. fn set_kobj_type(&self, ktype: Option<&'static dyn KObjType>) {
  623. self.inner().kobj_common.kobj_type = ktype;
  624. }
  625. fn name(&self) -> String {
  626. VIRTIO_BLK_BASENAME.to_string()
  627. }
  628. fn set_name(&self, _name: String) {
  629. // do nothing
  630. }
  631. fn kobj_state(&self) -> RwLockReadGuard<'_, KObjectState> {
  632. self.kobj_state.read()
  633. }
  634. fn kobj_state_mut(&self) -> RwLockWriteGuard<'_, KObjectState> {
  635. self.kobj_state.write()
  636. }
  637. fn set_kobj_state(&self, state: KObjectState) {
  638. *self.kobj_state.write() = state;
  639. }
  640. }