Process.h 9.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289
  1. #pragma once
  2. #include "types.h"
  3. #include "InlineLinkedList.h"
  4. #include <AK/String.h>
  5. #include "TSS.h"
  6. #include <AK/Vector.h>
  7. #include "i386.h"
  8. #include <VirtualFileSystem/VirtualFileSystem.h>
  9. #include <VirtualFileSystem/UnixTypes.h>
  10. #include "TTY.h"
  11. class FileHandle;
  12. class PageDirectory;
  13. class Region;
  14. class Zone;
  15. struct SignalActionData {
  16. LinearAddress handler_or_sigaction;
  17. dword mask { 0 };
  18. int flags { 0 };
  19. LinearAddress restorer;
  20. };
  21. class Process : public InlineLinkedListNode<Process> {
  22. friend class InlineLinkedListNode<Process>;
  23. public:
  24. static Process* createKernelProcess(void (*entry)(), String&& name);
  25. static Process* create_user_process(const String& path, uid_t, gid_t, pid_t ppid, int& error, Vector<String>&& arguments = Vector<String>(), Vector<String>&& environment = Vector<String>(), TTY* = nullptr);
  26. ~Process();
  27. static Vector<Process*> allProcesses();
  28. enum State {
  29. Invalid = 0,
  30. Runnable = 1,
  31. Running = 2,
  32. Terminated = 3,
  33. Crashing = 4,
  34. Exiting = 5,
  35. BeingInspected = 6,
  36. BlockedSleep = 7,
  37. BlockedWait = 8,
  38. BlockedRead = 9,
  39. };
  40. enum RingLevel {
  41. Ring0 = 0,
  42. Ring3 = 3,
  43. };
  44. bool isRing0() const { return m_ring == Ring0; }
  45. bool isRing3() const { return m_ring == Ring3; }
  46. static Process* fromPID(pid_t);
  47. static Process* kernelProcess();
  48. const String& name() const { return m_name; }
  49. pid_t pid() const { return m_pid; }
  50. pid_t sid() const { return m_sid; }
  51. pid_t pgid() const { return m_pgid; }
  52. DWORD ticks() const { return m_ticks; }
  53. WORD selector() const { return m_farPtr.selector; }
  54. TSS32& tss() { return m_tss; }
  55. State state() const { return m_state; }
  56. uid_t uid() const { return m_uid; }
  57. gid_t gid() const { return m_gid; }
  58. uid_t euid() const { return m_euid; }
  59. gid_t egid() const { return m_egid; }
  60. pid_t ppid() const { return m_ppid; }
  61. const FarPtr& farPtr() const { return m_farPtr; }
  62. FileHandle* fileHandleIfExists(int fd);
  63. static void doHouseKeeping();
  64. void block(Process::State);
  65. void unblock();
  66. void setWakeupTime(DWORD t) { m_wakeupTime = t; }
  67. DWORD wakeupTime() const { return m_wakeupTime; }
  68. static void for_each_in_pgrp(pid_t pgid, Function<void(Process&)>);
  69. static void prepForIRETToNewProcess();
  70. bool tick() { ++m_ticks; return --m_ticksLeft; }
  71. void setTicksLeft(DWORD t) { m_ticksLeft = t; }
  72. void setSelector(WORD s) { m_farPtr.selector = s; }
  73. void set_state(State s) { m_state = s; }
  74. pid_t sys$setsid();
  75. pid_t sys$getsid(pid_t);
  76. int sys$setpgid(pid_t pid, pid_t pgid);
  77. pid_t sys$getpgrp();
  78. pid_t sys$getpgid(pid_t);
  79. pid_t sys$tcgetpgrp(int fd);
  80. int sys$tcsetpgrp(int fd, pid_t pgid);
  81. uid_t sys$getuid();
  82. gid_t sys$getgid();
  83. uid_t sys$geteuid();
  84. gid_t sys$getegid();
  85. pid_t sys$getpid();
  86. pid_t sys$getppid();
  87. mode_t sys$umask(mode_t);
  88. int sys$open(const char* path, int options);
  89. int sys$close(int fd);
  90. ssize_t sys$read(int fd, void* outbuf, size_t nread);
  91. ssize_t sys$write(int fd, const void*, size_t);
  92. int sys$lstat(const char*, Unix::stat*);
  93. int sys$stat(const char*, Unix::stat*);
  94. int sys$lseek(int fd, off_t, int whence);
  95. int sys$kill(pid_t pid, int sig);
  96. int sys$geterror() { return m_error; }
  97. void sys$exit(int status);
  98. pid_t sys$spawn(const char* path, const char** args, const char** envp);
  99. pid_t sys$waitpid(pid_t, int* wstatus, int options);
  100. void* sys$mmap(void*, size_t size);
  101. int sys$munmap(void*, size_t size);
  102. int sys$set_mmap_name(void*, size_t, const char*);
  103. int sys$get_dir_entries(int fd, void*, size_t);
  104. int sys$getcwd(char*, size_t);
  105. int sys$chdir(const char*);
  106. int sys$sleep(unsigned seconds);
  107. int sys$gettimeofday(timeval*);
  108. int sys$gethostname(char* name, size_t length);
  109. int sys$get_arguments(int* argc, char*** argv);
  110. int sys$get_environment(char*** environ);
  111. int sys$uname(utsname*);
  112. int sys$readlink(const char*, char*, size_t);
  113. int sys$ttyname_r(int fd, char*, size_t);
  114. pid_t sys$fork(RegisterDump&);
  115. int sys$execve(const char* filename, const char** argv, const char** envp);
  116. Unix::sighandler_t sys$signal(int signum, Unix::sighandler_t);
  117. int sys$isatty(int fd);
  118. int sys$getdtablesize();
  119. int sys$dup(int oldfd);
  120. int sys$dup2(int oldfd, int newfd);
  121. int sys$sigaction(int signum, const Unix::sigaction* act, Unix::sigaction* old_act);
  122. static void initialize();
  123. static void processDidCrash(Process*);
  124. const TTY* tty() const { return m_tty; }
  125. size_t regionCount() const { return m_regions.size(); }
  126. const Vector<RetainPtr<Region>>& regions() const { return m_regions; }
  127. void dumpRegions();
  128. void didSchedule() { ++m_timesScheduled; }
  129. dword timesScheduled() const { return m_timesScheduled; }
  130. pid_t waitee() const { return m_waitee; }
  131. dword framePtr() const { return m_tss.ebp; }
  132. dword stackPtr() const { return m_tss.esp; }
  133. dword stackTop() const { return m_tss.ss == 0x10 ? m_stackTop0 : m_stackTop3; }
  134. bool isValidAddressForKernel(LinearAddress) const;
  135. bool validate_user_read(LinearAddress) const;
  136. bool validate_user_write(LinearAddress) const;
  137. InodeIdentifier cwdInode() const { return m_cwd ? m_cwd->inode : InodeIdentifier(); }
  138. InodeIdentifier executableInode() const { return m_executable ? m_executable->inode : InodeIdentifier(); }
  139. size_t number_of_open_file_descriptors() const;
  140. size_t max_open_file_descriptors() const { return m_max_open_file_descriptors; }
  141. FileHandle* file_descriptor(size_t i) { return m_file_descriptors[i].ptr(); }
  142. const FileHandle* file_descriptor(size_t i) const { return m_file_descriptors[i].ptr(); }
  143. void send_signal(int signal, Process* sender);
  144. void terminate_due_to_signal(int signal, Process* sender);
  145. Process* fork(RegisterDump&);
  146. int exec(const String& path, Vector<String>&& arguments, Vector<String>&& environment);
  147. private:
  148. friend class MemoryManager;
  149. friend bool scheduleNewProcess();
  150. Process(String&& name, uid_t, gid_t, pid_t ppid, RingLevel, RetainPtr<VirtualFileSystem::Node>&& cwd = nullptr, RetainPtr<VirtualFileSystem::Node>&& executable = nullptr, TTY* = nullptr, Process* fork_parent = nullptr);
  151. void push_value_on_stack(dword);
  152. PageDirectory* m_page_directory { nullptr };
  153. Process* m_prev { nullptr };
  154. Process* m_next { nullptr };
  155. String m_name;
  156. void (*m_entry)() { nullptr };
  157. pid_t m_pid { 0 };
  158. uid_t m_uid { 0 };
  159. gid_t m_gid { 0 };
  160. uid_t m_euid { 0 };
  161. gid_t m_egid { 0 };
  162. pid_t m_sid { 0 };
  163. pid_t m_pgid { 0 };
  164. DWORD m_ticks { 0 };
  165. DWORD m_ticksLeft { 0 };
  166. DWORD m_stackTop0 { 0 };
  167. DWORD m_stackTop3 { 0 };
  168. FarPtr m_farPtr;
  169. State m_state { Invalid };
  170. DWORD m_wakeupTime { 0 };
  171. TSS32 m_tss;
  172. Vector<RetainPtr<FileHandle>> m_file_descriptors;
  173. RingLevel m_ring { Ring0 };
  174. int m_error { 0 };
  175. void* m_kernelStack { nullptr };
  176. dword m_timesScheduled { 0 };
  177. pid_t m_waitee { -1 };
  178. int m_waiteeStatus { 0 };
  179. int m_fdBlockedOnRead { -1 };
  180. size_t m_max_open_file_descriptors { 16 };
  181. SignalActionData m_signal_action_data[32];
  182. RetainPtr<VirtualFileSystem::Node> m_cwd;
  183. RetainPtr<VirtualFileSystem::Node> m_executable;
  184. TTY* m_tty { nullptr };
  185. Region* allocate_region(LinearAddress, size_t, String&& name, bool is_readable = true, bool is_writable = true);
  186. bool deallocate_region(Region& region);
  187. Region* regionFromRange(LinearAddress, size_t);
  188. Vector<RetainPtr<Region>> m_regions;
  189. // FIXME: Implement some kind of ASLR?
  190. LinearAddress m_nextRegion;
  191. LinearAddress m_return_from_signal_trampoline;
  192. pid_t m_ppid { 0 };
  193. mode_t m_umask { 022 };
  194. static void notify_waiters(pid_t waitee, int exit_status, int signal);
  195. Vector<String> m_arguments;
  196. Vector<String> m_initialEnvironment;
  197. };
  198. class ProcessInspectionScope {
  199. public:
  200. ProcessInspectionScope(Process& process)
  201. : m_process(process)
  202. , m_original_state(process.state())
  203. {
  204. m_process.set_state(Process::BeingInspected);
  205. }
  206. ~ProcessInspectionScope()
  207. {
  208. m_process.set_state(m_original_state);
  209. }
  210. private:
  211. Process& m_process;
  212. Process::State m_original_state { Process::Invalid };
  213. };
  214. static inline const char* toString(Process::State state)
  215. {
  216. switch (state) {
  217. case Process::Invalid: return "Invalid";
  218. case Process::Runnable: return "Runnable";
  219. case Process::Running: return "Running";
  220. case Process::Terminated: return "Term";
  221. case Process::Crashing: return "Crash";
  222. case Process::Exiting: return "Exit";
  223. case Process::BlockedSleep: return "Sleep";
  224. case Process::BlockedWait: return "Wait";
  225. case Process::BlockedRead: return "Read";
  226. case Process::BeingInspected: return "Inspect";
  227. }
  228. ASSERT_NOT_REACHED();
  229. return nullptr;
  230. }
  231. extern void yield();
  232. extern bool scheduleNewProcess();
  233. extern void switchNow();
  234. extern void block(Process::State);
  235. extern void sleep(DWORD ticks);
  236. extern Process* current;