fat_ent.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415
  1. #include "fat_ent.h"
  2. #include <driver/disk/ahci/ahci.h>
  3. #include <common/errno.h>
  4. #include <mm/slab.h>
  5. static const char unavailable_character_in_short_name[] = {0x22, 0x2a, 0x2b, 0x2c, 0x2e, 0x2f, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x5b, 0x5c, 0x5d, 0x7c};
  6. /**
  7. * @brief 请求分配指定数量的簇
  8. *
  9. * @param inode 要分配簇的inode
  10. * @param clusters 返回的被分配的簇的簇号结构体
  11. * @param num_clusters 要分配的簇的数量
  12. * @return int 错误码
  13. */
  14. int fat32_alloc_clusters(struct vfs_index_node_t *inode, uint32_t *clusters, int32_t num_clusters)
  15. {
  16. int retval = 0;
  17. fat32_sb_info_t *fsbi = (fat32_sb_info_t *)inode->sb->private_sb_info;
  18. struct fat32_inode_info_t *finode = (struct fat32_inode_info_t *)inode->private_inode_info;
  19. struct block_device *blk = inode->sb->blk_device;
  20. uint64_t sec_per_fat = fsbi->sec_per_FAT;
  21. // todo: 对alloc的过程加锁
  22. // 申请1扇区的缓冲区
  23. uint32_t *buf = (uint32_t *)kmalloc(fsbi->bytes_per_sec, 0);
  24. int ent_per_sec = (fsbi->bytes_per_sec >> 2);
  25. int clus_idx = 0;
  26. for (int i = 0; i < sec_per_fat; ++i)
  27. {
  28. if (clus_idx >= num_clusters)
  29. goto done;
  30. memset(buf, 0, fsbi->bytes_per_sec);
  31. blk->bd_disk->fops->transfer(blk->bd_disk, AHCI_CMD_READ_DMA_EXT, fsbi->FAT1_base_sector + i, 1, (uint64_t)buf);
  32. // 依次检查簇是否空闲
  33. for (int j = 0; j < ent_per_sec; ++j)
  34. {
  35. if (clus_idx >= num_clusters)
  36. goto done;
  37. // 找到空闲簇
  38. if ((buf[j] & 0x0fffffff) == 0)
  39. {
  40. // kdebug("clus[%d] = %d", clus_idx, i * ent_per_sec + j);
  41. clusters[clus_idx] = i * ent_per_sec + j;
  42. ++clus_idx;
  43. }
  44. }
  45. }
  46. // 空间不足
  47. retval = -ENOSPC;
  48. done:;
  49. kfree(buf);
  50. if (retval == 0) // 成功
  51. {
  52. int cluster, idx;
  53. if (finode->first_clus == 0)
  54. {
  55. // 空文件
  56. finode->first_clus = clusters[0];
  57. cluster = finode->first_clus;
  58. // 写入inode到磁盘
  59. inode->sb->sb_ops->write_inode(inode);
  60. idx = 1;
  61. }
  62. else
  63. {
  64. // todo: 跳转到文件当前的最后一个簇
  65. idx = 0;
  66. int tmp_clus = finode->first_clus;
  67. cluster = tmp_clus;
  68. while (true)
  69. {
  70. tmp_clus = fat32_read_FAT_entry(blk, fsbi, cluster);
  71. if (tmp_clus <= 0x0ffffff7)
  72. cluster = tmp_clus;
  73. else
  74. break;
  75. }
  76. }
  77. // 写入fat表
  78. for (int i = idx; i < num_clusters; ++i)
  79. {
  80. // kdebug("write cluster i=%d : cluster=%d, value= %d", i, cluster, clusters[i]);
  81. fat32_write_FAT_entry(blk, fsbi, cluster, clusters[i]);
  82. cluster = clusters[i];
  83. }
  84. fat32_write_FAT_entry(blk, fsbi, cluster, 0x0ffffff8);
  85. return 0;
  86. }
  87. else // 出现错误
  88. {
  89. kwarn("err in alloc clusters");
  90. if (clus_idx < num_clusters)
  91. fat32_free_clusters(inode, clusters[0]);
  92. return retval;
  93. }
  94. return 0;
  95. }
  96. /**
  97. * @brief 释放从属于inode的,从cluster开始的所有簇
  98. *
  99. * @param inode 指定的文件的inode
  100. * @param cluster 指定簇
  101. * @return int 错误码
  102. */
  103. int fat32_free_clusters(struct vfs_index_node_t *inode, int32_t cluster)
  104. {
  105. // todo: 释放簇
  106. return 0;
  107. }
  108. /**
  109. * @brief 读取指定簇的FAT表项
  110. *
  111. * @param blk 块设备结构体
  112. * @param fsbi fat32超级块私有信息结构体
  113. * @param cluster 指定簇
  114. * @return uint32_t 下一个簇的簇号
  115. */
  116. uint32_t fat32_read_FAT_entry(struct block_device *blk, fat32_sb_info_t *fsbi, uint32_t cluster)
  117. {
  118. // 计算每个扇区内含有的FAT表项数
  119. // FAT每项4bytes
  120. uint32_t fat_ent_per_sec = (fsbi->bytes_per_sec >> 2); // 该值应为2的n次幂
  121. uint32_t buf[256];
  122. memset(buf, 0, fsbi->bytes_per_sec);
  123. // 读取一个sector的数据,
  124. blk->bd_disk->fops->transfer(blk->bd_disk, AHCI_CMD_READ_DMA_EXT, fsbi->FAT1_base_sector + (cluster / fat_ent_per_sec), 1,
  125. (uint64_t)&buf);
  126. // 返回下一个fat表项的值(也就是下一个cluster)
  127. return buf[cluster & (fat_ent_per_sec - 1)] & 0x0fffffff;
  128. }
  129. /**
  130. * @brief 写入指定簇的FAT表项
  131. *
  132. * @param blk 块设备结构体
  133. * @param fsbi fat32超级块私有信息结构体
  134. * @param cluster 指定簇
  135. * @param value 要写入该fat表项的值
  136. * @return uint32_t errcode
  137. */
  138. uint32_t fat32_write_FAT_entry(struct block_device *blk, fat32_sb_info_t *fsbi, uint32_t cluster, uint32_t value)
  139. {
  140. // 计算每个扇区内含有的FAT表项数
  141. // FAT每项4bytes
  142. uint32_t fat_ent_per_sec = (fsbi->bytes_per_sec >> 2); // 该值应为2的n次幂
  143. uint32_t *buf = kzalloc(fsbi->bytes_per_sec, 0);
  144. blk->bd_disk->fops->transfer(blk->bd_disk, AHCI_CMD_READ_DMA_EXT, fsbi->FAT1_base_sector + (cluster / fat_ent_per_sec), 1,
  145. (uint64_t)buf);
  146. buf[cluster & (fat_ent_per_sec - 1)] = (buf[cluster & (fat_ent_per_sec - 1)] & 0xf0000000) | (value & 0x0fffffff);
  147. // 向FAT1和FAT2写入数据
  148. blk->bd_disk->fops->transfer(blk->bd_disk, AHCI_CMD_WRITE_DMA_EXT, fsbi->FAT1_base_sector + (cluster / fat_ent_per_sec), 1,
  149. (uint64_t)buf);
  150. blk->bd_disk->fops->transfer(blk->bd_disk, AHCI_CMD_WRITE_DMA_EXT, fsbi->FAT2_base_sector + (cluster / fat_ent_per_sec), 1,
  151. (uint64_t)buf);
  152. kfree(buf);
  153. return 0;
  154. }
  155. /**
  156. * @brief 在父亲inode的目录项簇中,寻找连续num个空的目录项
  157. *
  158. * @param parent_inode 父inode
  159. * @param num 请求的目录项数量
  160. * @param mode 操作模式
  161. * @param res_sector 返回信息:缓冲区对应的扇区号
  162. * @param res_cluster 返回信息:缓冲区对应的簇号
  163. * @param res_data_buf_base 返回信息:缓冲区的内存基地址(记得要释放缓冲区内存!!!!)
  164. * @return struct fat32_Directory_t* 符合要求的entry的指针(指向地址高处的空目录项,也就是说,有连续num个≤这个指针的空目录项)
  165. */
  166. struct fat32_Directory_t *fat32_find_empty_dentry(struct vfs_index_node_t *parent_inode, uint32_t num, uint32_t mode, uint32_t *res_sector, uint64_t *res_cluster, uint64_t *res_data_buf_base)
  167. {
  168. // kdebug("find empty_dentry");
  169. struct fat32_inode_info_t *finode = (struct fat32_inode_info_t *)parent_inode->private_inode_info;
  170. fat32_sb_info_t *fsbi = (fat32_sb_info_t *)parent_inode->sb->private_sb_info;
  171. uint8_t *buf = kzalloc(fsbi->bytes_per_clus, 0);
  172. struct block_device *blk = parent_inode->sb->blk_device;
  173. // 计算父目录项的起始簇号
  174. uint32_t cluster = finode->first_clus;
  175. struct fat32_Directory_t *tmp_dEntry = NULL;
  176. // 指向最终的有用的dentry的指针
  177. struct fat32_Directory_t *result_dEntry = NULL;
  178. while (true)
  179. {
  180. // 计算父目录项的起始LBA扇区号
  181. uint64_t sector = fsbi->first_data_sector + (cluster - 2) * fsbi->sec_per_clus;
  182. // 读取父目录项的起始簇数据
  183. blk->bd_disk->fops->transfer(blk->bd_disk, AHCI_CMD_READ_DMA_EXT, sector, fsbi->sec_per_clus, (uint64_t)buf);
  184. tmp_dEntry = (struct fat32_Directory_t *)buf;
  185. // 计数连续的空目录项
  186. uint32_t count_continuity = 0;
  187. // 查找连续num个空闲目录项
  188. for (int i = 0; (i < fsbi->bytes_per_clus) && count_continuity < num; i += 32, ++tmp_dEntry)
  189. {
  190. if (!(tmp_dEntry->DIR_Name[0] == 0xe5 || tmp_dEntry->DIR_Name[0] == 0x00))
  191. {
  192. count_continuity = 0;
  193. continue;
  194. }
  195. if (count_continuity == 0)
  196. result_dEntry = tmp_dEntry;
  197. ++count_continuity;
  198. }
  199. // 成功查找到符合要求的目录项
  200. if (count_continuity == num)
  201. {
  202. result_dEntry += (num - 1);
  203. *res_sector = sector;
  204. *res_data_buf_base = (uint64_t)buf;
  205. *res_cluster = cluster;
  206. return result_dEntry;
  207. }
  208. // 当前簇没有发现符合条件的空闲目录项,寻找下一个簇
  209. uint64_t old_cluster = cluster;
  210. cluster = fat32_read_FAT_entry(blk, fsbi, cluster);
  211. if (cluster >= 0x0ffffff7) // 寻找完父目录的所有簇,都没有找到符合要求的空目录项
  212. {
  213. // 新增一个簇
  214. if (fat32_alloc_clusters(parent_inode, &cluster, 1) != 0)
  215. {
  216. kerror("Cannot allocate a new cluster!");
  217. while (1)
  218. pause();
  219. }
  220. // 将这个新的簇清空
  221. sector = fsbi->first_data_sector + (cluster - 2) * fsbi->sec_per_clus;
  222. void *tmp_buf = kzalloc(fsbi->bytes_per_clus, 0);
  223. blk->bd_disk->fops->transfer(blk->bd_disk, AHCI_CMD_WRITE_DMA_EXT, sector, fsbi->sec_per_clus, (uint64_t)tmp_buf);
  224. kfree(tmp_buf);
  225. }
  226. }
  227. }
  228. /**
  229. * @brief 检查文件名是否合法
  230. *
  231. * @param name 文件名
  232. * @param namelen 文件名长度
  233. * @param reserved 保留字段
  234. * @return int 合法:0, 其他:错误码
  235. */
  236. int fat32_check_name_available(const char *name, int namelen, int8_t reserved)
  237. {
  238. if (namelen > 255 || namelen <= 0)
  239. return -ENAMETOOLONG;
  240. // 首个字符不能是空格或者'.'
  241. if (name[0] == 0x20 || name[0] == '.')
  242. return -EINVAL;
  243. return 0;
  244. }
  245. /**
  246. * @brief 检查字符在短目录项中是否合法
  247. *
  248. * @param c 给定字符
  249. * @param index 字符在文件名中处于第几位
  250. * @return true 合法
  251. * @return false 不合法
  252. */
  253. bool fat32_check_char_available_in_short_name(const char c, int index)
  254. {
  255. // todo: 严格按照fat规范完善合法性检查功能
  256. if (index == 0)
  257. {
  258. if (c < 0x20)
  259. {
  260. if (c != 0x05)
  261. return false;
  262. return true;
  263. }
  264. }
  265. for (int i = 0; i < sizeof(unavailable_character_in_short_name) / sizeof(char); ++i)
  266. {
  267. if (c == unavailable_character_in_short_name[i])
  268. return false;
  269. }
  270. return true;
  271. }
  272. /**
  273. * @brief 填充短目录项的函数
  274. *
  275. * @param dEntry 目标dentry
  276. * @param target 目标dentry对应的短目录项
  277. * @param cluster 短目录项对应的文件/文件夹起始簇
  278. */
  279. void fat32_fill_shortname(struct vfs_dir_entry_t *dEntry, struct fat32_Directory_t *target, uint32_t cluster)
  280. {
  281. memset(target, 0, sizeof(struct fat32_Directory_t));
  282. {
  283. int tmp_index = 0;
  284. // kdebug("dEntry->name_length=%d", dEntry->name_length);
  285. for (tmp_index = 0; tmp_index < min(8, dEntry->name_length); ++tmp_index)
  286. {
  287. if (dEntry->name[tmp_index] == '.')
  288. break;
  289. if (fat32_check_char_available_in_short_name(dEntry->name[tmp_index], tmp_index))
  290. target->DIR_Name[tmp_index] = dEntry->name[tmp_index];
  291. else
  292. target->DIR_Name[tmp_index] = 0x20;
  293. }
  294. // 不满的部分使用0x20填充
  295. while (tmp_index < 8)
  296. {
  297. // kdebug("tmp index = %d", tmp_index);
  298. target->DIR_Name[tmp_index] = 0x20;
  299. ++tmp_index;
  300. }
  301. if (dEntry->dir_inode->attribute & VFS_ATTR_DIR)
  302. {
  303. while (tmp_index < 11)
  304. {
  305. // kdebug("tmp index = %d", tmp_index);
  306. target->DIR_Name[tmp_index] = 0x20;
  307. ++tmp_index;
  308. }
  309. }
  310. else
  311. {
  312. for (int j = 8; j < 11; ++j)
  313. {
  314. target->DIR_Name[j] = 'a';
  315. }
  316. }
  317. }
  318. struct vfs_index_node_t *inode = dEntry->dir_inode;
  319. target->DIR_Attr = 0;
  320. if (inode->attribute & VFS_ATTR_DIR)
  321. target->DIR_Attr |= ATTR_DIRECTORY;
  322. target->DIR_FileSize = dEntry->dir_inode->file_size;
  323. target->DIR_FstClusHI = (uint16_t)((cluster >> 16) & 0x0fff);
  324. target->DIR_FstClusLO = (uint16_t)(cluster & 0xffff);
  325. // todo: 填写短目录项中的时间信息
  326. }
  327. /**
  328. * @brief 填充长目录项的函数
  329. *
  330. * @param dEntry 目标dentry
  331. * @param target 起始长目录项
  332. * @param checksum 短目录项的校验和
  333. * @param cnt_longname 总的长目录项的个数
  334. */
  335. void fat32_fill_longname(struct vfs_dir_entry_t *dEntry, struct fat32_LongDirectory_t *target, uint8_t checksum, uint32_t cnt_longname)
  336. {
  337. uint32_t current_name_index = 0;
  338. struct fat32_LongDirectory_t *Ldentry = (struct fat32_LongDirectory_t *)(target + 1);
  339. // kdebug("filling long name, name=%s, namelen=%d", dEntry->name, dEntry->name_length);
  340. for (int i = 1; i <= cnt_longname; ++i)
  341. {
  342. --Ldentry;
  343. Ldentry->LDIR_Ord = i;
  344. for (int j = 0; j < 5; ++j, ++current_name_index)
  345. {
  346. if (current_name_index < dEntry->name_length)
  347. Ldentry->LDIR_Name1[j] = dEntry->name[current_name_index];
  348. else
  349. Ldentry->LDIR_Name1[j] = 0xffff;
  350. }
  351. for (int j = 0; j < 6; ++j, ++current_name_index)
  352. {
  353. if (current_name_index < dEntry->name_length)
  354. Ldentry->LDIR_Name2[j] = dEntry->name[current_name_index];
  355. else
  356. Ldentry->LDIR_Name2[j] = 0xffff;
  357. }
  358. for (int j = 0; j < 2; ++j, ++current_name_index)
  359. {
  360. if (current_name_index < dEntry->name_length)
  361. Ldentry->LDIR_Name3[j] = dEntry->name[current_name_index];
  362. else
  363. Ldentry->LDIR_Name3[j] = 0xffff;
  364. }
  365. Ldentry->LDIR_Attr = ATTR_LONG_NAME;
  366. Ldentry->LDIR_FstClusLO = 0;
  367. Ldentry->LDIR_Type = 0;
  368. Ldentry->LDIR_Chksum = checksum;
  369. }
  370. // 最后一个长目录项的ord要|=0x40
  371. Ldentry->LDIR_Ord |= 0x40;
  372. }