syscall.c 13 KB

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