1004e86ffSlogin use super::{_port, hba::HbaCmdTable, virt_2_phys}; 2b087521eSChiichen use crate::driver::base::block::block_device::{BlockDevice, BlockId}; 3b087521eSChiichen use crate::driver::base::block::disk_info::Partition; 4b087521eSChiichen use crate::driver::base::block::SeekFrom; 506d5e247SLoGin use crate::driver::base::device::bus::Bus; 6ad1d649eSGnoCiYeH 7a03c4f9dSLoGin use crate::driver::base::device::driver::Driver; 806d5e247SLoGin use crate::driver::base::device::{Device, DeviceType, IdTable}; 906d5e247SLoGin use crate::driver::base::kobject::{KObjType, KObject, KObjectState}; 1006d5e247SLoGin use crate::driver::base::kset::KSet; 11004e86ffSlogin use crate::driver::disk::ahci::HBA_PxIS_TFES; 12a03c4f9dSLoGin 1306d5e247SLoGin use crate::filesystem::kernfs::KernFSInode; 14004e86ffSlogin use crate::filesystem::mbr::MbrDiskPartionTable; 15004e86ffSlogin 16b087521eSChiichen use crate::kdebug; 1706d5e247SLoGin use crate::libs::rwlock::{RwLockReadGuard, RwLockWriteGuard}; 18004e86ffSlogin use crate::libs::{spinlock::SpinLock, vec_cursor::VecCursor}; 19*4fda81ceSLoGin use crate::mm::{phys_2_virt, verify_area, VirtAddr}; 20676b8ef6SMork use crate::syscall::SystemError; 21004e86ffSlogin use crate::{ 22004e86ffSlogin driver::disk::ahci::hba::{ 23004e86ffSlogin FisRegH2D, FisType, HbaCmdHeader, ATA_CMD_READ_DMA_EXT, ATA_CMD_WRITE_DMA_EXT, 24004e86ffSlogin ATA_DEV_BUSY, ATA_DEV_DRQ, 25004e86ffSlogin }, 26004e86ffSlogin kerror, 27004e86ffSlogin }; 28004e86ffSlogin 29004e86ffSlogin use alloc::sync::Weak; 30004e86ffSlogin use alloc::{string::String, sync::Arc, vec::Vec}; 31004e86ffSlogin 32004e86ffSlogin use core::fmt::Debug; 337ae679ddSLoGin use core::sync::atomic::{compiler_fence, Ordering}; 34004e86ffSlogin use core::{mem::size_of, ptr::write_bytes}; 35004e86ffSlogin 36004e86ffSlogin /// @brief: 只支持MBR分区格式的磁盘结构体 37004e86ffSlogin pub struct AhciDisk { 38004e86ffSlogin pub name: String, 39004e86ffSlogin pub flags: u16, // 磁盘的状态flags 40004e86ffSlogin pub partitions: Vec<Arc<Partition>>, // 磁盘分区数组 41004e86ffSlogin // port: &'static mut HbaPort, // 控制硬盘的端口 42004e86ffSlogin pub ctrl_num: u8, 43004e86ffSlogin pub port_num: u8, 44004e86ffSlogin /// 指向LockAhciDisk的弱引用 45004e86ffSlogin self_ref: Weak<LockedAhciDisk>, 46004e86ffSlogin } 47004e86ffSlogin 48004e86ffSlogin /// @brief: 带锁的AhciDisk 49004e86ffSlogin #[derive(Debug)] 50004e86ffSlogin pub struct LockedAhciDisk(pub SpinLock<AhciDisk>); 51004e86ffSlogin /// 函数实现 52004e86ffSlogin impl Debug for AhciDisk { 53004e86ffSlogin fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { 54004e86ffSlogin write!( 55004e86ffSlogin f, 56004e86ffSlogin "{{ name: {}, flags: {}, part_s: {:?} }}", 57004e86ffSlogin self.name, self.flags, self.partitions 58004e86ffSlogin )?; 59004e86ffSlogin return Ok(()); 60004e86ffSlogin } 61004e86ffSlogin } 62004e86ffSlogin 63004e86ffSlogin impl AhciDisk { 64004e86ffSlogin fn read_at( 65004e86ffSlogin &self, 66b087521eSChiichen lba_id_start: BlockId, // 起始lba编号 67004e86ffSlogin count: usize, // 读取lba的数量 68004e86ffSlogin buf: &mut [u8], 69676b8ef6SMork ) -> Result<usize, SystemError> { 707ae679ddSLoGin assert!((buf.len() & 511) == 0); 71004e86ffSlogin compiler_fence(core::sync::atomic::Ordering::SeqCst); 72004e86ffSlogin let check_length = ((count - 1) >> 4) + 1; // prdt length 737ae679ddSLoGin if count * 512 > buf.len() || check_length > 8 as usize { 74004e86ffSlogin kerror!("ahci read: e2big"); 75004e86ffSlogin // 不可能的操作 76676b8ef6SMork return Err(SystemError::E2BIG); 77004e86ffSlogin } else if count == 0 { 78004e86ffSlogin return Ok(0); 79004e86ffSlogin } 80004e86ffSlogin 81004e86ffSlogin let port = _port(self.ctrl_num, self.port_num); 82004e86ffSlogin volatile_write!(port.is, u32::MAX); // Clear pending interrupt bits 83004e86ffSlogin 84004e86ffSlogin let slot = port.find_cmdslot().unwrap_or(u32::MAX); 85004e86ffSlogin 86004e86ffSlogin if slot == u32::MAX { 87676b8ef6SMork return Err(SystemError::EIO); 88004e86ffSlogin } 89004e86ffSlogin 90004e86ffSlogin #[allow(unused_unsafe)] 91004e86ffSlogin let cmdheader: &mut HbaCmdHeader = unsafe { 92004e86ffSlogin (phys_2_virt( 93004e86ffSlogin volatile_read!(port.clb) as usize 94004e86ffSlogin + slot as usize * size_of::<HbaCmdHeader>() as usize, 95004e86ffSlogin ) as *mut HbaCmdHeader) 96004e86ffSlogin .as_mut() 97004e86ffSlogin .unwrap() 98004e86ffSlogin }; 99004e86ffSlogin 1007ae679ddSLoGin cmdheader.cfl = (size_of::<FisRegH2D>() / size_of::<u32>()) as u8; 101004e86ffSlogin 102004e86ffSlogin volatile_set_bit!(cmdheader.cfl, 1 << 6, false); // Read/Write bit : Read from device 103004e86ffSlogin volatile_write!(cmdheader.prdtl, check_length as u16); // PRDT entries count 104004e86ffSlogin 105004e86ffSlogin // 设置数据存放地址 106004e86ffSlogin let mut buf_ptr = buf as *mut [u8] as *mut usize as usize; 107660a04ceSlogin 108660a04ceSlogin // 由于目前的内存管理机制无法把用户空间的内存地址转换为物理地址,所以只能先把数据拷贝到内核空间 109660a04ceSlogin // TODO:在内存管理重构后,可以直接使用用户空间的内存地址 110*4fda81ceSLoGin 111*4fda81ceSLoGin let user_buf = verify_area(VirtAddr::new(buf_ptr as usize), buf.len()).is_ok(); 112660a04ceSlogin let mut kbuf = if user_buf { 1137ae679ddSLoGin let mut x: Vec<u8> = Vec::new(); 1147ae679ddSLoGin x.resize(buf.len(), 0); 115660a04ceSlogin Some(x) 116660a04ceSlogin } else { 117660a04ceSlogin None 118660a04ceSlogin }; 119660a04ceSlogin 120660a04ceSlogin if kbuf.is_some() { 121660a04ceSlogin buf_ptr = kbuf.as_mut().unwrap().as_mut_ptr() as usize; 122660a04ceSlogin } 123660a04ceSlogin 124004e86ffSlogin #[allow(unused_unsafe)] 125004e86ffSlogin let cmdtbl = unsafe { 126004e86ffSlogin (phys_2_virt(volatile_read!(cmdheader.ctba) as usize) as *mut HbaCmdTable) 127004e86ffSlogin .as_mut() 128004e86ffSlogin .unwrap() // 必须使用 as_mut ,得到的才是原来的变量 129004e86ffSlogin }; 130004e86ffSlogin let mut tmp_count = count; 131004e86ffSlogin 132004e86ffSlogin unsafe { 133004e86ffSlogin // 清空整个table的旧数据 134004e86ffSlogin write_bytes(cmdtbl, 0, 1); 135004e86ffSlogin } 1367ae679ddSLoGin // kdebug!("cmdheader.prdtl={}", volatile_read!(cmdheader.prdtl)); 137004e86ffSlogin 138004e86ffSlogin // 8K bytes (16 sectors) per PRDT 139004e86ffSlogin for i in 0..((volatile_read!(cmdheader.prdtl) - 1) as usize) { 140004e86ffSlogin volatile_write!(cmdtbl.prdt_entry[i].dba, virt_2_phys(buf_ptr) as u64); 1417ae679ddSLoGin cmdtbl.prdt_entry[i].dbc = 8 * 1024 - 1; 142004e86ffSlogin volatile_set_bit!(cmdtbl.prdt_entry[i].dbc, 1 << 31, true); // 允许中断 prdt_entry.i 143004e86ffSlogin buf_ptr += 8 * 1024; 144004e86ffSlogin tmp_count -= 16; 145004e86ffSlogin } 146004e86ffSlogin 147004e86ffSlogin // Last entry 148004e86ffSlogin let las = (volatile_read!(cmdheader.prdtl) - 1) as usize; 149004e86ffSlogin volatile_write!(cmdtbl.prdt_entry[las].dba, virt_2_phys(buf_ptr) as u64); 1507ae679ddSLoGin cmdtbl.prdt_entry[las].dbc = ((tmp_count << 9) - 1) as u32; // 数据长度 1517ae679ddSLoGin 152004e86ffSlogin volatile_set_bit!(cmdtbl.prdt_entry[las].dbc, 1 << 31, true); // 允许中断 153004e86ffSlogin 154004e86ffSlogin // 设置命令 155004e86ffSlogin let cmdfis = unsafe { 156004e86ffSlogin ((&mut cmdtbl.cfis) as *mut [u8] as *mut usize as *mut FisRegH2D) 157004e86ffSlogin .as_mut() 158004e86ffSlogin .unwrap() 159004e86ffSlogin }; 160004e86ffSlogin volatile_write!(cmdfis.fis_type, FisType::RegH2D as u8); 161004e86ffSlogin volatile_set_bit!(cmdfis.pm, 1 << 7, true); // command_bit set 162004e86ffSlogin volatile_write!(cmdfis.command, ATA_CMD_READ_DMA_EXT); 163004e86ffSlogin 164004e86ffSlogin volatile_write!(cmdfis.lba0, (lba_id_start & 0xFF) as u8); 165004e86ffSlogin volatile_write!(cmdfis.lba1, ((lba_id_start >> 8) & 0xFF) as u8); 166004e86ffSlogin volatile_write!(cmdfis.lba2, ((lba_id_start >> 16) & 0xFF) as u8); 167004e86ffSlogin volatile_write!(cmdfis.lba3, ((lba_id_start >> 24) & 0xFF) as u8); 168004e86ffSlogin volatile_write!(cmdfis.lba4, ((lba_id_start >> 32) & 0xFF) as u8); 169004e86ffSlogin volatile_write!(cmdfis.lba5, ((lba_id_start >> 40) & 0xFF) as u8); 170004e86ffSlogin 171004e86ffSlogin volatile_write!(cmdfis.countl, (count & 0xFF) as u8); 172004e86ffSlogin volatile_write!(cmdfis.counth, ((count >> 8) & 0xFF) as u8); 173004e86ffSlogin 174004e86ffSlogin volatile_write!(cmdfis.device, 1 << 6); // LBA Mode 175004e86ffSlogin 176004e86ffSlogin // 等待之前的操作完成 177004e86ffSlogin let mut spin_count = 0; 178004e86ffSlogin const SPIN_LIMIT: u32 = 10000; 179004e86ffSlogin 180004e86ffSlogin while (volatile_read!(port.tfd) as u8 & (ATA_DEV_BUSY | ATA_DEV_DRQ)) > 0 181004e86ffSlogin && spin_count < SPIN_LIMIT 182004e86ffSlogin { 183004e86ffSlogin spin_count += 1; 184004e86ffSlogin } 185004e86ffSlogin 186004e86ffSlogin if spin_count == SPIN_LIMIT { 187004e86ffSlogin kerror!("Port is hung"); 188676b8ef6SMork return Err(SystemError::EIO); 189004e86ffSlogin } 190004e86ffSlogin 191004e86ffSlogin volatile_set_bit!(port.ci, 1 << slot, true); // Issue command 192004e86ffSlogin // kdebug!("To wait ahci read complete."); 193004e86ffSlogin // 等待操作完成 194004e86ffSlogin loop { 195004e86ffSlogin if (volatile_read!(port.ci) & (1 << slot)) == 0 { 196004e86ffSlogin break; 197004e86ffSlogin } 198004e86ffSlogin if (volatile_read!(port.is) & HBA_PxIS_TFES) > 0 { 199004e86ffSlogin kerror!("Read disk error"); 200676b8ef6SMork return Err(SystemError::EIO); 201004e86ffSlogin } 202004e86ffSlogin } 203004e86ffSlogin 204660a04ceSlogin if kbuf.is_some() { 205660a04ceSlogin buf.copy_from_slice(kbuf.as_ref().unwrap()); 206660a04ceSlogin } 207660a04ceSlogin 208004e86ffSlogin compiler_fence(core::sync::atomic::Ordering::SeqCst); 209004e86ffSlogin // successfully read 210004e86ffSlogin return Ok(count * 512); 211004e86ffSlogin } 212004e86ffSlogin 213004e86ffSlogin fn write_at( 214004e86ffSlogin &self, 215b087521eSChiichen lba_id_start: BlockId, 216004e86ffSlogin count: usize, 217004e86ffSlogin buf: &[u8], 218676b8ef6SMork ) -> Result<usize, SystemError> { 2197ae679ddSLoGin assert!((buf.len() & 511) == 0); 220004e86ffSlogin compiler_fence(core::sync::atomic::Ordering::SeqCst); 221004e86ffSlogin let check_length = ((count - 1) >> 4) + 1; // prdt length 2227ae679ddSLoGin if count * 512 > buf.len() || check_length > 8 as usize { 223004e86ffSlogin // 不可能的操作 224676b8ef6SMork return Err(SystemError::E2BIG); 225004e86ffSlogin } else if count == 0 { 226004e86ffSlogin return Ok(0); 227004e86ffSlogin } 228004e86ffSlogin 229004e86ffSlogin let port = _port(self.ctrl_num, self.port_num); 230004e86ffSlogin 231004e86ffSlogin volatile_write!(port.is, u32::MAX); // Clear pending interrupt bits 232004e86ffSlogin 233004e86ffSlogin let slot = port.find_cmdslot().unwrap_or(u32::MAX); 234004e86ffSlogin 235004e86ffSlogin if slot == u32::MAX { 236676b8ef6SMork return Err(SystemError::EIO); 237004e86ffSlogin } 238004e86ffSlogin 239004e86ffSlogin compiler_fence(core::sync::atomic::Ordering::SeqCst); 240004e86ffSlogin #[allow(unused_unsafe)] 241004e86ffSlogin let cmdheader: &mut HbaCmdHeader = unsafe { 242004e86ffSlogin (phys_2_virt( 243004e86ffSlogin volatile_read!(port.clb) as usize 244004e86ffSlogin + slot as usize * size_of::<HbaCmdHeader>() as usize, 245004e86ffSlogin ) as *mut HbaCmdHeader) 246004e86ffSlogin .as_mut() 247004e86ffSlogin .unwrap() 248004e86ffSlogin }; 249004e86ffSlogin compiler_fence(core::sync::atomic::Ordering::SeqCst); 250004e86ffSlogin 251004e86ffSlogin volatile_write_bit!( 252004e86ffSlogin cmdheader.cfl, 253004e86ffSlogin (1 << 5) - 1 as u8, 254004e86ffSlogin (size_of::<FisRegH2D>() / size_of::<u32>()) as u8 255004e86ffSlogin ); // Command FIS size 256004e86ffSlogin 257004e86ffSlogin volatile_set_bit!(cmdheader.cfl, 7 << 5, true); // (p,c,w)都设置为1, Read/Write bit : Write from device 258004e86ffSlogin volatile_write!(cmdheader.prdtl, check_length as u16); // PRDT entries count 259004e86ffSlogin 260004e86ffSlogin // 设置数据存放地址 261004e86ffSlogin compiler_fence(core::sync::atomic::Ordering::SeqCst); 262004e86ffSlogin let mut buf_ptr = buf as *const [u8] as *mut usize as usize; 263660a04ceSlogin 264660a04ceSlogin // 由于目前的内存管理机制无法把用户空间的内存地址转换为物理地址,所以只能先把数据拷贝到内核空间 265660a04ceSlogin // TODO:在内存管理重构后,可以直接使用用户空间的内存地址 266*4fda81ceSLoGin let user_buf = verify_area(VirtAddr::new(buf_ptr as usize), buf.len()).is_ok(); 267660a04ceSlogin let mut kbuf = if user_buf { 268660a04ceSlogin let mut x: Vec<u8> = Vec::with_capacity(buf.len()); 269660a04ceSlogin x.resize(buf.len(), 0); 270660a04ceSlogin x.copy_from_slice(buf); 271660a04ceSlogin Some(x) 272660a04ceSlogin } else { 273660a04ceSlogin None 274660a04ceSlogin }; 275660a04ceSlogin 276660a04ceSlogin if kbuf.is_some() { 277660a04ceSlogin buf_ptr = kbuf.as_mut().unwrap().as_mut_ptr() as usize; 278660a04ceSlogin } 279660a04ceSlogin 280004e86ffSlogin #[allow(unused_unsafe)] 281004e86ffSlogin let cmdtbl = unsafe { 282004e86ffSlogin (phys_2_virt(volatile_read!(cmdheader.ctba) as usize) as *mut HbaCmdTable) 283004e86ffSlogin .as_mut() 284004e86ffSlogin .unwrap() 285004e86ffSlogin }; 286004e86ffSlogin let mut tmp_count = count; 287004e86ffSlogin compiler_fence(core::sync::atomic::Ordering::SeqCst); 288004e86ffSlogin 289004e86ffSlogin unsafe { 290004e86ffSlogin // 清空整个table的旧数据 291004e86ffSlogin write_bytes(cmdtbl, 0, 1); 292004e86ffSlogin } 293004e86ffSlogin 294004e86ffSlogin // 8K bytes (16 sectors) per PRDT 295004e86ffSlogin for i in 0..((volatile_read!(cmdheader.prdtl) - 1) as usize) { 296004e86ffSlogin volatile_write!(cmdtbl.prdt_entry[i].dba, virt_2_phys(buf_ptr) as u64); 297004e86ffSlogin volatile_write_bit!(cmdtbl.prdt_entry[i].dbc, (1 << 22) - 1, 8 * 1024 - 1); // 数据长度 298004e86ffSlogin volatile_set_bit!(cmdtbl.prdt_entry[i].dbc, 1 << 31, true); // 允许中断 299004e86ffSlogin buf_ptr += 8 * 1024; 300004e86ffSlogin tmp_count -= 16; 301004e86ffSlogin } 302004e86ffSlogin 303004e86ffSlogin // Last entry 304004e86ffSlogin let las = (volatile_read!(cmdheader.prdtl) - 1) as usize; 305004e86ffSlogin volatile_write!(cmdtbl.prdt_entry[las].dba, virt_2_phys(buf_ptr) as u64); 306004e86ffSlogin volatile_set_bit!(cmdtbl.prdt_entry[las].dbc, 1 << 31, true); // 允许中断 307004e86ffSlogin volatile_write_bit!( 308004e86ffSlogin cmdtbl.prdt_entry[las].dbc, 309004e86ffSlogin (1 << 22) - 1, 310004e86ffSlogin ((tmp_count << 9) - 1) as u32 311004e86ffSlogin ); // 数据长度 312004e86ffSlogin 313004e86ffSlogin // 设置命令 314004e86ffSlogin let cmdfis = unsafe { 315004e86ffSlogin ((&mut cmdtbl.cfis) as *mut [u8] as *mut usize as *mut FisRegH2D) 316004e86ffSlogin .as_mut() 317004e86ffSlogin .unwrap() 318004e86ffSlogin }; 319004e86ffSlogin volatile_write!(cmdfis.fis_type, FisType::RegH2D as u8); 320004e86ffSlogin volatile_set_bit!(cmdfis.pm, 1 << 7, true); // command_bit set 321004e86ffSlogin volatile_write!(cmdfis.command, ATA_CMD_WRITE_DMA_EXT); 322004e86ffSlogin 323004e86ffSlogin volatile_write!(cmdfis.lba0, (lba_id_start & 0xFF) as u8); 324004e86ffSlogin volatile_write!(cmdfis.lba1, ((lba_id_start >> 8) & 0xFF) as u8); 325004e86ffSlogin volatile_write!(cmdfis.lba2, ((lba_id_start >> 16) & 0xFF) as u8); 326004e86ffSlogin volatile_write!(cmdfis.lba3, ((lba_id_start >> 24) & 0xFF) as u8); 327004e86ffSlogin volatile_write!(cmdfis.lba4, ((lba_id_start >> 32) & 0xFF) as u8); 328004e86ffSlogin volatile_write!(cmdfis.lba5, ((lba_id_start >> 40) & 0xFF) as u8); 329004e86ffSlogin 330004e86ffSlogin volatile_write!(cmdfis.countl, (count & 0xFF) as u8); 331004e86ffSlogin volatile_write!(cmdfis.counth, ((count >> 8) & 0xFF) as u8); 332004e86ffSlogin 333004e86ffSlogin volatile_write!(cmdfis.device, 1 << 6); // LBA Mode 334004e86ffSlogin 335004e86ffSlogin volatile_set_bit!(port.ci, 1 << slot, true); // Issue command 336004e86ffSlogin 337004e86ffSlogin // 等待操作完成 338004e86ffSlogin loop { 339004e86ffSlogin if (volatile_read!(port.ci) & (1 << slot)) == 0 { 340004e86ffSlogin break; 341004e86ffSlogin } 342004e86ffSlogin if (volatile_read!(port.is) & HBA_PxIS_TFES) > 0 { 343004e86ffSlogin kerror!("Write disk error"); 344676b8ef6SMork return Err(SystemError::EIO); 345004e86ffSlogin } 346004e86ffSlogin } 347004e86ffSlogin 348004e86ffSlogin compiler_fence(core::sync::atomic::Ordering::SeqCst); 349004e86ffSlogin // successfully read 350004e86ffSlogin return Ok(count * 512); 351004e86ffSlogin } 352004e86ffSlogin 353676b8ef6SMork fn sync(&self) -> Result<(), SystemError> { 354004e86ffSlogin // 由于目前没有block cache, 因此sync返回成功即可 355004e86ffSlogin return Ok(()); 356004e86ffSlogin } 357004e86ffSlogin } 358004e86ffSlogin 359004e86ffSlogin impl LockedAhciDisk { 360004e86ffSlogin pub fn new( 361004e86ffSlogin name: String, 362004e86ffSlogin flags: u16, 363004e86ffSlogin ctrl_num: u8, 364004e86ffSlogin port_num: u8, 365676b8ef6SMork ) -> Result<Arc<LockedAhciDisk>, SystemError> { 366004e86ffSlogin // 构建磁盘结构体 367004e86ffSlogin let result: Arc<LockedAhciDisk> = Arc::new(LockedAhciDisk(SpinLock::new(AhciDisk { 368004e86ffSlogin name, 369004e86ffSlogin flags, 370004e86ffSlogin partitions: Default::default(), 371004e86ffSlogin ctrl_num, 372004e86ffSlogin port_num, 373004e86ffSlogin self_ref: Weak::default(), 374004e86ffSlogin }))); 375004e86ffSlogin 376004e86ffSlogin let table: MbrDiskPartionTable = result.read_mbr_table()?; 377004e86ffSlogin 378004e86ffSlogin // 求出有多少可用分区 379004e86ffSlogin for i in 0..4 { 3807ae679ddSLoGin compiler_fence(Ordering::SeqCst); 381004e86ffSlogin if table.dpte[i].part_type != 0 { 3827ae679ddSLoGin let w = Arc::downgrade(&result); 3837ae679ddSLoGin result.0.lock().partitions.push(Partition::new( 384004e86ffSlogin table.dpte[i].starting_sector() as u64, 385004e86ffSlogin table.dpte[i].starting_lba as u64, 386004e86ffSlogin table.dpte[i].total_sectors as u64, 3877ae679ddSLoGin w, 388004e86ffSlogin i as u16, 389004e86ffSlogin )); 390004e86ffSlogin } 391004e86ffSlogin } 3927ae679ddSLoGin 3937ae679ddSLoGin result.0.lock().self_ref = Arc::downgrade(&result); 3947ae679ddSLoGin 395004e86ffSlogin return Ok(result); 396004e86ffSlogin } 397004e86ffSlogin 398004e86ffSlogin /// @brief: 从磁盘中读取 MBR 分区表结构体 TODO: Cursor 399676b8ef6SMork pub fn read_mbr_table(&self) -> Result<MbrDiskPartionTable, SystemError> { 400004e86ffSlogin let mut table: MbrDiskPartionTable = Default::default(); 401004e86ffSlogin 402004e86ffSlogin // 数据缓冲区 403004e86ffSlogin let mut buf: Vec<u8> = Vec::new(); 404004e86ffSlogin buf.resize(size_of::<MbrDiskPartionTable>(), 0); 405004e86ffSlogin 4067ae679ddSLoGin self.read_at(0, 1, &mut buf)?; 407004e86ffSlogin // 创建 Cursor 用于按字节读取 408004e86ffSlogin let mut cursor = VecCursor::new(buf); 409004e86ffSlogin cursor.seek(SeekFrom::SeekCurrent(446))?; 410004e86ffSlogin 411004e86ffSlogin for i in 0..4 { 412b087521eSChiichen kdebug!("infomation of partition {}:\n", i); 413004e86ffSlogin 414004e86ffSlogin table.dpte[i].flags = cursor.read_u8()?; 415004e86ffSlogin table.dpte[i].starting_head = cursor.read_u8()?; 416004e86ffSlogin table.dpte[i].starting_sector_cylinder = cursor.read_u16()?; 417004e86ffSlogin table.dpte[i].part_type = cursor.read_u8()?; 418004e86ffSlogin table.dpte[i].ending_head = cursor.read_u8()?; 419004e86ffSlogin table.dpte[i].ending_sector_cylingder = cursor.read_u16()?; 420004e86ffSlogin table.dpte[i].starting_lba = cursor.read_u32()?; 421004e86ffSlogin table.dpte[i].total_sectors = cursor.read_u32()?; 422004e86ffSlogin 423b087521eSChiichen kdebug!("dpte[i] = {:?}", table.dpte[i]); 424004e86ffSlogin } 425004e86ffSlogin table.bs_trailsig = cursor.read_u16()?; 426004e86ffSlogin // kdebug!("bs_trailsig = {}", unsafe { 427004e86ffSlogin // read_unaligned(addr_of!(table.bs_trailsig)) 428004e86ffSlogin // }); 429004e86ffSlogin 430004e86ffSlogin return Ok(table); 431004e86ffSlogin } 432004e86ffSlogin } 433004e86ffSlogin 43406d5e247SLoGin impl KObject for LockedAhciDisk { 43506d5e247SLoGin fn as_any_ref(&self) -> &dyn core::any::Any { 43606d5e247SLoGin self 43706d5e247SLoGin } 43806d5e247SLoGin 43906d5e247SLoGin fn inode(&self) -> Option<Arc<KernFSInode>> { 44006d5e247SLoGin todo!() 44106d5e247SLoGin } 44206d5e247SLoGin 44306d5e247SLoGin fn kobj_type(&self) -> Option<&'static dyn KObjType> { 44406d5e247SLoGin todo!() 44506d5e247SLoGin } 44606d5e247SLoGin 44706d5e247SLoGin fn kset(&self) -> Option<Arc<KSet>> { 44806d5e247SLoGin todo!() 44906d5e247SLoGin } 45006d5e247SLoGin 45106d5e247SLoGin fn parent(&self) -> Option<Weak<dyn KObject>> { 45206d5e247SLoGin todo!() 45306d5e247SLoGin } 45406d5e247SLoGin 45506d5e247SLoGin fn set_inode(&self, _inode: Option<Arc<KernFSInode>>) { 45606d5e247SLoGin todo!() 45706d5e247SLoGin } 45806d5e247SLoGin 45906d5e247SLoGin fn kobj_state(&self) -> RwLockReadGuard<KObjectState> { 46006d5e247SLoGin todo!() 46106d5e247SLoGin } 46206d5e247SLoGin 46306d5e247SLoGin fn kobj_state_mut(&self) -> RwLockWriteGuard<KObjectState> { 46406d5e247SLoGin todo!() 46506d5e247SLoGin } 46606d5e247SLoGin 46706d5e247SLoGin fn set_kobj_state(&self, _state: KObjectState) { 46806d5e247SLoGin todo!() 46906d5e247SLoGin } 47006d5e247SLoGin 47106d5e247SLoGin fn name(&self) -> alloc::string::String { 47206d5e247SLoGin todo!() 47306d5e247SLoGin } 47406d5e247SLoGin 47506d5e247SLoGin fn set_name(&self, _name: alloc::string::String) { 47606d5e247SLoGin todo!() 47706d5e247SLoGin } 47806d5e247SLoGin 47906d5e247SLoGin fn set_kset(&self, _kset: Option<Arc<KSet>>) { 48006d5e247SLoGin todo!() 48106d5e247SLoGin } 48206d5e247SLoGin 48306d5e247SLoGin fn set_parent(&self, _parent: Option<Weak<dyn KObject>>) { 48406d5e247SLoGin todo!() 48506d5e247SLoGin } 486a03c4f9dSLoGin 487a03c4f9dSLoGin fn set_kobj_type(&self, _ktype: Option<&'static dyn KObjType>) { 488a03c4f9dSLoGin todo!() 489a03c4f9dSLoGin } 49006d5e247SLoGin } 491b087521eSChiichen 492b087521eSChiichen impl Device for LockedAhciDisk { 493b087521eSChiichen fn dev_type(&self) -> DeviceType { 494b087521eSChiichen return DeviceType::Block; 495b087521eSChiichen } 496b087521eSChiichen 49706d5e247SLoGin fn id_table(&self) -> IdTable { 498b087521eSChiichen todo!() 499b087521eSChiichen } 500b087521eSChiichen 50106d5e247SLoGin fn bus(&self) -> Option<Arc<dyn Bus>> { 50206d5e247SLoGin todo!("LockedAhciDisk::bus()") 503b087521eSChiichen } 504b087521eSChiichen 505a03c4f9dSLoGin fn set_bus(&self, _bus: Option<Arc<dyn Bus>>) { 506a03c4f9dSLoGin todo!("LockedAhciDisk::set_bus()") 507a03c4f9dSLoGin } 508a03c4f9dSLoGin 50906d5e247SLoGin fn driver(&self) -> Option<Arc<dyn Driver>> { 51006d5e247SLoGin todo!("LockedAhciDisk::driver()") 51106d5e247SLoGin } 51206d5e247SLoGin 51306d5e247SLoGin fn is_dead(&self) -> bool { 51406d5e247SLoGin false 51506d5e247SLoGin } 51606d5e247SLoGin 517a03c4f9dSLoGin fn set_driver(&self, _driver: Option<Weak<dyn Driver>>) { 51806d5e247SLoGin todo!("LockedAhciDisk::set_driver()") 519b087521eSChiichen } 520a03c4f9dSLoGin 521a03c4f9dSLoGin fn can_match(&self) -> bool { 522a03c4f9dSLoGin todo!() 523a03c4f9dSLoGin } 524a03c4f9dSLoGin 525a03c4f9dSLoGin fn set_can_match(&self, _can_match: bool) { 526a03c4f9dSLoGin todo!() 527a03c4f9dSLoGin } 528a03c4f9dSLoGin 529a03c4f9dSLoGin fn state_synced(&self) -> bool { 530a03c4f9dSLoGin todo!() 531a03c4f9dSLoGin } 532b087521eSChiichen } 533b087521eSChiichen 534004e86ffSlogin impl BlockDevice for LockedAhciDisk { 535004e86ffSlogin #[inline] 536004e86ffSlogin fn as_any_ref(&self) -> &dyn core::any::Any { 537004e86ffSlogin self 538004e86ffSlogin } 539004e86ffSlogin 540004e86ffSlogin #[inline] 541004e86ffSlogin fn blk_size_log2(&self) -> u8 { 542004e86ffSlogin 9 543004e86ffSlogin } 544004e86ffSlogin 545676b8ef6SMork fn sync(&self) -> Result<(), SystemError> { 546004e86ffSlogin return self.0.lock().sync(); 547004e86ffSlogin } 548004e86ffSlogin 549004e86ffSlogin #[inline] 550b087521eSChiichen fn device(&self) -> Arc<dyn Device> { 551004e86ffSlogin return self.0.lock().self_ref.upgrade().unwrap(); 552004e86ffSlogin } 553004e86ffSlogin 554004e86ffSlogin fn block_size(&self) -> usize { 555004e86ffSlogin todo!() 556004e86ffSlogin } 557004e86ffSlogin 558004e86ffSlogin fn partitions(&self) -> Vec<Arc<Partition>> { 559004e86ffSlogin return self.0.lock().partitions.clone(); 560004e86ffSlogin } 561b087521eSChiichen 562b087521eSChiichen #[inline] 563b087521eSChiichen fn read_at( 564b087521eSChiichen &self, 565b087521eSChiichen lba_id_start: BlockId, // 起始lba编号 566b087521eSChiichen count: usize, // 读取lba的数量 567b087521eSChiichen buf: &mut [u8], 568b087521eSChiichen ) -> Result<usize, SystemError> { 569b087521eSChiichen self.0.lock().read_at(lba_id_start, count, buf) 570b087521eSChiichen } 571b087521eSChiichen 572b087521eSChiichen #[inline] 573b087521eSChiichen fn write_at( 574b087521eSChiichen &self, 575b087521eSChiichen lba_id_start: BlockId, 576b087521eSChiichen count: usize, 577b087521eSChiichen buf: &[u8], 578b087521eSChiichen ) -> Result<usize, SystemError> { 579b087521eSChiichen self.0.lock().write_at(lba_id_start, count, buf) 580b087521eSChiichen } 581004e86ffSlogin } 582