11074eb34SSamuel Dai use alloc::string::ToString; 2b5b571e0SLoGin use core::cmp::Ordering; 32dbef785SGnoCiYeH use core::intrinsics::unlikely; 4004e86ffSlogin use core::{any::Any, fmt::Debug}; 52eab6dd7S曾俊 use log::error; 691e9d4abSLoGin use system_error::SystemError; 7004e86ffSlogin 8004e86ffSlogin use alloc::{ 9004e86ffSlogin collections::BTreeMap, 10004e86ffSlogin string::String, 11004e86ffSlogin sync::{Arc, Weak}, 12004e86ffSlogin vec::Vec, 13004e86ffSlogin }; 14004e86ffSlogin 159fa0e95eSLoGin use crate::driver::base::block::gendisk::GenDisk; 16c566df45SLoGin use crate::driver::base::device::device_number::DeviceNumber; 17*cf7f801eSMemoryShore use crate::filesystem::vfs::file::PageCache; 181074eb34SSamuel Dai use crate::filesystem::vfs::utils::DName; 19597ecc08STTaq use crate::filesystem::vfs::{Magic, SpecialNodeData, SuperBlock}; 202dbef785SGnoCiYeH use crate::ipc::pipe::LockedPipeInode; 21*cf7f801eSMemoryShore use crate::mm::fault::{PageFaultHandler, PageFaultMessage}; 22*cf7f801eSMemoryShore use crate::mm::VmFaultReason; 23004e86ffSlogin use crate::{ 24b087521eSChiichen driver::base::block::{block_device::LBA_SIZE, disk_info::Partition, SeekFrom}, 25004e86ffSlogin filesystem::vfs::{ 2673c607aaSYJwu2023 core::generate_inode_id, 2773c607aaSYJwu2023 file::{FileMode, FilePrivateData}, 286b4e7a29SLoGin syscall::ModeType, 2940609970SGnoCiYeH FileSystem, FileType, IndexNode, InodeId, Metadata, 30004e86ffSlogin }, 31004e86ffSlogin libs::{ 32004e86ffSlogin spinlock::{SpinLock, SpinLockGuard}, 33004e86ffSlogin vec_cursor::VecCursor, 34004e86ffSlogin }, 356fc066acSJomo time::PosixTimeSpec, 36004e86ffSlogin }; 37004e86ffSlogin 382dbef785SGnoCiYeH use super::entry::FATFile; 39004e86ffSlogin use super::{ 40004e86ffSlogin bpb::{BiosParameterBlock, FATType}, 41004e86ffSlogin entry::{FATDir, FATDirEntry, FATDirIter, FATEntry}, 42004e86ffSlogin utils::RESERVED_CLUSTERS, 43004e86ffSlogin }; 44004e86ffSlogin 45597ecc08STTaq const FAT_MAX_NAMELEN: u64 = 255; 46597ecc08STTaq 47004e86ffSlogin /// FAT32文件系统的最大的文件大小 48004e86ffSlogin pub const MAX_FILE_SIZE: u64 = 0xffff_ffff; 49004e86ffSlogin 50004e86ffSlogin /// @brief 表示当前簇和上一个簇的关系的结构体 51004e86ffSlogin /// 定义这样一个结构体的原因是,FAT文件系统的文件中,前后两个簇具有关联关系。 52bd70d2d1SLoGin #[allow(dead_code)] 53004e86ffSlogin #[derive(Debug, Clone, Copy, Default)] 54004e86ffSlogin pub struct Cluster { 55004e86ffSlogin pub cluster_num: u64, 56004e86ffSlogin pub parent_cluster: u64, 57004e86ffSlogin } 58004e86ffSlogin 59004e86ffSlogin impl PartialOrd for Cluster { 60004e86ffSlogin /// @brief 根据当前簇号比较大小 partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering>61004e86ffSlogin fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> { 62004e86ffSlogin return self.cluster_num.partial_cmp(&other.cluster_num); 63004e86ffSlogin } 64004e86ffSlogin } 65004e86ffSlogin 66004e86ffSlogin impl PartialEq for Cluster { 67004e86ffSlogin /// @brief 根据当前簇号比较是否相等 eq(&self, other: &Self) -> bool68004e86ffSlogin fn eq(&self, other: &Self) -> bool { 69004e86ffSlogin self.cluster_num == other.cluster_num 70004e86ffSlogin } 71004e86ffSlogin } 72004e86ffSlogin 73004e86ffSlogin impl Eq for Cluster {} 74004e86ffSlogin 75004e86ffSlogin #[derive(Debug)] 76004e86ffSlogin pub struct FATFileSystem { 77004e86ffSlogin /// 当前文件系统所在的分区 789fa0e95eSLoGin pub gendisk: Arc<GenDisk>, 79004e86ffSlogin /// 当前文件系统的BOPB 80004e86ffSlogin pub bpb: BiosParameterBlock, 81004e86ffSlogin /// 当前文件系统的第一个数据扇区(相对分区开始位置) 82004e86ffSlogin pub first_data_sector: u64, 83004e86ffSlogin /// 文件系统信息结构体 84004e86ffSlogin pub fs_info: Arc<LockedFATFsInfo>, 85004e86ffSlogin /// 文件系统的根inode 86004e86ffSlogin root_inode: Arc<LockedFATInode>, 87004e86ffSlogin } 88004e86ffSlogin 89004e86ffSlogin /// FAT文件系统的Inode 90004e86ffSlogin #[derive(Debug)] 91004e86ffSlogin pub struct LockedFATInode(SpinLock<FATInode>); 92004e86ffSlogin 93004e86ffSlogin #[derive(Debug)] 94004e86ffSlogin pub struct LockedFATFsInfo(SpinLock<FATFsInfo>); 95004e86ffSlogin 96004e86ffSlogin impl LockedFATFsInfo { 97004e86ffSlogin #[inline] new(fs_info: FATFsInfo) -> Self98004e86ffSlogin pub fn new(fs_info: FATFsInfo) -> Self { 99004e86ffSlogin return Self(SpinLock::new(fs_info)); 100004e86ffSlogin } 101004e86ffSlogin } 102004e86ffSlogin 103004e86ffSlogin #[derive(Debug)] 104004e86ffSlogin pub struct FATInode { 105004e86ffSlogin /// 指向父Inode的弱引用 106004e86ffSlogin parent: Weak<LockedFATInode>, 107004e86ffSlogin /// 指向自身的弱引用 108004e86ffSlogin self_ref: Weak<LockedFATInode>, 109004e86ffSlogin /// 子Inode的B树. 该数据结构用作缓存区。其中,它的key表示inode的名称。 110004e86ffSlogin /// 请注意,由于FAT的查询过程对大小写不敏感,因此我们选择让key全部是大写的,方便统一操作。 1111074eb34SSamuel Dai children: BTreeMap<DName, Arc<LockedFATInode>>, 112004e86ffSlogin /// 当前inode的元数据 113004e86ffSlogin metadata: Metadata, 114004e86ffSlogin /// 指向inode所在的文件系统对象的指针 115004e86ffSlogin fs: Weak<FATFileSystem>, 116004e86ffSlogin 117004e86ffSlogin /// 根据不同的Inode类型,创建不同的私有字段 118004e86ffSlogin inode_type: FATDirEntry, 1192dbef785SGnoCiYeH 1202dbef785SGnoCiYeH /// 若该节点是特殊文件节点,该字段则为真正的文件节点 1212dbef785SGnoCiYeH special_node: Option<SpecialNodeData>, 1221074eb34SSamuel Dai 1231074eb34SSamuel Dai /// 目录名 1241074eb34SSamuel Dai dname: DName, 125*cf7f801eSMemoryShore 126*cf7f801eSMemoryShore /// 页缓存 127*cf7f801eSMemoryShore page_cache: Option<Arc<PageCache>>, 128004e86ffSlogin } 129004e86ffSlogin 130004e86ffSlogin impl FATInode { 131004e86ffSlogin /// @brief 更新当前inode的元数据 update_metadata(&mut self)132004e86ffSlogin pub fn update_metadata(&mut self) { 133004e86ffSlogin // todo: 更新文件的访问时间等信息 134004e86ffSlogin match &self.inode_type { 135004e86ffSlogin FATDirEntry::File(f) | FATDirEntry::VolId(f) => { 136004e86ffSlogin self.metadata.size = f.size() as i64; 137004e86ffSlogin } 138004e86ffSlogin FATDirEntry::Dir(d) => { 139004e86ffSlogin self.metadata.size = d.size(&self.fs.upgrade().unwrap().clone()) as i64; 140004e86ffSlogin } 141004e86ffSlogin FATDirEntry::UnInit => { 1422eab6dd7S曾俊 error!("update_metadata: Uninitialized FATDirEntry: {:?}", self); 143004e86ffSlogin return; 144004e86ffSlogin } 145004e86ffSlogin }; 146004e86ffSlogin } 147004e86ffSlogin find(&mut self, name: &str) -> Result<Arc<LockedFATInode>, SystemError>148676b8ef6SMork fn find(&mut self, name: &str) -> Result<Arc<LockedFATInode>, SystemError> { 149004e86ffSlogin match &self.inode_type { 150004e86ffSlogin FATDirEntry::Dir(d) => { 1511074eb34SSamuel Dai let dname = DName::from(name.to_uppercase()); 152004e86ffSlogin // 尝试在缓存区查找 1531074eb34SSamuel Dai if let Some(entry) = self.children.get(&dname) { 154004e86ffSlogin return Ok(entry.clone()); 155004e86ffSlogin } 156004e86ffSlogin // 在缓存区找不到 157004e86ffSlogin // 在磁盘查找 158004e86ffSlogin let fat_entry: FATDirEntry = 159004e86ffSlogin d.find_entry(name, None, None, self.fs.upgrade().unwrap())?; 160004e86ffSlogin // 创建新的inode 161004e86ffSlogin let entry_inode: Arc<LockedFATInode> = LockedFATInode::new( 1621074eb34SSamuel Dai dname.clone(), 163004e86ffSlogin self.fs.upgrade().unwrap(), 164004e86ffSlogin self.self_ref.clone(), 165004e86ffSlogin fat_entry, 166004e86ffSlogin ); 167004e86ffSlogin // 加入缓存区, 由于FAT文件系统的大小写不敏感问题,因此存入缓存区的key应当是全大写的 1681074eb34SSamuel Dai self.children.insert(dname, entry_inode.clone()); 169004e86ffSlogin return Ok(entry_inode); 170004e86ffSlogin } 171004e86ffSlogin FATDirEntry::UnInit => { 172004e86ffSlogin panic!( 173004e86ffSlogin "Uninitialized FAT Inode, fs = {:?}, inode={self:?}", 174004e86ffSlogin self.fs 175004e86ffSlogin ) 176004e86ffSlogin } 177004e86ffSlogin _ => { 178676b8ef6SMork return Err(SystemError::ENOTDIR); 179004e86ffSlogin } 180004e86ffSlogin } 181004e86ffSlogin } 182004e86ffSlogin } 183004e86ffSlogin 184004e86ffSlogin impl LockedFATInode { new( dname: DName, fs: Arc<FATFileSystem>, parent: Weak<LockedFATInode>, inode_type: FATDirEntry, ) -> Arc<LockedFATInode>185004e86ffSlogin pub fn new( 1861074eb34SSamuel Dai dname: DName, 187004e86ffSlogin fs: Arc<FATFileSystem>, 188004e86ffSlogin parent: Weak<LockedFATInode>, 189004e86ffSlogin inode_type: FATDirEntry, 190004e86ffSlogin ) -> Arc<LockedFATInode> { 191004e86ffSlogin let file_type = if let FATDirEntry::Dir(_) = inode_type { 192004e86ffSlogin FileType::Dir 193004e86ffSlogin } else { 194004e86ffSlogin FileType::File 195004e86ffSlogin }; 196004e86ffSlogin 197004e86ffSlogin let inode: Arc<LockedFATInode> = Arc::new(LockedFATInode(SpinLock::new(FATInode { 198b5b571e0SLoGin parent, 199004e86ffSlogin self_ref: Weak::default(), 200004e86ffSlogin children: BTreeMap::new(), 201004e86ffSlogin fs: Arc::downgrade(&fs), 202b5b571e0SLoGin inode_type, 203004e86ffSlogin metadata: Metadata { 204004e86ffSlogin dev_id: 0, 205004e86ffSlogin inode_id: generate_inode_id(), 206004e86ffSlogin size: 0, 207004e86ffSlogin blk_size: fs.bpb.bytes_per_sector as usize, 208004e86ffSlogin blocks: if let FATType::FAT32(_) = fs.bpb.fat_type { 209004e86ffSlogin fs.bpb.total_sectors_32 as usize 210004e86ffSlogin } else { 211004e86ffSlogin fs.bpb.total_sectors_16 as usize 212004e86ffSlogin }, 2136fc066acSJomo atime: PosixTimeSpec::default(), 2146fc066acSJomo mtime: PosixTimeSpec::default(), 2156fc066acSJomo ctime: PosixTimeSpec::default(), 216b5b571e0SLoGin file_type, 2176b4e7a29SLoGin mode: ModeType::from_bits_truncate(0o777), 218004e86ffSlogin nlinks: 1, 219004e86ffSlogin uid: 0, 220004e86ffSlogin gid: 0, 22102343d0bSLoGin raw_dev: DeviceNumber::default(), 222004e86ffSlogin }, 2232dbef785SGnoCiYeH special_node: None, 2241074eb34SSamuel Dai dname, 225*cf7f801eSMemoryShore page_cache: None, 226004e86ffSlogin }))); 227004e86ffSlogin 228*cf7f801eSMemoryShore if !inode.0.lock().inode_type.is_dir() { 229*cf7f801eSMemoryShore let page_cache = PageCache::new(Some(Arc::downgrade(&inode) as Weak<dyn IndexNode>)); 230*cf7f801eSMemoryShore inode.0.lock().page_cache = Some(page_cache); 231*cf7f801eSMemoryShore } 232*cf7f801eSMemoryShore 233004e86ffSlogin inode.0.lock().self_ref = Arc::downgrade(&inode); 234004e86ffSlogin 235004e86ffSlogin inode.0.lock().update_metadata(); 236004e86ffSlogin 237004e86ffSlogin return inode; 238004e86ffSlogin } 239004e86ffSlogin } 240004e86ffSlogin 241004e86ffSlogin /// FsInfo结构体(内存中的一份拷贝,当卸载卷或者sync的时候,把它写入磁盘) 242004e86ffSlogin #[derive(Debug)] 243004e86ffSlogin pub struct FATFsInfo { 244004e86ffSlogin /// Lead Signature - must equal 0x41615252 245004e86ffSlogin lead_sig: u32, 246004e86ffSlogin /// Value must equal 0x61417272 247004e86ffSlogin struc_sig: u32, 248004e86ffSlogin /// 空闲簇数目 249004e86ffSlogin free_count: u32, 250004e86ffSlogin /// 第一个空闲簇的位置(不一定准确,仅供加速查找) 251004e86ffSlogin next_free: u32, 252004e86ffSlogin /// 0xAA550000 253004e86ffSlogin trail_sig: u32, 254004e86ffSlogin /// Dirty flag to flush to disk 255004e86ffSlogin dirty: bool, 256004e86ffSlogin /// FsInfo Structure 在磁盘上的字节偏移量 257004e86ffSlogin /// Not present for FAT12 and FAT16 258004e86ffSlogin offset: Option<u64>, 259004e86ffSlogin } 260004e86ffSlogin 261004e86ffSlogin impl FileSystem for FATFileSystem { root_inode(&self) -> Arc<dyn crate::filesystem::vfs::IndexNode>262004e86ffSlogin fn root_inode(&self) -> Arc<dyn crate::filesystem::vfs::IndexNode> { 263004e86ffSlogin return self.root_inode.clone(); 264004e86ffSlogin } 265004e86ffSlogin info(&self) -> crate::filesystem::vfs::FsInfo266004e86ffSlogin fn info(&self) -> crate::filesystem::vfs::FsInfo { 267004e86ffSlogin todo!() 268004e86ffSlogin } 269004e86ffSlogin 270004e86ffSlogin /// @brief 本函数用于实现动态转换。 271004e86ffSlogin /// 具体的文件系统在实现本函数时,最简单的方式就是:直接返回self as_any_ref(&self) -> &dyn Any272004e86ffSlogin fn as_any_ref(&self) -> &dyn Any { 273004e86ffSlogin self 274004e86ffSlogin } 2751d37ca6dSDonkey Kane name(&self) -> &str2761d37ca6dSDonkey Kane fn name(&self) -> &str { 2771d37ca6dSDonkey Kane "fat" 2781d37ca6dSDonkey Kane } 279597ecc08STTaq super_block(&self) -> SuperBlock280597ecc08STTaq fn super_block(&self) -> SuperBlock { 281597ecc08STTaq SuperBlock::new( 282597ecc08STTaq Magic::FAT_MAGIC, 283597ecc08STTaq self.bpb.bytes_per_sector.into(), 284597ecc08STTaq FAT_MAX_NAMELEN, 285597ecc08STTaq ) 286597ecc08STTaq } 287*cf7f801eSMemoryShore fault(&self, pfm: &mut PageFaultMessage) -> VmFaultReason288*cf7f801eSMemoryShore unsafe fn fault(&self, pfm: &mut PageFaultMessage) -> VmFaultReason { 289*cf7f801eSMemoryShore PageFaultHandler::filemap_fault(pfm) 290*cf7f801eSMemoryShore } 291*cf7f801eSMemoryShore map_pages( &self, pfm: &mut PageFaultMessage, start_pgoff: usize, end_pgoff: usize, ) -> VmFaultReason292*cf7f801eSMemoryShore unsafe fn map_pages( 293*cf7f801eSMemoryShore &self, 294*cf7f801eSMemoryShore pfm: &mut PageFaultMessage, 295*cf7f801eSMemoryShore start_pgoff: usize, 296*cf7f801eSMemoryShore end_pgoff: usize, 297*cf7f801eSMemoryShore ) -> VmFaultReason { 298*cf7f801eSMemoryShore PageFaultHandler::filemap_map_pages(pfm, start_pgoff, end_pgoff) 299*cf7f801eSMemoryShore } 300004e86ffSlogin } 301004e86ffSlogin 302004e86ffSlogin impl FATFileSystem { 3032286eda6SWaferJay /// FAT12允许的最大簇号 3042286eda6SWaferJay pub const FAT12_MAX_CLUSTER: u32 = 0xFF5; 3052286eda6SWaferJay /// FAT16允许的最大簇号 3062286eda6SWaferJay pub const FAT16_MAX_CLUSTER: u32 = 0xFFF5; 3072286eda6SWaferJay /// FAT32允许的最大簇号 3082286eda6SWaferJay pub const FAT32_MAX_CLUSTER: u32 = 0x0FFFFFF7; 3092286eda6SWaferJay new(gendisk: Arc<GenDisk>) -> Result<Arc<FATFileSystem>, SystemError>3109fa0e95eSLoGin pub fn new(gendisk: Arc<GenDisk>) -> Result<Arc<FATFileSystem>, SystemError> { 3119fa0e95eSLoGin let bpb = BiosParameterBlock::new(&gendisk)?; 312004e86ffSlogin // 从磁盘上读取FAT32文件系统的FsInfo结构体 313004e86ffSlogin let fs_info: FATFsInfo = match bpb.fat_type { 314004e86ffSlogin FATType::FAT32(bpb32) => { 3159fa0e95eSLoGin let fs_info_in_gendisk_bytes_offset = 3169fa0e95eSLoGin bpb32.fs_info as usize * bpb.bytes_per_sector as usize; 317004e86ffSlogin FATFsInfo::new( 3189fa0e95eSLoGin &gendisk, 3199fa0e95eSLoGin fs_info_in_gendisk_bytes_offset, 320004e86ffSlogin bpb.bytes_per_sector as usize, 321004e86ffSlogin )? 322004e86ffSlogin } 323004e86ffSlogin _ => FATFsInfo::default(), 324004e86ffSlogin }; 325004e86ffSlogin 326004e86ffSlogin // 根目录项占用的扇区数(向上取整) 327004e86ffSlogin let root_dir_sectors: u64 = ((bpb.root_entries_cnt as u64 * 32) 328004e86ffSlogin + (bpb.bytes_per_sector as u64 - 1)) 329004e86ffSlogin / (bpb.bytes_per_sector as u64); 330004e86ffSlogin 331004e86ffSlogin // FAT表大小(单位:扇区) 332004e86ffSlogin let fat_size = if bpb.fat_size_16 != 0 { 333004e86ffSlogin bpb.fat_size_16 as u64 334004e86ffSlogin } else { 335004e86ffSlogin match bpb.fat_type { 336004e86ffSlogin FATType::FAT32(x) => x.fat_size_32 as u64, 337004e86ffSlogin _ => { 3382eab6dd7S曾俊 error!("FAT12 and FAT16 volumes should have non-zero BPB_FATSz16"); 339676b8ef6SMork return Err(SystemError::EINVAL); 340004e86ffSlogin } 341004e86ffSlogin } 342004e86ffSlogin }; 343004e86ffSlogin 344004e86ffSlogin let first_data_sector = 345004e86ffSlogin bpb.rsvd_sec_cnt as u64 + (bpb.num_fats as u64 * fat_size) + root_dir_sectors; 346004e86ffSlogin 347004e86ffSlogin // 创建文件系统的根节点 348004e86ffSlogin let root_inode: Arc<LockedFATInode> = Arc::new(LockedFATInode(SpinLock::new(FATInode { 349004e86ffSlogin parent: Weak::default(), 350004e86ffSlogin self_ref: Weak::default(), 351004e86ffSlogin children: BTreeMap::new(), 352004e86ffSlogin fs: Weak::default(), 353004e86ffSlogin inode_type: FATDirEntry::UnInit, 354004e86ffSlogin metadata: Metadata { 355004e86ffSlogin dev_id: 0, 356004e86ffSlogin inode_id: generate_inode_id(), 357004e86ffSlogin size: 0, 358004e86ffSlogin blk_size: bpb.bytes_per_sector as usize, 359004e86ffSlogin blocks: if let FATType::FAT32(_) = bpb.fat_type { 360004e86ffSlogin bpb.total_sectors_32 as usize 361004e86ffSlogin } else { 362004e86ffSlogin bpb.total_sectors_16 as usize 363004e86ffSlogin }, 3646fc066acSJomo atime: PosixTimeSpec::default(), 3656fc066acSJomo mtime: PosixTimeSpec::default(), 3666fc066acSJomo ctime: PosixTimeSpec::default(), 367004e86ffSlogin file_type: FileType::Dir, 3686b4e7a29SLoGin mode: ModeType::from_bits_truncate(0o777), 369004e86ffSlogin nlinks: 1, 370004e86ffSlogin uid: 0, 371004e86ffSlogin gid: 0, 37202343d0bSLoGin raw_dev: DeviceNumber::default(), 373004e86ffSlogin }, 3742dbef785SGnoCiYeH special_node: None, 3751074eb34SSamuel Dai dname: DName::default(), 376*cf7f801eSMemoryShore page_cache: None, 377004e86ffSlogin }))); 378004e86ffSlogin 379004e86ffSlogin let result: Arc<FATFileSystem> = Arc::new(FATFileSystem { 3809fa0e95eSLoGin gendisk, 381004e86ffSlogin bpb, 382004e86ffSlogin first_data_sector, 383004e86ffSlogin fs_info: Arc::new(LockedFATFsInfo::new(fs_info)), 384b5b571e0SLoGin root_inode, 385004e86ffSlogin }); 386004e86ffSlogin 387004e86ffSlogin // 对root inode加锁,并继续完成初始化工作 388004e86ffSlogin let mut root_guard: SpinLockGuard<FATInode> = result.root_inode.0.lock(); 389004e86ffSlogin root_guard.inode_type = FATDirEntry::Dir(result.root_dir()); 390004e86ffSlogin root_guard.parent = Arc::downgrade(&result.root_inode); 391004e86ffSlogin root_guard.self_ref = Arc::downgrade(&result.root_inode); 392004e86ffSlogin root_guard.fs = Arc::downgrade(&result); 393004e86ffSlogin // 释放锁 394004e86ffSlogin drop(root_guard); 395004e86ffSlogin 396004e86ffSlogin return Ok(result); 397004e86ffSlogin } 398004e86ffSlogin 399004e86ffSlogin /// @brief 计算每个簇有多少个字节 400004e86ffSlogin #[inline] bytes_per_cluster(&self) -> u64401004e86ffSlogin pub fn bytes_per_cluster(&self) -> u64 { 402004e86ffSlogin return (self.bpb.bytes_per_sector as u64) * (self.bpb.sector_per_cluster as u64); 403004e86ffSlogin } 404004e86ffSlogin 405004e86ffSlogin /// @brief 读取当前簇在FAT表中存储的信息 406004e86ffSlogin /// 407004e86ffSlogin /// @param cluster 当前簇 408004e86ffSlogin /// 409004e86ffSlogin /// @return Ok(FATEntry) 当前簇在FAT表中,存储的信息。(详情见FATEntry的注释) 410676b8ef6SMork /// @return Err(SystemError) 错误码 get_fat_entry(&self, cluster: Cluster) -> Result<FATEntry, SystemError>411676b8ef6SMork pub fn get_fat_entry(&self, cluster: Cluster) -> Result<FATEntry, SystemError> { 412004e86ffSlogin let current_cluster = cluster.cluster_num; 4136d81180bSLoGin if current_cluster < 2 { 4146d81180bSLoGin // 0号簇和1号簇是保留簇,不允许用户使用 4156d81180bSLoGin return Err(SystemError::EINVAL); 4166d81180bSLoGin } 417004e86ffSlogin 418004e86ffSlogin let fat_type: FATType = self.bpb.fat_type; 419004e86ffSlogin // 获取FAT表的起始扇区(相对分区起始扇区的偏移量) 420004e86ffSlogin let fat_start_sector = self.fat_start_sector(); 421004e86ffSlogin let bytes_per_sec = self.bpb.bytes_per_sector as u64; 422004e86ffSlogin 423004e86ffSlogin // cluster对应的FAT表项在分区内的字节偏移量 424004e86ffSlogin let fat_bytes_offset = 425004e86ffSlogin fat_type.get_fat_bytes_offset(cluster, fat_start_sector, bytes_per_sec); 426004e86ffSlogin 4279fa0e95eSLoGin // FAT表项所在的分区内LBA地址 4289fa0e95eSLoGin let fat_ent_lba = fat_bytes_offset / LBA_SIZE as u64; 429004e86ffSlogin 430004e86ffSlogin // FAT表项在逻辑块内的字节偏移量 431004e86ffSlogin let blk_offset = self.get_in_block_offset(fat_bytes_offset); 432004e86ffSlogin 433b5b571e0SLoGin let mut v: Vec<u8> = vec![0; self.bpb.bytes_per_sector as usize]; 4349fa0e95eSLoGin self.gendisk.read_at(&mut v, fat_ent_lba as usize)?; 435004e86ffSlogin 436004e86ffSlogin let mut cursor = VecCursor::new(v); 437004e86ffSlogin cursor.seek(SeekFrom::SeekSet(blk_offset as i64))?; 438004e86ffSlogin 439004e86ffSlogin let res: FATEntry = match self.bpb.fat_type { 440004e86ffSlogin FATType::FAT12(_) => { 441004e86ffSlogin let mut entry = cursor.read_u16()?; 442004e86ffSlogin // 由于FAT12文件系统的FAT表,每个entry占用1.5字节,因此奇数的簇需要取高12位的值。 443004e86ffSlogin if (current_cluster & 1) > 0 { 444004e86ffSlogin entry >>= 4; 445004e86ffSlogin } else { 446004e86ffSlogin entry &= 0x0fff; 447004e86ffSlogin } 448004e86ffSlogin 449004e86ffSlogin if entry == 0 { 450004e86ffSlogin FATEntry::Unused 451004e86ffSlogin } else if entry == 0x0ff7 { 452004e86ffSlogin FATEntry::Bad 453004e86ffSlogin } else if entry >= 0x0ff8 { 454004e86ffSlogin FATEntry::EndOfChain 455004e86ffSlogin } else { 456004e86ffSlogin FATEntry::Next(Cluster { 457004e86ffSlogin cluster_num: entry as u64, 458004e86ffSlogin parent_cluster: current_cluster, 459004e86ffSlogin }) 460004e86ffSlogin } 461004e86ffSlogin } 462004e86ffSlogin FATType::FAT16(_) => { 463004e86ffSlogin let entry = cursor.read_u16()?; 464004e86ffSlogin 465004e86ffSlogin if entry == 0 { 466004e86ffSlogin FATEntry::Unused 467004e86ffSlogin } else if entry == 0xfff7 { 468004e86ffSlogin FATEntry::Bad 469004e86ffSlogin } else if entry >= 0xfff8 { 470004e86ffSlogin FATEntry::EndOfChain 471004e86ffSlogin } else { 472004e86ffSlogin FATEntry::Next(Cluster { 473004e86ffSlogin cluster_num: entry as u64, 474004e86ffSlogin parent_cluster: current_cluster, 475004e86ffSlogin }) 476004e86ffSlogin } 477004e86ffSlogin } 478004e86ffSlogin FATType::FAT32(_) => { 479004e86ffSlogin let entry = cursor.read_u32()? & 0x0fffffff; 480004e86ffSlogin 481004e86ffSlogin match entry { 482b5b571e0SLoGin _n if (0x0ffffff7..=0x0fffffff).contains(¤t_cluster) => { 483004e86ffSlogin // 当前簇号不是一个能被获得的簇(可能是文件系统出错了) 4842eab6dd7S曾俊 error!("FAT32 get fat entry: current cluster number [{}] is not an allocatable cluster number.", current_cluster); 485004e86ffSlogin FATEntry::Bad 486004e86ffSlogin } 487004e86ffSlogin 0 => FATEntry::Unused, 488004e86ffSlogin 0x0ffffff7 => FATEntry::Bad, 489004e86ffSlogin 0x0ffffff8..=0x0fffffff => FATEntry::EndOfChain, 490004e86ffSlogin _n => FATEntry::Next(Cluster { 491004e86ffSlogin cluster_num: entry as u64, 492004e86ffSlogin parent_cluster: current_cluster, 493004e86ffSlogin }), 494004e86ffSlogin } 495004e86ffSlogin } 496004e86ffSlogin }; 497004e86ffSlogin return Ok(res); 498004e86ffSlogin } 499004e86ffSlogin 500004e86ffSlogin /// @brief 读取当前簇在FAT表中存储的信息(直接返回读取到的值,而不加处理) 501004e86ffSlogin /// 502004e86ffSlogin /// @param cluster 当前簇 503004e86ffSlogin /// 504004e86ffSlogin /// @return Ok(u64) 当前簇在FAT表中,存储的信息。 505676b8ef6SMork /// @return Err(SystemError) 错误码 get_fat_entry_raw(&self, cluster: Cluster) -> Result<u64, SystemError>506676b8ef6SMork pub fn get_fat_entry_raw(&self, cluster: Cluster) -> Result<u64, SystemError> { 507004e86ffSlogin let current_cluster = cluster.cluster_num; 508004e86ffSlogin 509004e86ffSlogin let fat_type: FATType = self.bpb.fat_type; 510004e86ffSlogin // 获取FAT表的起始扇区(相对分区起始扇区的偏移量) 511004e86ffSlogin let fat_start_sector = self.fat_start_sector(); 512004e86ffSlogin let bytes_per_sec = self.bpb.bytes_per_sector as u64; 513004e86ffSlogin 514004e86ffSlogin // cluster对应的FAT表项在分区内的字节偏移量 515004e86ffSlogin let fat_bytes_offset = 516004e86ffSlogin fat_type.get_fat_bytes_offset(cluster, fat_start_sector, bytes_per_sec); 517004e86ffSlogin 5189fa0e95eSLoGin // FAT表项所在的分区内LBA地址 5199fa0e95eSLoGin let fat_ent_lba = self.gendisk_lba_from_offset(self.bytes_to_sector(fat_bytes_offset)); 520004e86ffSlogin 521004e86ffSlogin // FAT表项在逻辑块内的字节偏移量 522004e86ffSlogin let blk_offset = self.get_in_block_offset(fat_bytes_offset); 523004e86ffSlogin 524b5b571e0SLoGin let mut v: Vec<u8> = vec![0; self.bpb.bytes_per_sector as usize]; 5259fa0e95eSLoGin self.gendisk.read_at(&mut v, fat_ent_lba)?; 526004e86ffSlogin 527004e86ffSlogin let mut cursor = VecCursor::new(v); 528004e86ffSlogin cursor.seek(SeekFrom::SeekSet(blk_offset as i64))?; 529004e86ffSlogin 530004e86ffSlogin let res = match self.bpb.fat_type { 531004e86ffSlogin FATType::FAT12(_) => { 532004e86ffSlogin let mut entry = cursor.read_u16()?; 533004e86ffSlogin entry = if (current_cluster & 0x0001) > 0 { 534004e86ffSlogin entry >> 4 535004e86ffSlogin } else { 536004e86ffSlogin entry & 0x0fff 537004e86ffSlogin }; 538004e86ffSlogin entry as u64 539004e86ffSlogin } 540004e86ffSlogin FATType::FAT16(_) => { 541004e86ffSlogin let entry = (cursor.read_u16()?) as u64; 542004e86ffSlogin entry 543004e86ffSlogin } 544004e86ffSlogin FATType::FAT32(_) => { 545004e86ffSlogin let entry = cursor.read_u32()? & 0x0fff_ffff; 546004e86ffSlogin entry as u64 547004e86ffSlogin } 548004e86ffSlogin }; 549004e86ffSlogin 550004e86ffSlogin return Ok(res); 551004e86ffSlogin } 552004e86ffSlogin 5539fa0e95eSLoGin /// @brief 获取当前文件系统的root inode,在分区内的字节偏移量 root_dir_bytes_offset(&self) -> u64554004e86ffSlogin pub fn root_dir_bytes_offset(&self) -> u64 { 555004e86ffSlogin match self.bpb.fat_type { 556004e86ffSlogin FATType::FAT32(s) => { 557004e86ffSlogin let first_sec_cluster: u64 = (s.root_cluster as u64 - 2) 558004e86ffSlogin * (self.bpb.sector_per_cluster as u64) 559004e86ffSlogin + self.first_data_sector; 5609fa0e95eSLoGin return (self.gendisk_lba_from_offset(first_sec_cluster) * LBA_SIZE) as u64; 561004e86ffSlogin } 562004e86ffSlogin _ => { 563004e86ffSlogin let root_sec = (self.bpb.rsvd_sec_cnt as u64) 564004e86ffSlogin + (self.bpb.num_fats as u64) * (self.bpb.fat_size_16 as u64); 5659fa0e95eSLoGin return (self.gendisk_lba_from_offset(root_sec) * LBA_SIZE) as u64; 566004e86ffSlogin } 567004e86ffSlogin } 568004e86ffSlogin } 569004e86ffSlogin 5709fa0e95eSLoGin /// @brief 获取当前文件系统的根目录项区域的结束位置,在分区内的字节偏移量。 571004e86ffSlogin /// 请注意,当前函数只对FAT12/FAT16生效。对于FAT32,返回None root_dir_end_bytes_offset(&self) -> Option<u64>572004e86ffSlogin pub fn root_dir_end_bytes_offset(&self) -> Option<u64> { 573004e86ffSlogin match self.bpb.fat_type { 574004e86ffSlogin FATType::FAT12(_) | FATType::FAT16(_) => { 575004e86ffSlogin return Some( 576004e86ffSlogin self.root_dir_bytes_offset() + (self.bpb.root_entries_cnt as u64) * 32, 577004e86ffSlogin ); 578004e86ffSlogin } 579004e86ffSlogin _ => { 580004e86ffSlogin return None; 581004e86ffSlogin } 582004e86ffSlogin } 583004e86ffSlogin } 584004e86ffSlogin 5859fa0e95eSLoGin /// 获取簇在分区内的字节偏移量 cluster_bytes_offset(&self, cluster: Cluster) -> u64586004e86ffSlogin pub fn cluster_bytes_offset(&self, cluster: Cluster) -> u64 { 587004e86ffSlogin if cluster.cluster_num >= 2 { 588004e86ffSlogin // 指定簇的第一个扇区号 589004e86ffSlogin let first_sec_of_cluster = (cluster.cluster_num - 2) 590004e86ffSlogin * (self.bpb.sector_per_cluster as u64) 591004e86ffSlogin + self.first_data_sector; 5929fa0e95eSLoGin return first_sec_of_cluster * (self.bpb.bytes_per_sector as u64); 593004e86ffSlogin } else { 594004e86ffSlogin return 0; 595004e86ffSlogin } 596004e86ffSlogin } 597004e86ffSlogin 598004e86ffSlogin /// @brief 获取一个空闲簇 599004e86ffSlogin /// 600004e86ffSlogin /// @param prev_cluster 簇链的前一个簇。本函数将会把新获取的簇,连接到它的后面。 601004e86ffSlogin /// 602004e86ffSlogin /// @return Ok(Cluster) 新获取的空闲簇 603676b8ef6SMork /// @return Err(SystemError) 错误码 allocate_cluster(&self, prev_cluster: Option<Cluster>) -> Result<Cluster, SystemError>604676b8ef6SMork pub fn allocate_cluster(&self, prev_cluster: Option<Cluster>) -> Result<Cluster, SystemError> { 605004e86ffSlogin let end_cluster: Cluster = self.max_cluster_number(); 606004e86ffSlogin let start_cluster: Cluster = match self.bpb.fat_type { 607004e86ffSlogin FATType::FAT32(_) => { 608b5b571e0SLoGin let next_free: u64 = self.fs_info.0.lock().next_free().unwrap_or(0xffffffff); 609004e86ffSlogin if next_free < end_cluster.cluster_num { 610004e86ffSlogin Cluster::new(next_free) 611004e86ffSlogin } else { 612004e86ffSlogin Cluster::new(RESERVED_CLUSTERS as u64) 613004e86ffSlogin } 614004e86ffSlogin } 615004e86ffSlogin _ => Cluster::new(RESERVED_CLUSTERS as u64), 616004e86ffSlogin }; 617004e86ffSlogin 618004e86ffSlogin // 寻找一个空的簇 619004e86ffSlogin let free_cluster: Cluster = match self.get_free_cluster(start_cluster, end_cluster) { 620004e86ffSlogin Ok(c) => c, 621004e86ffSlogin Err(_) if start_cluster.cluster_num > RESERVED_CLUSTERS as u64 => { 622004e86ffSlogin self.get_free_cluster(Cluster::new(RESERVED_CLUSTERS as u64), end_cluster)? 623004e86ffSlogin } 624004e86ffSlogin Err(e) => return Err(e), 625004e86ffSlogin }; 626004e86ffSlogin 627004e86ffSlogin self.set_entry(free_cluster, FATEntry::EndOfChain)?; 628004e86ffSlogin // 减少空闲簇计数 629004e86ffSlogin self.fs_info.0.lock().update_free_count_delta(-1); 630004e86ffSlogin // 更新搜索空闲簇的参考量 631004e86ffSlogin self.fs_info 632004e86ffSlogin .0 633004e86ffSlogin .lock() 634004e86ffSlogin .update_next_free((free_cluster.cluster_num + 1) as u32); 635004e86ffSlogin 636004e86ffSlogin // 如果这个空闲簇不是簇链的第一个簇,那么把当前簇跟前一个簇连上。 637004e86ffSlogin if let Some(prev_cluster) = prev_cluster { 6382eab6dd7S曾俊 // debug!("set entry, prev ={prev_cluster:?}, next = {free_cluster:?}"); 639004e86ffSlogin self.set_entry(prev_cluster, FATEntry::Next(free_cluster))?; 640004e86ffSlogin } 641004e86ffSlogin // 清空新获取的这个簇 642004e86ffSlogin self.zero_cluster(free_cluster)?; 643004e86ffSlogin return Ok(free_cluster); 644004e86ffSlogin } 645004e86ffSlogin 646004e86ffSlogin /// @brief 释放簇链上的所有簇 647004e86ffSlogin /// 648004e86ffSlogin /// @param start_cluster 簇链的第一个簇 deallocate_cluster_chain(&self, start_cluster: Cluster) -> Result<(), SystemError>649676b8ef6SMork pub fn deallocate_cluster_chain(&self, start_cluster: Cluster) -> Result<(), SystemError> { 650004e86ffSlogin let clusters: Vec<Cluster> = self.clusters(start_cluster); 651004e86ffSlogin for c in clusters { 652004e86ffSlogin self.deallocate_cluster(c)?; 653004e86ffSlogin } 654004e86ffSlogin return Ok(()); 655004e86ffSlogin } 656004e86ffSlogin 657004e86ffSlogin /// @brief 释放簇 658004e86ffSlogin /// 659004e86ffSlogin /// @param 要释放的簇 deallocate_cluster(&self, cluster: Cluster) -> Result<(), SystemError>660676b8ef6SMork pub fn deallocate_cluster(&self, cluster: Cluster) -> Result<(), SystemError> { 661004e86ffSlogin let entry: FATEntry = self.get_fat_entry(cluster)?; 662004e86ffSlogin // 如果不是坏簇 663004e86ffSlogin if entry != FATEntry::Bad { 664004e86ffSlogin self.set_entry(cluster, FATEntry::Unused)?; 665004e86ffSlogin self.fs_info.0.lock().update_free_count_delta(1); 666004e86ffSlogin // 安全选项:清空被释放的簇 667bd70d2d1SLoGin #[cfg(feature = "fatfs-secure")] 668004e86ffSlogin self.zero_cluster(cluster)?; 669004e86ffSlogin return Ok(()); 670004e86ffSlogin } else { 671004e86ffSlogin // 不能释放坏簇 6722eab6dd7S曾俊 error!("Bad clusters cannot be freed."); 673676b8ef6SMork return Err(SystemError::EFAULT); 674004e86ffSlogin } 675004e86ffSlogin } 676004e86ffSlogin 677004e86ffSlogin /// @brief 获取文件系统的根目录项 root_dir(&self) -> FATDir678004e86ffSlogin pub fn root_dir(&self) -> FATDir { 679004e86ffSlogin match self.bpb.fat_type { 680004e86ffSlogin FATType::FAT32(s) => { 681004e86ffSlogin return FATDir { 682004e86ffSlogin first_cluster: Cluster::new(s.root_cluster as u64), 683004e86ffSlogin dir_name: String::from("/"), 684004e86ffSlogin root_offset: None, 685004e86ffSlogin short_dir_entry: None, 686004e86ffSlogin loc: None, 687004e86ffSlogin }; 688004e86ffSlogin } 689004e86ffSlogin _ => FATDir { 690004e86ffSlogin first_cluster: Cluster::new(0), 691004e86ffSlogin dir_name: String::from("/"), 692004e86ffSlogin root_offset: Some(self.root_dir_bytes_offset()), 693004e86ffSlogin short_dir_entry: None, 694004e86ffSlogin loc: None, 695004e86ffSlogin }, 696004e86ffSlogin } 697004e86ffSlogin } 698004e86ffSlogin 699004e86ffSlogin /// @brief 获取FAT表的起始扇区(相对分区起始扇区的偏移量) fat_start_sector(&self) -> u64700004e86ffSlogin pub fn fat_start_sector(&self) -> u64 { 701004e86ffSlogin let active_fat = self.active_fat(); 702004e86ffSlogin let fat_size = self.fat_size(); 703004e86ffSlogin return self.bpb.rsvd_sec_cnt as u64 + active_fat * fat_size; 704004e86ffSlogin } 705004e86ffSlogin 706004e86ffSlogin /// @brief 获取当前活动的FAT表 active_fat(&self) -> u64707004e86ffSlogin pub fn active_fat(&self) -> u64 { 708004e86ffSlogin if self.mirroring_enabled() { 709004e86ffSlogin return 0; 710004e86ffSlogin } else { 711004e86ffSlogin match self.bpb.fat_type { 712004e86ffSlogin FATType::FAT32(bpb32) => { 713004e86ffSlogin return (bpb32.ext_flags & 0x0f) as u64; 714004e86ffSlogin } 715004e86ffSlogin _ => { 716004e86ffSlogin return 0; 717004e86ffSlogin } 718004e86ffSlogin } 719004e86ffSlogin } 720004e86ffSlogin } 721004e86ffSlogin 722004e86ffSlogin /// @brief 获取当前文件系统的每个FAT表的大小 fat_size(&self) -> u64723004e86ffSlogin pub fn fat_size(&self) -> u64 { 724004e86ffSlogin if self.bpb.fat_size_16 != 0 { 725004e86ffSlogin return self.bpb.fat_size_16 as u64; 726004e86ffSlogin } else { 727004e86ffSlogin match self.bpb.fat_type { 728004e86ffSlogin FATType::FAT32(bpb32) => { 729004e86ffSlogin return bpb32.fat_size_32 as u64; 730004e86ffSlogin } 731004e86ffSlogin 732004e86ffSlogin _ => { 733004e86ffSlogin panic!("FAT12 and FAT16 volumes should have non-zero BPB_FATSz16"); 734004e86ffSlogin } 735004e86ffSlogin } 736004e86ffSlogin } 737004e86ffSlogin } 738004e86ffSlogin 739004e86ffSlogin /// @brief 判断当前文件系统是否启用了FAT表镜像 mirroring_enabled(&self) -> bool740004e86ffSlogin pub fn mirroring_enabled(&self) -> bool { 741004e86ffSlogin match self.bpb.fat_type { 742004e86ffSlogin FATType::FAT32(bpb32) => { 743004e86ffSlogin return (bpb32.ext_flags & 0x80) == 0; 744004e86ffSlogin } 745004e86ffSlogin _ => { 746004e86ffSlogin return false; 747004e86ffSlogin } 748004e86ffSlogin } 749004e86ffSlogin } 750004e86ffSlogin 7519fa0e95eSLoGin /// 获取分区内的扇区偏移量 752004e86ffSlogin #[inline] gendisk_lba_from_offset(&self, in_partition_sec_offset: u64) -> usize7539fa0e95eSLoGin pub fn gendisk_lba_from_offset(&self, in_partition_sec_offset: u64) -> usize { 7549fa0e95eSLoGin return (in_partition_sec_offset * (self.bpb.bytes_per_sector as u64 / LBA_SIZE as u64)) 755004e86ffSlogin as usize; 756004e86ffSlogin } 757004e86ffSlogin 758004e86ffSlogin /// @brief 获取每个扇区占用多少个LBA 759004e86ffSlogin #[inline] lba_per_sector(&self) -> usize760004e86ffSlogin pub fn lba_per_sector(&self) -> usize { 761004e86ffSlogin return self.bpb.bytes_per_sector as usize / LBA_SIZE; 762004e86ffSlogin } 763004e86ffSlogin 764004e86ffSlogin /// @brief 将分区内字节偏移量转换为扇区偏移量 765004e86ffSlogin #[inline] bytes_to_sector(&self, in_partition_bytes_offset: u64) -> u64766004e86ffSlogin pub fn bytes_to_sector(&self, in_partition_bytes_offset: u64) -> u64 { 767004e86ffSlogin return in_partition_bytes_offset / (self.bpb.bytes_per_sector as u64); 768004e86ffSlogin } 769004e86ffSlogin 770004e86ffSlogin /// @brief 根据字节偏移量计算在逻辑块内的字节偏移量 771004e86ffSlogin #[inline] get_in_block_offset(&self, bytes_offset: u64) -> u64772004e86ffSlogin pub fn get_in_block_offset(&self, bytes_offset: u64) -> u64 { 773004e86ffSlogin return bytes_offset % LBA_SIZE as u64; 774004e86ffSlogin } 775004e86ffSlogin 776004e86ffSlogin /// @brief 获取在FAT表中,以start_cluster开头的FAT链的所有簇的信息 777004e86ffSlogin /// 778004e86ffSlogin /// @param start_cluster 整个FAT链的起始簇号 clusters(&self, start_cluster: Cluster) -> Vec<Cluster>779004e86ffSlogin pub fn clusters(&self, start_cluster: Cluster) -> Vec<Cluster> { 780004e86ffSlogin return self.cluster_iter(start_cluster).collect(); 781004e86ffSlogin } 782004e86ffSlogin 783004e86ffSlogin /// @brief 获取在FAT表中,以start_cluster开头的FAT链的长度(总计经过多少个簇) 784004e86ffSlogin /// 785004e86ffSlogin /// @param start_cluster 整个FAT链的起始簇号 num_clusters_chain(&self, start_cluster: Cluster) -> u64786004e86ffSlogin pub fn num_clusters_chain(&self, start_cluster: Cluster) -> u64 { 787004e86ffSlogin return self 788004e86ffSlogin .cluster_iter(start_cluster) 789004e86ffSlogin .fold(0, |size, _cluster| size + 1); 790004e86ffSlogin } 791004e86ffSlogin /// @brief 获取一个簇迭代器对象 792004e86ffSlogin /// 793004e86ffSlogin /// @param start_cluster 整个FAT链的起始簇号 cluster_iter(&self, start_cluster: Cluster) -> ClusterIter794004e86ffSlogin fn cluster_iter(&self, start_cluster: Cluster) -> ClusterIter { 795004e86ffSlogin return ClusterIter { 796004e86ffSlogin current_cluster: Some(start_cluster), 797004e86ffSlogin fs: self, 798004e86ffSlogin }; 799004e86ffSlogin } 800004e86ffSlogin 801004e86ffSlogin /// @brief 获取从start_cluster开始的簇链中,第n个簇的信息。(请注意,下标从0开始) 802004e86ffSlogin #[inline] get_cluster_by_relative(&self, start_cluster: Cluster, n: usize) -> Option<Cluster>803004e86ffSlogin pub fn get_cluster_by_relative(&self, start_cluster: Cluster, n: usize) -> Option<Cluster> { 804b5b571e0SLoGin return self.cluster_iter(start_cluster).nth(n); 805004e86ffSlogin } 806004e86ffSlogin 807004e86ffSlogin /// @brief 获取整个簇链的最后一个簇 808004e86ffSlogin #[inline] get_last_cluster(&self, start_cluster: Cluster) -> Option<Cluster>809004e86ffSlogin pub fn get_last_cluster(&self, start_cluster: Cluster) -> Option<Cluster> { 810004e86ffSlogin return self.cluster_iter(start_cluster).last(); 811004e86ffSlogin } 812004e86ffSlogin 813004e86ffSlogin /// @brief 判断FAT文件系统的shut bit是否正常。 814004e86ffSlogin /// shut bit 表示文件系统是否正常卸载。如果这一位是1,则表示这个卷是“干净的” 815004e86ffSlogin /// 参考资料:https://thestarman.pcministry.com/DOS/DirtyShutdownFlag.html 816004e86ffSlogin /// 817004e86ffSlogin /// @return Ok(true) 正常 818004e86ffSlogin /// @return Ok(false) 不正常 819676b8ef6SMork /// @return Err(SystemError) 在判断时发生错误 82091e9d4abSLoGin #[allow(dead_code)] is_shut_bit_ok(&mut self) -> Result<bool, SystemError>821676b8ef6SMork pub fn is_shut_bit_ok(&mut self) -> Result<bool, SystemError> { 822004e86ffSlogin match self.bpb.fat_type { 823004e86ffSlogin FATType::FAT32(_) => { 824004e86ffSlogin // 对于FAT32, error bit位于第一个扇区的第8字节。 825004e86ffSlogin let bit = self.get_fat_entry_raw(Cluster::new(1))? & 0x0800_0000; 826004e86ffSlogin return Ok(bit > 0); 827004e86ffSlogin } 828004e86ffSlogin FATType::FAT16(_) => { 829004e86ffSlogin let bit = self.get_fat_entry_raw(Cluster::new(1))? & 0x8000; 830004e86ffSlogin return Ok(bit > 0); 831004e86ffSlogin } 832004e86ffSlogin _ => return Ok(true), 833004e86ffSlogin } 834004e86ffSlogin } 835004e86ffSlogin 836004e86ffSlogin /// @brief 判断FAT文件系统的hard error bit是否正常。 837004e86ffSlogin /// 如果此位为0,则文件系统驱动程序在上次安装卷时遇到磁盘 I/O 错误,这表明 838004e86ffSlogin /// 卷上的某些扇区可能已损坏。 839004e86ffSlogin /// 参考资料:https://thestarman.pcministry.com/DOS/DirtyShutdownFlag.html 840004e86ffSlogin /// 841004e86ffSlogin /// @return Ok(true) 正常 842004e86ffSlogin /// @return Ok(false) 不正常 843676b8ef6SMork /// @return Err(SystemError) 在判断时发生错误 is_hard_error_bit_ok(&mut self) -> Result<bool, SystemError>844676b8ef6SMork pub fn is_hard_error_bit_ok(&mut self) -> Result<bool, SystemError> { 845004e86ffSlogin match self.bpb.fat_type { 846004e86ffSlogin FATType::FAT32(_) => { 847004e86ffSlogin let bit = self.get_fat_entry_raw(Cluster::new(1))? & 0x0400_0000; 848004e86ffSlogin return Ok(bit > 0); 849004e86ffSlogin } 850004e86ffSlogin FATType::FAT16(_) => { 851004e86ffSlogin let bit = self.get_fat_entry_raw(Cluster::new(1))? & 0x4000; 852004e86ffSlogin return Ok(bit > 0); 853004e86ffSlogin } 854004e86ffSlogin _ => return Ok(true), 855004e86ffSlogin } 856004e86ffSlogin } 857004e86ffSlogin 858004e86ffSlogin /// @brief 设置文件系统的shut bit为正常状态 859004e86ffSlogin /// 参考资料:https://thestarman.pcministry.com/DOS/DirtyShutdownFlag.html 860004e86ffSlogin /// 861004e86ffSlogin /// @return Ok(()) 设置成功 862676b8ef6SMork /// @return Err(SystemError) 在设置过程中,出现错误 set_shut_bit_ok(&mut self) -> Result<(), SystemError>863676b8ef6SMork pub fn set_shut_bit_ok(&mut self) -> Result<(), SystemError> { 864004e86ffSlogin match self.bpb.fat_type { 865004e86ffSlogin FATType::FAT32(_) => { 866004e86ffSlogin let raw_entry = self.get_fat_entry_raw(Cluster::new(1))? | 0x0800_0000; 867004e86ffSlogin self.set_entry(Cluster::new(1), FATEntry::Next(Cluster::new(raw_entry)))?; 868004e86ffSlogin 869004e86ffSlogin return Ok(()); 870004e86ffSlogin } 871004e86ffSlogin 872004e86ffSlogin FATType::FAT16(_) => { 873004e86ffSlogin let raw_entry = self.get_fat_entry_raw(Cluster::new(1))? | 0x8000; 874004e86ffSlogin self.set_entry(Cluster::new(1), FATEntry::Next(Cluster::new(raw_entry)))?; 875004e86ffSlogin return Ok(()); 876004e86ffSlogin } 877004e86ffSlogin _ => return Ok(()), 878004e86ffSlogin } 879004e86ffSlogin } 880004e86ffSlogin 881004e86ffSlogin /// @brief 设置文件系统的hard error bit为正常状态 882004e86ffSlogin /// 参考资料:https://thestarman.pcministry.com/DOS/DirtyShutdownFlag.html 883004e86ffSlogin /// 884004e86ffSlogin /// @return Ok(()) 设置成功 885676b8ef6SMork /// @return Err(SystemError) 在设置过程中,出现错误 set_hard_error_bit_ok(&mut self) -> Result<(), SystemError>886676b8ef6SMork pub fn set_hard_error_bit_ok(&mut self) -> Result<(), SystemError> { 887004e86ffSlogin match self.bpb.fat_type { 888004e86ffSlogin FATType::FAT32(_) => { 889004e86ffSlogin let raw_entry = self.get_fat_entry_raw(Cluster::new(1))? | 0x0400_0000; 890004e86ffSlogin self.set_entry(Cluster::new(1), FATEntry::Next(Cluster::new(raw_entry)))?; 891004e86ffSlogin return Ok(()); 892004e86ffSlogin } 893004e86ffSlogin 894004e86ffSlogin FATType::FAT16(_) => { 895004e86ffSlogin let raw_entry = self.get_fat_entry_raw(Cluster::new(1))? | 0x4000; 896004e86ffSlogin self.set_entry(Cluster::new(1), FATEntry::Next(Cluster::new(raw_entry)))?; 897004e86ffSlogin return Ok(()); 898004e86ffSlogin } 899004e86ffSlogin _ => return Ok(()), 900004e86ffSlogin } 901004e86ffSlogin } 902004e86ffSlogin 903004e86ffSlogin /// @brief 执行文件系统卸载前的一些准备工作:设置好对应的标志位,并把缓存中的数据刷入磁盘 umount(&mut self) -> Result<(), SystemError>904676b8ef6SMork pub fn umount(&mut self) -> Result<(), SystemError> { 9059fa0e95eSLoGin self.fs_info.0.lock().flush(&self.gendisk)?; 906004e86ffSlogin 907004e86ffSlogin self.set_shut_bit_ok()?; 908004e86ffSlogin 909004e86ffSlogin self.set_hard_error_bit_ok()?; 910004e86ffSlogin 9119fa0e95eSLoGin self.gendisk.sync()?; 912004e86ffSlogin 913004e86ffSlogin return Ok(()); 914004e86ffSlogin } 915004e86ffSlogin 916004e86ffSlogin /// @brief 获取文件系统的最大簇号 max_cluster_number(&self) -> Cluster917004e86ffSlogin pub fn max_cluster_number(&self) -> Cluster { 918004e86ffSlogin match self.bpb.fat_type { 919004e86ffSlogin FATType::FAT32(s) => { 920004e86ffSlogin // FAT32 921004e86ffSlogin 922004e86ffSlogin // 数据扇区数量(总扇区数-保留扇区-FAT占用的扇区) 923004e86ffSlogin let data_sec: u64 = self.bpb.total_sectors_32 as u64 924004e86ffSlogin - (self.bpb.rsvd_sec_cnt as u64 925004e86ffSlogin + self.bpb.num_fats as u64 * s.fat_size_32 as u64); 926004e86ffSlogin 927004e86ffSlogin // 数据区的簇数量 928004e86ffSlogin let total_clusters: u64 = data_sec / self.bpb.sector_per_cluster as u64; 929004e86ffSlogin 930004e86ffSlogin // 返回最大的簇号 931004e86ffSlogin return Cluster::new(total_clusters + RESERVED_CLUSTERS as u64 - 1); 932004e86ffSlogin } 933004e86ffSlogin 934004e86ffSlogin _ => { 935004e86ffSlogin // FAT12 / FAT16 936004e86ffSlogin let root_dir_sectors: u64 = (((self.bpb.root_entries_cnt as u64) * 32) 937004e86ffSlogin + self.bpb.bytes_per_sector as u64 938004e86ffSlogin - 1) 939004e86ffSlogin / self.bpb.bytes_per_sector as u64; 940004e86ffSlogin // 数据区扇区数 941004e86ffSlogin let data_sec: u64 = self.bpb.total_sectors_16 as u64 942004e86ffSlogin - (self.bpb.rsvd_sec_cnt as u64 943004e86ffSlogin + (self.bpb.num_fats as u64 * self.bpb.fat_size_16 as u64) 944004e86ffSlogin + root_dir_sectors); 945004e86ffSlogin let total_clusters = data_sec / self.bpb.sector_per_cluster as u64; 946004e86ffSlogin return Cluster::new(total_clusters + RESERVED_CLUSTERS as u64 - 1); 947004e86ffSlogin } 948004e86ffSlogin } 949004e86ffSlogin } 950004e86ffSlogin 951004e86ffSlogin /// @brief 在文件系统中寻找一个簇号在给定的范围(左闭右开区间)内的空闲簇 952004e86ffSlogin /// 953004e86ffSlogin /// @param start_cluster 起始簇号 954004e86ffSlogin /// @param end_cluster 终止簇号(不包含) 955004e86ffSlogin /// 956004e86ffSlogin /// @return Ok(Cluster) 寻找到的空闲簇 957676b8ef6SMork /// @return Err(SystemError) 错误码。如果磁盘无剩余空间,或者簇号达到给定的最大值,则返回-ENOSPC. get_free_cluster( &self, start_cluster: Cluster, end_cluster: Cluster, ) -> Result<Cluster, SystemError>958004e86ffSlogin pub fn get_free_cluster( 959004e86ffSlogin &self, 960004e86ffSlogin start_cluster: Cluster, 961004e86ffSlogin end_cluster: Cluster, 962676b8ef6SMork ) -> Result<Cluster, SystemError> { 963004e86ffSlogin let max_cluster: Cluster = self.max_cluster_number(); 964004e86ffSlogin let mut cluster: u64 = start_cluster.cluster_num; 965004e86ffSlogin 966004e86ffSlogin let fat_type: FATType = self.bpb.fat_type; 967004e86ffSlogin let fat_start_sector: u64 = self.fat_start_sector(); 968004e86ffSlogin let bytes_per_sec: u64 = self.bpb.bytes_per_sector as u64; 969004e86ffSlogin 970004e86ffSlogin match fat_type { 971004e86ffSlogin FATType::FAT12(_) => { 972004e86ffSlogin let part_bytes_offset: u64 = 973004e86ffSlogin fat_type.get_fat_bytes_offset(start_cluster, fat_start_sector, bytes_per_sec); 974004e86ffSlogin let in_block_offset = self.get_in_block_offset(part_bytes_offset); 975004e86ffSlogin 9769fa0e95eSLoGin let lba = self.gendisk_lba_from_offset(self.bytes_to_sector(part_bytes_offset)); 977004e86ffSlogin 978004e86ffSlogin // 由于FAT12的FAT表不大于6K,因此直接读取6K 979004e86ffSlogin let num_lba = (6 * 1024) / LBA_SIZE; 980b5b571e0SLoGin let mut v: Vec<u8> = vec![0; num_lba * LBA_SIZE]; 9819fa0e95eSLoGin self.gendisk.read_at(&mut v, lba)?; 982004e86ffSlogin 983004e86ffSlogin let mut cursor: VecCursor = VecCursor::new(v); 984004e86ffSlogin cursor.seek(SeekFrom::SeekSet(in_block_offset as i64))?; 985004e86ffSlogin 986004e86ffSlogin let mut packed_val: u16 = cursor.read_u16()?; 987004e86ffSlogin loop { 988004e86ffSlogin let val = if (cluster & 0x1) > 0 { 989004e86ffSlogin packed_val >> 4 990004e86ffSlogin } else { 991004e86ffSlogin packed_val & 0x0fff 992004e86ffSlogin }; 993004e86ffSlogin if val == 0 { 994b5b571e0SLoGin return Ok(Cluster::new(cluster)); 995004e86ffSlogin } 996004e86ffSlogin 997004e86ffSlogin cluster += 1; 998004e86ffSlogin 999004e86ffSlogin // 磁盘无剩余空间,或者簇号达到给定的最大值 1000004e86ffSlogin if cluster == end_cluster.cluster_num || cluster == max_cluster.cluster_num { 1001676b8ef6SMork return Err(SystemError::ENOSPC); 1002004e86ffSlogin } 1003004e86ffSlogin 1004004e86ffSlogin packed_val = match cluster & 1 { 1005004e86ffSlogin 0 => cursor.read_u16()?, 1006004e86ffSlogin _ => { 1007004e86ffSlogin let next_byte = cursor.read_u8()? as u16; 1008004e86ffSlogin (packed_val >> 8) | (next_byte << 8) 1009004e86ffSlogin } 1010004e86ffSlogin }; 1011004e86ffSlogin } 1012004e86ffSlogin } 1013004e86ffSlogin FATType::FAT16(_) => { 1014004e86ffSlogin // todo: 优化这里,减少读取磁盘的次数。 1015004e86ffSlogin while cluster < end_cluster.cluster_num && cluster < max_cluster.cluster_num { 1016004e86ffSlogin let part_bytes_offset: u64 = fat_type.get_fat_bytes_offset( 1017004e86ffSlogin Cluster::new(cluster), 1018004e86ffSlogin fat_start_sector, 1019004e86ffSlogin bytes_per_sec, 1020004e86ffSlogin ); 1021004e86ffSlogin let in_block_offset = self.get_in_block_offset(part_bytes_offset); 1022004e86ffSlogin 10239fa0e95eSLoGin let lba = self.gendisk_lba_from_offset(self.bytes_to_sector(part_bytes_offset)); 1024004e86ffSlogin 1025b5b571e0SLoGin let mut v: Vec<u8> = vec![0; self.lba_per_sector() * LBA_SIZE]; 10269fa0e95eSLoGin self.gendisk.read_at(&mut v, lba)?; 1027004e86ffSlogin 1028004e86ffSlogin let mut cursor: VecCursor = VecCursor::new(v); 1029004e86ffSlogin cursor.seek(SeekFrom::SeekSet(in_block_offset as i64))?; 1030004e86ffSlogin 1031004e86ffSlogin let val = cursor.read_u16()?; 1032004e86ffSlogin // 找到空闲簇 1033004e86ffSlogin if val == 0 { 1034004e86ffSlogin return Ok(Cluster::new(val as u64)); 1035004e86ffSlogin } 1036004e86ffSlogin cluster += 1; 1037004e86ffSlogin } 1038004e86ffSlogin 1039004e86ffSlogin // 磁盘无剩余空间,或者簇号达到给定的最大值 1040676b8ef6SMork return Err(SystemError::ENOSPC); 1041004e86ffSlogin } 1042004e86ffSlogin FATType::FAT32(_) => { 1043004e86ffSlogin // todo: 优化这里,减少读取磁盘的次数。 1044004e86ffSlogin while cluster < end_cluster.cluster_num && cluster < max_cluster.cluster_num { 1045004e86ffSlogin let part_bytes_offset: u64 = fat_type.get_fat_bytes_offset( 1046004e86ffSlogin Cluster::new(cluster), 1047004e86ffSlogin fat_start_sector, 1048004e86ffSlogin bytes_per_sec, 1049004e86ffSlogin ); 1050004e86ffSlogin let in_block_offset = self.get_in_block_offset(part_bytes_offset); 1051004e86ffSlogin 10529fa0e95eSLoGin let lba = self.gendisk_lba_from_offset(self.bytes_to_sector(part_bytes_offset)); 1053004e86ffSlogin 1054b5b571e0SLoGin let mut v: Vec<u8> = vec![0; self.lba_per_sector() * LBA_SIZE]; 10559fa0e95eSLoGin self.gendisk.read_at(&mut v, lba)?; 1056004e86ffSlogin 1057004e86ffSlogin let mut cursor: VecCursor = VecCursor::new(v); 1058004e86ffSlogin cursor.seek(SeekFrom::SeekSet(in_block_offset as i64))?; 1059004e86ffSlogin 1060004e86ffSlogin let val = cursor.read_u32()? & 0x0fffffff; 1061004e86ffSlogin 1062004e86ffSlogin if val == 0 { 1063004e86ffSlogin return Ok(Cluster::new(cluster)); 1064004e86ffSlogin } 1065004e86ffSlogin cluster += 1; 1066004e86ffSlogin } 1067004e86ffSlogin 1068004e86ffSlogin // 磁盘无剩余空间,或者簇号达到给定的最大值 1069676b8ef6SMork return Err(SystemError::ENOSPC); 1070004e86ffSlogin } 1071004e86ffSlogin } 1072004e86ffSlogin } 1073004e86ffSlogin 1074004e86ffSlogin /// @brief 在FAT表中,设置指定的簇的信息。 1075004e86ffSlogin /// 1076004e86ffSlogin /// @param cluster 目标簇 1077004e86ffSlogin /// @param fat_entry 这个簇在FAT表中,存储的信息(下一个簇的簇号) set_entry(&self, cluster: Cluster, fat_entry: FATEntry) -> Result<(), SystemError>1078676b8ef6SMork pub fn set_entry(&self, cluster: Cluster, fat_entry: FATEntry) -> Result<(), SystemError> { 1079004e86ffSlogin // fat表项在分区上的字节偏移量 1080004e86ffSlogin let fat_part_bytes_offset: u64 = self.bpb.fat_type.get_fat_bytes_offset( 1081004e86ffSlogin cluster, 1082004e86ffSlogin self.fat_start_sector(), 1083004e86ffSlogin self.bpb.bytes_per_sector as u64, 1084004e86ffSlogin ); 1085004e86ffSlogin 1086004e86ffSlogin match self.bpb.fat_type { 1087004e86ffSlogin FATType::FAT12(_) => { 1088004e86ffSlogin // 计算要写入的值 1089004e86ffSlogin let raw_val: u16 = match fat_entry { 1090004e86ffSlogin FATEntry::Unused => 0, 1091004e86ffSlogin FATEntry::Bad => 0xff7, 1092004e86ffSlogin FATEntry::EndOfChain => 0xfff, 1093004e86ffSlogin FATEntry::Next(c) => c.cluster_num as u16, 1094004e86ffSlogin }; 1095004e86ffSlogin 1096004e86ffSlogin let in_block_offset = self.get_in_block_offset(fat_part_bytes_offset); 1097004e86ffSlogin 10989fa0e95eSLoGin let lba = self.gendisk_lba_from_offset(self.bytes_to_sector(fat_part_bytes_offset)); 1099004e86ffSlogin 1100b5b571e0SLoGin let mut v: Vec<u8> = vec![0; LBA_SIZE]; 11019fa0e95eSLoGin self.gendisk.read_at(&mut v, lba)?; 1102004e86ffSlogin 1103004e86ffSlogin let mut cursor: VecCursor = VecCursor::new(v); 1104004e86ffSlogin cursor.seek(SeekFrom::SeekSet(in_block_offset as i64))?; 1105004e86ffSlogin 1106004e86ffSlogin let old_val: u16 = cursor.read_u16()?; 1107004e86ffSlogin let new_val: u16 = if (cluster.cluster_num & 0x1) > 0 { 1108004e86ffSlogin (old_val & 0x000f) | (raw_val << 4) 1109004e86ffSlogin } else { 1110004e86ffSlogin (old_val & 0xf000) | raw_val 1111004e86ffSlogin }; 1112004e86ffSlogin 1113004e86ffSlogin // 写回数据到磁盘上 1114004e86ffSlogin cursor.seek(SeekFrom::SeekSet(in_block_offset as i64))?; 1115004e86ffSlogin cursor.write_u16(new_val)?; 11169fa0e95eSLoGin self.gendisk.write_at(cursor.as_slice(), lba)?; 1117004e86ffSlogin return Ok(()); 1118004e86ffSlogin } 1119004e86ffSlogin FATType::FAT16(_) => { 1120004e86ffSlogin // 计算要写入的值 1121004e86ffSlogin let raw_val: u16 = match fat_entry { 1122004e86ffSlogin FATEntry::Unused => 0, 1123004e86ffSlogin FATEntry::Bad => 0xfff7, 1124004e86ffSlogin FATEntry::EndOfChain => 0xfdff, 1125004e86ffSlogin FATEntry::Next(c) => c.cluster_num as u16, 1126004e86ffSlogin }; 1127004e86ffSlogin 1128004e86ffSlogin let in_block_offset = self.get_in_block_offset(fat_part_bytes_offset); 1129004e86ffSlogin 11309fa0e95eSLoGin let lba = self.gendisk_lba_from_offset(self.bytes_to_sector(fat_part_bytes_offset)); 1131004e86ffSlogin 1132b5b571e0SLoGin let mut v: Vec<u8> = vec![0; LBA_SIZE]; 11339fa0e95eSLoGin self.gendisk.read_at(&mut v, lba)?; 1134004e86ffSlogin 1135004e86ffSlogin let mut cursor: VecCursor = VecCursor::new(v); 1136004e86ffSlogin cursor.seek(SeekFrom::SeekSet(in_block_offset as i64))?; 1137004e86ffSlogin 1138004e86ffSlogin cursor.write_u16(raw_val)?; 11399fa0e95eSLoGin self.gendisk.write_at(cursor.as_slice(), lba)?; 1140004e86ffSlogin 1141004e86ffSlogin return Ok(()); 1142004e86ffSlogin } 1143004e86ffSlogin FATType::FAT32(_) => { 1144004e86ffSlogin let fat_size: u64 = self.fat_size(); 1145004e86ffSlogin let bound: u64 = if self.mirroring_enabled() { 1146004e86ffSlogin 1 1147004e86ffSlogin } else { 1148004e86ffSlogin self.bpb.num_fats as u64 1149004e86ffSlogin }; 11502eab6dd7S曾俊 // debug!("set entry, bound={bound}, fat_size={fat_size}"); 1151004e86ffSlogin for i in 0..bound { 1152004e86ffSlogin // 当前操作的FAT表在磁盘上的字节偏移量 1153004e86ffSlogin let f_offset: u64 = fat_part_bytes_offset + i * fat_size; 1154004e86ffSlogin let in_block_offset: u64 = self.get_in_block_offset(f_offset); 11559fa0e95eSLoGin let lba = self.gendisk_lba_from_offset(self.bytes_to_sector(f_offset)); 1156004e86ffSlogin 11572eab6dd7S曾俊 // debug!("set entry, lba={lba}, in_block_offset={in_block_offset}"); 1158b5b571e0SLoGin let mut v: Vec<u8> = vec![0; LBA_SIZE]; 11599fa0e95eSLoGin self.gendisk.read_at(&mut v, lba)?; 1160004e86ffSlogin 1161004e86ffSlogin let mut cursor: VecCursor = VecCursor::new(v); 1162004e86ffSlogin cursor.seek(SeekFrom::SeekSet(in_block_offset as i64))?; 1163004e86ffSlogin 1164004e86ffSlogin // FAT32的高4位保留 1165004e86ffSlogin let old_bits = cursor.read_u32()? & 0xf0000000; 1166004e86ffSlogin 1167004e86ffSlogin if fat_entry == FATEntry::Unused 1168004e86ffSlogin && cluster.cluster_num >= 0x0ffffff7 1169004e86ffSlogin && cluster.cluster_num <= 0x0fffffff 1170004e86ffSlogin { 11712eab6dd7S曾俊 error!( 1172004e86ffSlogin "FAT32: Reserved Cluster {:?} cannot be marked as free", 1173004e86ffSlogin cluster 1174004e86ffSlogin ); 1175676b8ef6SMork return Err(SystemError::EPERM); 1176004e86ffSlogin } 1177004e86ffSlogin 1178004e86ffSlogin // 计算要写入的值 1179004e86ffSlogin let mut raw_val: u32 = match fat_entry { 1180004e86ffSlogin FATEntry::Unused => 0, 1181004e86ffSlogin FATEntry::Bad => 0x0FFFFFF7, 1182004e86ffSlogin FATEntry::EndOfChain => 0x0FFFFFFF, 1183004e86ffSlogin FATEntry::Next(c) => c.cluster_num as u32, 1184004e86ffSlogin }; 1185004e86ffSlogin 1186004e86ffSlogin // 恢复保留位 1187004e86ffSlogin raw_val |= old_bits; 1188004e86ffSlogin 11892eab6dd7S曾俊 // debug!("sent entry, raw_val={raw_val}"); 1190004e86ffSlogin 1191004e86ffSlogin cursor.seek(SeekFrom::SeekSet(in_block_offset as i64))?; 1192004e86ffSlogin cursor.write_u32(raw_val)?; 1193004e86ffSlogin 11949fa0e95eSLoGin self.gendisk.write_at(cursor.as_slice(), lba)?; 1195004e86ffSlogin } 1196004e86ffSlogin 1197004e86ffSlogin return Ok(()); 1198004e86ffSlogin } 1199004e86ffSlogin } 1200004e86ffSlogin } 1201004e86ffSlogin 12029fa0e95eSLoGin /// # 清空指定的簇 1203004e86ffSlogin /// 12049fa0e95eSLoGin /// # 参数 12059fa0e95eSLoGin /// - cluster 要被清空的簇 zero_cluster(&self, cluster: Cluster) -> Result<(), SystemError>1206676b8ef6SMork pub fn zero_cluster(&self, cluster: Cluster) -> Result<(), SystemError> { 1207004e86ffSlogin // 准备数据,用于写入 1208004e86ffSlogin let zeros: Vec<u8> = vec![0u8; self.bytes_per_cluster() as usize]; 12099fa0e95eSLoGin let offset = self.cluster_bytes_offset(cluster) as usize; 12109fa0e95eSLoGin self.gendisk.write_at_bytes(&zeros, offset)?; 1211004e86ffSlogin return Ok(()); 1212004e86ffSlogin } 1213004e86ffSlogin } 1214004e86ffSlogin 1215004e86ffSlogin impl Drop for FATFileSystem { drop(&mut self)1216004e86ffSlogin fn drop(&mut self) { 1217004e86ffSlogin let r = self.umount(); 1218004e86ffSlogin if r.is_err() { 12192eab6dd7S曾俊 error!( 1220676b8ef6SMork "Umount FAT filesystem failed: errno={:?}, FS detail:{self:?}", 12218d72b68dSJomo r.as_ref().unwrap_err() 1222004e86ffSlogin ); 1223004e86ffSlogin } 1224004e86ffSlogin } 1225004e86ffSlogin } 1226004e86ffSlogin 1227004e86ffSlogin impl FATFsInfo { 1228004e86ffSlogin const LEAD_SIG: u32 = 0x41615252; 1229004e86ffSlogin const STRUC_SIG: u32 = 0x61417272; 1230004e86ffSlogin const TRAIL_SIG: u32 = 0xAA550000; 123191e9d4abSLoGin #[allow(dead_code)] 1232004e86ffSlogin const FS_INFO_SIZE: u64 = 512; 1233004e86ffSlogin 1234004e86ffSlogin /// @brief 从磁盘上读取FAT文件系统的FSInfo结构体 1235004e86ffSlogin /// 1236004e86ffSlogin /// @param partition 磁盘分区 12379fa0e95eSLoGin /// @param in_gendisk_fs_info_offset FSInfo扇区在gendisk内的字节偏移量(单位:字节) 1238004e86ffSlogin /// @param bytes_per_sec 每扇区字节数 new( gendisk: &Arc<GenDisk>, in_gendisk_fs_info_offset: usize, bytes_per_sec: usize, ) -> Result<Self, SystemError>1239004e86ffSlogin pub fn new( 12409fa0e95eSLoGin gendisk: &Arc<GenDisk>, 12419fa0e95eSLoGin in_gendisk_fs_info_offset: usize, 1242004e86ffSlogin bytes_per_sec: usize, 1243676b8ef6SMork ) -> Result<Self, SystemError> { 1244b5b571e0SLoGin let mut v = vec![0; bytes_per_sec]; 1245004e86ffSlogin 12469fa0e95eSLoGin // 读取磁盘上的FsInfo扇区 12479fa0e95eSLoGin gendisk.read_at_bytes(&mut v, in_gendisk_fs_info_offset)?; 12489fa0e95eSLoGin 1249004e86ffSlogin let mut cursor = VecCursor::new(v); 1250004e86ffSlogin 1251b5b571e0SLoGin let mut fsinfo = FATFsInfo { 1252b5b571e0SLoGin lead_sig: cursor.read_u32()?, 1253b5b571e0SLoGin ..Default::default() 1254b5b571e0SLoGin }; 1255004e86ffSlogin cursor.seek(SeekFrom::SeekCurrent(480))?; 1256004e86ffSlogin fsinfo.struc_sig = cursor.read_u32()?; 1257004e86ffSlogin fsinfo.free_count = cursor.read_u32()?; 1258004e86ffSlogin fsinfo.next_free = cursor.read_u32()?; 1259004e86ffSlogin 1260004e86ffSlogin cursor.seek(SeekFrom::SeekCurrent(12))?; 1261004e86ffSlogin 1262004e86ffSlogin fsinfo.trail_sig = cursor.read_u32()?; 1263004e86ffSlogin fsinfo.dirty = false; 12649fa0e95eSLoGin fsinfo.offset = Some(gendisk.disk_bytes_offset(in_gendisk_fs_info_offset) as u64); 1265004e86ffSlogin 1266004e86ffSlogin if fsinfo.is_valid() { 1267004e86ffSlogin return Ok(fsinfo); 1268004e86ffSlogin } else { 12692eab6dd7S曾俊 error!("Error occurred while parsing FATFsInfo."); 1270676b8ef6SMork return Err(SystemError::EINVAL); 1271004e86ffSlogin } 1272004e86ffSlogin } 1273004e86ffSlogin 1274004e86ffSlogin /// @brief 判断是否为正确的FsInfo结构体 is_valid(&self) -> bool1275004e86ffSlogin fn is_valid(&self) -> bool { 1276004e86ffSlogin self.lead_sig == Self::LEAD_SIG 1277004e86ffSlogin && self.struc_sig == Self::STRUC_SIG 1278004e86ffSlogin && self.trail_sig == Self::TRAIL_SIG 1279004e86ffSlogin } 1280004e86ffSlogin 1281004e86ffSlogin /// @brief 根据fsinfo的信息,计算当前总的空闲簇数量 1282004e86ffSlogin /// 1283004e86ffSlogin /// @param 当前文件系统的最大簇号 count_free_cluster(&self, max_cluster: Cluster) -> Option<u64>1284004e86ffSlogin pub fn count_free_cluster(&self, max_cluster: Cluster) -> Option<u64> { 1285004e86ffSlogin let count_clusters = max_cluster.cluster_num - RESERVED_CLUSTERS as u64 + 1; 1286004e86ffSlogin // 信息不合理,当前的FsInfo中存储的free count大于计算出来的值 1287004e86ffSlogin if self.free_count as u64 > count_clusters { 1288004e86ffSlogin return None; 1289004e86ffSlogin } else { 1290004e86ffSlogin match self.free_count { 1291004e86ffSlogin // free count字段不可用 1292004e86ffSlogin 0xffffffff => return None, 1293004e86ffSlogin // 返回FsInfo中存储的数据 1294004e86ffSlogin n => return Some(n as u64), 1295004e86ffSlogin } 1296004e86ffSlogin } 1297004e86ffSlogin } 1298004e86ffSlogin 1299004e86ffSlogin /// @brief 更新FsInfo中的“空闲簇统计信息“为new_count 1300004e86ffSlogin /// 1301004e86ffSlogin /// 请注意,除非手动调用`flush()`,否则本函数不会将数据刷入磁盘 update_free_count_abs(&mut self, new_count: u32)1302004e86ffSlogin pub fn update_free_count_abs(&mut self, new_count: u32) { 1303004e86ffSlogin self.free_count = new_count; 1304004e86ffSlogin } 1305004e86ffSlogin 1306004e86ffSlogin /// @brief 更新FsInfo中的“空闲簇统计信息“,把它加上delta. 1307004e86ffSlogin /// 1308004e86ffSlogin /// 请注意,除非手动调用`flush()`,否则本函数不会将数据刷入磁盘 update_free_count_delta(&mut self, delta: i32)1309004e86ffSlogin pub fn update_free_count_delta(&mut self, delta: i32) { 1310004e86ffSlogin self.free_count = (self.free_count as i32 + delta) as u32; 1311004e86ffSlogin } 1312004e86ffSlogin 1313004e86ffSlogin /// @brief 更新FsInfo中的“第一个空闲簇统计信息“为next_free. 1314004e86ffSlogin /// 1315004e86ffSlogin /// 请注意,除非手动调用`flush()`,否则本函数不会将数据刷入磁盘 update_next_free(&mut self, next_free: u32)1316004e86ffSlogin pub fn update_next_free(&mut self, next_free: u32) { 1317004e86ffSlogin // 这个值是参考量,不一定要准确,仅供加速查找 1318004e86ffSlogin self.next_free = next_free; 1319004e86ffSlogin } 1320004e86ffSlogin 1321004e86ffSlogin /// @brief 获取fs info 记载的第一个空闲簇。(不一定准确,仅供参考) next_free(&self) -> Option<u64>1322004e86ffSlogin pub fn next_free(&self) -> Option<u64> { 1323004e86ffSlogin match self.next_free { 1324004e86ffSlogin 0xffffffff => return None, 1325004e86ffSlogin 0 | 1 => return None, 1326004e86ffSlogin n => return Some(n as u64), 1327004e86ffSlogin }; 1328004e86ffSlogin } 1329004e86ffSlogin 1330004e86ffSlogin /// @brief 把fs info刷入磁盘 1331004e86ffSlogin /// 1332004e86ffSlogin /// @param partition fs info所在的分区 flush(&self, gendisk: &Arc<GenDisk>) -> Result<(), SystemError>13339fa0e95eSLoGin pub fn flush(&self, gendisk: &Arc<GenDisk>) -> Result<(), SystemError> { 1334004e86ffSlogin if let Some(off) = self.offset { 1335004e86ffSlogin let in_block_offset = off % LBA_SIZE as u64; 1336004e86ffSlogin 1337004e86ffSlogin let lba = off as usize / LBA_SIZE; 1338004e86ffSlogin 1339b5b571e0SLoGin let mut v: Vec<u8> = vec![0; LBA_SIZE]; 13409fa0e95eSLoGin gendisk.read_at(&mut v, lba)?; 1341004e86ffSlogin 1342004e86ffSlogin let mut cursor: VecCursor = VecCursor::new(v); 1343004e86ffSlogin cursor.seek(SeekFrom::SeekSet(in_block_offset as i64))?; 1344004e86ffSlogin 1345004e86ffSlogin cursor.write_u32(self.lead_sig)?; 1346004e86ffSlogin cursor.seek(SeekFrom::SeekCurrent(480))?; 1347004e86ffSlogin cursor.write_u32(self.struc_sig)?; 1348004e86ffSlogin cursor.write_u32(self.free_count)?; 1349004e86ffSlogin cursor.write_u32(self.next_free)?; 1350004e86ffSlogin cursor.seek(SeekFrom::SeekCurrent(12))?; 1351004e86ffSlogin cursor.write_u32(self.trail_sig)?; 1352004e86ffSlogin 13539fa0e95eSLoGin gendisk.write_at(cursor.as_slice(), lba)?; 1354004e86ffSlogin } 1355004e86ffSlogin return Ok(()); 1356004e86ffSlogin } 1357004e86ffSlogin 1358004e86ffSlogin /// @brief 读取磁盘上的Fs Info扇区,将里面的内容更新到结构体中 1359004e86ffSlogin /// 1360004e86ffSlogin /// @param partition fs info所在的分区 update(&mut self, partition: Arc<Partition>) -> Result<(), SystemError>1361676b8ef6SMork pub fn update(&mut self, partition: Arc<Partition>) -> Result<(), SystemError> { 1362004e86ffSlogin if let Some(off) = self.offset { 1363004e86ffSlogin let in_block_offset = off % LBA_SIZE as u64; 1364004e86ffSlogin 1365004e86ffSlogin let lba = off as usize / LBA_SIZE; 1366004e86ffSlogin 1367b5b571e0SLoGin let mut v: Vec<u8> = vec![0; LBA_SIZE]; 1368004e86ffSlogin partition.disk().read_at(lba, 1, &mut v)?; 1369004e86ffSlogin let mut cursor: VecCursor = VecCursor::new(v); 1370004e86ffSlogin cursor.seek(SeekFrom::SeekSet(in_block_offset as i64))?; 1371004e86ffSlogin self.lead_sig = cursor.read_u32()?; 1372004e86ffSlogin 1373004e86ffSlogin cursor.seek(SeekFrom::SeekCurrent(480))?; 1374004e86ffSlogin self.struc_sig = cursor.read_u32()?; 1375004e86ffSlogin self.free_count = cursor.read_u32()?; 1376004e86ffSlogin self.next_free = cursor.read_u32()?; 1377004e86ffSlogin cursor.seek(SeekFrom::SeekCurrent(12))?; 1378004e86ffSlogin self.trail_sig = cursor.read_u32()?; 1379004e86ffSlogin } 1380004e86ffSlogin return Ok(()); 1381004e86ffSlogin } 1382004e86ffSlogin } 1383004e86ffSlogin 1384004e86ffSlogin impl IndexNode for LockedFATInode { read_at( &self, offset: usize, len: usize, buf: &mut [u8], _data: SpinLockGuard<FilePrivateData>, ) -> Result<usize, SystemError>1385004e86ffSlogin fn read_at( 1386004e86ffSlogin &self, 1387004e86ffSlogin offset: usize, 1388004e86ffSlogin len: usize, 1389004e86ffSlogin buf: &mut [u8], 1390dfe53cf0SGnoCiYeH _data: SpinLockGuard<FilePrivateData>, 1391676b8ef6SMork ) -> Result<usize, SystemError> { 1392004e86ffSlogin let mut guard: SpinLockGuard<FATInode> = self.0.lock(); 1393004e86ffSlogin match &guard.inode_type { 1394004e86ffSlogin FATDirEntry::File(f) | FATDirEntry::VolId(f) => { 1395004e86ffSlogin let r = f.read( 1396004e86ffSlogin &guard.fs.upgrade().unwrap(), 1397004e86ffSlogin &mut buf[0..len], 1398004e86ffSlogin offset as u64, 1399004e86ffSlogin ); 1400004e86ffSlogin guard.update_metadata(); 1401004e86ffSlogin return r; 1402004e86ffSlogin } 1403004e86ffSlogin FATDirEntry::Dir(_) => { 1404676b8ef6SMork return Err(SystemError::EISDIR); 1405004e86ffSlogin } 1406004e86ffSlogin FATDirEntry::UnInit => { 14072eab6dd7S曾俊 error!("FATFS: param: Inode_type uninitialized."); 1408676b8ef6SMork return Err(SystemError::EROFS); 1409004e86ffSlogin } 1410004e86ffSlogin } 1411004e86ffSlogin } 1412004e86ffSlogin write_at( &self, offset: usize, len: usize, buf: &[u8], _data: SpinLockGuard<FilePrivateData>, ) -> Result<usize, SystemError>1413004e86ffSlogin fn write_at( 1414004e86ffSlogin &self, 1415004e86ffSlogin offset: usize, 1416004e86ffSlogin len: usize, 1417004e86ffSlogin buf: &[u8], 1418dfe53cf0SGnoCiYeH _data: SpinLockGuard<FilePrivateData>, 1419676b8ef6SMork ) -> Result<usize, SystemError> { 1420004e86ffSlogin let mut guard: SpinLockGuard<FATInode> = self.0.lock(); 1421004e86ffSlogin let fs: &Arc<FATFileSystem> = &guard.fs.upgrade().unwrap(); 1422004e86ffSlogin 1423004e86ffSlogin match &mut guard.inode_type { 1424004e86ffSlogin FATDirEntry::File(f) | FATDirEntry::VolId(f) => { 1425004e86ffSlogin let r = f.write(fs, &buf[0..len], offset as u64); 1426004e86ffSlogin guard.update_metadata(); 1427004e86ffSlogin return r; 1428004e86ffSlogin } 1429004e86ffSlogin FATDirEntry::Dir(_) => { 1430676b8ef6SMork return Err(SystemError::EISDIR); 1431004e86ffSlogin } 1432004e86ffSlogin FATDirEntry::UnInit => { 14332eab6dd7S曾俊 error!("FATFS: param: Inode_type uninitialized."); 1434676b8ef6SMork return Err(SystemError::EROFS); 1435004e86ffSlogin } 1436004e86ffSlogin } 1437004e86ffSlogin } 1438004e86ffSlogin create( &self, name: &str, file_type: FileType, _mode: ModeType, ) -> Result<Arc<dyn IndexNode>, SystemError>1439004e86ffSlogin fn create( 1440004e86ffSlogin &self, 1441004e86ffSlogin name: &str, 1442004e86ffSlogin file_type: FileType, 14436b4e7a29SLoGin _mode: ModeType, 1444676b8ef6SMork ) -> Result<Arc<dyn IndexNode>, SystemError> { 1445004e86ffSlogin // 由于FAT32不支持文件权限的功能,因此忽略mode参数 1446004e86ffSlogin let mut guard: SpinLockGuard<FATInode> = self.0.lock(); 1447004e86ffSlogin let fs: &Arc<FATFileSystem> = &guard.fs.upgrade().unwrap(); 1448004e86ffSlogin 1449004e86ffSlogin match &mut guard.inode_type { 1450004e86ffSlogin FATDirEntry::File(_) | FATDirEntry::VolId(_) => { 1451676b8ef6SMork return Err(SystemError::ENOTDIR); 1452004e86ffSlogin } 1453004e86ffSlogin FATDirEntry::Dir(d) => match file_type { 1454004e86ffSlogin FileType::File => { 1455004e86ffSlogin d.create_file(name, fs)?; 1456004e86ffSlogin return Ok(guard.find(name)?); 1457004e86ffSlogin } 1458004e86ffSlogin FileType::Dir => { 1459004e86ffSlogin d.create_dir(name, fs)?; 1460004e86ffSlogin return Ok(guard.find(name)?); 1461004e86ffSlogin } 1462004e86ffSlogin 14631074eb34SSamuel Dai FileType::SymLink => return Err(SystemError::ENOSYS), 1464676b8ef6SMork _ => return Err(SystemError::EINVAL), 1465004e86ffSlogin }, 1466004e86ffSlogin FATDirEntry::UnInit => { 14672eab6dd7S曾俊 error!("FATFS: param: Inode_type uninitialized."); 1468676b8ef6SMork return Err(SystemError::EROFS); 1469004e86ffSlogin } 1470004e86ffSlogin } 1471004e86ffSlogin } 1472004e86ffSlogin fs(&self) -> Arc<dyn FileSystem>1473004e86ffSlogin fn fs(&self) -> Arc<dyn FileSystem> { 1474004e86ffSlogin return self.0.lock().fs.upgrade().unwrap(); 1475004e86ffSlogin } 1476004e86ffSlogin as_any_ref(&self) -> &dyn core::any::Any1477004e86ffSlogin fn as_any_ref(&self) -> &dyn core::any::Any { 1478004e86ffSlogin return self; 1479004e86ffSlogin } 1480004e86ffSlogin metadata(&self) -> Result<Metadata, SystemError>1481676b8ef6SMork fn metadata(&self) -> Result<Metadata, SystemError> { 1482004e86ffSlogin return Ok(self.0.lock().metadata.clone()); 1483004e86ffSlogin } set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError>14846f189d27Slinfeng fn set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError> { 14856f189d27Slinfeng let inode = &mut self.0.lock(); 14866f189d27Slinfeng inode.metadata.atime = metadata.atime; 14876f189d27Slinfeng inode.metadata.mtime = metadata.mtime; 14886f189d27Slinfeng inode.metadata.ctime = metadata.ctime; 14896f189d27Slinfeng inode.metadata.mode = metadata.mode; 14906f189d27Slinfeng inode.metadata.uid = metadata.uid; 14916f189d27Slinfeng inode.metadata.gid = metadata.gid; 14926f189d27Slinfeng Ok(()) 14936f189d27Slinfeng } resize(&self, len: usize) -> Result<(), SystemError>14946d81180bSLoGin fn resize(&self, len: usize) -> Result<(), SystemError> { 14956d81180bSLoGin let mut guard: SpinLockGuard<FATInode> = self.0.lock(); 14966d81180bSLoGin let fs: &Arc<FATFileSystem> = &guard.fs.upgrade().unwrap(); 14976d81180bSLoGin let old_size = guard.metadata.size as usize; 14986d81180bSLoGin 14996d81180bSLoGin match &mut guard.inode_type { 15006d81180bSLoGin FATDirEntry::File(file) | FATDirEntry::VolId(file) => { 15016d81180bSLoGin // 如果新的长度和旧的长度相同,那么就直接返回 1502b5b571e0SLoGin match len.cmp(&old_size) { 1503b5b571e0SLoGin Ordering::Equal => { 15046d81180bSLoGin return Ok(()); 1505b5b571e0SLoGin } 1506b5b571e0SLoGin Ordering::Greater => { 15076d81180bSLoGin // 如果新的长度比旧的长度大,那么就在文件末尾添加空白 15086d81180bSLoGin let mut buf: Vec<u8> = Vec::new(); 15096d81180bSLoGin let mut remain_size = len - old_size; 15106d81180bSLoGin let buf_size = remain_size; 15116d81180bSLoGin // let buf_size = core::cmp::min(remain_size, 512 * 1024); 15126d81180bSLoGin buf.resize(buf_size, 0); 15136d81180bSLoGin 15146d81180bSLoGin let mut offset = old_size; 15156d81180bSLoGin while remain_size > 0 { 15166d81180bSLoGin let write_size = core::cmp::min(remain_size, buf_size); 15176d81180bSLoGin file.write(fs, &buf[0..write_size], offset as u64)?; 15186d81180bSLoGin remain_size -= write_size; 15196d81180bSLoGin offset += write_size; 15206d81180bSLoGin } 1521b5b571e0SLoGin } 1522b5b571e0SLoGin Ordering::Less => { 15236d81180bSLoGin file.truncate(fs, len as u64)?; 15246d81180bSLoGin } 1525b5b571e0SLoGin } 15266d81180bSLoGin guard.update_metadata(); 15276d81180bSLoGin return Ok(()); 15286d81180bSLoGin } 15291074eb34SSamuel Dai FATDirEntry::Dir(_) => return Err(SystemError::ENOSYS), 15306d81180bSLoGin FATDirEntry::UnInit => { 15312eab6dd7S曾俊 error!("FATFS: param: Inode_type uninitialized."); 15326d81180bSLoGin return Err(SystemError::EROFS); 15336d81180bSLoGin } 15346d81180bSLoGin } 15356d81180bSLoGin } 1536004e86ffSlogin truncate(&self, len: usize) -> Result<(), SystemError>153704babc3fSMemoryShore fn truncate(&self, len: usize) -> Result<(), SystemError> { 153804babc3fSMemoryShore let guard: SpinLockGuard<FATInode> = self.0.lock(); 153904babc3fSMemoryShore let old_size = guard.metadata.size as usize; 154004babc3fSMemoryShore if len < old_size { 154104babc3fSMemoryShore drop(guard); 154204babc3fSMemoryShore self.resize(len) 154304babc3fSMemoryShore } else { 154404babc3fSMemoryShore Ok(()) 154504babc3fSMemoryShore } 154604babc3fSMemoryShore } 154704babc3fSMemoryShore list(&self) -> Result<Vec<String>, SystemError>1548676b8ef6SMork fn list(&self) -> Result<Vec<String>, SystemError> { 1549004e86ffSlogin let mut guard: SpinLockGuard<FATInode> = self.0.lock(); 1550004e86ffSlogin let fatent: &FATDirEntry = &guard.inode_type; 1551004e86ffSlogin match fatent { 1552004e86ffSlogin FATDirEntry::File(_) | FATDirEntry::VolId(_) => { 1553676b8ef6SMork return Err(SystemError::ENOTDIR); 1554004e86ffSlogin } 1555004e86ffSlogin FATDirEntry::Dir(dir) => { 1556004e86ffSlogin // 获取当前目录下的所有目录项 1557004e86ffSlogin let mut ret: Vec<String> = Vec::new(); 1558004e86ffSlogin let dir_iter: FATDirIter = dir.to_iter(guard.fs.upgrade().unwrap()); 1559004e86ffSlogin for ent in dir_iter { 1560004e86ffSlogin ret.push(ent.name()); 1561004e86ffSlogin 1562004e86ffSlogin // ====== 生成inode缓存,存入B树 15631074eb34SSamuel Dai let name = DName::from(ent.name().to_uppercase()); 15642eab6dd7S曾俊 // debug!("name={name}"); 1565004e86ffSlogin 15661074eb34SSamuel Dai if !guard.children.contains_key(&name) 15671074eb34SSamuel Dai && name.as_ref() != "." 15681074eb34SSamuel Dai && name.as_ref() != ".." 1569004e86ffSlogin { 1570004e86ffSlogin // 创建新的inode 1571004e86ffSlogin let entry_inode: Arc<LockedFATInode> = LockedFATInode::new( 15721074eb34SSamuel Dai name.clone(), 1573004e86ffSlogin guard.fs.upgrade().unwrap(), 1574004e86ffSlogin guard.self_ref.clone(), 1575004e86ffSlogin ent, 1576004e86ffSlogin ); 1577004e86ffSlogin // 加入缓存区, 由于FAT文件系统的大小写不敏感问题,因此存入缓存区的key应当是全大写的 15781074eb34SSamuel Dai guard.children.insert(name, entry_inode.clone()); 1579004e86ffSlogin } 1580004e86ffSlogin } 1581004e86ffSlogin return Ok(ret); 1582004e86ffSlogin } 1583004e86ffSlogin FATDirEntry::UnInit => { 15842eab6dd7S曾俊 error!("FATFS: param: Inode_type uninitialized."); 1585676b8ef6SMork return Err(SystemError::EROFS); 1586004e86ffSlogin } 1587004e86ffSlogin } 1588004e86ffSlogin } 1589004e86ffSlogin find(&self, name: &str) -> Result<Arc<dyn IndexNode>, SystemError>1590676b8ef6SMork fn find(&self, name: &str) -> Result<Arc<dyn IndexNode>, SystemError> { 1591004e86ffSlogin let mut guard: SpinLockGuard<FATInode> = self.0.lock(); 1592004e86ffSlogin let target = guard.find(name)?; 1593004e86ffSlogin return Ok(target); 1594004e86ffSlogin } 1595004e86ffSlogin open( &self, _data: SpinLockGuard<FilePrivateData>, _mode: &FileMode, ) -> Result<(), SystemError>1596dfe53cf0SGnoCiYeH fn open( 1597dfe53cf0SGnoCiYeH &self, 1598dfe53cf0SGnoCiYeH _data: SpinLockGuard<FilePrivateData>, 1599dfe53cf0SGnoCiYeH _mode: &FileMode, 1600dfe53cf0SGnoCiYeH ) -> Result<(), SystemError> { 1601004e86ffSlogin return Ok(()); 1602004e86ffSlogin } 1603004e86ffSlogin close(&self, _data: SpinLockGuard<FilePrivateData>) -> Result<(), SystemError>1604dfe53cf0SGnoCiYeH fn close(&self, _data: SpinLockGuard<FilePrivateData>) -> Result<(), SystemError> { 1605004e86ffSlogin return Ok(()); 1606004e86ffSlogin } 1607004e86ffSlogin unlink(&self, name: &str) -> Result<(), SystemError>1608676b8ef6SMork fn unlink(&self, name: &str) -> Result<(), SystemError> { 1609004e86ffSlogin let mut guard: SpinLockGuard<FATInode> = self.0.lock(); 1610004e86ffSlogin let target: Arc<LockedFATInode> = guard.find(name)?; 1611004e86ffSlogin // 对目标inode上锁,以防更改 1612004e86ffSlogin let target_guard: SpinLockGuard<FATInode> = target.0.lock(); 1613004e86ffSlogin // 先从缓存删除 16141074eb34SSamuel Dai let nod = guard.children.remove(&DName::from(name.to_uppercase())); 16152dbef785SGnoCiYeH 16162dbef785SGnoCiYeH // 若删除缓存中为管道的文件,则不需要再到磁盘删除 1617b5b571e0SLoGin if nod.is_some() { 16182dbef785SGnoCiYeH let file_type = target_guard.metadata.file_type; 16192dbef785SGnoCiYeH if file_type == FileType::Pipe { 16202dbef785SGnoCiYeH return Ok(()); 16212dbef785SGnoCiYeH } 16222dbef785SGnoCiYeH } 1623004e86ffSlogin 1624004e86ffSlogin let dir = match &guard.inode_type { 1625004e86ffSlogin FATDirEntry::File(_) | FATDirEntry::VolId(_) => { 1626676b8ef6SMork return Err(SystemError::ENOTDIR); 1627004e86ffSlogin } 1628004e86ffSlogin FATDirEntry::Dir(d) => d, 1629004e86ffSlogin FATDirEntry::UnInit => { 16302eab6dd7S曾俊 error!("FATFS: param: Inode_type uninitialized."); 1631676b8ef6SMork return Err(SystemError::EROFS); 1632004e86ffSlogin } 1633004e86ffSlogin }; 1634004e86ffSlogin // 检查文件是否存在 1635004e86ffSlogin dir.check_existence(name, Some(false), guard.fs.upgrade().unwrap())?; 1636004e86ffSlogin 1637004e86ffSlogin // 再从磁盘删除 1638004e86ffSlogin let r = dir.remove(guard.fs.upgrade().unwrap().clone(), name, true); 1639004e86ffSlogin drop(target_guard); 1640004e86ffSlogin return r; 1641004e86ffSlogin } 1642004e86ffSlogin rmdir(&self, name: &str) -> Result<(), SystemError>1643676b8ef6SMork fn rmdir(&self, name: &str) -> Result<(), SystemError> { 1644004e86ffSlogin let mut guard: SpinLockGuard<FATInode> = self.0.lock(); 1645004e86ffSlogin let target: Arc<LockedFATInode> = guard.find(name)?; 1646004e86ffSlogin // 对目标inode上锁,以防更改 1647004e86ffSlogin let target_guard: SpinLockGuard<FATInode> = target.0.lock(); 1648004e86ffSlogin // 先从缓存删除 16491074eb34SSamuel Dai guard.children.remove(&DName::from(name.to_uppercase())); 1650004e86ffSlogin 1651004e86ffSlogin let dir = match &guard.inode_type { 1652004e86ffSlogin FATDirEntry::File(_) | FATDirEntry::VolId(_) => { 1653676b8ef6SMork return Err(SystemError::ENOTDIR); 1654004e86ffSlogin } 1655004e86ffSlogin FATDirEntry::Dir(d) => d, 1656004e86ffSlogin FATDirEntry::UnInit => { 16572eab6dd7S曾俊 error!("FATFS: param: Inode_type uninitialized."); 1658676b8ef6SMork return Err(SystemError::EROFS); 1659004e86ffSlogin } 1660004e86ffSlogin }; 1661004e86ffSlogin // 检查文件夹是否存在 1662004e86ffSlogin dir.check_existence(name, Some(true), guard.fs.upgrade().unwrap())?; 1663004e86ffSlogin 1664004e86ffSlogin // 再从磁盘删除 166578bf93f0SYJwu2023 let r: Result<(), SystemError> = 166678bf93f0SYJwu2023 dir.remove(guard.fs.upgrade().unwrap().clone(), name, true); 1667b5b571e0SLoGin match r { 1668b5b571e0SLoGin Ok(_) => return r, 1669b5b571e0SLoGin Err(r) => { 1670676b8ef6SMork if r == SystemError::ENOTEMPTY { 1671004e86ffSlogin // 如果要删除的是目录,且不为空,则删除动作未发生,重新加入缓存 16721074eb34SSamuel Dai guard 16731074eb34SSamuel Dai .children 16741074eb34SSamuel Dai .insert(DName::from(name.to_uppercase()), target.clone()); 1675004e86ffSlogin drop(target_guard); 1676004e86ffSlogin } 1677004e86ffSlogin return Err(r); 1678004e86ffSlogin } 1679004e86ffSlogin } 1680b5b571e0SLoGin } 1681004e86ffSlogin move_to( &self, old_name: &str, target: &Arc<dyn IndexNode>, new_name: &str, ) -> Result<(), SystemError>16829e481b3bSTTaq fn move_to( 16839e481b3bSTTaq &self, 16849e481b3bSTTaq old_name: &str, 16859e481b3bSTTaq target: &Arc<dyn IndexNode>, 16869e481b3bSTTaq new_name: &str, 16879e481b3bSTTaq ) -> Result<(), SystemError> { 16889e481b3bSTTaq let old_id = self.metadata().unwrap().inode_id; 16899e481b3bSTTaq let new_id = target.metadata().unwrap().inode_id; 16909e481b3bSTTaq // 若在同一父目录下 16919e481b3bSTTaq if old_id == new_id { 16929e481b3bSTTaq let mut guard = self.0.lock(); 16939e481b3bSTTaq let old_inode: Arc<LockedFATInode> = guard.find(old_name)?; 16949e481b3bSTTaq // 对目标inode上锁,以防更改 16959e481b3bSTTaq let old_inode_guard: SpinLockGuard<FATInode> = old_inode.0.lock(); 16969e481b3bSTTaq let fs = old_inode_guard.fs.upgrade().unwrap(); 16979e481b3bSTTaq // 从缓存删除 16981074eb34SSamuel Dai let _nod = guard.children.remove(&DName::from(old_name.to_uppercase())); 16999e481b3bSTTaq let old_dir = match &guard.inode_type { 17009e481b3bSTTaq FATDirEntry::File(_) | FATDirEntry::VolId(_) => { 17019e481b3bSTTaq return Err(SystemError::ENOTDIR); 17029e481b3bSTTaq } 17039e481b3bSTTaq FATDirEntry::Dir(d) => d, 17049e481b3bSTTaq FATDirEntry::UnInit => { 17052eab6dd7S曾俊 error!("FATFS: param: Inode_type uninitialized."); 17069e481b3bSTTaq return Err(SystemError::EROFS); 17079e481b3bSTTaq } 17089e481b3bSTTaq }; 17099e481b3bSTTaq // 检查文件是否存在 17109e481b3bSTTaq // old_dir.check_existence(old_name, Some(false), guard.fs.upgrade().unwrap())?; 17119e481b3bSTTaq 17129e481b3bSTTaq old_dir.rename(fs, old_name, new_name)?; 17139e481b3bSTTaq } else { 17149e481b3bSTTaq let mut old_guard = self.0.lock(); 17159e481b3bSTTaq let other: &LockedFATInode = target 17169e481b3bSTTaq .downcast_ref::<LockedFATInode>() 17179e481b3bSTTaq .ok_or(SystemError::EPERM)?; 17189e481b3bSTTaq 17199e481b3bSTTaq let new_guard = other.0.lock(); 17209e481b3bSTTaq let old_inode: Arc<LockedFATInode> = old_guard.find(old_name)?; 17219e481b3bSTTaq // 对目标inode上锁,以防更改 17229e481b3bSTTaq let old_inode_guard: SpinLockGuard<FATInode> = old_inode.0.lock(); 17239e481b3bSTTaq let fs = old_inode_guard.fs.upgrade().unwrap(); 17249e481b3bSTTaq // 从缓存删除 17251074eb34SSamuel Dai let _nod = old_guard 17261074eb34SSamuel Dai .children 17271074eb34SSamuel Dai .remove(&DName::from(old_name.to_uppercase())); 17289e481b3bSTTaq let old_dir = match &old_guard.inode_type { 17299e481b3bSTTaq FATDirEntry::File(_) | FATDirEntry::VolId(_) => { 17309e481b3bSTTaq return Err(SystemError::ENOTDIR); 17319e481b3bSTTaq } 17329e481b3bSTTaq FATDirEntry::Dir(d) => d, 17339e481b3bSTTaq FATDirEntry::UnInit => { 17342eab6dd7S曾俊 error!("FATFS: param: Inode_type uninitialized."); 17359e481b3bSTTaq return Err(SystemError::EROFS); 17369e481b3bSTTaq } 17379e481b3bSTTaq }; 17389e481b3bSTTaq let new_dir = match &new_guard.inode_type { 17399e481b3bSTTaq FATDirEntry::File(_) | FATDirEntry::VolId(_) => { 17409e481b3bSTTaq return Err(SystemError::ENOTDIR); 17419e481b3bSTTaq } 17429e481b3bSTTaq FATDirEntry::Dir(d) => d, 17439e481b3bSTTaq FATDirEntry::UnInit => { 17442eab6dd7S曾俊 error!("FATFA: param: Inode_type uninitialized."); 17459e481b3bSTTaq return Err(SystemError::EROFS); 17469e481b3bSTTaq } 17479e481b3bSTTaq }; 17489e481b3bSTTaq // 检查文件是否存在 17499e481b3bSTTaq old_dir.check_existence(old_name, Some(false), old_guard.fs.upgrade().unwrap())?; 17509e481b3bSTTaq old_dir.rename_across(fs, new_dir, old_name, new_name)?; 17519e481b3bSTTaq } 17529e481b3bSTTaq 17539e481b3bSTTaq return Ok(()); 17549e481b3bSTTaq } 17559e481b3bSTTaq get_entry_name(&self, ino: InodeId) -> Result<String, SystemError>1756676b8ef6SMork fn get_entry_name(&self, ino: InodeId) -> Result<String, SystemError> { 1757004e86ffSlogin let guard: SpinLockGuard<FATInode> = self.0.lock(); 1758004e86ffSlogin if guard.metadata.file_type != FileType::Dir { 1759676b8ef6SMork return Err(SystemError::ENOTDIR); 1760004e86ffSlogin } 17616b4e7a29SLoGin match ino.into() { 1762004e86ffSlogin 0 => { 1763004e86ffSlogin return Ok(String::from(".")); 1764004e86ffSlogin } 1765004e86ffSlogin 1 => { 1766004e86ffSlogin return Ok(String::from("..")); 1767004e86ffSlogin } 1768004e86ffSlogin ino => { 1769004e86ffSlogin // 暴力遍历所有的children,判断inode id是否相同 1770004e86ffSlogin // TODO: 优化这里,这个地方性能很差! 1771004e86ffSlogin let mut key: Vec<String> = guard 1772004e86ffSlogin .children 17731074eb34SSamuel Dai .iter() 17741074eb34SSamuel Dai .filter_map(|(k, v)| { 17751074eb34SSamuel Dai if v.0.lock().metadata.inode_id.into() == ino { 17761074eb34SSamuel Dai Some(k.to_string()) 17771074eb34SSamuel Dai } else { 17781074eb34SSamuel Dai None 17791074eb34SSamuel Dai } 17806b4e7a29SLoGin }) 1781004e86ffSlogin .collect(); 1782004e86ffSlogin 1783004e86ffSlogin match key.len() { 1784676b8ef6SMork 0=>{return Err(SystemError::ENOENT);} 1785004e86ffSlogin 1=>{return Ok(key.remove(0));} 17866b4e7a29SLoGin _ => panic!("FatFS get_entry_name: key.len()={key_len}>1, current inode_id={inode_id:?}, to find={to_find:?}", key_len=key.len(), inode_id = guard.metadata.inode_id, to_find=ino) 1787004e86ffSlogin } 1788004e86ffSlogin } 1789004e86ffSlogin } 1790004e86ffSlogin } 17912dbef785SGnoCiYeH mknod( &self, filename: &str, mode: ModeType, _dev_t: DeviceNumber, ) -> Result<Arc<dyn IndexNode>, SystemError>17922dbef785SGnoCiYeH fn mknod( 17932dbef785SGnoCiYeH &self, 17942dbef785SGnoCiYeH filename: &str, 17952dbef785SGnoCiYeH mode: ModeType, 1796c566df45SLoGin _dev_t: DeviceNumber, 17972dbef785SGnoCiYeH ) -> Result<Arc<dyn IndexNode>, SystemError> { 17982dbef785SGnoCiYeH let mut inode = self.0.lock(); 17992dbef785SGnoCiYeH if inode.metadata.file_type != FileType::Dir { 18002dbef785SGnoCiYeH return Err(SystemError::ENOTDIR); 18012dbef785SGnoCiYeH } 18022dbef785SGnoCiYeH 18032dbef785SGnoCiYeH // 判断需要创建的类型 18042dbef785SGnoCiYeH if unlikely(mode.contains(ModeType::S_IFREG)) { 18052dbef785SGnoCiYeH // 普通文件 1806b5b571e0SLoGin return self.create(filename, FileType::File, mode); 18072dbef785SGnoCiYeH } 18082dbef785SGnoCiYeH 18091074eb34SSamuel Dai let filename = DName::from(filename.to_uppercase()); 18102dbef785SGnoCiYeH let nod = LockedFATInode::new( 18111074eb34SSamuel Dai filename.clone(), 18122dbef785SGnoCiYeH inode.fs.upgrade().unwrap(), 18132dbef785SGnoCiYeH inode.self_ref.clone(), 18142dbef785SGnoCiYeH FATDirEntry::File(FATFile::default()), 18152dbef785SGnoCiYeH ); 18162dbef785SGnoCiYeH 18172dbef785SGnoCiYeH if mode.contains(ModeType::S_IFIFO) { 18182dbef785SGnoCiYeH nod.0.lock().metadata.file_type = FileType::Pipe; 18192dbef785SGnoCiYeH // 创建pipe文件 18202dbef785SGnoCiYeH let pipe_inode = LockedPipeInode::new(); 18212dbef785SGnoCiYeH // 设置special_node 18222dbef785SGnoCiYeH nod.0.lock().special_node = Some(SpecialNodeData::Pipe(pipe_inode)); 18232dbef785SGnoCiYeH } else if mode.contains(ModeType::S_IFBLK) { 18242dbef785SGnoCiYeH nod.0.lock().metadata.file_type = FileType::BlockDevice; 18252dbef785SGnoCiYeH unimplemented!() 18262dbef785SGnoCiYeH } else if mode.contains(ModeType::S_IFCHR) { 18272dbef785SGnoCiYeH nod.0.lock().metadata.file_type = FileType::CharDevice; 18282dbef785SGnoCiYeH unimplemented!() 18291effcfe5SGnoCiYeH } else { 18301effcfe5SGnoCiYeH return Err(SystemError::EINVAL); 18312dbef785SGnoCiYeH } 18322dbef785SGnoCiYeH 18331074eb34SSamuel Dai inode.children.insert(filename, nod.clone()); 18342dbef785SGnoCiYeH Ok(nod) 18352dbef785SGnoCiYeH } 18362dbef785SGnoCiYeH special_node(&self) -> Option<SpecialNodeData>18372dbef785SGnoCiYeH fn special_node(&self) -> Option<SpecialNodeData> { 18382dbef785SGnoCiYeH self.0.lock().special_node.clone() 18392dbef785SGnoCiYeH } 18401074eb34SSamuel Dai dname(&self) -> Result<DName, SystemError>18411074eb34SSamuel Dai fn dname(&self) -> Result<DName, SystemError> { 18421074eb34SSamuel Dai Ok(self.0.lock().dname.clone()) 18431074eb34SSamuel Dai } 18441074eb34SSamuel Dai parent(&self) -> Result<Arc<dyn IndexNode>, SystemError>18451074eb34SSamuel Dai fn parent(&self) -> Result<Arc<dyn IndexNode>, SystemError> { 18461074eb34SSamuel Dai self.0 18471074eb34SSamuel Dai .lock() 18481074eb34SSamuel Dai .parent 18491074eb34SSamuel Dai .upgrade() 18501074eb34SSamuel Dai .map(|item| item as Arc<dyn IndexNode>) 18511074eb34SSamuel Dai .ok_or(SystemError::EINVAL) 18521074eb34SSamuel Dai } 1853*cf7f801eSMemoryShore page_cache(&self) -> Option<Arc<PageCache>>1854*cf7f801eSMemoryShore fn page_cache(&self) -> Option<Arc<PageCache>> { 1855*cf7f801eSMemoryShore self.0.lock().page_cache.clone() 1856*cf7f801eSMemoryShore } 1857004e86ffSlogin } 1858004e86ffSlogin 1859004e86ffSlogin impl Default for FATFsInfo { default() -> Self1860004e86ffSlogin fn default() -> Self { 1861004e86ffSlogin return FATFsInfo { 1862004e86ffSlogin lead_sig: FATFsInfo::LEAD_SIG, 1863004e86ffSlogin struc_sig: FATFsInfo::STRUC_SIG, 1864004e86ffSlogin free_count: 0xFFFFFFFF, 1865004e86ffSlogin next_free: RESERVED_CLUSTERS, 1866004e86ffSlogin trail_sig: FATFsInfo::TRAIL_SIG, 1867004e86ffSlogin dirty: false, 1868004e86ffSlogin offset: None, 1869004e86ffSlogin }; 1870004e86ffSlogin } 1871004e86ffSlogin } 1872004e86ffSlogin 1873004e86ffSlogin impl Cluster { new(cluster: u64) -> Self1874004e86ffSlogin pub fn new(cluster: u64) -> Self { 1875004e86ffSlogin return Cluster { 1876004e86ffSlogin cluster_num: cluster, 1877004e86ffSlogin parent_cluster: 0, 1878004e86ffSlogin }; 1879004e86ffSlogin } 1880004e86ffSlogin } 1881004e86ffSlogin 1882004e86ffSlogin /// @brief 用于迭代FAT表的内容的簇迭代器对象 1883004e86ffSlogin #[derive(Debug)] 1884004e86ffSlogin struct ClusterIter<'a> { 1885004e86ffSlogin /// 迭代器的next要返回的簇 1886004e86ffSlogin current_cluster: Option<Cluster>, 1887004e86ffSlogin /// 属于的文件系统 1888004e86ffSlogin fs: &'a FATFileSystem, 1889004e86ffSlogin } 1890004e86ffSlogin 1891004e86ffSlogin impl<'a> Iterator for ClusterIter<'a> { 1892004e86ffSlogin type Item = Cluster; 1893004e86ffSlogin next(&mut self) -> Option<Self::Item>1894004e86ffSlogin fn next(&mut self) -> Option<Self::Item> { 1895004e86ffSlogin // 当前要返回的簇 1896004e86ffSlogin let ret: Option<Cluster> = self.current_cluster; 1897004e86ffSlogin 1898004e86ffSlogin // 获得下一个要返回簇 1899004e86ffSlogin let new: Option<Cluster> = match self.current_cluster { 1900004e86ffSlogin Some(c) => { 1901004e86ffSlogin let entry: Option<FATEntry> = self.fs.get_fat_entry(c).ok(); 1902004e86ffSlogin match entry { 1903004e86ffSlogin Some(FATEntry::Next(c)) => Some(c), 1904004e86ffSlogin _ => None, 1905004e86ffSlogin } 1906004e86ffSlogin } 1907004e86ffSlogin _ => None, 1908004e86ffSlogin }; 1909004e86ffSlogin 1910004e86ffSlogin self.current_cluster = new; 1911004e86ffSlogin return ret; 1912004e86ffSlogin } 1913004e86ffSlogin } 1914