process.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523
  1. /* Process management: create, exit, round-robin schedule, ps, kill. */
  2. #include "process.h"
  3. #include "elf.h"
  4. #include "idle.h"
  5. #include "io.h"
  6. #include "kmalloc.h"
  7. #include "mm.h"
  8. #include "paging.h"
  9. #include "serial.h"
  10. #include "timer.h"
  11. struct process *procs; /* dynamically-sized process table */
  12. volatile unsigned int current_pid;
  13. static unsigned int proc_cap; /* current capacity of procs[] */
  14. static unsigned int next_pid_counter = 1; /* monotonic, wraps */
  15. static unsigned int fallback_stack_next; /* 0..PROC_FALLBACK_STACK_MAX */
  16. #define INITIAL_PROC_CAP 16
  17. /* ---- interrupt flag save/restore (for short critical sections) ---- */
  18. static inline unsigned int irq_save_disable(void)
  19. {
  20. unsigned int flags;
  21. __asm__ volatile ("pushfl; popl %0; cli" : "=r"(flags));
  22. return flags;
  23. }
  24. static inline void irq_restore(unsigned int flags)
  25. {
  26. __asm__ volatile ("pushl %0; popfl" : : "r"(flags));
  27. }
  28. /* Allocate a process stack and return its BASE address (page-aligned), or 0.
  29. * *owned is set to 1 if it came from the frame allocator (must be freed on
  30. * exit), 0 if it came from the fallback pool. */
  31. static unsigned int stack_alloc(int *owned)
  32. {
  33. unsigned int base = mm_alloc_page();
  34. if (base) {
  35. *owned = 1;
  36. return base;
  37. }
  38. if (fallback_stack_next < PROC_FALLBACK_STACK_MAX) {
  39. unsigned int top = PROC_FALLBACK_STACK_BASE
  40. + fallback_stack_next * PROC_STACK_SIZE
  41. + PROC_STACK_SIZE;
  42. fallback_stack_next++;
  43. *owned = 0;
  44. return top - PROC_STACK_SIZE;
  45. }
  46. return 0;
  47. }
  48. static void name_copy(char *dst, const char *src)
  49. {
  50. unsigned int i;
  51. for (i = 0; i < PROC_NAME_LEN - 1 && src[i]; i++)
  52. dst[i] = src[i];
  53. dst[i] = '\0';
  54. }
  55. /* Double the process table. Called with interrupts disabled. */
  56. static int grow_proc_table(void)
  57. {
  58. unsigned int new_cap = proc_cap * 2;
  59. struct process *np =
  60. (struct process *)kmalloc(new_cap * sizeof(struct process));
  61. unsigned int i;
  62. if (!np)
  63. return 0;
  64. for (i = 0; i < proc_cap; i++)
  65. np[i] = procs[i];
  66. for (i = proc_cap; i < new_cap; i++)
  67. np[i].state = PROC_UNUSED;
  68. kfree(procs);
  69. procs = np;
  70. proc_cap = new_cap;
  71. return 1;
  72. }
  73. /* Find a free process slot (1..proc_cap-1), growing the table if needed.
  74. * Slot 0 is the window manager and is never returned. Called with interrupts
  75. * disabled. Returns the slot index, or -1 on failure. */
  76. static int alloc_slot(void)
  77. {
  78. unsigned int slot;
  79. for (slot = 1; slot < proc_cap; slot++)
  80. if (procs[slot].state == PROC_UNUSED)
  81. return (int)slot;
  82. if (!grow_proc_table())
  83. return -1;
  84. for (slot = 1; slot < proc_cap; slot++)
  85. if (procs[slot].state == PROC_UNUSED)
  86. return (int)slot;
  87. return -1;
  88. }
  89. void process_init(void)
  90. {
  91. unsigned int i;
  92. procs = (struct process *)kmalloc(INITIAL_PROC_CAP * sizeof(struct process));
  93. if (!procs) {
  94. serial_puts(SERIAL_COM1, "process_init: out of memory\n");
  95. for (;;)
  96. __asm__ volatile ("cli; hlt");
  97. }
  98. proc_cap = INITIAL_PROC_CAP;
  99. for (i = 0; i < proc_cap; i++)
  100. procs[i].state = PROC_UNUSED;
  101. procs[0].state = PROC_RUNNING;
  102. procs[0].pid = 0;
  103. procs[0].esp = 0;
  104. procs[0].screen = (void *)0;
  105. procs[0].stack_base = 0; /* bootstrap stack, never freed */
  106. procs[0].cr3 = paging_current_cr3();
  107. procs[0].kstack_top = 0x42800; /* bootstrap stack top */
  108. name_copy(procs[0].name, "wm");
  109. current_pid = 0;
  110. }
  111. /*
  112. * Build initial stack frame for a new process so that popa + iret
  113. * "returns" to the entry point. For arg-taking entries the argument
  114. * string is copied onto the stack and a pointer to it passed as the
  115. * first C parameter.
  116. *
  117. * Stack layout (high to low):
  118. *
  119. * [copied arg string, if any, rounded up to 4-byte boundary]
  120. * arg pointer -- first C parameter (only if has_arg)
  121. * process_exit address -- return address seen by the entry function
  122. * EFLAGS (0x202) -- IF=1
  123. * CS (0x08)
  124. * EIP (entry) -- iret target
  125. * EAX ECX EDX EBX ESP_orig EBP ESI EDI (pusha frame)
  126. * <- saved ESP
  127. */
  128. static int setup_process(const char *name, unsigned int entry,
  129. int has_arg, const char *arg)
  130. {
  131. int slot, owned;
  132. unsigned int base, top, *sp, arg_ptr = 0, cr3;
  133. unsigned int flags;
  134. flags = irq_save_disable();
  135. slot = alloc_slot();
  136. if (slot < 0) {
  137. irq_restore(flags);
  138. return -1;
  139. }
  140. cr3 = paging_new_directory();
  141. if (!cr3) {
  142. irq_restore(flags);
  143. return -1;
  144. }
  145. base = stack_alloc(&owned);
  146. if (!base) {
  147. mm_free_page(cr3);
  148. irq_restore(flags);
  149. return -1;
  150. }
  151. top = base + PROC_STACK_SIZE;
  152. sp = (unsigned int *)top;
  153. if (has_arg && arg) {
  154. unsigned int len, aligned, i;
  155. char *dst;
  156. for (len = 0; arg[len]; len++)
  157. ;
  158. len++;
  159. aligned = (len + 3) & ~3u;
  160. sp = (unsigned int *)((unsigned int)sp - aligned);
  161. dst = (char *)sp;
  162. for (i = 0; i < len; i++)
  163. dst[i] = arg[i];
  164. for (; i < aligned; i++)
  165. dst[i] = '\0';
  166. arg_ptr = (unsigned int)sp;
  167. }
  168. if (has_arg)
  169. *--sp = arg_ptr;
  170. *--sp = (unsigned int)process_exit;
  171. *--sp = 0x202; /* EFLAGS: IF=1 */
  172. *--sp = 0x08; /* CS */
  173. *--sp = entry; /* EIP */
  174. *--sp = 0; /* EAX */
  175. *--sp = 0; /* ECX */
  176. *--sp = 0; /* EDX */
  177. *--sp = 0; /* EBX */
  178. *--sp = 0; /* ESP (ignored by popa) */
  179. *--sp = 0; /* EBP */
  180. *--sp = 0; /* ESI */
  181. *--sp = 0; /* EDI */
  182. procs[slot].esp = (unsigned int)sp;
  183. procs[slot].state = PROC_READY;
  184. procs[slot].pid = next_pid_counter++;
  185. procs[slot].stack_base = owned ? base : 0;
  186. procs[slot].cr3 = cr3;
  187. procs[slot].kstack_top = top;
  188. name_copy(procs[slot].name, name);
  189. /* Child inherits the parent's output screen (command output lands in the
  190. terminal that spawned it). */
  191. procs[slot].screen = procs[current_pid].screen;
  192. irq_restore(flags);
  193. return (int)procs[slot].pid;
  194. }
  195. int process_create(const char *name, void (*entry)(void))
  196. {
  197. return setup_process(name, (unsigned int)entry, 0, (void *)0);
  198. }
  199. int process_create_arg(const char *name, void (*entry)(const char *),
  200. const char *arg)
  201. {
  202. return setup_process(name, (unsigned int)entry, 1, arg);
  203. }
  204. /* Create a process whose entry takes a raw pointer argument (no string copy). */
  205. int process_create_ptr(const char *name, void (*entry)(void *), void *arg)
  206. {
  207. int slot, owned;
  208. unsigned int base, top, *sp, cr3;
  209. unsigned int flags;
  210. flags = irq_save_disable();
  211. slot = alloc_slot();
  212. if (slot < 0) {
  213. irq_restore(flags);
  214. return -1;
  215. }
  216. cr3 = paging_new_directory();
  217. if (!cr3) {
  218. irq_restore(flags);
  219. return -1;
  220. }
  221. base = stack_alloc(&owned);
  222. if (!base) {
  223. mm_free_page(cr3);
  224. irq_restore(flags);
  225. return -1;
  226. }
  227. top = base + PROC_STACK_SIZE;
  228. sp = (unsigned int *)top;
  229. *--sp = (unsigned int)arg; /* first C parameter */
  230. *--sp = (unsigned int)process_exit;/* return address */
  231. *--sp = 0x202; /* EFLAGS: IF=1 */
  232. *--sp = 0x08; /* CS */
  233. *--sp = (unsigned int)entry; /* EIP */
  234. *--sp = 0; *--sp = 0; *--sp = 0; *--sp = 0; /* EAX ECX EDX EBX */
  235. *--sp = 0; *--sp = 0; *--sp = 0; *--sp = 0; /* ESP EBP ESI EDI */
  236. procs[slot].esp = (unsigned int)sp;
  237. procs[slot].state = PROC_READY;
  238. procs[slot].pid = next_pid_counter++;
  239. procs[slot].stack_base = owned ? base : 0;
  240. procs[slot].cr3 = cr3;
  241. procs[slot].kstack_top = top;
  242. name_copy(procs[slot].name, name);
  243. procs[slot].screen = procs[current_pid].screen;
  244. irq_restore(flags);
  245. return (int)procs[slot].pid;
  246. }
  247. /* Load an ELF image into a fresh address space and run it as a ring-3 process. */
  248. int process_create_user(const char *name, const void *image, unsigned int size)
  249. {
  250. int slot, owned;
  251. unsigned int base, top, *sp, cr3, entry;
  252. unsigned int flags;
  253. int i;
  254. flags = irq_save_disable();
  255. slot = alloc_slot();
  256. if (slot < 0) {
  257. irq_restore(flags);
  258. return -1;
  259. }
  260. cr3 = paging_new_directory();
  261. if (!cr3) {
  262. irq_restore(flags);
  263. return -1;
  264. }
  265. entry = elf_load(cr3, image, size);
  266. if (!entry) {
  267. mm_free_page(cr3);
  268. irq_restore(flags);
  269. return -1;
  270. }
  271. /* Map the user stack just below USER_STACK_TOP. */
  272. for (i = 0; i < USER_STACK_PAGES; i++) {
  273. unsigned int phys = mm_alloc_page();
  274. unsigned int va = USER_STACK_TOP - (unsigned int)(i + 1) * 0x1000;
  275. if (!phys ||
  276. !paging_map_page(cr3, va, phys,
  277. PTE_USER | PTE_WRITABLE | PTE_PRESENT)) {
  278. mm_free_page(cr3);
  279. irq_restore(flags);
  280. return -1;
  281. }
  282. }
  283. base = stack_alloc(&owned);
  284. if (!base) {
  285. mm_free_page(cr3);
  286. irq_restore(flags);
  287. return -1;
  288. }
  289. top = base + PROC_STACK_SIZE;
  290. sp = (unsigned int *)top;
  291. *--sp = 0x23; /* SS: user data */
  292. *--sp = USER_STACK_TOP; /* ESP: user stack */
  293. *--sp = 0x202; /* EFLAGS: IF=1 */
  294. *--sp = 0x1B; /* CS: user code */
  295. *--sp = entry; /* EIP */
  296. *--sp = 0; *--sp = 0; *--sp = 0; *--sp = 0; /* EAX ECX EDX EBX */
  297. *--sp = 0; *--sp = 0; *--sp = 0; *--sp = 0; /* ESP EBP ESI EDI */
  298. procs[slot].esp = (unsigned int)sp;
  299. procs[slot].state = PROC_READY;
  300. procs[slot].pid = next_pid_counter++;
  301. procs[slot].stack_base = owned ? base : 0;
  302. procs[slot].cr3 = cr3;
  303. procs[slot].kstack_top = top;
  304. name_copy(procs[slot].name, name);
  305. procs[slot].screen = procs[current_pid].screen;
  306. irq_restore(flags);
  307. return (int)procs[slot].pid;
  308. }
  309. /* Set the output screen of the currently-running process (used by a terminal
  310. at startup to bind itself to its own screen). */
  311. void process_set_screen(struct text_screen *screen)
  312. {
  313. procs[current_pid].screen = screen;
  314. }
  315. void process_map_mmio_all(unsigned int phys_base, unsigned int size)
  316. {
  317. unsigned int i, kernel_cr3 = paging_current_cr3();
  318. paging_map_mmio(phys_base, size);
  319. for (i = 0; i < proc_cap; i++) {
  320. if (procs[i].cr3 && procs[i].cr3 != kernel_cr3)
  321. paging_map_mmio_cr3(procs[i].cr3, phys_base, size);
  322. }
  323. }
  324. void process_exit(void)
  325. {
  326. procs[current_pid].state = PROC_DEAD;
  327. __asm__ volatile ("sti"); /* re-enable IRQs so the PIT can switch us out */
  328. for (;;)
  329. __asm__ volatile ("hlt");
  330. }
  331. /*
  332. * Round-robin scheduler. Called from the PIT IRQ stub with interrupts
  333. * disabled. Picks the next runnable process and updates current_pid.
  334. * The caller (switch.S) takes care of actually switching ESP.
  335. */
  336. void schedule(void)
  337. {
  338. unsigned int i, next;
  339. /* Reap dead processes, freeing their stacks. Skip the current slot: we
  340. * may be running on its stack right now (it just called process_exit),
  341. * so it is reaped on a later schedule() from another process's context. */
  342. for (i = 0; i < proc_cap; i++) {
  343. if (procs[i].state == PROC_DEAD && i != current_pid) {
  344. if (procs[i].stack_base)
  345. mm_free_page(procs[i].stack_base);
  346. if (procs[i].cr3 && procs[i].cr3 != paging_current_cr3())
  347. mm_free_page(procs[i].cr3);
  348. procs[i].stack_base = 0;
  349. procs[i].cr3 = 0;
  350. procs[i].state = PROC_UNUSED;
  351. }
  352. }
  353. /* Wake sleeping processes whose deadline has passed. */
  354. for (i = 0; i < proc_cap; i++) {
  355. if (procs[i].state == PROC_SLEEPING &&
  356. (int)(procs[i].wake_ms - get_ticks_ms()) <= 0)
  357. procs[i].state = PROC_READY;
  358. }
  359. /* Mark current as READY (it was RUNNING). */
  360. if (procs[current_pid].state == PROC_RUNNING)
  361. procs[current_pid].state = PROC_READY;
  362. /* Find next runnable slot. */
  363. next = current_pid;
  364. for (i = 0; i < proc_cap; i++) {
  365. next = (next + 1) % proc_cap;
  366. if (procs[next].state == PROC_READY) {
  367. procs[next].state = PROC_RUNNING;
  368. current_pid = next;
  369. return;
  370. }
  371. }
  372. /* Nothing else runnable -- stay on current if still alive. */
  373. if (procs[current_pid].state == PROC_READY) {
  374. procs[current_pid].state = PROC_RUNNING;
  375. return;
  376. }
  377. /* Everything dead: fall back to slot 0 (window manager). */
  378. procs[0].state = PROC_RUNNING;
  379. current_pid = 0;
  380. }
  381. /* ---- user-facing helpers ---- */
  382. static const char *state_str(unsigned int s)
  383. {
  384. switch (s) {
  385. case PROC_RUNNING: return "run ";
  386. case PROC_READY: return "ready";
  387. default: return "? ";
  388. }
  389. }
  390. static void put_dec(unsigned int n)
  391. {
  392. char buf[12];
  393. unsigned int i = sizeof(buf) - 1;
  394. buf[i] = '\0';
  395. if (n == 0) {
  396. io_putchar('0');
  397. return;
  398. }
  399. while (n && i > 0) {
  400. buf[--i] = (char)('0' + (n % 10));
  401. n /= 10;
  402. }
  403. io_putstr(buf + i);
  404. }
  405. void process_ps(void)
  406. {
  407. unsigned int i;
  408. io_putstr("PID STATE NAME\n");
  409. for (i = 0; i < proc_cap; i++) {
  410. if (procs[i].state == PROC_UNUSED || procs[i].state == PROC_DEAD)
  411. continue;
  412. io_putchar(' ');
  413. put_dec(procs[i].pid);
  414. io_putstr(" ");
  415. io_putstr(state_str(procs[i].state));
  416. io_putstr(" ");
  417. io_putstr(procs[i].name);
  418. io_putchar('\n');
  419. }
  420. }
  421. int process_kill(unsigned int pid)
  422. {
  423. unsigned int i;
  424. if (pid == 0)
  425. return -1; /* cannot kill window manager */
  426. for (i = 1; i < proc_cap; i++) {
  427. if (procs[i].state != PROC_UNUSED && procs[i].state != PROC_DEAD &&
  428. procs[i].pid == pid) {
  429. procs[i].state = PROC_DEAD;
  430. return 0;
  431. }
  432. }
  433. return -1;
  434. }
  435. /* Return 1 if a process with `pid` is still alive (READY/RUNNING/SLEEPING). */
  436. int process_is_alive(unsigned int pid)
  437. {
  438. unsigned int i;
  439. for (i = 0; i < proc_cap; i++)
  440. if (procs[i].pid == pid &&
  441. (procs[i].state == PROC_READY ||
  442. procs[i].state == PROC_RUNNING ||
  443. procs[i].state == PROC_SLEEPING))
  444. return 1;
  445. return 0;
  446. }
  447. /* Block the current process for `ms` milliseconds. Marks it sleeping and
  448. * yields to the scheduler; it is woken when its deadline passes. */
  449. void process_sleep_ms(unsigned int ms)
  450. {
  451. procs[current_pid].wake_ms = get_ticks_ms() + ms;
  452. procs[current_pid].state = PROC_SLEEPING;
  453. __asm__ volatile ("sti"); /* re-enable IRQs so the PIT can switch us out */
  454. while (procs[current_pid].state == PROC_SLEEPING)
  455. cpu_idle();
  456. }
  457. /* Wait (yield) until the process with `pid` has exited. */
  458. void process_wait(unsigned int pid)
  459. {
  460. while (process_is_alive(pid))
  461. process_sleep_ms(10);
  462. }