1 #![allow(dead_code)]
2 use core::{cmp::min, intrinsics::unlikely};
3 use system_error::SystemError;
4
5 use crate::{
6 driver::base::block::{block_device::LBA_SIZE, SeekFrom},
7 kwarn,
8 libs::vec_cursor::VecCursor,
9 };
10 use alloc::{
11 string::{String, ToString},
12 sync::Arc,
13 vec::Vec,
14 };
15
16 use super::{
17 fs::{Cluster, FATFileSystem, MAX_FILE_SIZE},
18 utils::decode_u8_ascii,
19 };
20
21 #[derive(Debug, Clone, Copy, Default)]
22 pub struct FileAttributes {
23 value: u8,
24 }
25
26 /// FAT表中，关于每个簇的信息
27 #[derive(Debug, Eq, PartialEq)]
28 pub enum FATEntry {
29 /// 当前簇未使用
30 Unused,
31 /// 当前簇是坏簇
32 Bad,
33 /// 当前簇是整个FAT簇链的最后一个簇
34 EndOfChain,
35 /// 在整个链中，当前簇的下一个簇的值
36 Next(Cluster),
37 }
38
39 /// FAT目录项的枚举类型
40 #[derive(Debug, Clone)]
41 pub enum FATDirEntry {
42 File(FATFile),
43 VolId(FATFile),
44 Dir(FATDir),
45 UnInit,
46 }
47
48 /// FAT文件系统中的文件
49 #[derive(Debug, Default, Clone)]
50 pub struct FATFile {
51 /// 文件的第一个簇
52 pub first_cluster: Cluster,
53 /// 文件名
54 pub file_name: String,
55 /// 文件对应的短目录项
56 pub short_dir_entry: ShortDirEntry,
57 /// 文件目录项的起始、终止簇。格式：(簇，簇内偏移量)
58 pub loc: ((Cluster, u64), (Cluster, u64)),
59 }
60
61 impl FATFile {
62 /// @brief 获取文件大小
63 #[inline]
size(&self) -> u6464 pub fn size(&self) -> u64 {
65 return self.short_dir_entry.file_size as u64;
66 }
67
68 /// @brief 设置当前文件大小（仅仅更改short_dir_entry内的值）
69 #[inline]
set_size(&mut self, size: u32)70 pub fn set_size(&mut self, size: u32) {
71 self.short_dir_entry.file_size = size;
72 }
73
74 /// @brief 从文件读取数据。读取的字节数与buf长度相等
75 ///
76 /// @param buf 输出缓冲区
77 /// @param offset 起始位置在文件中的偏移量
78 ///
79 /// @return Ok(usize) 成功读取到的字节数
80 /// @return Err(SystemError) 读取时出现错误，返回错误码
read( &self, fs: &Arc<FATFileSystem>, buf: &mut [u8], offset: u64, ) -> Result<usize, SystemError>81 pub fn read(
82 &self,
83 fs: &Arc<FATFileSystem>,
84 buf: &mut [u8],
85 offset: u64,
86 ) -> Result<usize, SystemError> {
87 if offset >= self.size() {
88 return Ok(0);
89 }
90
91 // 文件内的簇偏移量
92 let start_cluster_number: u64 = offset / fs.bytes_per_cluster();
93 // 计算对应在分区内的簇号
94 let mut current_cluster = if let Some(c) =
95 fs.get_cluster_by_relative(self.first_cluster, start_cluster_number as usize)
96 {
97 c
98 } else {
99 return Ok(0);
100 };
101
102 let bytes_remain: u64 = self.size() - offset;
103
104 // 计算簇内偏移量
105 let mut in_cluster_offset: u64 = offset % fs.bytes_per_cluster();
106 let to_read_size: usize = min(buf.len(), bytes_remain as usize);
107
108 let mut start = 0;
109 let mut read_ok = 0;
110
111 loop {
112 // 当前簇已经读取完，尝试读取下一个簇
113 if in_cluster_offset >= fs.bytes_per_cluster() {
114 if let Some(FATEntry::Next(c)) = fs.get_fat_entry(current_cluster).ok() {
115 current_cluster = c;
116 in_cluster_offset %= fs.bytes_per_cluster();
117 } else {
118 break;
119 }
120 }
121
122 // 计算下一次读取，能够读多少字节
123 let end_len: usize = min(
124 to_read_size - read_ok,
125 min(
126 (fs.bytes_per_cluster() - in_cluster_offset) as usize,
127 buf.len() - read_ok,
128 ),
129 );
130
131 // 从磁盘上读取数据
132 let offset = fs.cluster_bytes_offset(current_cluster) + in_cluster_offset;
133 let r = fs.partition.disk().read_at_bytes(
134 offset as usize,
135 end_len,
136 &mut buf[start..start + end_len],
137 )?;
138
139 // 更新偏移量计数信息
140 read_ok += r;
141 start += r;
142 in_cluster_offset += r as u64;
143 if read_ok == to_read_size {
144 break;
145 }
146 }
147 // todo: 更新时间信息
148 return Ok(read_ok);
149 }
150
151 /// @brief 向文件写入数据。写入的字节数与buf长度相等
152 ///
153 /// @param buf 输入缓冲区
154 /// @param offset 起始位置在文件中的偏移量
155 ///
156 /// @return Ok(usize) 成功写入的字节数
157 /// @return Err(SystemError) 写入时出现错误，返回错误码
write( &mut self, fs: &Arc<FATFileSystem>, buf: &[u8], offset: u64, ) -> Result<usize, SystemError>158 pub fn write(
159 &mut self,
160 fs: &Arc<FATFileSystem>,
161 buf: &[u8],
162 offset: u64,
163 ) -> Result<usize, SystemError> {
164 self.ensure_len(fs, offset, buf.len() as u64)?;
165
166 // 要写入的第一个簇的簇号
167 let start_cluster_num = offset / fs.bytes_per_cluster();
168 // 获取要写入的第一个簇
169 let mut current_cluster: Cluster = if let Some(c) =
170 fs.get_cluster_by_relative(self.first_cluster, start_cluster_num as usize)
171 {
172 c
173 } else {
174 return Ok(0);
175 };
176
177 let mut in_cluster_bytes_offset: u64 = offset % fs.bytes_per_cluster();
178
179 let mut start: usize = 0;
180 let mut write_ok: usize = 0;
181
182 // 循环写入数据
183 loop {
184 if in_cluster_bytes_offset >= fs.bytes_per_cluster() {
185 if let Some(FATEntry::Next(c)) = fs.get_fat_entry(current_cluster).ok() {
186 current_cluster = c;
187 in_cluster_bytes_offset = in_cluster_bytes_offset % fs.bytes_per_cluster();
188 } else {
189 break;
190 }
191 }
192
193 let end_len = min(
194 (fs.bytes_per_cluster() - in_cluster_bytes_offset) as usize,
195 buf.len() - write_ok,
196 );
197
198 // 计算本次写入位置在磁盘上的偏移量
199 let offset = fs.cluster_bytes_offset(current_cluster) + in_cluster_bytes_offset;
200 // 写入磁盘
201 let w: usize = fs.partition.disk().write_at_bytes(
202 offset as usize,
203 end_len,
204 &buf[start..start + end_len],
205 )?;
206
207 // 更新偏移量数据
208 write_ok += w;
209 start += w;
210 in_cluster_bytes_offset += w as u64;
211
212 if write_ok == buf.len() {
213 break;
214 }
215 }
216 // todo: 更新时间信息
217 return Ok(write_ok);
218 }
219
220 /// @brief 确保文件从指定偏移量开始，仍有长度为len的空间。
221 /// 如果文件大小不够，就尝试分配更多的空间给这个文件。
222 ///
223 /// @param fs 当前文件所属的文件系统
224 /// @param offset 起始位置在文件内的字节偏移量
225 /// @param len 期待的空闲空间长度
226 ///
227 /// @return Ok(()) 经过操作后，offset后面具有长度至少为len的空闲空间
228 /// @return Err(SystemError) 处理过程中出现了异常。
ensure_len( &mut self, fs: &Arc<FATFileSystem>, offset: u64, len: u64, ) -> Result<(), SystemError>229 fn ensure_len(
230 &mut self,
231 fs: &Arc<FATFileSystem>,
232 offset: u64,
233 len: u64,
234 ) -> Result<(), SystemError> {
235 // 文件内本身就还有空余的空间
236 if offset + len <= self.size() {
237 return Ok(());
238 }
239
240 // 计算文件的最后一个簇中有多少空闲空间
241 let in_cluster_offset = self.size() % fs.bytes_per_cluster();
242 let mut bytes_remain_in_cluster = if in_cluster_offset == 0 {
243 0
244 } else {
245 fs.bytes_per_cluster() - in_cluster_offset
246 };
247
248 // 计算还需要申请多少空间
249 let extra_bytes = min((offset + len) - self.size(), MAX_FILE_SIZE - self.size());
250
251 // 如果文件大小为0,证明它还没有分配簇，因此分配一个簇给它
252 if self.size() == 0 {
253 // first_cluster应当为0,否则将产生空间泄露的错误
254 assert_eq!(self.first_cluster, Cluster::default());
255 self.first_cluster = fs.allocate_cluster(None)?;
256 self.short_dir_entry.set_first_cluster(self.first_cluster);
257 bytes_remain_in_cluster = fs.bytes_per_cluster();
258 }
259
260 // 如果还需要更多的簇
261 if bytes_remain_in_cluster < extra_bytes {
262 let clusters_to_allocate =
263 (extra_bytes - bytes_remain_in_cluster + fs.bytes_per_cluster() - 1)
264 / fs.bytes_per_cluster();
265 let last_cluster = if let Some(c) = fs.get_last_cluster(self.first_cluster) {
266 c
267 } else {
268 kwarn!("FAT: last cluster not found, File = {self:?}");
269 return Err(SystemError::EINVAL);
270 };
271 // 申请簇
272 let mut current_cluster: Cluster = last_cluster;
273 for _ in 0..clusters_to_allocate {
274 current_cluster = fs.allocate_cluster(Some(current_cluster))?;
275 }
276 }
277
278 // 如果文件被扩展，则清空刚刚被扩展的部分的数据
279 if offset > self.size() {
280 // 文件内的簇偏移
281 let start_cluster: u64 = self.size() / fs.bytes_per_cluster();
282 let start_cluster: Cluster = fs
283 .get_cluster_by_relative(self.first_cluster, start_cluster as usize)
284 .unwrap();
285 // 计算当前文件末尾在磁盘上的字节偏移量
286 let start_offset: u64 =
287 fs.cluster_bytes_offset(start_cluster) + self.size() % fs.bytes_per_cluster();
288 // 扩展之前，最后一个簇内还剩下多少字节的空间
289 let bytes_remain: u64 = fs.bytes_per_cluster() - (self.size() % fs.bytes_per_cluster());
290 // 计算在扩展之后的最后一个簇内，文件的终止字节
291 let cluster_offset_start = offset / fs.bytes_per_cluster();
292 // 扩展后，文件的最后
293 let end_cluster: Cluster = fs
294 .get_cluster_by_relative(self.first_cluster, cluster_offset_start as usize)
295 .unwrap();
296
297 if start_cluster != end_cluster {
298 self.zero_range(fs, start_offset, start_offset + bytes_remain)?;
299 } else {
300 self.zero_range(fs, start_offset, start_offset + offset - self.size())?;
301 }
302 }
303 // 计算文件的新大小
304 let new_size = self.size() + extra_bytes;
305 self.set_size(new_size as u32);
306 // 计算短目录项所在的位置，更新短目录项
307 let short_entry_offset = fs.cluster_bytes_offset(self.loc.1 .0) + self.loc.1 .1;
308 // todo: 更新时间信息
309 // 把短目录项写入磁盘
310 self.short_dir_entry.flush(fs, short_entry_offset)?;
311 return Ok(());
312 }
313
314 /// @brief 把磁盘上[range_start, range_end)范围的数据清零
315 ///
316 /// @param range_start 磁盘上起始位置（单位：字节）
317 /// @param range_end 磁盘上终止位置（单位：字节）
zero_range( &self, fs: &Arc<FATFileSystem>, range_start: u64, range_end: u64, ) -> Result<(), SystemError>318 fn zero_range(
319 &self,
320 fs: &Arc<FATFileSystem>,
321 range_start: u64,
322 range_end: u64,
323 ) -> Result<(), SystemError> {
324 if range_end <= range_start {
325 return Ok(());
326 }
327
328 let zeroes: Vec<u8> = vec![0u8; (range_end - range_start) as usize];
329 fs.partition
330 .disk()
331 .write_at(range_start as usize, zeroes.len(), zeroes.as_slice())?;
332 return Ok(());
333 }
334
335 /// @brief 截断文件的内容，并设置新的文件大小。如果new_size大于当前文件大小，则不做操作。
336 ///
337 /// @param new_size 新的文件大小，如果它大于当前文件大小，则不做操作。
338 ///
339 /// @return Ok(()) 操作成功
340 /// @return Err(SystemError) 在操作时出现错误
truncate(&mut self, fs: &Arc<FATFileSystem>, new_size: u64) -> Result<(), SystemError>341 pub fn truncate(&mut self, fs: &Arc<FATFileSystem>, new_size: u64) -> Result<(), SystemError> {
342 if new_size >= self.size() {
343 return Ok(());
344 }
345
346 let new_last_cluster = (new_size + fs.bytes_per_cluster() - 1) / fs.bytes_per_cluster();
347 if let Some(begin_delete) =
348 fs.get_cluster_by_relative(self.first_cluster, new_last_cluster as usize)
349 {
350 fs.deallocate_cluster_chain(begin_delete)?;
351 };
352
353 if new_size == 0 {
354 assert!(new_last_cluster == 0);
355 self.short_dir_entry.set_first_cluster(Cluster::new(0));
356 self.first_cluster = Cluster::new(0);
357 }
358
359 self.set_size(new_size as u32);
360 // 计算短目录项在磁盘内的字节偏移量
361 let short_entry_offset = fs.cluster_bytes_offset((self.loc.1).0) + (self.loc.1).1;
362 self.short_dir_entry.flush(fs, short_entry_offset)?;
363
364 return Ok(());
365 }
366 }
367
368 /// FAT文件系统中的文件夹
369 #[derive(Debug, Default, Clone)]
370 pub struct FATDir {
371 /// 目录的第一个簇
372 pub first_cluster: Cluster,
373 /// 该字段仅对FAT12、FAT16生效
374 pub root_offset: Option<u64>,
375 /// 文件夹名称
376 pub dir_name: String,
377 pub short_dir_entry: Option<ShortDirEntry>,
378 /// 文件的起始、终止簇。格式：(簇，簇内偏移量)
379 pub loc: Option<((Cluster, u64), (Cluster, u64))>,
380 }
381
382 impl FATDir {
383 /// @brief 获得用于遍历当前目录的迭代器
384 ///
385 /// @param fs 当前目录所在的文件系统
to_iter(&self, fs: Arc<FATFileSystem>) -> FATDirIter386 pub fn to_iter(&self, fs: Arc<FATFileSystem>) -> FATDirIter {
387 return FATDirIter {
388 current_cluster: self.first_cluster,
389 offset: self.root_offset.unwrap_or(0),
390 is_root: self.is_root(),
391 fs: fs,
392 };
393 }
394
395 /// @brief 判断当前目录是否为根目录（仅对FAT12和FAT16生效）
396 #[inline]
is_root(&self) -> bool397 pub fn is_root(&self) -> bool {
398 return self.root_offset.is_some();
399 }
400
401 /// @brief 获取当前目录所占用的大小
size(&self, fs: &Arc<FATFileSystem>) -> u64402 pub fn size(&self, fs: &Arc<FATFileSystem>) -> u64 {
403 return fs.num_clusters_chain(self.first_cluster) * fs.bytes_per_cluster();
404 }
405
406 /// @brief 在目录项中，寻找num_free个连续空闲目录项
407 ///
408 /// @param num_free 需要的空闲目录项数目.
409 /// @param fs 当前文件夹属于的文件系统
410 ///
411 /// @return Ok(Option<(第一个符合条件的空闲目录项所在的簇，簇内偏移量))
412 /// @return Err(错误码)
find_free_entries( &self, num_free: u64, fs: Arc<FATFileSystem>, ) -> Result<Option<(Cluster, u64)>, SystemError>413 pub fn find_free_entries(
414 &self,
415 num_free: u64,
416 fs: Arc<FATFileSystem>,
417 ) -> Result<Option<(Cluster, u64)>, SystemError> {
418 let mut free = 0;
419 let mut current_cluster: Cluster = self.first_cluster;
420 let mut offset = self.root_offset.unwrap_or(0);
421 // 第一个符合条件的空闲目录项
422 let mut first_free: Option<(Cluster, u64)> = None;
423
424 loop {
425 // 如果当前簇没有空间了，并且当前不是FAT12和FAT16的根目录，那么就读取下一个簇。
426 if offset >= fs.bytes_per_cluster() && !self.is_root() {
427 // 成功读取下一个簇
428 if let Some(FATEntry::Next(c)) = fs.get_fat_entry(current_cluster).ok() {
429 current_cluster = c;
430 // 计算簇内偏移量
431 offset = offset % fs.bytes_per_cluster();
432 } else {
433 // 读取失败，当前已经是最后一个簇，退出循环
434 break;
435 }
436 }
437 // 如果当前目录是FAT12和FAT16的根目录，且已经读取完，就直接返回。
438 if self.is_root() && offset > fs.root_dir_end_bytes_offset().unwrap() {
439 return Ok(None);
440 }
441
442 let e_offset = fs.cluster_bytes_offset(current_cluster) + offset;
443 let entry: FATRawDirEntry = get_raw_dir_entry(&fs, e_offset)?;
444
445 match entry {
446 FATRawDirEntry::Free | FATRawDirEntry::FreeRest => {
447 if free == 0 {
448 first_free = Some((current_cluster, offset));
449 }
450
451 free += 1;
452 if free == num_free {
453 // kdebug!("first_free = {first_free:?}, current_free = ({current_cluster:?}, {offset})");
454 return Ok(first_free);
455 }
456 }
457
458 // 遇到一个不空闲的目录项，那么重新开始计算空闲目录项
459 _ => {
460 free = 0;
461 }
462 }
463 offset += FATRawDirEntry::DIR_ENTRY_LEN;
464 }
465
466 // 剩余的需要获取的目录项
467 let remain_entries = num_free - free;
468
469 // 计算需要申请多少个簇
470 let clusters_required =
471 (remain_entries * FATRawDirEntry::DIR_ENTRY_LEN + fs.bytes_per_cluster() - 1)
472 / fs.bytes_per_cluster();
473 let mut first_cluster = Cluster::default();
474 let mut prev_cluster = current_cluster;
475 // kdebug!(
476 // "clusters_required={clusters_required}, prev_cluster={prev_cluster:?}, free ={free}"
477 // );
478 // 申请簇
479 for i in 0..clusters_required {
480 let c: Cluster = fs.allocate_cluster(Some(prev_cluster))?;
481 if i == 0 {
482 first_cluster = c;
483 }
484
485 prev_cluster = c;
486 }
487
488 if free > 0 {
489 // 空闲目录项跨越了簇，返回第一个空闲目录项
490 return Ok(first_free);
491 } else {
492 // 空闲目录项是在全新的簇开始的
493 return Ok(Some((first_cluster, 0)));
494 }
495 }
496
497 /// @brief 在当前目录中寻找目录项
498 ///
499 /// @param name 目录项的名字
500 /// @param expect_dir 该值为Some时有效。如果期待目标目录项是文件夹，那么值为Some(true), 否则为Some(false).
501 /// @param short_name_gen 短目录项名称生成器
502 /// @param fs 当前目录所属的文件系统
503 ///
504 /// @return Ok(FATDirEntry) 找到期待的目录项
505 /// @return Err(SystemError) 错误码
find_entry( &self, name: &str, expect_dir: Option<bool>, mut short_name_gen: Option<&mut ShortNameGenerator>, fs: Arc<FATFileSystem>, ) -> Result<FATDirEntry, SystemError>506 pub fn find_entry(
507 &self,
508 name: &str,
509 expect_dir: Option<bool>,
510 mut short_name_gen: Option<&mut ShortNameGenerator>,
511 fs: Arc<FATFileSystem>,
512 ) -> Result<FATDirEntry, SystemError> {
513 LongDirEntry::validate_long_name(name)?;
514 // 迭代当前目录下的文件/文件夹
515 for e in self.to_iter(fs) {
516 if e.eq_name(name) {
517 if expect_dir.is_some() && Some(e.is_dir()) != expect_dir {
518 if e.is_dir() {
519 // 期望得到文件，但是是文件夹
520 return Err(SystemError::EISDIR);
521 } else {
522 // 期望得到文件夹，但是是文件
523 return Err(SystemError::ENOTDIR);
524 }
525 }
526 // 找到期望的目录项
527 return Ok(e);
528 }
529
530 if let Some(ref mut sng) = short_name_gen {
531 sng.add_name(&e.short_name_raw())
532 }
533 }
534 // 找不到文件/文件夹
535 return Err(SystemError::ENOENT);
536 }
537
538 /// @brief 在当前目录下打开文件，获取FATFile结构体
open_file(&self, name: &str, fs: Arc<FATFileSystem>) -> Result<FATFile, SystemError>539 pub fn open_file(&self, name: &str, fs: Arc<FATFileSystem>) -> Result<FATFile, SystemError> {
540 let f: FATFile = self.find_entry(name, Some(false), None, fs)?.to_file()?;
541 return Ok(f);
542 }
543
544 /// @brief 在当前目录下打开文件夹，获取FATDir结构体
open_dir(&self, name: &str, fs: Arc<FATFileSystem>) -> Result<FATDir, SystemError>545 pub fn open_dir(&self, name: &str, fs: Arc<FATFileSystem>) -> Result<FATDir, SystemError> {
546 let d: FATDir = self.find_entry(name, Some(true), None, fs)?.to_dir()?;
547 return Ok(d);
548 }
549
550 /// @brief 在当前文件夹下创建文件。
551 ///
552 /// @param name 文件名
553 /// @param fs 当前文件夹所属的文件系统
create_file(&self, name: &str, fs: &Arc<FATFileSystem>) -> Result<FATFile, SystemError>554 pub fn create_file(&self, name: &str, fs: &Arc<FATFileSystem>) -> Result<FATFile, SystemError> {
555 let r: Result<FATDirEntryOrShortName, SystemError> =
556 self.check_existence(name, Some(false), fs.clone());
557 // 检查错误码，如果能够表明目录项已经存在，则返回-EEXIST
558 if r.is_err() {
559 let err_val = r.unwrap_err();
560 if err_val == (SystemError::EISDIR) || err_val == (SystemError::ENOTDIR) {
561 return Err(SystemError::EEXIST);
562 } else {
563 return Err(err_val);
564 }
565 }
566
567 match r.unwrap() {
568 FATDirEntryOrShortName::ShortName(short_name) => {
569 // 确认名称是一个可行的长文件名
570 LongDirEntry::validate_long_name(name)?;
571 // 创建目录项
572 let x: Result<FATFile, SystemError> = self
573 .create_dir_entries(
574 name.trim(),
575 &short_name,
576 None,
577 FileAttributes {
578 value: FileAttributes::ARCHIVE,
579 },
580 fs.clone(),
581 )
582 .map(|e| e.to_file())?;
583 return x;
584 }
585
586 FATDirEntryOrShortName::DirEntry(_) => {
587 // 已经存在这样的一个目录项了
588 return Err(SystemError::EEXIST);
589 }
590 }
591 }
592
create_dir(&self, name: &str, fs: &Arc<FATFileSystem>) -> Result<FATDir, SystemError>593 pub fn create_dir(&self, name: &str, fs: &Arc<FATFileSystem>) -> Result<FATDir, SystemError> {
594 let r: Result<FATDirEntryOrShortName, SystemError> =
595 self.check_existence(name, Some(true), fs.clone());
596 // kdebug!("check existence ok");
597 // 检查错误码，如果能够表明目录项已经存在，则返回-EEXIST
598 if r.is_err() {
599 let err_val = r.unwrap_err();
600 if err_val == (SystemError::EISDIR) || err_val == (SystemError::ENOTDIR) {
601 return Err(SystemError::EEXIST);
602 } else {
603 return Err(err_val);
604 }
605 }
606
607 match r.unwrap() {
608 // 文件夹不存在，创建文件夹
609 FATDirEntryOrShortName::ShortName(short_name) => {
610 LongDirEntry::validate_long_name(name)?;
611 // 目标目录项
612 let mut short_entry = ShortDirEntry::default();
613
614 let first_cluster: Cluster = fs.allocate_cluster(None)?;
615 short_entry.set_first_cluster(first_cluster);
616
617 // === 接下来在子目录中创建'.'目录项和'..'目录项
618 let mut offset = 0;
619 // '.'目录项
620 let mut dot_entry = ShortDirEntry::default();
621 dot_entry.name = ShortNameGenerator::new(".").generate().unwrap();
622 dot_entry.attributes.value = FileAttributes::DIRECTORY;
623 dot_entry.set_first_cluster(first_cluster);
624
625 // todo: 设置创建、访问时间
626 dot_entry.flush(&fs, fs.cluster_bytes_offset(first_cluster) + offset)?;
627
628 // 偏移量加上一个目录项的长度
629 offset += FATRawDirEntry::DIR_ENTRY_LEN;
630
631 // '..'目录项
632 let mut dot_dot_entry = ShortDirEntry::default();
633 dot_dot_entry.name = ShortNameGenerator::new("..").generate().unwrap();
634 dot_dot_entry.attributes.value = FileAttributes::DIRECTORY;
635 dot_dot_entry.set_first_cluster(self.first_cluster);
636 // todo: 设置创建、访问时间
637
638 dot_dot_entry.flush(&fs, fs.cluster_bytes_offset(first_cluster) + offset)?;
639
640 // kdebug!("to create dentries");
641 // 在当前目录下创建目标目录项
642 let res = self
643 .create_dir_entries(
644 name.trim(),
645 &short_name,
646 Some(short_entry),
647 FileAttributes {
648 value: FileAttributes::DIRECTORY,
649 },
650 fs.clone(),
651 )
652 .map(|e| e.to_dir())?;
653 // kdebug!("create dentries ok");
654 return res;
655 }
656 FATDirEntryOrShortName::DirEntry(_) => {
657 // 已经存在这样的一个目录项了
658 return Err(SystemError::EEXIST);
659 }
660 }
661 }
662 /// @brief 检查目录项在当前文件夹下是否存在
663 ///
664 /// @param name 目录项的名字
665 /// @param expect_dir 该值为Some时有效。如果期待目标目录项是文件夹，那么值为Some(true), 否则为Some(false).
666 /// @param fs 当前目录所属的文件系统
667 ///
668 /// @return Ok(FATDirEntryOrShortName::DirEntry) 找到期待的目录项
669 /// @return Ok(FATDirEntryOrShortName::ShortName) 当前文件夹下不存在指定的目录项，因此返回一个可行的短文件名
670 /// @return Err(SystemError) 错误码
check_existence( &self, name: &str, expect_dir: Option<bool>, fs: Arc<FATFileSystem>, ) -> Result<FATDirEntryOrShortName, SystemError>671 pub fn check_existence(
672 &self,
673 name: &str,
674 expect_dir: Option<bool>,
675 fs: Arc<FATFileSystem>,
676 ) -> Result<FATDirEntryOrShortName, SystemError> {
677 let mut sng = ShortNameGenerator::new(name);
678
679 loop {
680 let e: Result<FATDirEntry, SystemError> =
681 self.find_entry(name, expect_dir, Some(&mut sng), fs.clone());
682 match e {
683 Ok(e) => {
684 // 找到，返回目录项
685 return Ok(FATDirEntryOrShortName::DirEntry(e));
686 }
687 Err(e) => {
688 // 如果没找到，则不返回错误
689 if e == SystemError::ENOENT {
690 } else {
691 // 其他错误，则返回
692 return Err(e);
693 }
694 }
695 }
696
697 // 没找到文件，则生成短文件名
698 if let Ok(name) = sng.generate() {
699 return Ok(FATDirEntryOrShortName::ShortName(name));
700 }
701
702 sng.next_iteration();
703 }
704 }
705
706 /// @brief 创建一系列的目录项
707 ///
708 /// @param long_name 长文件名
709 /// @param short_name 短文件名
710 /// @param short_dentry 可选的生成好的短目录项结构体
711 /// @param attrs FAT目录项的属性
712 /// @param fs 当前文件夹所属的文件系统
713 ///
714 /// @return Ok(FATDirEntry) FAT目录项的枚举类型（目录项链条的最后一个长目录项）
create_dir_entries( &self, long_name: &str, short_name: &[u8; 11], short_dentry: Option<ShortDirEntry>, attrs: FileAttributes, fs: Arc<FATFileSystem>, ) -> Result<FATDirEntry, SystemError>715 fn create_dir_entries(
716 &self,
717 long_name: &str,
718 short_name: &[u8; 11],
719 short_dentry: Option<ShortDirEntry>,
720 attrs: FileAttributes,
721 fs: Arc<FATFileSystem>,
722 ) -> Result<FATDirEntry, SystemError> {
723 let mut short_dentry: ShortDirEntry = short_dentry.unwrap_or(ShortDirEntry::default());
724 short_dentry.name = short_name.clone();
725 short_dentry.attributes = attrs;
726
727 // todo: 设置创建时间、修改时间
728
729 let mut long_name_gen: LongNameEntryGenerator =
730 LongNameEntryGenerator::new(long_name, short_dentry.checksum());
731 let num_entries = long_name_gen.num_entries() as u64;
732
733 // kdebug!("to find free entries");
734 let free_entries: Option<(Cluster, u64)> =
735 self.find_free_entries(num_entries, fs.clone())?;
736 // 目录项开始位置
737 let start_loc: (Cluster, u64) = match free_entries {
738 Some(c) => c,
739 None => return Err(SystemError::ENOSPC),
740 };
741 let offsets: Vec<(Cluster, u64)> =
742 FATDirEntryOffsetIter::new(fs.clone(), start_loc, num_entries, None).collect();
743
744 // 迭代长目录项
745 for off in &offsets.as_slice()[..offsets.len() - 1] {
746 // 获取生成的下一个长目录项
747 let long_entry: LongDirEntry = long_name_gen.next().unwrap();
748 // 获取这个长目录项在磁盘内的字节偏移量
749 let bytes_offset = fs.cluster_bytes_offset(off.0) + off.1;
750 long_entry.flush(fs.clone(), bytes_offset)?;
751 }
752
753 let start: (Cluster, u64) = offsets[0];
754 let end: (Cluster, u64) = *offsets.last().unwrap();
755 // 短目录项在磁盘上的字节偏移量
756 let offset = fs.cluster_bytes_offset(end.0) + end.1;
757 short_dentry.flush(&fs, offset)?;
758
759 return Ok(short_dentry.to_dir_entry_with_long_name(long_name.to_string(), (start, end)));
760 }
761
762 /// @brief 判断当前目录是否为空
763 ///
764 /// @return true 当前目录为空
765 /// @return false 当前目录不为空
is_empty(&self, fs: Arc<FATFileSystem>) -> bool766 pub fn is_empty(&self, fs: Arc<FATFileSystem>) -> bool {
767 for e in self.to_iter(fs) {
768 let s = e.short_name();
769 if s == "." || s == ".." {
770 continue;
771 } else {
772 return false;
773 }
774 }
775 return true;
776 }
777
778 /// @brief 从当前文件夹中删除文件或者文件夹。如果目标文件夹不为空，则不能删除，返回-ENOTEMPTY.
779 ///
780 /// @param fs 当前FATDir所属的文件系统
781 /// @param name 目录项的名字
782 /// @param remove_clusters 是否删除与指定的目录项相关联的数据簇
783 ///
784 /// @return Ok() 成功时无返回值
785 /// @return Err(SystemError) 如果目标文件夹不为空，则不能删除，返回-ENOTEMPTY. 或者返回底层传上来的错误
remove( &self, fs: Arc<FATFileSystem>, name: &str, remove_clusters: bool, ) -> Result<(), SystemError>786 pub fn remove(
787 &self,
788 fs: Arc<FATFileSystem>,
789 name: &str,
790 remove_clusters: bool,
791 ) -> Result<(), SystemError> {
792 let e: FATDirEntry = self.find_entry(name, None, None, fs.clone())?;
793
794 // 判断文件夹是否为空，如果空，则不删除，报错。
795 if e.is_dir() && !(e.to_dir().unwrap().is_empty(fs.clone())) {
796 return Err(SystemError::ENOTEMPTY);
797 }
798
799 if e.first_cluster().cluster_num >= 2 && remove_clusters {
800 // 删除与指定的目录项相关联的数据簇
801 fs.deallocate_cluster_chain(e.first_cluster())?;
802 }
803
804 if e.get_dir_range().is_some() {
805 self.remove_dir_entries(fs, e.get_dir_range().unwrap())?;
806 }
807
808 return Ok(());
809 }
810
811 /// @brief 在当前目录中删除多个目录项
812 ///
813 /// @param fs 当前目录所属的文件系统
814 /// @param cluster_range 要删除的目录项的范围（以簇+簇内偏移量的形式表示）
remove_dir_entries( &self, fs: Arc<FATFileSystem>, cluster_range: ((Cluster, u64), (Cluster, u64)), ) -> Result<(), SystemError>815 fn remove_dir_entries(
816 &self,
817 fs: Arc<FATFileSystem>,
818 cluster_range: ((Cluster, u64), (Cluster, u64)),
819 ) -> Result<(), SystemError> {
820 // 收集所有的要移除的目录项
821 let offsets: Vec<(Cluster, u64)> =
822 FATDirEntryOffsetIter::new(fs.clone(), cluster_range.0, 15, Some(cluster_range.1))
823 .collect();
824 // 逐个设置这些目录项为“空闲”状态
825 for off in offsets {
826 let disk_bytes_offset = fs.cluster_bytes_offset(off.0) + off.1;
827 let mut short_entry = ShortDirEntry::default();
828 short_entry.name[0] = 0xe5;
829 short_entry.flush(&fs, disk_bytes_offset)?;
830 }
831 return Ok(());
832 }
833
834 /// @brief 根据名字在当前文件夹下寻找目录项
835 ///
836 /// @return Ok(FATDirEntry) 目标目录项
837 /// @return Err(SystemError) 底层传上来的错误码
get_dir_entry( &self, fs: Arc<FATFileSystem>, name: &str, ) -> Result<FATDirEntry, SystemError>838 pub fn get_dir_entry(
839 &self,
840 fs: Arc<FATFileSystem>,
841 name: &str,
842 ) -> Result<FATDirEntry, SystemError> {
843 if name == "." || name == "/" {
844 return Ok(FATDirEntry::Dir(self.clone()));
845 }
846
847 LongDirEntry::validate_long_name(name)?;
848 return self.find_entry(name, None, None, fs);
849 }
850
851 /// @brief 在当前目录内，重命名一个目录项
852 ///
rename( &self, fs: Arc<FATFileSystem>, old_name: &str, new_name: &str, ) -> Result<FATDirEntry, SystemError>853 pub fn rename(
854 &self,
855 fs: Arc<FATFileSystem>,
856 old_name: &str,
857 new_name: &str,
858 ) -> Result<FATDirEntry, SystemError> {
859 // 判断源目录项是否存在
860 let old_dentry: FATDirEntry = if let FATDirEntryOrShortName::DirEntry(dentry) =
861 self.check_existence(old_name, None, fs.clone())?
862 {
863 dentry
864 } else {
865 // 如果目标目录项不存在，则返回错误
866 return Err(SystemError::ENOENT);
867 };
868
869 let short_name = if let FATDirEntryOrShortName::ShortName(s) =
870 self.check_existence(new_name, None, fs.clone())?
871 {
872 s
873 } else {
874 // 如果目标目录项存在，那么就返回错误
875 return Err(SystemError::EEXIST);
876 };
877
878 let old_short_dentry: Option<ShortDirEntry> = old_dentry.short_dir_entry();
879 if let Some(se) = old_short_dentry {
880 // 删除原来的目录项
881 self.remove(fs.clone(), old_dentry.name().as_str(), false)?;
882
883 // 创建新的目录项
884 let new_dentry: FATDirEntry = self.create_dir_entries(
885 new_name,
886 &short_name,
887 Some(se),
888 se.attributes,
889 fs.clone(),
890 )?;
891
892 return Ok(new_dentry);
893 } else {
894 // 不允许对根目录项进行重命名
895 return Err(SystemError::EPERM);
896 }
897 }
898 }
899
900 impl FileAttributes {
901 pub const READ_ONLY: u8 = 1 << 0;
902 pub const HIDDEN: u8 = 1 << 1;
903 pub const SYSTEM: u8 = 1 << 2;
904 pub const VOLUME_ID: u8 = 1 << 3;
905 pub const DIRECTORY: u8 = 1 << 4;
906 pub const ARCHIVE: u8 = 1 << 5;
907 pub const LONG_NAME: u8 = FileAttributes::READ_ONLY
908 | FileAttributes::HIDDEN
909 | FileAttributes::SYSTEM
910 | FileAttributes::VOLUME_ID;
911
912 /// @brief 判断属性是否存在
913 #[inline]
contains(&self, attr: u8) -> bool914 pub fn contains(&self, attr: u8) -> bool {
915 return (self.value & attr) != 0;
916 }
917
new(attr: u8) -> Self918 pub fn new(attr: u8) -> Self {
919 return Self { value: attr };
920 }
921 }
922
923 /// FAT32的短目录项
924 #[derive(Debug, Clone, Copy, Default)]
925 pub struct ShortDirEntry {
926 /// short name
927 name: [u8; 11],
928 /// 目录项属性 (见 FileAttributes )
929 attributes: FileAttributes,
930
931 /// Windows NT系统的保留字段。用来表示短目录项文件名。
932 /// EXT|BASE => 8(BASE).3(EXT)
933 /// BASE:LowerCase(8),UpperCase(0)
934 /// EXT:LowerCase(16),UpperCase(0)
935 nt_res: u8,
936
937 /// 文件创建时间的毫秒级时间戳
938 crt_time_tenth: u8,
939 /// 创建时间
940 crt_time: u16,
941 /// 创建日期
942 crt_date: u16,
943 /// 最后一次访问日期
944 lst_acc_date: u16,
945 /// High word of first cluster(0 for FAT12 and FAT16)
946 fst_clus_hi: u16,
947 /// 最后写入时间
948 wrt_time: u16,
949 /// 最后写入日期
950 wrt_date: u16,
951 /// Low word of first cluster
952 fst_clus_lo: u16,
953 /// 文件大小
954 file_size: u32,
955 }
956
957 /// FAT32的长目录项
958 #[derive(Debug, Clone, Copy, Default)]
959 pub struct LongDirEntry {
960 /// 长目录项的序号
961 ord: u8,
962 /// 长文件名的第1-5个字符，每个字符占2bytes
963 name1: [u16; 5],
964 /// 目录项属性必须为ATTR_LONG_NAME
965 file_attrs: FileAttributes,
966 /// Entry Type: 如果为0，则说明这是长目录项的子项
967 /// 非零值是保留的。
968 dirent_type: u8,
969 /// 短文件名的校验和
970 checksum: u8,
971 /// 长文件名的第6-11个字符，每个字符占2bytes
972 name2: [u16; 6],
973 /// 必须为0
974 first_clus_low: u16,
975 /// 长文件名的12-13个字符，每个字符占2bytes
976 name3: [u16; 2],
977 }
978
979 impl LongDirEntry {
980 /// 长目录项的字符串长度（单位：word）
981 pub const LONG_NAME_STR_LEN: usize = 13;
982
983 /// @brief 初始化一个新的长目录项
984 ///
985 /// @param ord 顺序
986 /// @param name_part 长目录项名称的数组（长度必须为13）
987 /// @param check_sum 短目录项的校验和
988 ///
989 /// @return Self 初始化好的长目录项对象
new(ord: u8, name_part: &[u16], check_sum: u8) -> Self990 fn new(ord: u8, name_part: &[u16], check_sum: u8) -> Self {
991 let mut result = LongDirEntry::default();
992 result.ord = ord;
993 result
994 .insert_name(name_part)
995 .expect("Name part's len should be equal to 13.");
996 result.file_attrs.value = FileAttributes::LONG_NAME;
997 result.dirent_type = 0;
998 result.checksum = check_sum;
999 // 该字段需要外层的代码手动赋值
1000 result.first_clus_low = 0;
1001 return result;
1002 }
1003
1004 /// @brief 填写长目录项的名称字段。
1005 ///
1006 /// @param name_part 要被填入当前长目录项的名字（数组长度必须为13）
1007 ///
1008 /// @return Ok(())
1009 /// @return Err(SystemError) 错误码
insert_name(&mut self, name_part: &[u16]) -> Result<(), SystemError>1010 fn insert_name(&mut self, name_part: &[u16]) -> Result<(), SystemError> {
1011 if name_part.len() != Self::LONG_NAME_STR_LEN {
1012 return Err(SystemError::EINVAL);
1013 }
1014 self.name1.copy_from_slice(&name_part[0..5]);
1015 self.name2.copy_from_slice(&name_part[5..11]);
1016 self.name3.copy_from_slice(&name_part[11..13]);
1017 return Ok(());
1018 }
1019
1020 /// @brief 将当前长目录项的名称字段，原样地拷贝到一个长度为13的u16数组中。
1021 /// @param dst 拷贝的目的地，一个[u16]数组，长度必须为13。
copy_name_to_slice(&self, dst: &mut [u16]) -> Result<(), SystemError>1022 pub fn copy_name_to_slice(&self, dst: &mut [u16]) -> Result<(), SystemError> {
1023 if dst.len() != Self::LONG_NAME_STR_LEN {
1024 return Err(SystemError::EINVAL);
1025 }
1026 dst[0..5].copy_from_slice(&self.name1);
1027 dst[5..11].copy_from_slice(&self.name2);
1028 dst[11..13].copy_from_slice(&self.name3);
1029 return Ok(());
1030 }
1031
1032 /// @brief 是否为最后一个长目录项
1033 ///
1034 /// @return true 是最后一个长目录项
1035 /// @return false 不是最后一个长目录项
is_last(&self) -> bool1036 pub fn is_last(&self) -> bool {
1037 return self.ord & 0x40 > 0;
1038 }
1039
1040 /// @brief 校验字符串是否符合长目录项的命名要求
1041 ///
1042 /// @return Ok(()) 名称合法
1043 /// @return Err(SystemError) 名称不合法，返回错误码
validate_long_name(mut name: &str) -> Result<(), SystemError>1044 pub fn validate_long_name(mut name: &str) -> Result<(), SystemError> {
1045 // 去除首尾多余的空格
1046 name = name.trim();
1047
1048 // 名称不能为0
1049 if name.len() == 0 {
1050 return Err(SystemError::EINVAL);
1051 }
1052
1053 // 名称长度不能大于255
1054 if name.len() > 255 {
1055 return Err(SystemError::ENAMETOOLONG);
1056 }
1057
1058 // 检查是否符合命名要求
1059 for c in name.chars() {
1060 match c {
1061 'a'..='z' | 'A'..='Z' | '0'..='9' => {}
1062 '\u{80}'..='\u{ffff}' => {}
1063 '$' | '%' | '\'' | '-' | '_' | '@' | '~' | '`' | '!' | '(' | ')' | '{' | '}'
1064 | '^' | '#' | '&' => {}
1065 '+' | ',' | ';' | '=' | '[' | ']' | '.' | ' ' => {}
1066 _ => {
1067 return Err(SystemError::EILSEQ);
1068 }
1069 }
1070 }
1071 return Ok(());
1072 }
1073
1074 /// @brief 把当前长目录项写入磁盘
1075 ///
1076 /// @param fs 对应的文件系统
1077 /// @param disk_bytes_offset 长目录项所在位置对应的在磁盘上的字节偏移量
1078 ///
1079 /// @return Ok(())
1080 /// @return Err(SystemError) 错误码
flush(&self, fs: Arc<FATFileSystem>, disk_bytes_offset: u64) -> Result<(), SystemError>1081 pub fn flush(&self, fs: Arc<FATFileSystem>, disk_bytes_offset: u64) -> Result<(), SystemError> {
1082 // 从磁盘读取数据
1083 let blk_offset = fs.get_in_block_offset(disk_bytes_offset);
1084 let lba = fs.get_lba_from_offset(
1085 fs.bytes_to_sector(fs.get_in_partition_bytes_offset(disk_bytes_offset)),
1086 );
1087 let mut v: Vec<u8> = Vec::new();
1088 v.resize(1 * fs.lba_per_sector() * LBA_SIZE, 0);
1089 fs.partition
1090 .disk()
1091 .read_at(lba, 1 * fs.lba_per_sector(), &mut v)?;
1092
1093 let mut cursor: VecCursor = VecCursor::new(v);
1094 // 切换游标到对应位置
1095 cursor.seek(SeekFrom::SeekSet(blk_offset as i64))?;
1096
1097 // 写入数据
1098 cursor.write_u8(self.ord)?;
1099 for b in &self.name1 {
1100 cursor.write_u16(*b)?;
1101 }
1102
1103 cursor.write_u8(self.file_attrs.value)?;
1104 cursor.write_u8(self.dirent_type)?;
1105 cursor.write_u8(self.checksum)?;
1106
1107 for b in &self.name2 {
1108 cursor.write_u16(*b)?;
1109 }
1110
1111 cursor.write_u16(self.first_clus_low)?;
1112
1113 for b in &self.name3 {
1114 cursor.write_u16(*b)?;
1115 }
1116
1117 // 把修改后的长目录项刷入磁盘
1118 fs.partition
1119 .disk()
1120 .write_at(lba, 1 * fs.lba_per_sector(), cursor.as_slice())?;
1121 fs.partition.disk().sync()?;
1122
1123 return Ok(());
1124 }
1125 }
1126
1127 impl ShortDirEntry {
1128 const PADDING: u8 = ' ' as u8;
1129
1130 /// @brief 判断当前目录项是否为文件夹
1131 ///
1132 /// @return true 是文件夹
1133 /// @return false 不是文件夹
is_dir(&self) -> bool1134 pub fn is_dir(&self) -> bool {
1135 return (self.attributes.contains(FileAttributes::DIRECTORY))
1136 && (!self.attributes.contains(FileAttributes::VOLUME_ID));
1137 }
1138
1139 /// @brief 判断当前目录项是否为文件
1140 ///
1141 /// @return true 是文件
1142 /// @return false 不是文件
is_file(&self) -> bool1143 pub fn is_file(&self) -> bool {
1144 return (!self.attributes.contains(FileAttributes::DIRECTORY))
1145 && (!self.attributes.contains(FileAttributes::VOLUME_ID));
1146 }
1147
1148 /// @brief 判断当前目录项是否为卷号
1149 ///
1150 /// @return true 是卷号
1151 /// @return false 不是卷号
is_volume_id(&self) -> bool1152 pub fn is_volume_id(&self) -> bool {
1153 return (!self.attributes.contains(FileAttributes::DIRECTORY))
1154 && self.attributes.contains(FileAttributes::VOLUME_ID);
1155 }
1156
1157 /// @brief 将短目录项的名字转换为String
name_to_string(&self) -> String1158 fn name_to_string(&self) -> String {
1159 // 计算基础名的长度
1160 let base_len = self.name[..8]
1161 .iter()
1162 .rposition(|x| *x != ShortDirEntry::PADDING)
1163 .map(|len| len + 1)
1164 .unwrap_or(0);
1165 // 计算扩展名的长度
1166 let ext_len = self.name[8..]
1167 .iter()
1168 .rposition(|x| *x != ShortDirEntry::PADDING)
1169 .map(|len| len + 1)
1170 .unwrap_or(0);
1171
1172 // 声明存储完整名字的数组（包含“.”）
1173 let mut name = [ShortDirEntry::PADDING; 12];
1174 // 拷贝基础名
1175 name[..base_len].copy_from_slice(&self.name[..base_len]);
1176
1177 // 拷贝扩展名，并计算总的长度
1178 let total_len = if ext_len > 0 {
1179 name[base_len] = '.' as u8;
1180 name[base_len + 1..base_len + 1 + ext_len].copy_from_slice(&self.name[8..8 + ext_len]);
1181 // 总长度为基础名长度+点号+扩展名长度
1182 base_len + 1 + ext_len
1183 } else {
1184 base_len
1185 };
1186
1187 if name[0] == 0x05 {
1188 name[0] = 0xe5;
1189 }
1190
1191 let iter = name[..total_len].iter().map(|c| decode_u8_ascii(*c));
1192 // 返回最终的字符串
1193 return String::from_iter(iter);
1194 }
1195
1196 /// @brief 将短目录项结构体，转换为FATDirEntry枚举类型
1197 ///
1198 /// @param loc 当前文件的起始、终止簇。格式：(簇，簇内偏移量)
1199 /// @return 生成的FATDirENtry枚举类型
to_dir_entry(&self, loc: (Cluster, u64)) -> FATDirEntry1200 pub fn to_dir_entry(&self, loc: (Cluster, u64)) -> FATDirEntry {
1201 // 当前文件的第一个簇
1202 let first_cluster =
1203 Cluster::new(((self.fst_clus_hi as u64) << 16) | (self.fst_clus_lo as u64));
1204
1205 // 当前是文件或卷号
1206 if self.is_file() || self.is_volume_id() {
1207 let mut file: FATFile = FATFile::default();
1208
1209 file.file_name = self.name_to_string();
1210 file.first_cluster = first_cluster;
1211 file.short_dir_entry = self.clone();
1212 file.loc = (loc, loc);
1213
1214 // 根据当前短目录项的类型的不同，返回对应的枚举类型。
1215 if self.is_file() {
1216 return FATDirEntry::File(file);
1217 } else {
1218 return FATDirEntry::VolId(file);
1219 }
1220 } else {
1221 // 当前是文件夹
1222 let mut dir = FATDir::default();
1223 dir.dir_name = self.name_to_string();
1224 dir.first_cluster = first_cluster;
1225 dir.root_offset = None;
1226 dir.short_dir_entry = Some(self.clone());
1227 dir.loc = Some((loc, loc));
1228
1229 return FATDirEntry::Dir(dir);
1230 }
1231 }
1232
1233 /// @brief 将短目录项结构体，转换为FATDirEntry枚举类型. 并且，该短目录项具有对应的长目录项。
1234 /// 因此，需要传入从长目录项获得的完整的文件名
1235 ///
1236 /// @param name 从长目录项获取的完整文件名
1237 /// @param loc 当前文件的起始、终止簇。格式：(簇，簇内偏移量)
1238 /// @return 生成的FATDirENtry枚举类型
to_dir_entry_with_long_name( &self, name: String, loc: ((Cluster, u64), (Cluster, u64)), ) -> FATDirEntry1239 pub fn to_dir_entry_with_long_name(
1240 &self,
1241 name: String,
1242 loc: ((Cluster, u64), (Cluster, u64)),
1243 ) -> FATDirEntry {
1244 // 当前文件的第一个簇
1245 let first_cluster =
1246 Cluster::new(((self.fst_clus_hi as u64) << 16) | (self.fst_clus_lo as u64));
1247
1248 if self.is_file() || self.is_volume_id() {
1249 let mut file = FATFile::default();
1250
1251 file.first_cluster = first_cluster;
1252 file.file_name = name;
1253 file.loc = loc;
1254 file.short_dir_entry = self.clone();
1255
1256 if self.is_file() {
1257 return FATDirEntry::File(file);
1258 } else {
1259 return FATDirEntry::VolId(file);
1260 }
1261 } else {
1262 let mut dir = FATDir::default();
1263
1264 dir.first_cluster = first_cluster;
1265 dir.dir_name = name;
1266 dir.loc = Some(loc);
1267 dir.short_dir_entry = Some(self.clone());
1268 dir.root_offset = None;
1269
1270 return FATDirEntry::Dir(dir);
1271 }
1272 }
1273
1274 /// @brief 计算短目录项的名称的校验和
checksum(&self) -> u81275 fn checksum(&self) -> u8 {
1276 let mut result = 0;
1277
1278 for c in &self.name {
1279 result = (result << 7) + (result >> 1) + *c;
1280 }
1281 return result;
1282 }
1283
1284 /// @brief 把当前短目录项写入磁盘
1285 ///
1286 /// @param fs 对应的文件系统
1287 /// @param disk_bytes_offset 短目录项所在位置对应的在磁盘上的字节偏移量
1288 ///
1289 /// @return Ok(())
1290 /// @return Err(SystemError) 错误码
flush( &self, fs: &Arc<FATFileSystem>, disk_bytes_offset: u64, ) -> Result<(), SystemError>1291 pub fn flush(
1292 &self,
1293 fs: &Arc<FATFileSystem>,
1294 disk_bytes_offset: u64,
1295 ) -> Result<(), SystemError> {
1296 // 从磁盘读取数据
1297 let blk_offset = fs.get_in_block_offset(disk_bytes_offset);
1298 let lba = fs.get_lba_from_offset(
1299 fs.bytes_to_sector(fs.get_in_partition_bytes_offset(disk_bytes_offset)),
1300 );
1301 let mut v: Vec<u8> = Vec::new();
1302 v.resize(1 * fs.lba_per_sector() * LBA_SIZE, 0);
1303 fs.partition
1304 .disk()
1305 .read_at(lba, 1 * fs.lba_per_sector(), &mut v)?;
1306
1307 let mut cursor: VecCursor = VecCursor::new(v);
1308 // 切换游标到对应位置
1309 cursor.seek(SeekFrom::SeekSet(blk_offset as i64))?;
1310 cursor.write_exact(&self.name)?;
1311 cursor.write_u8(self.attributes.value)?;
1312 cursor.write_u8(self.nt_res)?;
1313 cursor.write_u8(self.crt_time_tenth)?;
1314 cursor.write_u16(self.crt_time)?;
1315 cursor.write_u16(self.crt_date)?;
1316 cursor.write_u16(self.lst_acc_date)?;
1317 cursor.write_u16(self.fst_clus_hi)?;
1318 cursor.write_u16(self.wrt_time)?;
1319 cursor.write_u16(self.wrt_date)?;
1320 cursor.write_u16(self.fst_clus_lo)?;
1321 cursor.write_u32(self.file_size)?;
1322
1323 // 把修改后的长目录项刷入磁盘
1324 fs.partition
1325 .disk()
1326 .write_at(lba, 1 * fs.lba_per_sector(), cursor.as_slice())?;
1327 fs.partition.disk().sync()?;
1328
1329 return Ok(());
1330 }
1331
1332 /// @brief 设置短目录项的“第一个簇”字段的值
set_first_cluster(&mut self, cluster: Cluster)1333 pub fn set_first_cluster(&mut self, cluster: Cluster) {
1334 self.fst_clus_lo = (cluster.cluster_num & 0x0000ffff) as u16;
1335 self.fst_clus_hi = ((cluster.cluster_num & 0xffff0000) >> 16) as u16;
1336 }
1337 }
1338
1339 /// @brief FAT文件系统标准定义的目录项
1340 #[derive(Debug, Clone)]
1341 pub enum FATRawDirEntry {
1342 /// 短目录项
1343 Short(ShortDirEntry),
1344 /// 长目录项
1345 Long(LongDirEntry),
1346 /// 当前目录项的Name[0]==0xe5, 是空闲目录项
1347 Free,
1348 /// 当前目录项的Name[0]==0xe5, 是空闲目录项，且在这之后没有被分配过的目录项了。
1349 FreeRest,
1350 }
1351
1352 impl FATRawDirEntry {
1353 /// 每个目录项的长度（单位：字节）
1354 pub const DIR_ENTRY_LEN: u64 = 32;
1355
1356 /// @brief 判断当前目录项是否为这个文件的最后一个目录项
is_last(&self) -> bool1357 fn is_last(&self) -> bool {
1358 match self {
1359 &Self::Short(_) => {
1360 return true;
1361 }
1362 &Self::Long(l) => {
1363 return l.is_last();
1364 }
1365 _ => {
1366 return false;
1367 }
1368 }
1369 }
1370
1371 /// @brief 判断当前目录项是否为长目录项
is_long(&self) -> bool1372 fn is_long(&self) -> bool {
1373 if let Self::Long(_) = self {
1374 return true;
1375 } else {
1376 return false;
1377 }
1378 }
1379
1380 /// @brief 判断当前目录项是否为短目录项
is_short(&self) -> bool1381 fn is_short(&self) -> bool {
1382 if let Self::Short(_) = self {
1383 return true;
1384 } else {
1385 return false;
1386 }
1387 }
1388 }
1389
1390 /// @brief FAT文件系统的目录项迭代器
1391 #[derive(Debug)]
1392 pub struct FATDirIter {
1393 /// 当前正在迭代的簇
1394 current_cluster: Cluster,
1395 /// 当前正在迭代的簇的簇内偏移量
1396 offset: u64,
1397 /// True for the root directories of FAT12 and FAT16
1398 is_root: bool,
1399 /// 指向当前文件系统的指针
1400 fs: Arc<FATFileSystem>,
1401 }
1402
1403 impl FATDirIter {
1404 /// @brief 迭代当前inode的目录项(获取下一个目录项)
1405 ///
1406 /// @return Ok(Cluster, u64, Option<FATDirEntry>)
1407 /// Cluster: 下一个要读取的簇号
1408 /// u64: 下一个要读取的簇内偏移量
1409 /// Option<FATDirEntry>: 读取到的目录项（如果没有读取到，就返回失败）
1410 /// @return Err(错误码) 可能出现了内部错误，或者是磁盘错误等。具体原因看错误码。
get_dir_entry(&mut self) -> Result<(Cluster, u64, Option<FATDirEntry>), SystemError>1411 fn get_dir_entry(&mut self) -> Result<(Cluster, u64, Option<FATDirEntry>), SystemError> {
1412 loop {
1413 if unlikely(self.current_cluster.cluster_num < 2) {
1414 return Ok((self.current_cluster, self.offset, None));
1415 }
1416
1417 // 如果当前簇已经被读完，那么尝试获取下一个簇
1418 if self.offset >= self.fs.bytes_per_cluster() && !self.is_root {
1419 match self.fs.get_fat_entry(self.current_cluster)? {
1420 FATEntry::Next(c) => {
1421 // 获得下一个簇的信息
1422 self.current_cluster = c;
1423 self.offset %= self.fs.bytes_per_cluster();
1424 }
1425
1426 _ => {
1427 // 没有下一个簇了，返回None
1428 return Ok((self.current_cluster, self.offset, None));
1429 }
1430 }
1431 }
1432
1433 // 如果当前是FAT12/FAT16文件系统，并且当前inode是根目录项。
1434 // 如果offset大于根目录项的最大大小（已经遍历完根目录），那么就返回None
1435 if self.is_root && self.offset > self.fs.root_dir_end_bytes_offset().unwrap() {
1436 return Ok((self.current_cluster, self.offset, None));
1437 }
1438
1439 // 获取簇在磁盘内的字节偏移量
1440 let offset: u64 = self.fs.cluster_bytes_offset(self.current_cluster) + self.offset;
1441
1442 // 从磁盘读取原始的dentry
1443 let raw_dentry: FATRawDirEntry = get_raw_dir_entry(&self.fs, offset)?;
1444
1445 // 由于迭代顺序从前往后，因此：
1446 // 如果找到1个短目录项，那么证明有一个完整的entry被找到，因此返回。
1447 // 如果找到1个长目录项，那么，就依次往下迭代查找，直到找到一个短目录项，然后返回结果。这里找到的所有的目录项，都属于同一个文件/文件夹。
1448 match raw_dentry {
1449 FATRawDirEntry::Short(s) => {
1450 // 当前找到一个短目录项，更新offset之后，直接返回
1451 self.offset += FATRawDirEntry::DIR_ENTRY_LEN;
1452 return Ok((
1453 self.current_cluster,
1454 self.offset,
1455 Some(s.to_dir_entry((
1456 self.current_cluster,
1457 self.offset - FATRawDirEntry::DIR_ENTRY_LEN,
1458 ))),
1459 ));
1460 }
1461 FATRawDirEntry::Long(_) => {
1462 // 当前找到一个长目录项
1463
1464 // 声明一个数组，来容纳所有的entry。（先把最后一个entry放进去）
1465 let mut long_name_entries: Vec<FATRawDirEntry> = vec![raw_dentry];
1466 let start_offset: u64 = self.offset;
1467 let start_cluster: Cluster = self.current_cluster;
1468
1469 self.offset += FATRawDirEntry::DIR_ENTRY_LEN;
1470
1471 // 由于在FAT文件系统中，文件名最长为255字节，因此，最多有20个长目录项以及1个短目录项。
1472 // 由于上面已经塞了1个长目录项，因此接下来最多需要迭代20次
1473 // 循环查找目录项，直到遇到1个短目录项，或者是空闲目录项
1474 for _ in 0..20 {
1475 // 如果当前簇已经被读完，那么尝试获取下一个簇
1476 if self.offset >= self.fs.bytes_per_cluster() && !self.is_root {
1477 match self.fs.get_fat_entry(self.current_cluster)? {
1478 FATEntry::Next(c) => {
1479 // 获得下一个簇的信息
1480 self.current_cluster = c;
1481 self.offset %= self.fs.bytes_per_cluster();
1482 }
1483
1484 _ => {
1485 // 没有下一个簇了，退出迭代
1486 break;
1487 }
1488 }
1489 }
1490 // 如果当前是FAT12/FAT16文件系统，并且当前inode是根目录项。
1491 // 如果offset大于根目录项的最大大小（已经遍历完根目录），那么就退出迭代
1492 if self.is_root
1493 && self.offset > self.fs.root_dir_end_bytes_offset().unwrap()
1494 {
1495 break;
1496 }
1497
1498 // 获取簇在磁盘内的字节偏移量
1499 let offset: u64 =
1500 self.fs.cluster_bytes_offset(self.current_cluster) + self.offset;
1501 // 从磁盘读取原始的dentry
1502 let raw_dentry: FATRawDirEntry = get_raw_dir_entry(&self.fs, offset)?;
1503
1504 match raw_dentry {
1505 FATRawDirEntry::Short(_) => {
1506 // 当前遇到1个短目录项，证明当前文件/文件夹的所有dentry都被读取完了，因此在将其加入数组后，退出迭代。
1507 long_name_entries.push(raw_dentry);
1508 break;
1509 }
1510 FATRawDirEntry::Long(_) => {
1511 // 当前遇到1个长目录项，将其加入数组，然后更新offset，继续迭代。
1512 long_name_entries.push(raw_dentry);
1513 self.offset += FATRawDirEntry::DIR_ENTRY_LEN;
1514 }
1515
1516 _ => {
1517 // 遇到了空闲簇，但没遇到短目录项，说明文件系统出错了，退出。
1518 break;
1519 }
1520 }
1521 }
1522 // kdebug!("collect dentries done. long_name_entries={long_name_entries:?}");
1523 let dir_entry: Result<FATDirEntry, SystemError> = FATDirEntry::new(
1524 long_name_entries,
1525 (
1526 (start_cluster, start_offset),
1527 (self.current_cluster, self.offset),
1528 ),
1529 );
1530 // kdebug!("dir_entry={:?}", dir_entry);
1531 match dir_entry {
1532 Ok(d) => {
1533 // kdebug!("dir_entry ok");
1534 self.offset += FATRawDirEntry::DIR_ENTRY_LEN;
1535 return Ok((self.current_cluster, self.offset, Some(d)));
1536 }
1537
1538 Err(_) => {
1539 // kdebug!("dir_entry err, e={}", e);
1540 self.offset += FATRawDirEntry::DIR_ENTRY_LEN;
1541 }
1542 }
1543 }
1544 FATRawDirEntry::Free => {
1545 // 当前目录项是空的
1546 self.offset += FATRawDirEntry::DIR_ENTRY_LEN;
1547 }
1548 FATRawDirEntry::FreeRest => {
1549 // 当前目录项是空的，且之后都是空的，因此直接返回
1550 return Ok((self.current_cluster, self.offset, None));
1551 }
1552 }
1553 }
1554 }
1555 }
1556
1557 /// 为DirIter实现迭代器trait
1558 impl Iterator for FATDirIter {
1559 type Item = FATDirEntry;
1560
next(&mut self) -> Option<Self::Item>1561 fn next(&mut self) -> Option<Self::Item> {
1562 match self.get_dir_entry() {
1563 Ok((cluster, offset, result)) => {
1564 self.current_cluster = cluster;
1565 self.offset = offset;
1566 return result;
1567 }
1568 Err(_) => {
1569 return None;
1570 }
1571 }
1572 }
1573 }
1574
1575 impl FATDirEntry {
1576 /// @brief 构建FATDirEntry枚举类型
1577 ///
1578 /// @param long_name_entries 长目录项的数组。
1579 /// 格式：[第20个（或者是最大ord的那个）, 19, 18, ..., 1, 短目录项]
1580 ///
1581 /// @return Ok(FATDirEntry) 构建好的FATDirEntry类型的对象
1582 /// @return Err(SystemError) 错误码
new( mut long_name_entries: Vec<FATRawDirEntry>, loc: ((Cluster, u64), (Cluster, u64)), ) -> Result<Self, SystemError>1583 pub fn new(
1584 mut long_name_entries: Vec<FATRawDirEntry>,
1585 loc: ((Cluster, u64), (Cluster, u64)),
1586 ) -> Result<Self, SystemError> {
1587 if long_name_entries.is_empty() {
1588 return Err(SystemError::EINVAL);
1589 }
1590
1591 if !long_name_entries[0].is_last() || !long_name_entries.last().unwrap().is_short() {
1592 // 存在孤立的目录项，文件系统出现异常，因此返回错误，表明其只读。
1593 // TODO: 标记整个FAT文件系统为只读的
1594 return Err(SystemError::EROFS);
1595 }
1596
1597 // 取出短目录项（位于vec的末尾）
1598 let short_dentry: ShortDirEntry = match long_name_entries.pop().unwrap() {
1599 FATRawDirEntry::Short(s) => s,
1600 _ => unreachable!(),
1601 };
1602
1603 let mut extractor = LongNameExtractor::new();
1604 for entry in &long_name_entries {
1605 match entry {
1606 &FATRawDirEntry::Long(l) => {
1607 extractor.process(l)?;
1608 }
1609
1610 _ => {
1611 return Err(SystemError::EROFS);
1612 }
1613 }
1614 }
1615 // 检验校验和是否正确
1616 if extractor.validate_checksum(&short_dentry) {
1617 // 校验和正确，返回一个长目录项
1618 return Ok(short_dentry.to_dir_entry_with_long_name(extractor.to_string(), loc));
1619 } else {
1620 // 校验和不相同，认为文件系统出错
1621 return Err(SystemError::EROFS);
1622 }
1623 }
1624
1625 /// @brief 获取短目录项的名字
short_name(&self) -> String1626 pub fn short_name(&self) -> String {
1627 match self {
1628 FATDirEntry::File(f) | FATDirEntry::VolId(f) => {
1629 return f.short_dir_entry.name_to_string();
1630 }
1631 FATDirEntry::Dir(d) => match d.short_dir_entry {
1632 Some(s) => {
1633 return s.name_to_string();
1634 }
1635 None => {
1636 return String::from("/");
1637 }
1638 },
1639 FATDirEntry::UnInit => unreachable!("FATFS: FATDirEntry uninitialized."),
1640 }
1641 }
1642
1643 /// @brief 获取短目录项结构体
short_dir_entry(&self) -> Option<ShortDirEntry>1644 pub fn short_dir_entry(&self) -> Option<ShortDirEntry> {
1645 match &self {
1646 FATDirEntry::File(f) => {
1647 return Some(f.short_dir_entry);
1648 }
1649 FATDirEntry::Dir(d) => {
1650 return d.short_dir_entry;
1651 }
1652 FATDirEntry::VolId(s) => {
1653 return Some(s.short_dir_entry);
1654 }
1655 FATDirEntry::UnInit => unreachable!("FATFS: FATDirEntry uninitialized."),
1656 }
1657 }
1658
1659 /// @brief 获取目录项的第一个簇的簇号
first_cluster(&self) -> Cluster1660 pub fn first_cluster(&self) -> Cluster {
1661 match self {
1662 FATDirEntry::File(f) => {
1663 return f.first_cluster;
1664 }
1665 FATDirEntry::Dir(d) => {
1666 return d.first_cluster;
1667 }
1668 FATDirEntry::VolId(s) => {
1669 return s.first_cluster;
1670 }
1671 FATDirEntry::UnInit => unreachable!("FATFS: FATDirEntry uninitialized."),
1672 }
1673 }
1674
1675 /// @brief 获取当前目录项所占用的簇的范围
1676 ///
1677 /// @return (起始簇，簇内偏移量), (终止簇，簇内偏移量)
get_dir_range(&self) -> Option<((Cluster, u64), (Cluster, u64))>1678 pub fn get_dir_range(&self) -> Option<((Cluster, u64), (Cluster, u64))> {
1679 match self {
1680 FATDirEntry::File(f) => Some(f.loc),
1681 FATDirEntry::Dir(d) => d.loc,
1682 FATDirEntry::VolId(s) => Some(s.loc),
1683 FATDirEntry::UnInit => unreachable!("FATFS: FATDirEntry uninitialized."),
1684 }
1685 }
1686
1687 /// @brief 获取原始的短目录项名（FAT标准规定的）
short_name_raw(&self) -> [u8; 11]1688 pub fn short_name_raw(&self) -> [u8; 11] {
1689 match self {
1690 FATDirEntry::File(f) => {
1691 return f.short_dir_entry.name;
1692 }
1693 FATDirEntry::Dir(d) => match d.short_dir_entry {
1694 // 存在短目录项，直接返回
1695 Some(s) => {
1696 return s.name;
1697 }
1698 // 是根目录项
1699 None => {
1700 let mut s = [0x20u8; 11];
1701 s[0] = '/' as u8;
1702 return s;
1703 }
1704 },
1705 FATDirEntry::VolId(s) => {
1706 return s.short_dir_entry.name;
1707 }
1708
1709 FATDirEntry::UnInit => unreachable!("FATFS: FATDirEntry uninitialized."),
1710 }
1711 }
1712
1713 /// @brief 获取目录项的名字
name(&self) -> String1714 pub fn name(&self) -> String {
1715 match self {
1716 FATDirEntry::File(f) => {
1717 return f.file_name.clone();
1718 }
1719 FATDirEntry::VolId(s) => {
1720 return s.file_name.clone();
1721 }
1722 FATDirEntry::Dir(d) => {
1723 return d.dir_name.clone();
1724 }
1725 FATDirEntry::UnInit => unreachable!("FATFS: FATDirEntry uninitialized."),
1726 }
1727 }
1728
1729 /// @brief 判断目录项是否为文件
is_file(&self) -> bool1730 pub fn is_file(&self) -> bool {
1731 match self {
1732 &FATDirEntry::File(_) | &FATDirEntry::VolId(_) => true,
1733 _ => false,
1734 }
1735 }
1736
1737 /// @brief 判断目录项是否为文件夹
is_dir(&self) -> bool1738 pub fn is_dir(&self) -> bool {
1739 match &self {
1740 &FATDirEntry::Dir(_) => true,
1741 _ => false,
1742 }
1743 }
1744
1745 /// @brief 判断目录项是否为Volume id
is_vol_id(&self) -> bool1746 pub fn is_vol_id(&self) -> bool {
1747 match self {
1748 &FATDirEntry::VolId(_) => true,
1749 _ => false,
1750 }
1751 }
1752
1753 /// @brief 判断FAT目录项的名字与给定的是否相等
1754 ///
1755 /// 由于FAT32对大小写不敏感，因此将字符都转为大写，然后比较
1756 ///
1757 /// @return bool 相等 => true
1758 /// 不相等 => false
eq_name(&self, name: &str) -> bool1759 pub fn eq_name(&self, name: &str) -> bool {
1760 // 由于FAT32对大小写不敏感，因此将字符都转为大写，然后比较。
1761 let binding = self.short_name();
1762 let short_name = binding.chars().flat_map(|c| c.to_uppercase());
1763 let binding = self.name();
1764 let long_name = binding.chars().flat_map(|c| c.to_uppercase());
1765 let name = name.chars().flat_map(|c| c.to_uppercase());
1766
1767 let long_name_matches: bool = long_name.eq(name.clone());
1768 let short_name_matches: bool = short_name.eq(name);
1769
1770 return long_name_matches || short_name_matches;
1771 }
1772
1773 /// @brief 将FATDirEntry转换为FATFile对象
to_file(&self) -> Result<FATFile, SystemError>1774 pub fn to_file(&self) -> Result<FATFile, SystemError> {
1775 if self.is_file() == false {
1776 return Err(SystemError::EISDIR);
1777 }
1778
1779 match &self {
1780 FATDirEntry::File(f) | FATDirEntry::VolId(f) => {
1781 return Ok(f.clone());
1782 }
1783 _ => unreachable!(),
1784 }
1785 }
1786
1787 /// @brief 将FATDirEntry转换为FATDir对象
to_dir(&self) -> Result<FATDir, SystemError>1788 pub fn to_dir(&self) -> Result<FATDir, SystemError> {
1789 if self.is_dir() == false {
1790 return Err(SystemError::ENOTDIR);
1791 }
1792 match &self {
1793 FATDirEntry::Dir(d) => {
1794 return Ok(d.clone());
1795 }
1796 _ => unreachable!(),
1797 }
1798 }
1799 }
1800
1801 /// 用于生成短目录项文件名的生成器。
1802 #[derive(Debug, Default)]
1803 pub struct ShortNameGenerator {
1804 /// 短目录项的名字
1805 name: [u8; 11],
1806 /// 生成器的标志位（使用impl里面的mask来解析）
1807 flags: u8,
1808 /// 基础名的长度
1809 basename_len: u8,
1810 /// 对于文件名形如(TE021F~1.TXT)的，短前缀+校验码的短目录项，该字段表示基础名末尾数字的对应位。
1811 checksum_bitmask: u16,
1812 /// Fletcher-16 Checksum(与填写到ShortDirEntry里面的不一样)
1813 checksum: u16,
1814 /// 对于形如(TEXTFI~1.TXT)的短目录项名称，其中的数字的bitmask（第0位置位则表示这个数字是0）
1815 suffix_bitmask: u16,
1816 }
1817
1818 impl ShortNameGenerator {
1819 /// 短目录项的名称的长度
1820 const SHORT_NAME_LEN: usize = 8;
1821
1822 // ===== flags标志位的含义 =====
1823 const IS_LOSSY: u8 = (1 << 0);
1824 const IS_EXACT_MATCH: u8 = (1 << 1);
1825 const IS_DOT: u8 = (1 << 2);
1826 const IS_DOTDOT: u8 = (1 << 3);
1827 /// 名称被完全拷贝
1828 const NAME_FITS: u8 = (1 << 4);
1829
1830 /// @brief 初始化一个短目录项名称生成器
new(mut name: &str) -> Self1831 pub fn new(mut name: &str) -> Self {
1832 name = name.trim();
1833
1834 let mut short_name: [u8; 11] = [0x20u8; 11];
1835 if name == "." {
1836 short_name[0] = '.' as u8;
1837 }
1838
1839 if name == ".." {
1840 short_name[0] = '.' as u8;
1841 short_name[1] = '.' as u8;
1842 }
1843
1844 // @name_fits: 名称是否被完全拷贝
1845 // @basename_len: 基础名的长度
1846 // @is_lossy: 是否存在不合法的字符
1847 let (name_fits, basename_len, is_lossy) = match name.rfind('.') {
1848 Some(index) => {
1849 // 文件名里面有".", 且index为最右边的点号所在的下标（bytes index)
1850 // 拷贝基础名
1851 let (b_len, fits, b_lossy) =
1852 Self::copy_part(&mut short_name[..Self::SHORT_NAME_LEN], &name[..index]);
1853
1854 // 拷贝扩展名
1855 let (_, ext_fits, ext_lossy) = Self::copy_part(
1856 &mut short_name[Self::SHORT_NAME_LEN..Self::SHORT_NAME_LEN + 3],
1857 &name[index + 1..],
1858 );
1859
1860 (fits && ext_fits, b_len, b_lossy || ext_lossy)
1861 }
1862 None => {
1863 // 文件名中，不存在"."
1864 let (b_len, fits, b_lossy) =
1865 Self::copy_part(&mut short_name[..Self::SHORT_NAME_LEN], &name);
1866 (fits, b_len, b_lossy)
1867 }
1868 };
1869
1870 let mut flags: u8 = 0;
1871 // 设置flags
1872 if is_lossy {
1873 flags |= Self::IS_LOSSY;
1874 }
1875 if name == "." {
1876 flags |= Self::IS_DOT;
1877 }
1878 if name == ".." {
1879 flags |= Self::IS_DOTDOT;
1880 }
1881
1882 if name_fits {
1883 flags |= Self::NAME_FITS;
1884 }
1885
1886 return ShortNameGenerator {
1887 name: short_name,
1888 flags: flags,
1889 basename_len: basename_len,
1890 checksum: Self::fletcher_16_checksum(name),
1891 ..Default::default()
1892 };
1893 }
1894
1895 /// @brief 拷贝字符串到一个u8数组
1896 ///
1897 /// @return (u8, bool, bool)
1898 /// return.0: 拷贝了的字符串的长度
1899 /// return.1: 是否完全拷贝完整个字符串
1900 /// return.2: 拷贝过程中，是否出现了不合法字符
copy_part(dest: &mut [u8], src: &str) -> (u8, bool, bool)1901 fn copy_part(dest: &mut [u8], src: &str) -> (u8, bool, bool) {
1902 let mut dest_len: usize = 0;
1903 let mut lossy_conv = false;
1904
1905 for c in src.chars() {
1906 // 如果src还有字符，而dest已经满了，那么表示没有完全拷贝完。
1907 if dest_len == dest.len() {
1908 return (dest_len as u8, false, lossy_conv);
1909 }
1910
1911 if c == ' ' || c == '.' {
1912 lossy_conv = true;
1913 continue;
1914 }
1915
1916 let cp: char = match c {
1917 'a'..='z' | 'A'..='Z' | '0'..='9' => c,
1918 '$' | '%' | '\'' | '-' | '_' | '@' | '~' | '`' | '!' | '(' | ')' | '{' | '}'
1919 | '^' | '#' | '&' => c,
1920 _ => '_',
1921 };
1922
1923 // 判断是否存在不符合条件的字符
1924 lossy_conv = lossy_conv || c != cp;
1925
1926 // 拷贝字符
1927 dest[dest_len] = c.to_ascii_uppercase() as u8;
1928 dest_len += 1;
1929 }
1930
1931 // 返回结果
1932 return (dest_len as u8, true, lossy_conv);
1933 }
1934
fletcher_16_checksum(name: &str) -> u161935 fn fletcher_16_checksum(name: &str) -> u16 {
1936 let mut sum1: u16 = 0;
1937 let mut sum2: u16 = 0;
1938 for c in name.chars() {
1939 sum1 = (sum1 + (c as u16)) % 0xff;
1940 sum2 = (sum1 + sum2) & 0xff;
1941 }
1942 return (sum2 << 8) | sum1;
1943 }
1944
1945 /// @brief 更新生成器的状态
1946 /// 当长目录项不存在的时候，需要调用这个函数来更新生成器的状态
add_name(&mut self, name: &[u8; 11])1947 pub fn add_name(&mut self, name: &[u8; 11]) {
1948 // === 判断名称是否严格的完全匹配
1949 if name == &self.name {
1950 self.flags |= Self::IS_EXACT_MATCH;
1951 }
1952
1953 // === 检查是否存在长前缀的格式冲突。对于这样的短目录项名称：(TEXTFI~1.TXT)
1954 // 获取名称前缀
1955 let prefix_len = min(self.basename_len, 6) as usize;
1956 // 获取后缀的那个数字
1957 let num_suffix: Option<u32> = if name[prefix_len] as char == '~' {
1958 (name[prefix_len + 1] as char).to_digit(10)
1959 } else {
1960 None
1961 };
1962
1963 // 判断扩展名是否匹配
1964 let ext_matches: bool = name[8..] == self.name[8..];
1965
1966 if name[..prefix_len] == self.name[..prefix_len] // 基础名前缀相同
1967 && num_suffix.is_some() // 基础名具有数字后缀
1968 && ext_matches
1969 // 扩展名相匹配
1970 {
1971 let num = num_suffix.unwrap();
1972 self.suffix_bitmask |= 1 << num;
1973 }
1974
1975 // === 检查是否存在短前缀+校验和的冲突，文件名形如：(TE021F~1.TXT)
1976 let prefix_len = min(self.basename_len, 2) as usize;
1977 let num_suffix: Option<u32> = if name[prefix_len + 4] as char == '~' {
1978 (name[prefix_len + 1] as char).to_digit(10)
1979 } else {
1980 None
1981 };
1982
1983 if name[..prefix_len] == self.name[..prefix_len] && num_suffix.is_some() && ext_matches {
1984 // 获取短文件名中的校验码字段
1985 let checksum_result: Result<
1986 Result<u16, core::num::ParseIntError>,
1987 core::str::Utf8Error,
1988 > = core::str::from_utf8(&name[prefix_len..prefix_len + 4])
1989 .map(|s| u16::from_str_radix(s, 16));
1990 // 如果校验码相同
1991 if checksum_result == Ok(Ok(self.checksum)) {
1992 let num = num_suffix.unwrap();
1993 // 置位checksum_bitmask中，基础名末尾数字的对应位
1994 self.checksum_bitmask |= 1 << num;
1995 }
1996 }
1997 }
1998
generate(&self) -> Result<[u8; 11], SystemError>1999 pub fn generate(&self) -> Result<[u8; 11], SystemError> {
2000 if self.is_dot() || self.is_dotdot() {
2001 return Ok(self.name);
2002 }
2003
2004 // 如果当前名字不存在不合法的字符，且名称被完整拷贝，但是exact match为false，可以认为名称没有冲突，直接返回
2005 if !self.is_lossy() && self.name_fits() && !self.is_exact_match() {
2006 return Ok(self.name);
2007 }
2008
2009 // 尝试使用长前缀（6字符）
2010 for i in 1..5 {
2011 if self.suffix_bitmask & (1 << i) == 0 {
2012 return Ok(self.build_prefixed_name(i as u32, false));
2013 }
2014 }
2015
2016 // 尝试使用短前缀+校验码
2017 for i in 1..10 {
2018 if self.checksum_bitmask & (1 << i) == 0 {
2019 return Ok(self.build_prefixed_name(i as u32, true));
2020 }
2021 }
2022 // 由于产生太多的冲突，因此返回错误（“短文件名已经存在”）
2023 return Err(SystemError::EEXIST);
2024 }
2025
next_iteration(&mut self)2026 pub fn next_iteration(&mut self) {
2027 // 在下一次迭代中，尝试一个不同的校验和
2028 self.checksum = (core::num::Wrapping(self.checksum) + core::num::Wrapping(1)).0;
2029 // 清空bitmask
2030 self.suffix_bitmask = 0;
2031 self.checksum_bitmask = 0;
2032 }
2033
2034 /// @brief 构造具有前缀的短目录项名称
2035 ///
2036 /// @param num 这是第几个重名的前缀名
2037 /// @param with_checksum 前缀名中是否包含校验码
2038 ///
2039 /// @return 构造好的短目录项名称数组
build_prefixed_name(&self, num: u32, with_checksum: bool) -> [u8; 11]2040 fn build_prefixed_name(&self, num: u32, with_checksum: bool) -> [u8; 11] {
2041 let mut buf: [u8; 11] = [0x20u8; 11];
2042 let prefix_len: usize = if with_checksum {
2043 let prefix_len: usize = min(self.basename_len as usize, 2);
2044 buf[..prefix_len].copy_from_slice(&self.name[..prefix_len]);
2045 buf[prefix_len..prefix_len + 4].copy_from_slice(&Self::u16_to_u8_array(self.checksum));
2046 prefix_len + 4
2047 } else {
2048 let prefix_len = min(self.basename_len as usize, 6);
2049 buf[..prefix_len].copy_from_slice(&self.name[..prefix_len]);
2050 prefix_len
2051 };
2052
2053 buf[prefix_len] = '~' as u8;
2054 buf[prefix_len + 1] = char::from_digit(num, 10).unwrap() as u8;
2055 buf[8..].copy_from_slice(&self.name[8..]);
2056 return buf;
2057 }
2058
2059 /// @brief 将一个u16数字转换为十六进制大写字符串对应的ascii数组。
2060 /// 举例：将x=12345转换为16进制字符串“3039”对应的ascii码数组：[51,48,51,57]
u16_to_u8_array(x: u16) -> [u8; 4]2061 fn u16_to_u8_array(x: u16) -> [u8; 4] {
2062 let c1 = char::from_digit((x as u32 >> 12) & 0xf, 16)
2063 .unwrap()
2064 .to_ascii_uppercase() as u8;
2065 let c2 = char::from_digit((x as u32 >> 8) & 0xf, 16)
2066 .unwrap()
2067 .to_ascii_uppercase() as u8;
2068 let c3 = char::from_digit((x as u32 >> 4) & 0xf, 16)
2069 .unwrap()
2070 .to_ascii_uppercase() as u8;
2071 let c4 = char::from_digit((x as u32 >> 0) & 0xf, 16)
2072 .unwrap()
2073 .to_ascii_uppercase() as u8;
2074 return [c1, c2, c3, c4];
2075 }
2076
2077 #[inline]
is_lossy(&self) -> bool2078 fn is_lossy(&self) -> bool {
2079 return (self.flags & Self::IS_LOSSY) > 0;
2080 }
2081
2082 #[inline]
is_exact_match(&self) -> bool2083 fn is_exact_match(&self) -> bool {
2084 return (self.flags & Self::IS_EXACT_MATCH) > 0;
2085 }
2086
2087 #[inline]
is_dot(&self) -> bool2088 fn is_dot(&self) -> bool {
2089 return (self.flags & Self::IS_DOT) > 0;
2090 }
2091
2092 #[inline]
is_dotdot(&self) -> bool2093 fn is_dotdot(&self) -> bool {
2094 return (self.flags & Self::IS_DOTDOT) > 0;
2095 }
2096
2097 #[inline]
name_fits(&self) -> bool2098 fn name_fits(&self) -> bool {
2099 return (self.flags & Self::NAME_FITS) > 0;
2100 }
2101 }
2102
2103 /// 从多个LongName中提取完整文件名字段的提取器
2104 struct LongNameExtractor {
2105 name: Vec<u16>,
2106 checksum: u8,
2107 index: u8,
2108 }
2109
2110 impl LongNameExtractor {
new() -> Self2111 fn new() -> Self {
2112 return LongNameExtractor {
2113 name: Vec::new(),
2114 checksum: 0,
2115 index: 0,
2116 };
2117 }
2118
2119 /// @brief 提取长目录项的名称
2120 /// @param longname_dentry 长目录项
2121 /// 请注意，必须倒序输入长目录项对象
process(&mut self, longname_dentry: LongDirEntry) -> Result<(), SystemError>2122 fn process(&mut self, longname_dentry: LongDirEntry) -> Result<(), SystemError> {
2123 let is_last: bool = longname_dentry.is_last();
2124 let index: u8 = longname_dentry.ord & 0x1f;
2125
2126 if index == 0 {
2127 self.name.clear();
2128 return Err(SystemError::EROFS);
2129 }
2130
2131 // 如果是最后一个LongDirEntry，则初始化当前生成器
2132 if is_last {
2133 self.index = index;
2134 self.checksum = longname_dentry.checksum;
2135 self.name
2136 .resize(index as usize * LongDirEntry::LONG_NAME_STR_LEN, 0);
2137 } else if self.index == 0
2138 || index != self.index - 1
2139 || self.checksum != longname_dentry.checksum
2140 {
2141 // 如果当前index为0,或者index不连续，或者是校验和不同，那么认为文件系统损坏，清除生成器的名称字段
2142 // TODO: 对文件系统的变为只读状态状况的拦截
2143 self.name.clear();
2144 return Err(SystemError::EROFS);
2145 } else {
2146 // 由于dentry倒序输入，因此index是每次减1的
2147 self.index -= 1;
2148 }
2149
2150 let pos: usize = ((index - 1) as usize) * LongDirEntry::LONG_NAME_STR_LEN;
2151 // 将当前目录项的值，拷贝到生成器的数组中
2152 longname_dentry
2153 .copy_name_to_slice(&mut self.name[pos..pos + LongDirEntry::LONG_NAME_STR_LEN])?;
2154 return Ok(());
2155 }
2156
2157 /// @brief 返回名称的长度
2158 #[inline]
len(&self) -> usize2159 fn len(&self) -> usize {
2160 return self.name.len();
2161 }
2162
2163 /// @brief 返回抽取得到的名称字符串
to_string(&self) -> String2164 fn to_string(&self) -> String {
2165 let mut s = String::from_utf16_lossy(self.name.as_slice());
2166 // 计算字符串的长度。如果字符串中有\0，那么就截取字符串的前面部分
2167 if let Some(len) = s.find('\u{0}') {
2168 s.truncate(len);
2169 }
2170 return s;
2171 }
2172
2173 /// @brief 判断校验码是否与指定的短目录项的校验码相同
2174 ///
2175 /// @return bool 相同 => true
2176 /// 不同 => false
validate_checksum(&self, short_dentry: &ShortDirEntry) -> bool2177 fn validate_checksum(&self, short_dentry: &ShortDirEntry) -> bool {
2178 return self.checksum == short_dentry.checksum();
2179 }
2180 }
2181
2182 /// @brief 长目录项生成器
2183 #[derive(Debug)]
2184 struct LongNameEntryGenerator {
2185 name: Vec<u16>,
2186 // 短目录项的校验和
2187 checksum: u8,
2188 // 当前迭代器的索引
2189 idx: u8,
2190 /// 最后一个目录项的索引
2191 last_index: u8,
2192 }
2193
2194 impl LongNameEntryGenerator {
2195 /// @brief 初始化长目录项生成器
2196 ///
2197 /// @param name 长文件名数组
2198 /// @param checksum 短目录项的校验和
new(name: &str, checksum: u8) -> Self2199 pub fn new(name: &str, checksum: u8) -> Self {
2200 let mut name: Vec<u16> = name.chars().map(|c| c as u16).collect();
2201
2202 let padding_bytes: usize = (13 - (name.len() % 13)) % 13;
2203 // 填充最后一个长目录项的文件名
2204 for i in 0..padding_bytes {
2205 if i == 0 {
2206 name.push(0);
2207 } else {
2208 name.push(0xffff);
2209 }
2210 }
2211
2212 // 先从最后一个长目录项开始生成
2213 let start_index = (name.len() / 13) as u8;
2214 return LongNameEntryGenerator {
2215 name: name,
2216 checksum: checksum,
2217 idx: start_index,
2218 last_index: start_index,
2219 };
2220 }
2221
2222 /// @brief 返回要生成的长目录项的总数
num_entries(&self) -> u82223 pub fn num_entries(&self) -> u8 {
2224 return self.last_index + 1;
2225 }
2226 }
2227
2228 impl Iterator for LongNameEntryGenerator {
2229 type Item = LongDirEntry;
2230
next(&mut self) -> Option<Self::Item>2231 fn next(&mut self) -> Option<Self::Item> {
2232 match self.idx {
2233 0 => {
2234 return None;
2235 }
2236 // 最后一个长目录项
2237 n if n == self.last_index => {
2238 // 最后一个长目录项的ord需要与0x40相或
2239 let ord: u8 = n | 0x40;
2240 let start_idx = ((n - 1) * 13) as usize;
2241 self.idx -= 1;
2242 return Some(LongDirEntry::new(
2243 ord,
2244 &self.name.as_slice()[start_idx..start_idx + 13],
2245 self.checksum,
2246 ));
2247 }
2248 n => {
2249 // 其它的长目录项
2250 let start_idx = ((n - 1) * 13) as usize;
2251 self.idx -= 1;
2252 return Some(LongDirEntry::new(
2253 n,
2254 &self.name.as_slice()[start_idx..start_idx + 13],
2255 self.checksum,
2256 ));
2257 }
2258 }
2259 }
2260 }
2261
2262 #[derive(Debug)]
2263 pub enum FATDirEntryOrShortName {
2264 DirEntry(FATDirEntry),
2265 ShortName([u8; 11]),
2266 }
2267
2268 /// @brief 对FAT目录项的迭代器(基于簇和簇内偏移量)
2269 #[derive(Debug)]
2270 struct FATDirEntryOffsetIter {
2271 /// 当前迭代的偏移量(下一次迭代要返回的值)
2272 current_offset: (Cluster, u64),
2273 /// 截止迭代的位置（end_offset所在的位置也会被迭代器返回)
2274 end_offset: Option<(Cluster, u64)>,
2275 /// 属于的文件系统
2276 fs: Arc<FATFileSystem>,
2277 /// 当前已经迭代了多少次
2278 index: u64,
2279 /// 总共要迭代多少次
2280 len: u64,
2281 /// 如果end_offset不为None，该字段表示“是否已经到达了迭代终点”
2282 fin: bool,
2283 }
2284
2285 impl FATDirEntryOffsetIter {
2286 /// @brief 初始化FAT目录项的迭代器(基于簇和簇内偏移量)
2287 ///
2288 /// @param fs 属于的文件系统
2289 /// @param start 起始偏移量
2290 /// @param len 要迭代的次数
2291 /// @param end_offset 截止迭代的位置（end_offset所在的位置也会被迭代器返回)
2292 ///
2293 /// @return 构建好的迭代器对象
new( fs: Arc<FATFileSystem>, start: (Cluster, u64), len: u64, end_offset: Option<(Cluster, u64)>, ) -> Self2294 pub fn new(
2295 fs: Arc<FATFileSystem>,
2296 start: (Cluster, u64),
2297 len: u64,
2298 end_offset: Option<(Cluster, u64)>,
2299 ) -> Self {
2300 return FATDirEntryOffsetIter {
2301 current_offset: start,
2302 end_offset,
2303 fs,
2304 index: 0,
2305 len,
2306 fin: false,
2307 };
2308 }
2309 }
2310
2311 impl Iterator for FATDirEntryOffsetIter {
2312 type Item = (Cluster, u64);
2313
next(&mut self) -> Option<Self::Item>2314 fn next(&mut self) -> Option<Self::Item> {
2315 if self.index == self.len || self.fin {
2316 return None;
2317 }
2318
2319 let r: (Cluster, u64) = self.current_offset;
2320 // 计算新的字节偏移量
2321 let mut new_offset = r.1 + FATRawDirEntry::DIR_ENTRY_LEN;
2322 let mut new_cluster: Cluster = r.0;
2323 // 越过了当前簇,则获取下一个簇
2324 if new_offset >= self.fs.bytes_per_cluster() {
2325 new_offset %= self.fs.bytes_per_cluster();
2326
2327 match self.fs.get_fat_entry(new_cluster) {
2328 Ok(FATEntry::Next(c)) => {
2329 new_cluster = c;
2330 }
2331 // 没有下一个簇了
2332 _ => {
2333 self.fin = true;
2334 }
2335 }
2336 }
2337
2338 if let Some(off) = self.end_offset {
2339 // 判断当前簇是否是要求停止搜索的最后一个位置
2340 self.fin = off == self.current_offset;
2341 }
2342 // 更新当前迭代的偏移量
2343 self.current_offset = (new_cluster, new_offset);
2344 self.index += 1;
2345
2346 return Some(r);
2347 }
2348 }
2349
2350 /// @brief 根据磁盘内字节偏移量，读取磁盘，并生成一个FATRawDirEntry对象
get_raw_dir_entry( fs: &Arc<FATFileSystem>, in_disk_bytes_offset: u64, ) -> Result<FATRawDirEntry, SystemError>2351 pub fn get_raw_dir_entry(
2352 fs: &Arc<FATFileSystem>,
2353 in_disk_bytes_offset: u64,
2354 ) -> Result<FATRawDirEntry, SystemError> {
2355 // 块内偏移量
2356 let blk_offset: u64 = fs.get_in_block_offset(in_disk_bytes_offset);
2357 let lba = fs.get_lba_from_offset(
2358 fs.bytes_to_sector(fs.get_in_partition_bytes_offset(in_disk_bytes_offset)),
2359 );
2360
2361 // let step1 = fs.get_in_partition_bytes_offset(in_disk_bytes_offset);
2362 // let step2 = fs.bytes_to_sector(step1);
2363 // let lba = fs.get_lba_from_offset(step2);
2364 // kdebug!("step1={step1}, step2={step2}, lba={lba}");
2365 let mut v: Vec<u8> = Vec::new();
2366 v.resize(1 * LBA_SIZE, 0);
2367
2368 fs.partition.disk().read_at(lba, 1, &mut v)?;
2369
2370 let mut cursor: VecCursor = VecCursor::new(v);
2371 // 切换游标到对应位置
2372 cursor.seek(SeekFrom::SeekSet(blk_offset as i64))?;
2373
2374 let dir_0 = cursor.read_u8()?;
2375
2376 match dir_0 {
2377 0x00 => {
2378 return Ok(FATRawDirEntry::FreeRest);
2379 }
2380 0xe5 => {
2381 return Ok(FATRawDirEntry::Free);
2382 }
2383 _ => {
2384 cursor.seek(SeekFrom::SeekCurrent(10))?;
2385 let file_attr: FileAttributes = FileAttributes::new(cursor.read_u8()?);
2386
2387 // 指针回到目录项的开始处
2388 cursor.seek(SeekFrom::SeekSet(blk_offset as i64))?;
2389
2390 if file_attr.contains(FileAttributes::LONG_NAME) {
2391 // 当前目录项是一个长目录项
2392 let mut long_dentry = LongDirEntry::default();
2393
2394 long_dentry.ord = cursor.read_u8()?;
2395 cursor.read_u16_into(&mut long_dentry.name1)?;
2396 long_dentry.file_attrs = FileAttributes::new(cursor.read_u8()?);
2397 long_dentry.dirent_type = cursor.read_u8()?;
2398 long_dentry.checksum = cursor.read_u8()?;
2399
2400 cursor.read_u16_into(&mut long_dentry.name2)?;
2401 long_dentry.first_clus_low = cursor.read_u16()?;
2402 cursor.read_u16_into(&mut long_dentry.name3)?;
2403
2404 return Ok(FATRawDirEntry::Long(long_dentry));
2405 } else {
2406 // 当前目录项是一个短目录项
2407 let mut short_dentry = ShortDirEntry::default();
2408 cursor.read_exact(&mut short_dentry.name)?;
2409
2410 short_dentry.attributes = FileAttributes::new(cursor.read_u8()?);
2411
2412 short_dentry.nt_res = cursor.read_u8()?;
2413 short_dentry.crt_time_tenth = cursor.read_u8()?;
2414 short_dentry.crt_time = cursor.read_u16()?;
2415 short_dentry.crt_date = cursor.read_u16()?;
2416 short_dentry.lst_acc_date = cursor.read_u16()?;
2417 short_dentry.fst_clus_hi = cursor.read_u16()?;
2418 short_dentry.wrt_time = cursor.read_u16()?;
2419 short_dentry.wrt_date = cursor.read_u16()?;
2420 short_dentry.fst_clus_lo = cursor.read_u16()?;
2421 short_dentry.file_size = cursor.read_u32()?;
2422
2423 return Ok(FATRawDirEntry::Short(short_dentry));
2424 }
2425 }
2426 }
2427 }
2428