syscall.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371
  1. /* Syscall dispatcher: services int 0x80 requests from ring-3. */
  2. #include "syscall.h"
  3. #include "io.h"
  4. #include "paging.h"
  5. #include "process.h"
  6. #include "rtc.h"
  7. #include "serial.h"
  8. #include "sys_fs.h"
  9. #include "sys_gfx.h"
  10. #include "sys_info.h"
  11. #include "sys_mem.h"
  12. #include "sys_net.h"
  13. #include "sys_wm.h"
  14. #include "terminal.h"
  15. #include "timer.h"
  16. #include "tty.h"
  17. #include "vfs.h"
  18. static int copy_user_string(char *dst, unsigned int max, const char *src)
  19. {
  20. unsigned int i;
  21. if (!src || !max ||
  22. !paging_user_range_ok(current_proc()->cr3, (unsigned int)src,
  23. max, 0))
  24. return -1;
  25. for (i = 0; i + 1 < max && src[i]; i++)
  26. dst[i] = src[i];
  27. dst[i] = '\0';
  28. return 0;
  29. }
  30. static int syscall_dispatch_locked(int num, int a1, int a2, int a3)
  31. {
  32. switch (num) {
  33. case SYS_PUTSTR:
  34. io_putstr((const char *)a1);
  35. return 0;
  36. case SYS_GET_TICKS_MS:
  37. return (int)get_ticks_ms();
  38. case SYS_SLEEP_MS:
  39. process_sleep_ms((unsigned int)a1);
  40. return 0;
  41. case SYS_EXIT:
  42. process_exit(); /* never returns */
  43. return 0;
  44. case SYS_READ_FILE:
  45. return sys_read_file((const char *)a1, (void *)a2, (unsigned int)a3);
  46. case SYS_WRITE_FILE:
  47. return sys_write_file((const char *)a1, (const void *)a2,
  48. (unsigned int)a3);
  49. case SYS_LIST_DIR:
  50. return sys_list_dir((const char *)a1, (unsigned int)a2,
  51. (struct sys_dirent *)a3);
  52. case SYS_UNLINK:
  53. return sys_unlink((const char *)a1);
  54. case SYS_MKDIR:
  55. return sys_mkdir((const char *)a1);
  56. case SYS_RMDIR:
  57. return sys_rmdir((const char *)a1);
  58. case SYS_LIST_MOUNTS:
  59. return sys_list_mounts((unsigned int)a1, (struct sys_mount *)a2);
  60. case SYS_MEMINFO:
  61. return sys_meminfo((struct sys_meminfo *)a1);
  62. case SYS_E820:
  63. return sys_e820((unsigned int)a1, (struct sys_e820 *)a2);
  64. case SYS_MOUSEINFO:
  65. return sys_mouseinfo((struct sys_mouseinfo *)a1);
  66. case SYS_STORAGE_INFO:
  67. return sys_storage_info((struct sys_storage_info *)a1);
  68. case SYS_BLKDEV:
  69. return sys_blkdev((unsigned int)a1, (struct sys_blkdev *)a2);
  70. case SYS_NET_INFO:
  71. return sys_net_info((struct sys_netinfo *)a1);
  72. case SYS_NET_PRINT_INFO:
  73. return sys_net_print_info();
  74. case SYS_NET_ACQUIRE:
  75. return sys_net_acquire();
  76. case SYS_NET_RELEASE:
  77. return sys_net_release();
  78. case SYS_NET_MAC:
  79. return sys_net_mac((unsigned char *)a1);
  80. case SYS_NET_GET_IP:
  81. sys_net_get_ip((unsigned char *)a1);
  82. return 0;
  83. case SYS_NET_SET_IP:
  84. sys_net_set_ip((const unsigned char *)a1);
  85. return 0;
  86. case SYS_NET_GET_MASK:
  87. sys_net_get_mask((unsigned char *)a1);
  88. return 0;
  89. case SYS_NET_GET_GW:
  90. sys_net_get_gw((unsigned char *)a1);
  91. return 0;
  92. case SYS_NET_GET_DNS:
  93. sys_net_get_dns((unsigned char *)a1);
  94. return 0;
  95. case SYS_NET_SET_DNS:
  96. sys_net_set_dns((const unsigned char *)a1);
  97. return 0;
  98. case SYS_NET_TX:
  99. return sys_net_tx((const unsigned char *)a1, (unsigned int)a2);
  100. case SYS_NET_RX:
  101. return sys_net_rx((unsigned char *)a1, (unsigned int)a2);
  102. case SYS_NET_DECODE:
  103. sys_net_decode((const unsigned char *)a1, (unsigned int)a2);
  104. return 0;
  105. case SYS_NET_REPLY:
  106. return sys_net_reply((const unsigned char *)a1, (unsigned int)a2,
  107. (unsigned char *)a3);
  108. case SYS_NET_LOOPBACK:
  109. return sys_net_loopback(a1);
  110. case SYS_NET_REGS:
  111. return sys_net_regs();
  112. case SYS_NET_RESET:
  113. return sys_net_reset();
  114. case SYS_DHCP_RUN:
  115. return sys_dhcp_run((unsigned int)a1);
  116. case SYS_DHCP_INFO:
  117. return sys_dhcp_info((unsigned char *)a1, (unsigned int *)a2);
  118. case SYS_DNS_RESOLVE:
  119. return sys_dns_resolve((const char *)a1, (unsigned char *)a2);
  120. case SYS_NETLOG:
  121. return sys_netlog((const char *)a1);
  122. case SYS_NETLOG_CONF:
  123. return sys_netlog_conf(a1, (const unsigned char *)a2);
  124. case SYS_TCP_CONNECT:
  125. return sys_tcp_connect((const unsigned char *)a1,
  126. (const unsigned char *)a2,
  127. (unsigned int)a3);
  128. case SYS_TCP_PEER_MSS:
  129. return sys_tcp_peer_mss();
  130. case SYS_TCP_SEND:
  131. return sys_tcp_send((const void *)a1, (unsigned int)a2);
  132. case SYS_TCP_RECV:
  133. return sys_tcp_recv((void *)a1, (unsigned int)a2, (unsigned int)a3);
  134. case SYS_TCP_CLOSE:
  135. sys_tcp_close();
  136. return 0;
  137. case SYS_NET_NEXT_HOP:
  138. return sys_net_next_hop((const unsigned char *)a1,
  139. (unsigned char *)a2);
  140. case SYS_NET_ARP:
  141. return sys_net_arp((const unsigned char *)a1, (unsigned char *)a2);
  142. case SYS_NET_CONFIGURED:
  143. return sys_net_configured();
  144. case SYS_GETCWD: {
  145. const char *cwd = current_proc()->cwd;
  146. char *out = (char *)a1;
  147. unsigned int i = 0, max = (unsigned int)a2;
  148. if (!cwd || max == 0)
  149. return -1;
  150. for (i = 0; cwd[i] && i + 1 < max; i++)
  151. out[i] = cwd[i];
  152. out[i] = '\0';
  153. return 0;
  154. }
  155. case SYS_PROCINFO:
  156. return process_procinfo((unsigned int)a1,
  157. (struct sys_procinfo *)a2);
  158. case SYS_GET_CURSOR:
  159. return (int)io_get_cursor();
  160. case SYS_SET_CURSOR:
  161. io_set_cursor((unsigned int)a1);
  162. return 0;
  163. case SYS_GFX_BEGIN:
  164. return sys_gfx_begin((struct sys_gfx_info *)a1);
  165. case SYS_GFX_PRESENT:
  166. return sys_gfx_present();
  167. case SYS_GFX_END:
  168. return sys_gfx_end();
  169. case SYS_KEY_POLL:
  170. return sys_gfx_key_poll();
  171. case SYS_RTC_HMS: {
  172. struct sys_time *out = (struct sys_time *)a1;
  173. unsigned int h, m, s;
  174. if (!out)
  175. return -1;
  176. rtc_read_hms(&h, &m, &s);
  177. out->hour = h;
  178. out->minute = m;
  179. out->second = s;
  180. return 0;
  181. }
  182. case SYS_RTC_DATETIME: {
  183. char buf[20];
  184. char *out = (char *)a1;
  185. unsigned int i;
  186. if ((unsigned int)a2 < sizeof(buf) ||
  187. !paging_user_range_ok(current_proc()->cr3,
  188. (unsigned int)out, sizeof(buf), 1))
  189. return -1;
  190. rtc_read_datetime(buf);
  191. for (i = 0; i < sizeof(buf); i++)
  192. out[i] = buf[i];
  193. return 0;
  194. }
  195. case SYS_WM_ATTACH:
  196. return sys_wm_attach((struct wm_screen_info *)a1);
  197. case SYS_WM_INFO:
  198. return sys_wm_info((unsigned int)a1,
  199. (struct wm_window_info *)a2);
  200. case SYS_WM_MAP:
  201. return sys_wm_map((unsigned int)a1,
  202. (struct wm_map_info *)a2);
  203. case SYS_WM_ACK:
  204. return sys_wm_ack((unsigned int)a1, (unsigned int)a2);
  205. case SYS_WM_FOCUS:
  206. return sys_wm_focus((unsigned int)a1);
  207. case SYS_WM_SET_GEOM:
  208. return sys_wm_set_geom((unsigned int)a1,
  209. (const struct wm_geom *)a2);
  210. case SYS_WM_CREATE_TERM:
  211. return sys_wm_create_term();
  212. case SYS_WM_CLOSE:
  213. return sys_wm_close((unsigned int)a1);
  214. case SYS_WM_POLL:
  215. return sys_wm_poll((struct wm_status *)a1);
  216. case SYS_WM_BEGIN:
  217. return sys_wm_begin();
  218. case SYS_WM_PRESENT:
  219. return sys_wm_present((const struct wm_present_info *)a1);
  220. case SYS_WM_SYNC:
  221. return sys_wm_sync();
  222. case SYS_WIN_CREATE:
  223. return sys_win_create((const struct win_create *)a1,
  224. (struct win_info *)a2);
  225. case SYS_WIN_PRESENT:
  226. return sys_win_present();
  227. case SYS_WIN_CLOSE:
  228. return sys_win_close();
  229. case SYS_WM_RESIZE:
  230. return sys_wm_resize((unsigned int)a1,
  231. (const struct wm_size *)a2);
  232. case SYS_WIN_INFO:
  233. return sys_win_info((struct win_info *)a1);
  234. case SYS_WIN_ACK_RESIZE:
  235. return sys_win_ack_resize();
  236. case SYS_WIN_POINTER:
  237. return sys_win_pointer((struct win_pointer *)a1);
  238. case SYS_WIN_EVENT:
  239. return sys_win_event((struct win_event *)a1);
  240. case SYS_MEM_ALLOC:
  241. return sys_mem_alloc((unsigned int)a1);
  242. case SYS_MEM_GROW:
  243. return sys_mem_grow((unsigned int)a1);
  244. case SYS_MEM_FREE:
  245. return sys_mem_free();
  246. case SYS_WIN_KEY_WAIT:
  247. return sys_win_key_wait((unsigned int)a1);
  248. case SYS_SCHEDINFO:
  249. if (!paging_user_range_ok(current_proc()->cr3, (unsigned int)a1,
  250. sizeof(struct sys_schedinfo), 1))
  251. return -1;
  252. return sched_snapshot((struct sys_schedinfo *)a1);
  253. case SYS_TTY_CREATE:
  254. return tty_create();
  255. case SYS_TTY_READ: {
  256. int id = a1;
  257. char *buf = (char *)a2;
  258. unsigned int max = (unsigned int)a3;
  259. if (!tty_valid(id) || !buf || !max ||
  260. !paging_user_range_ok(current_proc()->cr3,
  261. (unsigned int)buf, max, 1))
  262. return -1;
  263. return tty_read(id, buf, max);
  264. }
  265. case SYS_SPAWN: {
  266. struct sys_spawn in;
  267. struct vfs_file f;
  268. struct vfs_mount *m = 0;
  269. char path[VFS_PATH_MAX], arg[VFS_PATH_MAX], cwd[VFS_PATH_MAX];
  270. const char *name;
  271. int pid;
  272. if (!paging_user_range_ok(current_proc()->cr3,
  273. (unsigned int)a1, sizeof(in), 0))
  274. return -1;
  275. {
  276. const char *p = (const char *)a1;
  277. unsigned int i;
  278. unsigned char *d = (unsigned char *)&in;
  279. for (i = 0; i < sizeof(in); i++)
  280. d[i] = (unsigned char)p[i];
  281. }
  282. if (in.tty && !tty_valid((int)in.tty))
  283. return -1;
  284. if (copy_user_string(path, sizeof(path), in.path) != 0 ||
  285. copy_user_string(arg, sizeof(arg), in.arg) != 0 ||
  286. copy_user_string(cwd, sizeof(cwd), in.cwd) != 0)
  287. return -1;
  288. if (vfs_load_file(path, &f, &m) != 0)
  289. return -1;
  290. name = path;
  291. {
  292. const char *q = path;
  293. while (*q) {
  294. if (*q == '/')
  295. name = q + 1;
  296. q++;
  297. }
  298. }
  299. pid = process_create_user_tty(name, f.data, f.size, arg, cwd,
  300. in.tty);
  301. vfs_release_file(m, &f);
  302. return pid;
  303. }
  304. case SYS_SPAWN_KCMD: {
  305. char name[16], arg[VFS_PATH_MAX];
  306. if (copy_user_string(name, sizeof(name), (const char *)a1) != 0 ||
  307. copy_user_string(arg, sizeof(arg), (const char *)a2) != 0)
  308. return -1;
  309. if (a3 && !tty_valid(a3))
  310. return -1;
  311. return term_kcmd_spawn(name, arg, (unsigned int)a3);
  312. }
  313. case SYS_ALIVE:
  314. return process_is_alive((unsigned int)a1);
  315. case SYS_KILL:
  316. return process_kill((unsigned int)a1);
  317. case SYS_CHDIR: {
  318. char arg[VFS_PATH_MAX], abs[VFS_PATH_MAX];
  319. unsigned int size;
  320. int is_dir;
  321. if (copy_user_string(arg, sizeof(arg), (const char *)a1) != 0)
  322. return -1;
  323. if (vfs_join_path(current_proc()->cwd, arg[0] ? arg : ".",
  324. abs, sizeof(abs)) != 0)
  325. return -1;
  326. if (vfs_stat(abs, &size, &is_dir) != 0 || !is_dir)
  327. return -1;
  328. {
  329. unsigned int i;
  330. for (i = 0; abs[i] && i + 1 < sizeof(current_proc()->cwd); i++)
  331. current_proc()->cwd[i] = abs[i];
  332. current_proc()->cwd[i] = '\0';
  333. }
  334. return 0;
  335. }
  336. default:
  337. return -1;
  338. }
  339. }
  340. /* All ring-3 syscalls run under the big kernel lock. Blocking syscalls drop
  341. * it through sched_yield(); the lock is taken back before the dispatcher
  342. * resumes, so the rest of the kernel sees one syscall at a time. */
  343. int syscall_dispatch(int num, int a1, int a2, int a3)
  344. {
  345. struct process *p = current_proc();
  346. int r;
  347. /* A process killed while it was in ring 3 may reach the gate before its
  348. * CPU notices the DEAD state. Do not let it run one more syscall on
  349. * resources that may already be reused. */
  350. if (p && p->state == PROC_DEAD)
  351. process_exit();
  352. bkl_lock();
  353. r = syscall_dispatch_locked(num, a1, a2, a3);
  354. bkl_unlock();
  355. return r;
  356. }