Task.cpp 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811
  1. #include "types.h"
  2. #include "Task.h"
  3. #include "kmalloc.h"
  4. #include "VGA.h"
  5. #include "StdLib.h"
  6. #include "i386.h"
  7. #include "system.h"
  8. #include <VirtualFileSystem/FileHandle.h>
  9. #include <VirtualFileSystem/VirtualFileSystem.h>
  10. #include <ELFLoader/ExecSpace.h>
  11. #include "MemoryManager.h"
  12. #include "errno.h"
  13. #include "i8253.h"
  14. #include "RTC.h"
  15. //#define DEBUG_IO
  16. //#define TASK_DEBUG
  17. static const DWORD defaultStackSize = 16384;
  18. Task* current;
  19. Task* s_kernelTask;
  20. static pid_t next_pid;
  21. static InlineLinkedList<Task>* s_tasks;
  22. static InlineLinkedList<Task>* s_deadTasks;
  23. static bool contextSwitch(Task*);
  24. static void redoKernelTaskTSS()
  25. {
  26. if (!s_kernelTask->selector())
  27. s_kernelTask->setSelector(allocateGDTEntry());
  28. auto& tssDescriptor = getGDTEntry(s_kernelTask->selector());
  29. tssDescriptor.setBase(&s_kernelTask->tss());
  30. tssDescriptor.setLimit(0xffff);
  31. tssDescriptor.dpl = 0;
  32. tssDescriptor.segment_present = 1;
  33. tssDescriptor.granularity = 1;
  34. tssDescriptor.zero = 0;
  35. tssDescriptor.operation_size = 1;
  36. tssDescriptor.descriptor_type = 0;
  37. tssDescriptor.type = 9;
  38. flushGDT();
  39. }
  40. void Task::prepForIRETToNewTask()
  41. {
  42. redoKernelTaskTSS();
  43. s_kernelTask->tss().backlink = current->selector();
  44. loadTaskRegister(s_kernelTask->selector());
  45. }
  46. void Task::initialize()
  47. {
  48. current = nullptr;
  49. next_pid = 0;
  50. s_tasks = new InlineLinkedList<Task>;
  51. s_deadTasks = new InlineLinkedList<Task>;
  52. s_kernelTask = Task::createKernelTask(nullptr, "colonel");
  53. redoKernelTaskTSS();
  54. loadTaskRegister(s_kernelTask->selector());
  55. }
  56. #ifdef TASK_SANITY_CHECKS
  57. void Task::checkSanity(const char* msg)
  58. {
  59. char ch = current->name()[0];
  60. kprintf("<%p> %s{%u}%b [%d] :%b: sanity check <%s>\n",
  61. current->name().characters(),
  62. current->name().characters(),
  63. current->name().length(),
  64. current->name()[current->name().length() - 1],
  65. current->pid(), ch, msg ? msg : "");
  66. ASSERT((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'));
  67. }
  68. #endif
  69. void Task::allocateLDT()
  70. {
  71. ASSERT(!m_tss.ldt);
  72. static const WORD numLDTEntries = 4;
  73. WORD newLDTSelector = allocateGDTEntry();
  74. m_ldtEntries = new Descriptor[numLDTEntries];
  75. #if 0
  76. kprintf("new ldt selector = %x\n", newLDTSelector);
  77. kprintf("new ldt table at = %p\n", m_ldtEntries);
  78. kprintf("new ldt table size = %u\n", (numLDTEntries * 8) - 1);
  79. #endif
  80. Descriptor& ldt = getGDTEntry(newLDTSelector);
  81. ldt.setBase(m_ldtEntries);
  82. ldt.setLimit(numLDTEntries * 8 - 1);
  83. ldt.dpl = 0;
  84. ldt.segment_present = 1;
  85. ldt.granularity = 0;
  86. ldt.zero = 0;
  87. ldt.operation_size = 1;
  88. ldt.descriptor_type = 0;
  89. ldt.type = Descriptor::LDT;
  90. m_tss.ldt = newLDTSelector;
  91. }
  92. Vector<Task*> Task::allTasks()
  93. {
  94. InterruptDisabler disabler;
  95. Vector<Task*> tasks;
  96. tasks.ensureCapacity(s_tasks->sizeSlow());
  97. for (auto* task = s_tasks->head(); task; task = task->next())
  98. tasks.append(task);
  99. return tasks;
  100. }
  101. Task::Region* Task::allocateRegion(size_t size, String&& name)
  102. {
  103. // FIXME: This needs sanity checks. What if this overlaps existing regions?
  104. auto zone = MemoryManager::the().createZone(size);
  105. ASSERT(zone);
  106. m_regions.append(make<Region>(m_nextRegion, size, move(zone), move(name)));
  107. m_nextRegion = m_nextRegion.offset(size).offset(16384);
  108. return m_regions.last().ptr();
  109. }
  110. bool Task::deallocateRegion(Region& region)
  111. {
  112. for (size_t i = 0; i < m_regions.size(); ++i) {
  113. if (m_regions[i].ptr() == &region) {
  114. // FIXME: This seems racy.
  115. MemoryManager::the().unmapRegion(*this, region);
  116. m_regions.remove(i);
  117. return true;
  118. }
  119. }
  120. return false;
  121. }
  122. Task::Region* Task::regionFromRange(LinearAddress laddr, size_t size)
  123. {
  124. for (auto& region : m_regions) {
  125. if (region->linearAddress == laddr && region->size == size)
  126. return region.ptr();
  127. }
  128. return nullptr;
  129. }
  130. void* Task::sys$mmap(void* addr, size_t size)
  131. {
  132. // FIXME: Implement mapping at a client-preferred address.
  133. ASSERT(addr == nullptr);
  134. auto* region = allocateRegion(size, "mmap");
  135. if (!region)
  136. return (void*)-1;
  137. MemoryManager::the().mapRegion(*this, *region);
  138. return (void*)region->linearAddress.get();
  139. }
  140. int Task::sys$munmap(void* addr, size_t size)
  141. {
  142. auto* region = regionFromRange(LinearAddress((dword)addr), size);
  143. if (!region)
  144. return -1;
  145. if (!deallocateRegion(*region))
  146. return -1;
  147. return 0;
  148. }
  149. int Task::sys$spawn(const char* path)
  150. {
  151. int error = 0;
  152. auto* child = Task::createUserTask(path, m_uid, m_gid, m_pid, error);
  153. if (child)
  154. return child->pid();
  155. return error;
  156. }
  157. Task* Task::createUserTask(const String& path, uid_t uid, gid_t gid, pid_t parentPID, int& error)
  158. {
  159. auto parts = path.split('/');
  160. if (parts.isEmpty()) {
  161. error = -ENOENT;
  162. return nullptr;
  163. }
  164. auto handle = VirtualFileSystem::the().open(path);
  165. if (!handle) {
  166. error = -ENOENT; // FIXME: Get a more detailed error from VFS.
  167. return nullptr;
  168. }
  169. auto elfData = handle->readEntireFile();
  170. if (!elfData) {
  171. error = -EIO; // FIXME: Get a more detailed error from VFS.
  172. return nullptr;
  173. }
  174. InterruptDisabler disabler; // FIXME: Get rid of this, jesus christ. This "critical" section is HUGE.
  175. Task* t = new Task(parts.takeLast(), uid, gid, parentPID, Ring3);
  176. ExecSpace space;
  177. space.hookableAlloc = [&] (const String& name, size_t size) {
  178. if (!size)
  179. return (void*)nullptr;
  180. size = ((size / 4096) + 1) * 4096;
  181. Region* region = t->allocateRegion(size, String(name));
  182. ASSERT(region);
  183. MemoryManager::the().mapRegion(*t, *region);
  184. return (void*)region->linearAddress.asPtr();
  185. };
  186. bool success = space.loadELF(move(elfData));
  187. if (!success) {
  188. delete t;
  189. kprintf("Failure loading ELF %s\n", path.characters());
  190. error = -ENOEXEC;
  191. return nullptr;
  192. }
  193. t->m_tss.eip = (dword)space.symbolPtr("_start");
  194. if (!t->m_tss.eip) {
  195. delete t;
  196. error = -ENOEXEC;
  197. return nullptr;
  198. }
  199. MemoryManager::the().unmapRegionsForTask(*t);
  200. MemoryManager::the().mapRegionsForTask(*current);
  201. s_tasks->prepend(t);
  202. system.nprocess++;
  203. #ifdef TASK_DEBUG
  204. kprintf("Task %u (%s) spawned @ %p\n", t->pid(), t->name().characters(), t->m_tss.eip);
  205. #endif
  206. error = 0;
  207. return t;
  208. }
  209. Task* Task::createKernelTask(void (*e)(), String&& name)
  210. {
  211. Task* task = new Task(move(name), (uid_t)0, (gid_t)0, (pid_t)0, Ring0);
  212. task->m_tss.eip = (dword)e;
  213. if (task->pid() != 0) {
  214. InterruptDisabler disabler;
  215. s_tasks->prepend(task);
  216. system.nprocess++;
  217. #ifdef TASK_DEBUG
  218. kprintf("Kernel task %u (%s) spawned @ %p\n", task->pid(), task->name().characters(), task->m_tss.eip);
  219. #endif
  220. }
  221. return task;
  222. }
  223. Task::Task(String&& name, uid_t uid, gid_t gid, pid_t parentPID, RingLevel ring)
  224. : m_name(move(name))
  225. , m_pid(next_pid++)
  226. , m_uid(uid)
  227. , m_gid(gid)
  228. , m_state(Runnable)
  229. , m_ring(ring)
  230. , m_parentPID(parentPID)
  231. {
  232. m_fileHandles.append(nullptr); // stdin
  233. m_fileHandles.append(nullptr); // stdout
  234. m_fileHandles.append(nullptr); // stderr
  235. auto* parentTask = Task::fromPID(parentPID);
  236. if (parentTask)
  237. m_cwd = parentTask->m_cwd;
  238. else
  239. m_cwd = "/";
  240. m_nextRegion = LinearAddress(0x600000);
  241. memset(&m_tss, 0, sizeof(m_tss));
  242. if (isRing3()) {
  243. memset(&m_ldtEntries, 0, sizeof(m_ldtEntries));
  244. allocateLDT();
  245. }
  246. // Only IF is set when a task boots.
  247. m_tss.eflags = 0x0202;
  248. word cs, ds, ss;
  249. if (isRing0()) {
  250. cs = 0x08;
  251. ds = 0x10;
  252. ss = 0x10;
  253. } else {
  254. cs = 0x1b;
  255. ds = 0x23;
  256. ss = 0x23;
  257. }
  258. m_tss.ds = ds;
  259. m_tss.es = ds;
  260. m_tss.fs = ds;
  261. m_tss.gs = ds;
  262. m_tss.ss = ss;
  263. m_tss.cs = cs;
  264. m_tss.cr3 = MemoryManager::the().pageDirectoryBase().get();
  265. if (isRing0()) {
  266. // FIXME: This memory is leaked.
  267. // But uh, there's also no kernel task termination, so I guess it's not technically leaked...
  268. dword stackBottom = (dword)kmalloc(defaultStackSize);
  269. m_stackTop = (stackBottom + defaultStackSize) & 0xffffff8;
  270. m_tss.esp = m_stackTop;
  271. } else {
  272. auto* region = allocateRegion(defaultStackSize, "stack");
  273. ASSERT(region);
  274. m_stackTop = region->linearAddress.offset(defaultStackSize).get() & 0xfffffff8;
  275. }
  276. m_tss.esp = m_stackTop;
  277. if (isRing3()) {
  278. // Ring3 tasks need a separate stack for Ring0.
  279. m_kernelStack = kmalloc(defaultStackSize);
  280. DWORD ring0StackTop = ((DWORD)m_kernelStack + defaultStackSize) & 0xffffff8;
  281. m_tss.ss0 = 0x10;
  282. m_tss.esp0 = ring0StackTop;
  283. }
  284. // HACK: Ring2 SS in the TSS is the current PID.
  285. m_tss.ss2 = m_pid;
  286. m_farPtr.offset = 0x98765432;
  287. }
  288. Task::~Task()
  289. {
  290. InterruptDisabler disabler;
  291. system.nprocess--;
  292. delete [] m_ldtEntries;
  293. m_ldtEntries = nullptr;
  294. if (m_kernelStack) {
  295. kfree(m_kernelStack);
  296. m_kernelStack = nullptr;
  297. }
  298. }
  299. void Task::dumpRegions()
  300. {
  301. kprintf("Task %s(%u) regions:\n", name().characters(), pid());
  302. kprintf("BEGIN END SIZE NAME\n");
  303. for (auto& region : m_regions) {
  304. kprintf("%x -- %x %x %s\n",
  305. region->linearAddress.get(),
  306. region->linearAddress.offset(region->size - 1).get(),
  307. region->size,
  308. region->name.characters());
  309. }
  310. }
  311. void Task::sys$exit(int status)
  312. {
  313. cli();
  314. #ifdef TASK_DEBUG
  315. kprintf("sys$exit: %s(%u) exit with status %d\n", name().characters(), pid(), status);
  316. #endif
  317. setState(Exiting);
  318. MemoryManager::the().unmapRegionsForTask(*this);
  319. s_tasks->remove(this);
  320. if (!scheduleNewTask()) {
  321. kprintf("Task::taskDidCrash: Failed to schedule a new task :(\n");
  322. HANG;
  323. }
  324. s_deadTasks->append(this);
  325. switchNow();
  326. }
  327. void Task::taskDidCrash(Task* crashedTask)
  328. {
  329. ASSERT_INTERRUPTS_DISABLED();
  330. crashedTask->setState(Crashing);
  331. crashedTask->dumpRegions();
  332. s_tasks->remove(crashedTask);
  333. MemoryManager::the().unmapRegionsForTask(*crashedTask);
  334. if (!scheduleNewTask()) {
  335. kprintf("Task::taskDidCrash: Failed to schedule a new task :(\n");
  336. HANG;
  337. }
  338. s_deadTasks->append(crashedTask);
  339. switchNow();
  340. }
  341. void Task::doHouseKeeping()
  342. {
  343. InterruptDisabler disabler;
  344. if (s_deadTasks->isEmpty())
  345. return;
  346. Task* next = nullptr;
  347. for (auto* deadTask = s_deadTasks->head(); deadTask; deadTask = next) {
  348. next = deadTask->next();
  349. delete deadTask;
  350. }
  351. s_deadTasks->clear();
  352. }
  353. void yield()
  354. {
  355. if (!current) {
  356. kprintf( "PANIC: yield() with !current" );
  357. HANG;
  358. }
  359. //kprintf("%s<%u> yield()\n", current->name().characters(), current->pid());
  360. InterruptDisabler disabler;
  361. if (!scheduleNewTask())
  362. return;
  363. //kprintf("yield() jumping to new task: %x (%s)\n", current->farPtr().selector, current->name().characters());
  364. switchNow();
  365. }
  366. void switchNow()
  367. {
  368. Descriptor& descriptor = getGDTEntry(current->selector());
  369. descriptor.type = 9;
  370. flushGDT();
  371. asm("sti\n"
  372. "ljmp *(%%eax)\n"
  373. ::"a"(&current->farPtr())
  374. );
  375. }
  376. bool scheduleNewTask()
  377. {
  378. ASSERT_INTERRUPTS_DISABLED();
  379. if (!current) {
  380. // XXX: The first ever context_switch() goes to the idle task.
  381. // This to setup a reliable place we can return to.
  382. return contextSwitch(Task::kernelTask());
  383. }
  384. // Check and unblock tasks whose wait conditions have been met.
  385. for (auto* task = s_tasks->head(); task; task = task->next()) {
  386. if (task->state() == Task::BlockedSleep) {
  387. if (task->wakeupTime() <= system.uptime) {
  388. task->unblock();
  389. continue;
  390. }
  391. }
  392. if (task->state() == Task::BlockedWait) {
  393. if (!Task::fromPID(task->waitee())) {
  394. task->unblock();
  395. continue;
  396. }
  397. }
  398. if (task->state() == Task::BlockedRead) {
  399. ASSERT(task->m_fdBlockedOnRead != -1);
  400. if (task->m_fileHandles[task->m_fdBlockedOnRead]->hasDataAvailableForRead()) {
  401. task->unblock();
  402. continue;
  403. }
  404. }
  405. }
  406. #if 0
  407. kprintf("Scheduler choices:\n");
  408. for (auto* task = s_tasks->head(); task; task = task->next()) {
  409. if (task->state() == Task::BlockedWait || task->state() == Task::BlockedSleep)
  410. continue;
  411. kprintf("%w %s(%u)\n", task->state(), task->name().characters(), task->pid());
  412. }
  413. #endif
  414. auto* prevHead = s_tasks->head();
  415. for (;;) {
  416. // Move head to tail.
  417. s_tasks->append(s_tasks->removeHead());
  418. auto* task = s_tasks->head();
  419. if (task->state() == Task::Runnable || task->state() == Task::Running) {
  420. //kprintf("switch to %s (%p vs %p)\n", task->name().characters(), task, current);
  421. return contextSwitch(task);
  422. }
  423. if (task == prevHead) {
  424. // Back at task_head, nothing wants to run.
  425. kprintf("Nothing wants to run!\n");
  426. kprintf("PID OWNER STATE NSCHED NAME\n");
  427. for (auto* task = s_tasks->head(); task; task = task->next()) {
  428. kprintf("%w %w:%w %b %w %s\n",
  429. task->pid(),
  430. task->uid(),
  431. task->gid(),
  432. task->state(),
  433. task->timesScheduled(),
  434. task->name().characters());
  435. }
  436. kprintf("Switch to kernel task\n");
  437. return contextSwitch(Task::kernelTask());
  438. }
  439. }
  440. }
  441. static bool contextSwitch(Task* t)
  442. {
  443. //kprintf("c_s to %s (same:%u)\n", t->name().characters(), current == t);
  444. t->setTicksLeft(5);
  445. t->didSchedule();
  446. if (current == t)
  447. return false;
  448. // Some sanity checking to force a crash earlier.
  449. auto csRPL = t->tss().cs & 3;
  450. auto ssRPL = t->tss().ss & 3;
  451. if (csRPL != ssRPL) {
  452. kprintf("Fuckup! Switching from %s(%u) to %s(%u) has RPL mismatch\n",
  453. current->name().characters(), current->pid(),
  454. t->name().characters(), t->pid()
  455. );
  456. kprintf("code: %w:%x\n", t->tss().cs, t->tss().eip);
  457. kprintf(" stk: %w:%x\n", t->tss().ss, t->tss().esp);
  458. ASSERT(csRPL == ssRPL);
  459. }
  460. if (current) {
  461. // If the last task hasn't blocked (still marked as running),
  462. // mark it as runnable for the next round.
  463. if (current->state() == Task::Running)
  464. current->setState(Task::Runnable);
  465. bool success = MemoryManager::the().unmapRegionsForTask(*current);
  466. ASSERT(success);
  467. }
  468. bool success = MemoryManager::the().mapRegionsForTask(*t);
  469. ASSERT(success);
  470. current = t;
  471. t->setState(Task::Running);
  472. if (!t->selector())
  473. t->setSelector(allocateGDTEntry());
  474. auto& tssDescriptor = getGDTEntry(t->selector());
  475. tssDescriptor.limit_hi = 0;
  476. tssDescriptor.limit_lo = 0xFFFF;
  477. tssDescriptor.base_lo = (DWORD)(&t->tss()) & 0xFFFF;
  478. tssDescriptor.base_hi = ((DWORD)(&t->tss()) >> 16) & 0xFF;
  479. tssDescriptor.base_hi2 = ((DWORD)(&t->tss()) >> 24) & 0xFF;
  480. tssDescriptor.dpl = 0;
  481. tssDescriptor.segment_present = 1;
  482. tssDescriptor.granularity = 1;
  483. tssDescriptor.zero = 0;
  484. tssDescriptor.operation_size = 1;
  485. tssDescriptor.descriptor_type = 0;
  486. tssDescriptor.type = 11; // Busy TSS
  487. flushGDT();
  488. return true;
  489. }
  490. Task* Task::fromPID(pid_t pid)
  491. {
  492. for (auto* task = s_tasks->head(); task; task = task->next()) {
  493. if (task->pid() == pid)
  494. return task;
  495. }
  496. return nullptr;
  497. }
  498. FileHandle* Task::fileHandleIfExists(int fd)
  499. {
  500. if (fd < 0)
  501. return nullptr;
  502. if ((unsigned)fd < m_fileHandles.size())
  503. return m_fileHandles[fd].ptr();
  504. return nullptr;
  505. }
  506. ssize_t Task::sys$get_dir_entries(int fd, void* buffer, size_t size)
  507. {
  508. auto* handle = fileHandleIfExists(fd);
  509. if (!handle)
  510. return -1;
  511. return handle->get_dir_entries((byte*)buffer, size);
  512. }
  513. int Task::sys$seek(int fd, int offset)
  514. {
  515. auto* handle = fileHandleIfExists(fd);
  516. if (!handle)
  517. return -1;
  518. return handle->seek(offset, SEEK_SET);
  519. }
  520. ssize_t Task::sys$read(int fd, void* outbuf, size_t nread)
  521. {
  522. Task::checkSanity("Task::sys$read");
  523. #ifdef DEBUG_IO
  524. kprintf("Task::sys$read: called(%d, %p, %u)\n", fd, outbuf, nread);
  525. #endif
  526. auto* handle = fileHandleIfExists(fd);
  527. #ifdef DEBUG_IO
  528. kprintf("Task::sys$read: handle=%p\n", handle);
  529. #endif
  530. if (!handle) {
  531. kprintf("Task::sys$read: handle not found :(\n");
  532. return -1;
  533. }
  534. #ifdef DEBUG_IO
  535. kprintf("call read on handle=%p\n", handle);
  536. #endif
  537. if (handle->isBlocking()) {
  538. if (!handle->hasDataAvailableForRead()) {
  539. m_fdBlockedOnRead = fd;
  540. block(BlockedRead);
  541. yield();
  542. }
  543. }
  544. nread = handle->read((byte*)outbuf, nread);
  545. #ifdef DEBUG_IO
  546. kprintf("Task::sys$read: nread=%u\n", nread);
  547. #endif
  548. return nread;
  549. }
  550. int Task::sys$close(int fd)
  551. {
  552. auto* handle = fileHandleIfExists(fd);
  553. if (!handle)
  554. return -1;
  555. // FIXME: Implement.
  556. return 0;
  557. }
  558. int Task::sys$lstat(const char* path, void* statbuf)
  559. {
  560. auto handle = VirtualFileSystem::the().open(move(path));
  561. if (!handle)
  562. return -1;
  563. handle->stat((Unix::stat*)statbuf);
  564. return 0;
  565. }
  566. int Task::sys$getcwd(char* buffer, size_t size)
  567. {
  568. if (size < m_cwd.length() + 1) {
  569. // FIXME: return -ERANGE;
  570. return -1;
  571. }
  572. memcpy(buffer, m_cwd.characters(), m_cwd.length());
  573. buffer[m_cwd.length()] = '\0';
  574. return 0;
  575. }
  576. int Task::sys$open(const char* path, size_t pathLength)
  577. {
  578. Task::checkSanity("sys$open");
  579. #ifdef DEBUG_IO
  580. kprintf("Task::sys$open(): PID=%u, path=%s {%u}\n", m_pid, path, pathLength);
  581. #endif
  582. auto* handle = openFile(String(path, pathLength));
  583. if (handle)
  584. return handle->fd();
  585. return -1;
  586. }
  587. FileHandle* Task::openFile(String&& path)
  588. {
  589. auto handle = VirtualFileSystem::the().open(move(path));
  590. if (!handle) {
  591. #ifdef DEBUG_IO
  592. kprintf("vfs::open() failed\n");
  593. #endif
  594. return nullptr;
  595. }
  596. handle->setFD(m_fileHandles.size());
  597. #ifdef DEBUG_IO
  598. kprintf("vfs::open() worked! handle=%p, fd=%d\n", handle.ptr(), handle->fd());
  599. #endif
  600. m_fileHandles.append(move(handle)); // FIXME: allow non-move Vector::append
  601. return m_fileHandles.last().ptr();
  602. }
  603. int Task::sys$kill(pid_t pid, int sig)
  604. {
  605. (void) sig;
  606. if (pid == 0) {
  607. // FIXME: Send to same-group processes.
  608. ASSERT(pid != 0);
  609. }
  610. if (pid == -1) {
  611. // FIXME: Send to all processes.
  612. ASSERT(pid != -1);
  613. }
  614. ASSERT_NOT_REACHED();
  615. Task* peer = Task::fromPID(pid);
  616. if (!peer) {
  617. // errno = ESRCH;
  618. return -1;
  619. }
  620. return -1;
  621. }
  622. int Task::sys$sleep(unsigned seconds)
  623. {
  624. if (!seconds)
  625. return 0;
  626. sleep(seconds * TICKS_PER_SECOND);
  627. return 0;
  628. }
  629. int Task::sys$gettimeofday(timeval* tv)
  630. {
  631. InterruptDisabler disabler;
  632. auto now = RTC::now();
  633. tv->tv_sec = now;
  634. tv->tv_usec = 0;
  635. return 0;
  636. }
  637. uid_t Task::sys$getuid()
  638. {
  639. return m_uid;
  640. }
  641. gid_t Task::sys$getgid()
  642. {
  643. return m_gid;
  644. }
  645. pid_t Task::sys$getpid()
  646. {
  647. return m_pid;
  648. }
  649. pid_t Task::sys$waitpid(pid_t waitee)
  650. {
  651. InterruptDisabler disabler;
  652. if (!Task::fromPID(waitee))
  653. return -1;
  654. m_waitee = waitee;
  655. block(BlockedWait);
  656. yield();
  657. return m_waitee;
  658. }
  659. void Task::unblock()
  660. {
  661. ASSERT(m_state != Task::Runnable && m_state != Task::Running);
  662. system.nblocked--;
  663. m_state = Task::Runnable;
  664. }
  665. void Task::block(Task::State state)
  666. {
  667. ASSERT(current->state() == Task::Running);
  668. system.nblocked++;
  669. current->setState(state);
  670. }
  671. void block(Task::State state)
  672. {
  673. current->block(state);
  674. yield();
  675. }
  676. void sleep(DWORD ticks)
  677. {
  678. ASSERT(current->state() == Task::Running);
  679. current->setWakeupTime(system.uptime + ticks);
  680. current->block(Task::BlockedSleep);
  681. yield();
  682. }
  683. Task* Task::kernelTask()
  684. {
  685. ASSERT(s_kernelTask);
  686. return s_kernelTask;
  687. }
  688. Task::Region::Region(LinearAddress a, size_t s, RetainPtr<Zone>&& z, String&& n)
  689. : linearAddress(a)
  690. , size(s)
  691. , zone(move(z))
  692. , name(move(n))
  693. {
  694. }
  695. Task::Region::~Region()
  696. {
  697. }