FileDescriptor.cpp 10.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410
  1. #include "FileDescriptor.h"
  2. #include <Kernel/FileSystem/FileSystem.h>
  3. #include <Kernel/Devices/CharacterDevice.h>
  4. #include <LibC/errno_numbers.h>
  5. #include "UnixTypes.h"
  6. #include <AK/BufferStream.h>
  7. #include <Kernel/FileSystem/FIFO.h>
  8. #include <Kernel/TTY/TTY.h>
  9. #include <Kernel/TTY/MasterPTY.h>
  10. #include <Kernel/Net/Socket.h>
  11. #include <Kernel/Process.h>
  12. #include <Kernel/Devices/BlockDevice.h>
  13. #include <Kernel/VM/MemoryManager.h>
  14. #include <Kernel/SharedMemory.h>
  15. Retained<FileDescriptor> FileDescriptor::create(RetainPtr<Inode>&& inode)
  16. {
  17. return adopt(*new FileDescriptor(move(inode)));
  18. }
  19. Retained<FileDescriptor> FileDescriptor::create(RetainPtr<File>&& file, SocketRole role)
  20. {
  21. return adopt(*new FileDescriptor(move(file), role));
  22. }
  23. FileDescriptor::FileDescriptor(RetainPtr<Inode>&& inode)
  24. : m_inode(move(inode))
  25. {
  26. }
  27. FileDescriptor::FileDescriptor(RetainPtr<File>&& file, SocketRole role)
  28. : m_file(move(file))
  29. {
  30. set_socket_role(role);
  31. }
  32. FileDescriptor::~FileDescriptor()
  33. {
  34. if (is_socket())
  35. socket()->detach(*this);
  36. if (is_fifo())
  37. static_cast<FIFO*>(m_file.ptr())->detach(m_fifo_direction);
  38. if (m_file) {
  39. m_file->close();
  40. m_file = nullptr;
  41. }
  42. m_inode = nullptr;
  43. }
  44. void FileDescriptor::set_socket_role(SocketRole role)
  45. {
  46. if (role == m_socket_role)
  47. return;
  48. ASSERT(is_socket());
  49. if (m_socket_role != SocketRole::None)
  50. socket()->detach(*this);
  51. m_socket_role = role;
  52. socket()->attach(*this);
  53. }
  54. Retained<FileDescriptor> FileDescriptor::clone()
  55. {
  56. RetainPtr<FileDescriptor> descriptor;
  57. if (is_fifo()) {
  58. descriptor = fifo()->open_direction(m_fifo_direction);
  59. } else {
  60. if (m_file) {
  61. descriptor = FileDescriptor::create(m_file.copy_ref(), m_socket_role);
  62. descriptor->m_inode = m_inode.copy_ref();
  63. } else {
  64. descriptor = FileDescriptor::create(m_inode.copy_ref());
  65. }
  66. }
  67. ASSERT(descriptor);
  68. descriptor->m_current_offset = m_current_offset;
  69. descriptor->m_is_blocking = m_is_blocking;
  70. descriptor->m_file_flags = m_file_flags;
  71. return *descriptor;
  72. }
  73. bool addition_would_overflow(off_t a, off_t b)
  74. {
  75. ASSERT(a > 0);
  76. uint64_t ua = a;
  77. return (ua + b) > OFF_T_MAX;
  78. }
  79. KResult FileDescriptor::fstat(stat& buffer)
  80. {
  81. ASSERT(!is_fifo());
  82. if (!m_inode && !m_file)
  83. return KResult(-EBADF);
  84. auto metadata = this->metadata();
  85. if (!metadata.is_valid())
  86. return KResult(-EIO);
  87. buffer.st_rdev = encoded_device(metadata.major_device, metadata.minor_device);
  88. buffer.st_ino = metadata.inode.index();
  89. buffer.st_mode = metadata.mode;
  90. buffer.st_nlink = metadata.link_count;
  91. buffer.st_uid = metadata.uid;
  92. buffer.st_gid = metadata.gid;
  93. buffer.st_dev = 0; // FIXME
  94. buffer.st_size = metadata.size;
  95. buffer.st_blksize = metadata.block_size;
  96. buffer.st_blocks = metadata.block_count;
  97. buffer.st_atime = metadata.atime;
  98. buffer.st_mtime = metadata.mtime;
  99. buffer.st_ctime = metadata.ctime;
  100. return KSuccess;
  101. }
  102. KResult FileDescriptor::fchmod(mode_t mode)
  103. {
  104. if (!m_inode)
  105. return KResult(-EBADF);
  106. return VFS::the().chmod(*m_inode, mode);
  107. }
  108. off_t FileDescriptor::seek(off_t offset, int whence)
  109. {
  110. ASSERT(!is_fifo());
  111. if (!m_inode && !m_file)
  112. return -EBADF;
  113. // FIXME: The file type should be cached on the vnode.
  114. // It's silly that we have to do a full metadata lookup here.
  115. auto metadata = this->metadata();
  116. if (!metadata.is_valid())
  117. return -EIO;
  118. if (metadata.is_socket() || metadata.is_fifo())
  119. return -ESPIPE;
  120. off_t newOffset;
  121. switch (whence) {
  122. case SEEK_SET:
  123. newOffset = offset;
  124. break;
  125. case SEEK_CUR:
  126. newOffset = m_current_offset + offset;
  127. if (newOffset < 0)
  128. return -EINVAL;
  129. break;
  130. case SEEK_END:
  131. ASSERT(metadata.size); // FIXME: What do I do?
  132. newOffset = metadata.size;
  133. break;
  134. default:
  135. return -EINVAL;
  136. }
  137. m_current_offset = newOffset;
  138. return m_current_offset;
  139. }
  140. ssize_t FileDescriptor::read(byte* buffer, ssize_t count)
  141. {
  142. if (m_file) {
  143. int nread = m_file->read(*this, buffer, count);
  144. if (!m_file->is_seekable())
  145. m_current_offset += nread;
  146. return nread;
  147. }
  148. ASSERT(inode());
  149. ssize_t nread = inode()->read_bytes(m_current_offset, count, buffer, this);
  150. m_current_offset += nread;
  151. return nread;
  152. }
  153. ssize_t FileDescriptor::write(const byte* data, ssize_t size)
  154. {
  155. if (m_file) {
  156. int nwritten = m_file->write(*this, data, size);
  157. if (m_file->is_seekable())
  158. m_current_offset += nwritten;
  159. return nwritten;
  160. }
  161. ASSERT(m_inode);
  162. ssize_t nwritten = m_inode->write_bytes(m_current_offset, size, data, this);
  163. m_current_offset += nwritten;
  164. return nwritten;
  165. }
  166. bool FileDescriptor::can_write()
  167. {
  168. if (m_file)
  169. return m_file->can_write(*this);
  170. return true;
  171. }
  172. bool FileDescriptor::can_read()
  173. {
  174. if (m_file)
  175. return m_file->can_read(*this);
  176. return true;
  177. }
  178. ByteBuffer FileDescriptor::read_entire_file()
  179. {
  180. // HACK ALERT: (This entire function)
  181. ASSERT(!is_fifo());
  182. if (m_file) {
  183. auto buffer = ByteBuffer::create_uninitialized(1024);
  184. ssize_t nread = m_file->read(*this, buffer.pointer(), buffer.size());
  185. ASSERT(nread >= 0);
  186. buffer.trim(nread);
  187. return buffer;
  188. }
  189. ASSERT(m_inode);
  190. return m_inode->read_entire(this);
  191. }
  192. bool FileDescriptor::is_directory() const
  193. {
  194. ASSERT(!is_fifo());
  195. return metadata().is_directory();
  196. }
  197. ssize_t FileDescriptor::get_dir_entries(byte* buffer, ssize_t size)
  198. {
  199. auto metadata = this->metadata();
  200. if (!metadata.is_valid())
  201. return -EIO;
  202. if (!metadata.is_directory())
  203. return -ENOTDIR;
  204. int size_to_allocate = max(PAGE_SIZE, metadata.size);
  205. auto temp_buffer = ByteBuffer::create_uninitialized(size_to_allocate);
  206. BufferStream stream(temp_buffer);
  207. VFS::the().traverse_directory_inode(*m_inode, [&stream] (auto& entry) {
  208. stream << (dword)entry.inode.index();
  209. stream << (byte)entry.file_type;
  210. stream << (dword)entry.name_length;
  211. stream << entry.name;
  212. return true;
  213. });
  214. stream.snip();
  215. if (size < temp_buffer.size())
  216. return -1;
  217. memcpy(buffer, temp_buffer.pointer(), temp_buffer.size());
  218. return stream.offset();
  219. }
  220. bool FileDescriptor::is_device() const
  221. {
  222. return m_file && m_file->is_device();
  223. }
  224. bool FileDescriptor::is_tty() const
  225. {
  226. return m_file && m_file->is_tty();
  227. }
  228. const TTY* FileDescriptor::tty() const
  229. {
  230. if (!is_tty())
  231. return nullptr;
  232. return static_cast<const TTY*>(m_file.ptr());
  233. }
  234. TTY* FileDescriptor::tty()
  235. {
  236. if (!is_tty())
  237. return nullptr;
  238. return static_cast<TTY*>(m_file.ptr());
  239. }
  240. bool FileDescriptor::is_master_pty() const
  241. {
  242. return m_file && m_file->is_master_pty();
  243. }
  244. const MasterPTY* FileDescriptor::master_pty() const
  245. {
  246. if (!is_master_pty())
  247. return nullptr;
  248. return static_cast<const MasterPTY*>(m_file.ptr());
  249. }
  250. MasterPTY* FileDescriptor::master_pty()
  251. {
  252. if (!is_master_pty())
  253. return nullptr;
  254. return static_cast<MasterPTY*>(m_file.ptr());
  255. }
  256. int FileDescriptor::close()
  257. {
  258. return 0;
  259. }
  260. bool FileDescriptor::is_fsfile() const
  261. {
  262. return !is_tty() && !is_fifo() && !is_device() && !is_socket() && !is_shared_memory();
  263. }
  264. KResultOr<String> FileDescriptor::absolute_path()
  265. {
  266. if (m_file)
  267. return m_file->absolute_path(*this);
  268. ASSERT(m_inode);
  269. return VFS::the().absolute_path(*m_inode);
  270. }
  271. InodeMetadata FileDescriptor::metadata() const
  272. {
  273. if (m_inode)
  274. return m_inode->metadata();
  275. return { };
  276. }
  277. KResultOr<Region*> FileDescriptor::mmap(Process& process, LinearAddress laddr, size_t offset, size_t size, int prot)
  278. {
  279. if (m_file)
  280. return m_file->mmap(process, laddr, offset, size);
  281. if (is_shared_memory()) {
  282. if (!shared_memory()->vmo())
  283. return KResult(-ENODEV);
  284. return process.allocate_region_with_vmo(laddr, size, *shared_memory()->vmo(), offset, shared_memory()->name(), true, true);
  285. }
  286. if (!is_fsfile())
  287. return KResult(-ENODEV);
  288. ASSERT(m_inode);
  289. // FIXME: If PROT_EXEC, check that the underlying file system isn't mounted noexec.
  290. String region_name;
  291. #if 0
  292. // FIXME: I would like to do this, but it would instantiate all the damn inodes.
  293. region_name = absolute_path();
  294. #else
  295. region_name = "Memory-mapped file";
  296. #endif
  297. InterruptDisabler disabler;
  298. // FIXME: Implement mapping at a client-specified address. Most of the support is already in plcae.
  299. ASSERT(laddr.as_ptr() == nullptr);
  300. auto* region = process.allocate_file_backed_region(LinearAddress(), size, inode(), move(region_name), prot & PROT_READ, prot & PROT_WRITE);
  301. region->page_in();
  302. return region;
  303. }
  304. KResult FileDescriptor::truncate(off_t length)
  305. {
  306. if (is_file()) {
  307. return m_inode->truncate(length);
  308. }
  309. ASSERT(is_shared_memory());
  310. return shared_memory()->truncate(length);
  311. }
  312. bool FileDescriptor::is_shared_memory() const
  313. {
  314. return m_file && m_file->is_shared_memory();
  315. }
  316. SharedMemory* FileDescriptor::shared_memory()
  317. {
  318. if (!is_shared_memory())
  319. return nullptr;
  320. return static_cast<SharedMemory*>(m_file.ptr());
  321. }
  322. const SharedMemory* FileDescriptor::shared_memory() const
  323. {
  324. if (!is_shared_memory())
  325. return nullptr;
  326. return static_cast<const SharedMemory*>(m_file.ptr());
  327. }
  328. bool FileDescriptor::is_fifo() const
  329. {
  330. return m_file && m_file->is_fifo();
  331. }
  332. FIFO* FileDescriptor::fifo()
  333. {
  334. if (!is_fifo())
  335. return nullptr;
  336. return static_cast<FIFO*>(m_file.ptr());
  337. }
  338. bool FileDescriptor::is_socket() const
  339. {
  340. return m_file && m_file->is_socket();
  341. }
  342. Socket* FileDescriptor::socket()
  343. {
  344. if (!is_socket())
  345. return nullptr;
  346. return static_cast<Socket*>(m_file.ptr());
  347. }
  348. const Socket* FileDescriptor::socket() const
  349. {
  350. if (!is_socket())
  351. return nullptr;
  352. return static_cast<const Socket*>(m_file.ptr());
  353. }