process.h 3.7 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586
  1. /* Preemptive round-robin multitasking for i586, ring-0 only. */
  2. #ifndef PROCESS_H
  3. #define PROCESS_H
  4. #define PROC_STACK_SIZE 0x1000 /* 4 KB per process (= 1 page) */
  5. /* Process stacks are allocated from the frame allocator (mm.c), i.e. above the
  6. * VGA shadow buffer. If a page is unavailable we fall back to a small static
  7. * pool in BSS so the system still boots with fewer processes. */
  8. #define PROC_FALLBACK_STACK_MAX 8
  9. #define PROC_UNUSED 0
  10. #define PROC_READY 1
  11. #define PROC_RUNNING 2
  12. #define PROC_DEAD 3
  13. #define PROC_SLEEPING 4
  14. #define TIMESLICE_TICKS 20 /* context switch every 20 ms (PIT @ 1 kHz) */
  15. #define PROC_NAME_LEN 12
  16. #define PROC_CWD_MAX 64
  17. struct text_screen; /* forward decl (see screen.h) */
  18. struct sys_procinfo; /* forward decl (see syscall.h; `top` snapshot) */
  19. struct process {
  20. unsigned int esp;
  21. unsigned int state;
  22. unsigned int pid;
  23. char name[PROC_NAME_LEN];
  24. struct text_screen *screen; /* output target for io_putchar & co. */
  25. unsigned int stack_base; /* page to free on exit, or 0 (bootstrap/fallback) */
  26. unsigned int cr3; /* physical address of this process's page dir */
  27. unsigned int kstack_top; /* ring-0 stack top (for TSS esp0) */
  28. unsigned int wake_ms; /* tick deadline when PROC_SLEEPING */
  29. char cwd[PROC_CWD_MAX]; /* working directory (ring-3 commands) */
  30. /* CPU accounting for `top`. switch.S credits the running process on
  31. * every PIT tick, so the layout after cwd must match PCB_CPU_TICKS /
  32. * PCB_SIZE there (see the _Static_assert in process.c). */
  33. unsigned int cpu_ticks; /* ticks spent as the running process */
  34. unsigned int start_ticks; /* get_ticks_ms() at creation */
  35. };
  36. /* User-mode virtual address layout (ring-3 processes). */
  37. #define USER_BASE 0x40000000 /* user program link/load address */
  38. #define USER_STACK_TOP 0x40200000 /* user stack top (grows down) */
  39. #define USER_STACK_PAGES 2 /* user stack size in 4 KB pages */
  40. /* Dynamically-sized process table (grown on demand; see process.c). */
  41. extern struct process *procs;
  42. extern volatile unsigned int current_pid;
  43. void process_init(void);
  44. int process_create(const char *name, void (*entry)(void));
  45. int process_create_arg(const char *name, void (*entry)(const char *),
  46. const char *arg);
  47. int process_create_ptr(const char *name, void (*entry)(void *), void *arg);
  48. /* Load an ELF image into a fresh address space and run it as a ring-3
  49. * process, with `arg` (may be NULL) as the first C parameter of _start.
  50. * Returns the pid, -1 when out of resources, or -2 when the image is not a
  51. * loadable ELF. */
  52. int process_create_user(const char *name, const void *image, unsigned int size,
  53. const char *arg, const char *cwd);
  54. void process_set_screen(struct text_screen *screen);
  55. /* Map an MMIO range into the kernel's page directory and every live process
  56. * copy (and thus every process created later, which clones the kernel map).
  57. * Drivers that map their register window at command time must use this: a
  58. * process runs with its own page-directory copy, so paging_map_mmio() alone
  59. * would only be visible to the kernel bootstrap context. */
  60. void process_map_mmio_all(unsigned int phys_base, unsigned int size);
  61. void process_exit(void);
  62. void schedule(void);
  63. void process_ps(void);
  64. /* Fill *out with a snapshot of the index-th live process (slot order) for
  65. * the `top` command. Returns 1 when found, 0 at the end of the table. */
  66. int process_procinfo(unsigned int index, struct sys_procinfo *out);
  67. int process_kill(unsigned int pid);
  68. int process_is_alive(unsigned int pid);
  69. void process_wait(unsigned int pid);
  70. /* Block the current process for `ms` milliseconds (yields the CPU). */
  71. void process_sleep_ms(unsigned int ms);
  72. #endif