Inode.cpp 9.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273
  1. /*
  2. * Copyright (c) 2022, Undefine <undefine@undefine.pl>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <AK/Time.h>
  7. #include <Kernel/Debug.h>
  8. #include <Kernel/FileSystem/FATFS/Inode.h>
  9. #include <Kernel/KBufferBuilder.h>
  10. namespace Kernel {
  11. ErrorOr<NonnullLockRefPtr<FATInode>> FATInode::create(FATFS& fs, FATEntry entry, Vector<FATLongFileNameEntry> const& lfn_entries)
  12. {
  13. auto filename = TRY(compute_filename(entry, lfn_entries));
  14. return adopt_nonnull_lock_ref_or_enomem(new (nothrow) FATInode(fs, entry, move(filename)));
  15. }
  16. FATInode::FATInode(FATFS& fs, FATEntry entry, NonnullOwnPtr<KString> filename)
  17. : Inode(fs, first_cluster())
  18. , m_entry(entry)
  19. , m_filename(move(filename))
  20. {
  21. dbgln_if(FAT_DEBUG, "FATFS: Creating inode {} with filename \"{}\"", index(), m_filename);
  22. m_metadata = {
  23. .inode = identifier(),
  24. .size = m_entry.file_size,
  25. .mode = static_cast<mode_t>((has_flag(m_entry.attributes, FATAttributes::Directory) ? S_IFDIR : S_IFREG) | 0777),
  26. .uid = 0,
  27. .gid = 0,
  28. .link_count = 0,
  29. .atime = fat_date_time(m_entry.last_accessed_date, { 0 }),
  30. .ctime = fat_date_time(m_entry.creation_date, m_entry.creation_time),
  31. .mtime = fat_date_time(m_entry.modification_date, m_entry.modification_time),
  32. .dtime = 0,
  33. .block_count = 0,
  34. .block_size = 0,
  35. .major_device = 0,
  36. .minor_device = 0,
  37. };
  38. }
  39. ErrorOr<Vector<BlockBasedFileSystem::BlockIndex>> FATInode::compute_block_list()
  40. {
  41. VERIFY(m_inode_lock.is_locked());
  42. dbgln_if(FAT_DEBUG, "FATFS: computing block list for inode {}", index());
  43. u32 cluster = first_cluster();
  44. Vector<BlockBasedFileSystem::BlockIndex> block_list;
  45. auto fat_sector = TRY(KBuffer::try_create_with_size("FATFS: FAT read buffer"sv, fs().m_logical_block_size));
  46. auto fat_sector_buffer = UserOrKernelBuffer::for_kernel_buffer(fat_sector->data());
  47. while (cluster < no_more_clusters) {
  48. dbgln_if(FAT_DEBUG, "FATFS: Appending cluster {} to inode {}'s cluster chain", cluster, index());
  49. BlockBasedFileSystem::BlockIndex first_block = fs().first_block_of_cluster(cluster);
  50. for (u8 i = 0; i < fs().boot_record()->sectors_per_cluster; i++)
  51. block_list.append(BlockBasedFileSystem::BlockIndex { first_block.value() + i });
  52. u32 fat_offset = cluster * sizeof(u32);
  53. u32 fat_sector_index = fs().boot_record()->reserved_sector_count + (fat_offset / fs().m_logical_block_size);
  54. u32 entry_offset = fat_offset % fs().m_logical_block_size;
  55. TRY(fs().raw_read(fat_sector_index, fat_sector_buffer));
  56. cluster = *reinterpret_cast<u32*>(&fat_sector->data()[entry_offset]);
  57. cluster &= cluster_number_mask;
  58. }
  59. return block_list;
  60. }
  61. ErrorOr<NonnullOwnPtr<KBuffer>> FATInode::read_block_list()
  62. {
  63. VERIFY(m_inode_lock.is_locked());
  64. dbgln_if(FAT_DEBUG, "FATFS: reading block list for inode {} ({} blocks)", index(), m_block_list.size());
  65. if (m_block_list.is_empty())
  66. m_block_list = TRY(compute_block_list());
  67. auto builder = TRY(KBufferBuilder::try_create());
  68. u8 buffer[512];
  69. VERIFY(fs().m_logical_block_size <= sizeof(buffer));
  70. auto buf = UserOrKernelBuffer::for_kernel_buffer(buffer);
  71. for (BlockBasedFileSystem::BlockIndex block : m_block_list) {
  72. dbgln_if(FAT_DEBUG, "FATFS: reading block: {}", block);
  73. TRY(fs().raw_read(block, buf));
  74. TRY(builder.append((char const*)buffer, fs().m_logical_block_size));
  75. }
  76. auto blocks = builder.build();
  77. if (!blocks)
  78. return ENOMEM;
  79. return blocks.release_nonnull();
  80. }
  81. ErrorOr<LockRefPtr<FATInode>> FATInode::traverse(Function<ErrorOr<bool>(LockRefPtr<FATInode>)> callback)
  82. {
  83. VERIFY(has_flag(m_entry.attributes, FATAttributes::Directory));
  84. Vector<FATLongFileNameEntry> lfn_entries;
  85. auto blocks = TRY(read_block_list());
  86. for (u32 i = 0; i < blocks->size() / sizeof(FATEntry); i++) {
  87. auto* entry = reinterpret_cast<FATEntry*>(blocks->data() + i * sizeof(FATEntry));
  88. if (entry->filename[0] == end_entry_byte) {
  89. dbgln_if(FAT_DEBUG, "FATFS: Found end entry");
  90. return nullptr;
  91. } else if (static_cast<u8>(entry->filename[0]) == unused_entry_byte) {
  92. dbgln_if(FAT_DEBUG, "FATFS: Found unused entry");
  93. lfn_entries.clear();
  94. } else if (entry->attributes == FATAttributes::LongFileName) {
  95. dbgln_if(FAT_DEBUG, "FATFS: Found LFN entry");
  96. TRY(lfn_entries.try_append(*reinterpret_cast<FATLongFileNameEntry*>(entry)));
  97. } else {
  98. dbgln_if(FAT_DEBUG, "FATFS: Found 8.3 entry");
  99. lfn_entries.reverse();
  100. auto inode = TRY(FATInode::create(fs(), *entry, lfn_entries));
  101. if (TRY(callback(inode)))
  102. return inode;
  103. lfn_entries.clear();
  104. }
  105. }
  106. return EINVAL;
  107. }
  108. ErrorOr<NonnullOwnPtr<KString>> FATInode::compute_filename(FATEntry& entry, Vector<FATLongFileNameEntry> const& lfn_entries)
  109. {
  110. if (lfn_entries.is_empty()) {
  111. StringBuilder filename;
  112. filename.append(byte_terminated_string(StringView(entry.filename, normal_filename_length), ' '));
  113. if (entry.extension[0] != ' ') {
  114. filename.append('.');
  115. filename.append(byte_terminated_string(StringView(entry.extension, normal_extension_length), ' '));
  116. }
  117. return TRY(KString::try_create(filename.string_view()));
  118. } else {
  119. StringBuilder filename;
  120. for (auto& lfn_entry : lfn_entries) {
  121. filename.append(lfn_entry.characters1[0]);
  122. filename.append(lfn_entry.characters1[1]);
  123. filename.append(lfn_entry.characters1[2]);
  124. filename.append(lfn_entry.characters1[3]);
  125. filename.append(lfn_entry.characters1[4]);
  126. filename.append(lfn_entry.characters2[0]);
  127. filename.append(lfn_entry.characters2[1]);
  128. filename.append(lfn_entry.characters2[2]);
  129. filename.append(lfn_entry.characters2[3]);
  130. filename.append(lfn_entry.characters2[4]);
  131. filename.append(lfn_entry.characters2[5]);
  132. filename.append(lfn_entry.characters3[0]);
  133. filename.append(lfn_entry.characters3[1]);
  134. }
  135. return TRY(KString::try_create(byte_terminated_string(filename.string_view(), lfn_entry_text_termination)));
  136. }
  137. VERIFY_NOT_REACHED();
  138. }
  139. time_t FATInode::fat_date_time(FATPackedDate date, FATPackedTime time)
  140. {
  141. if (date.value == 0)
  142. return 0;
  143. return Time::from_timestamp(first_fat_year + date.year, date.month, date.day, time.hour, time.minute, time.second * 2, 0).to_seconds();
  144. }
  145. StringView FATInode::byte_terminated_string(StringView string, u8 fill_byte)
  146. {
  147. if (auto index = string.find_last_not(fill_byte); index.has_value())
  148. return string.substring_view(0, index.value());
  149. return string;
  150. }
  151. u32 FATInode::first_cluster() const
  152. {
  153. return (((u32)m_entry.first_cluster_high) << 16) | m_entry.first_cluster_low;
  154. }
  155. ErrorOr<size_t> FATInode::read_bytes_locked(off_t offset, size_t size, UserOrKernelBuffer& buffer, OpenFileDescription*) const
  156. {
  157. dbgln_if(FAT_DEBUG, "FATFS: Reading inode {}: size: {} offset: {}", identifier().index(), size, offset);
  158. // FIXME: Read only the needed blocks instead of the whole file
  159. auto blocks = TRY(const_cast<FATInode&>(*this).read_block_list());
  160. TRY(buffer.write(blocks->data() + offset, min(size, m_block_list.size() * fs().m_logical_block_size - offset)));
  161. return min(size, m_block_list.size() * fs().m_logical_block_size - offset);
  162. }
  163. InodeMetadata FATInode::metadata() const
  164. {
  165. return m_metadata;
  166. }
  167. ErrorOr<void> FATInode::traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)> callback) const
  168. {
  169. MutexLocker locker(m_inode_lock);
  170. VERIFY(has_flag(m_entry.attributes, FATAttributes::Directory));
  171. [[maybe_unused]] auto inode = TRY(const_cast<FATInode&>(*this).traverse([&callback](auto inode) -> ErrorOr<bool> {
  172. if (inode->m_filename->view() == "" || inode->m_filename->view() == "." || inode->m_filename->view() == "..")
  173. return false;
  174. TRY(callback({ inode->m_filename->view(), inode->identifier(), static_cast<u8>(inode->m_entry.attributes) }));
  175. return false;
  176. }));
  177. return {};
  178. }
  179. ErrorOr<NonnullLockRefPtr<Inode>> FATInode::lookup(StringView name)
  180. {
  181. MutexLocker locker(m_inode_lock);
  182. VERIFY(has_flag(m_entry.attributes, FATAttributes::Directory));
  183. auto inode = TRY(traverse([name](auto child) -> ErrorOr<bool> {
  184. return child->m_filename->view() == name;
  185. }));
  186. if (inode.is_null())
  187. return ENOENT;
  188. else
  189. return inode.release_nonnull();
  190. }
  191. ErrorOr<size_t> FATInode::write_bytes_locked(off_t, size_t, UserOrKernelBuffer const&, OpenFileDescription*)
  192. {
  193. return EROFS;
  194. }
  195. ErrorOr<NonnullLockRefPtr<Inode>> FATInode::create_child(StringView, mode_t, dev_t, UserID, GroupID)
  196. {
  197. return EROFS;
  198. }
  199. ErrorOr<void> FATInode::add_child(Inode&, StringView, mode_t)
  200. {
  201. return EROFS;
  202. }
  203. ErrorOr<void> FATInode::remove_child(StringView)
  204. {
  205. return EROFS;
  206. }
  207. ErrorOr<void> FATInode::chmod(mode_t)
  208. {
  209. return EROFS;
  210. }
  211. ErrorOr<void> FATInode::chown(UserID, GroupID)
  212. {
  213. return EROFS;
  214. }
  215. ErrorOr<void> FATInode::flush_metadata()
  216. {
  217. return EROFS;
  218. }
  219. }