syscall.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601
  1. /* Syscall dispatcher: services int 0x80 requests from ring-3. */
  2. #include "syscall.h"
  3. #include "backlight.h"
  4. #include "bootcon.h"
  5. #include "init.h"
  6. #include "io.h"
  7. #include "paging.h"
  8. #include "power.h"
  9. #include "process.h"
  10. #include "rtc.h"
  11. #include "serial.h"
  12. #include "sys_fs.h"
  13. #include "sys_info.h"
  14. #include "sys_mem.h"
  15. #include "sys_net.h"
  16. #include "sys_wm.h"
  17. #include "terminal.h"
  18. #include "timer.h"
  19. #include "tty.h"
  20. #include "vfs.h"
  21. #include "vga.h"
  22. #include "wifi.h"
  23. static int copy_user_string(char *dst, unsigned int max, const char *src)
  24. {
  25. unsigned int i;
  26. if (!src || !max ||
  27. !paging_user_range_ok(current_proc()->cr3, (unsigned int)src,
  28. max, 0))
  29. return -1;
  30. for (i = 0; i + 1 < max && src[i]; i++)
  31. dst[i] = src[i];
  32. dst[i] = '\0';
  33. return 0;
  34. }
  35. static int syscall_dispatch_locked(int num, int a1, int a2, int a3)
  36. {
  37. switch (num) {
  38. case SYS_PUTSTR:
  39. io_putstr((const char *)a1);
  40. return 0;
  41. case SYS_GET_TICKS_MS:
  42. return (int)get_ticks_ms();
  43. case SYS_SLEEP_MS:
  44. process_sleep_ms((unsigned int)a1);
  45. return 0;
  46. case SYS_EXIT:
  47. process_exit(); /* never returns */
  48. return 0;
  49. case SYS_READ_FILE:
  50. return sys_read_file((const char *)a1, (void *)a2, (unsigned int)a3);
  51. case SYS_WRITE_FILE:
  52. return sys_write_file((const char *)a1, (const void *)a2,
  53. (unsigned int)a3);
  54. case SYS_LIST_DIR:
  55. return sys_list_dir((const char *)a1, (unsigned int)a2,
  56. (struct sys_dirent *)a3);
  57. case SYS_UNLINK:
  58. return sys_unlink((const char *)a1);
  59. case SYS_MKDIR:
  60. return sys_mkdir((const char *)a1);
  61. case SYS_RMDIR:
  62. return sys_rmdir((const char *)a1);
  63. case SYS_LIST_MOUNTS:
  64. return sys_list_mounts((unsigned int)a1, (struct sys_mount *)a2);
  65. case SYS_FS_STAT:
  66. return sys_stat_path((const char *)a1, (struct sys_stat *)a2);
  67. case SYS_MEMINFO:
  68. return sys_meminfo((struct sys_meminfo *)a1);
  69. case SYS_E820:
  70. return sys_e820((unsigned int)a1, (struct sys_e820 *)a2);
  71. case SYS_MOUSEINFO:
  72. return sys_mouseinfo((struct sys_mouseinfo *)a1);
  73. case SYS_STORAGE_INFO:
  74. return sys_storage_info((struct sys_storage_info *)a1);
  75. case SYS_BLKDEV:
  76. return sys_blkdev((unsigned int)a1, (struct sys_blkdev *)a2);
  77. case SYS_BLK_READ:
  78. return sys_blk_read((unsigned int)a1, (unsigned int)a2, (void *)a3);
  79. case SYS_MOUNT_CTL:
  80. return sys_mount_ctl(a1, a2, a3);
  81. case SYS_NET_INFO:
  82. return sys_net_info((struct sys_netinfo *)a1);
  83. case SYS_NET_PRINT_INFO:
  84. return sys_net_print_info();
  85. case SYS_NET_ACQUIRE:
  86. return sys_net_acquire();
  87. case SYS_NET_RELEASE:
  88. return sys_net_release();
  89. case SYS_NET_MAC:
  90. return sys_net_mac((unsigned char *)a1);
  91. case SYS_NET_GET_IP:
  92. sys_net_get_ip((unsigned char *)a1);
  93. return 0;
  94. case SYS_NET_SET_IP:
  95. sys_net_set_ip((const unsigned char *)a1);
  96. return 0;
  97. case SYS_NET_GET_MASK:
  98. sys_net_get_mask((unsigned char *)a1);
  99. return 0;
  100. case SYS_NET_GET_GW:
  101. sys_net_get_gw((unsigned char *)a1);
  102. return 0;
  103. case SYS_NET_GET_DNS:
  104. sys_net_get_dns((unsigned char *)a1);
  105. return 0;
  106. case SYS_NET_SET_DNS:
  107. sys_net_set_dns((const unsigned char *)a1);
  108. return 0;
  109. case SYS_NET_TX:
  110. return sys_net_tx((const unsigned char *)a1, (unsigned int)a2);
  111. case SYS_NET_RX:
  112. return sys_net_rx((unsigned char *)a1, (unsigned int)a2);
  113. case SYS_NET_DECODE:
  114. sys_net_decode((const unsigned char *)a1, (unsigned int)a2);
  115. return 0;
  116. case SYS_NET_REPLY:
  117. return sys_net_reply((const unsigned char *)a1, (unsigned int)a2,
  118. (unsigned char *)a3);
  119. case SYS_NET_LOOPBACK:
  120. return sys_net_loopback(a1);
  121. case SYS_NET_REGS:
  122. return sys_net_regs();
  123. case SYS_NET_RESET:
  124. return sys_net_reset();
  125. case SYS_NET_SPEED:
  126. return sys_net_speed((unsigned int)a1);
  127. case SYS_NET_MAC_SET:
  128. return sys_net_mac_set((const unsigned char *)a1);
  129. case SYS_DHCP_RUN:
  130. return sys_dhcp_run((unsigned int)a1);
  131. case SYS_DHCP_INFO:
  132. return sys_dhcp_info((unsigned char *)a1, (unsigned int *)a2);
  133. case SYS_DNS_RESOLVE:
  134. return sys_dns_resolve((const char *)a1, (unsigned char *)a2);
  135. case SYS_NETLOG:
  136. return sys_netlog((const char *)a1);
  137. case SYS_NETLOG_CONF:
  138. return sys_netlog_conf(a1, (const unsigned char *)a2);
  139. case SYS_TCP_CONNECT:
  140. return sys_tcp_connect((const unsigned char *)a1,
  141. (const unsigned char *)a2,
  142. (unsigned int)a3);
  143. case SYS_TCP_PEER_MSS:
  144. return sys_tcp_peer_mss();
  145. case SYS_TCP_SEND:
  146. return sys_tcp_send((const void *)a1, (unsigned int)a2);
  147. case SYS_TCP_RECV:
  148. return sys_tcp_recv((void *)a1, (unsigned int)a2, (unsigned int)a3);
  149. case SYS_TCP_CLOSE:
  150. sys_tcp_close();
  151. return 0;
  152. case SYS_TCP_LISTEN:
  153. return sys_tcp_listen((unsigned int)a1);
  154. case SYS_TCP_ACCEPT:
  155. return sys_tcp_accept();
  156. case SYS_TCP_SRV_RECV:
  157. return sys_tcp_srv_recv((void *)a1, (unsigned int)a2,
  158. (unsigned int)a3);
  159. case SYS_TCP_SRV_SEND:
  160. return sys_tcp_srv_send((const void *)a1, (unsigned int)a2);
  161. case SYS_TCP_SRV_CLOSE:
  162. sys_tcp_srv_close();
  163. return 0;
  164. case SYS_TCP_PEER:
  165. return sys_tcp_peer((unsigned char *)a1, (unsigned int *)a2);
  166. case SYS_NET_NEXT_HOP:
  167. return sys_net_next_hop((const unsigned char *)a1,
  168. (unsigned char *)a2);
  169. case SYS_NET_ARP:
  170. return sys_net_arp((const unsigned char *)a1, (unsigned char *)a2);
  171. case SYS_NET_CONFIGURED:
  172. return sys_net_configured();
  173. case SYS_GETCWD: {
  174. const char *cwd = current_proc()->cwd;
  175. char *out = (char *)a1;
  176. unsigned int i = 0, max = (unsigned int)a2;
  177. if (!cwd || max == 0)
  178. return -1;
  179. for (i = 0; cwd[i] && i + 1 < max; i++)
  180. out[i] = cwd[i];
  181. out[i] = '\0';
  182. return 0;
  183. }
  184. case SYS_PROCINFO:
  185. return process_procinfo((unsigned int)a1,
  186. (struct sys_procinfo *)a2);
  187. case SYS_KEY_POLL:
  188. return sys_wm_key_poll();
  189. case SYS_RTC_HMS: {
  190. struct sys_time *out = (struct sys_time *)a1;
  191. unsigned int h, m, s;
  192. if (!out)
  193. return -1;
  194. rtc_read_hms(&h, &m, &s);
  195. out->hour = h;
  196. out->minute = m;
  197. out->second = s;
  198. return 0;
  199. }
  200. case SYS_RTC_DATETIME: {
  201. char buf[20];
  202. char *out = (char *)a1;
  203. unsigned int i;
  204. if ((unsigned int)a2 < sizeof(buf) ||
  205. !paging_user_range_ok(current_proc()->cr3,
  206. (unsigned int)out, sizeof(buf), 1))
  207. return -1;
  208. rtc_read_datetime(buf);
  209. for (i = 0; i < sizeof(buf); i++)
  210. out[i] = buf[i];
  211. return 0;
  212. }
  213. case SYS_RTC_GET: {
  214. struct sys_datetime dt;
  215. struct sys_datetime *out = (struct sys_datetime *)a1;
  216. if (!paging_user_range_ok(current_proc()->cr3, (unsigned int)out,
  217. sizeof(dt), 1))
  218. return -1;
  219. rtc_read_datetime_full(&dt);
  220. *out = dt;
  221. return 0;
  222. }
  223. case SYS_RTC_SET: {
  224. struct sys_datetime dt;
  225. const unsigned char *in = (const unsigned char *)a1;
  226. unsigned char *d = (unsigned char *)&dt;
  227. unsigned int i;
  228. if (!paging_user_range_ok(current_proc()->cr3, (unsigned int)in,
  229. sizeof(dt), 0))
  230. return -1;
  231. for (i = 0; i < sizeof(dt); i++)
  232. d[i] = in[i];
  233. return rtc_set_datetime(&dt);
  234. }
  235. case SYS_NTP_SYNC: {
  236. struct sys_datetime dt;
  237. struct sys_datetime *out = (struct sys_datetime *)a3;
  238. char server[64];
  239. int r;
  240. if (!paging_user_range_ok(current_proc()->cr3, (unsigned int)out,
  241. sizeof(dt), 1))
  242. return -1;
  243. if (copy_user_string(server, sizeof(server), (const char *)a1) != 0)
  244. return -1;
  245. r = sys_ntp_sync(server, (unsigned int)a2, &dt);
  246. if (r == 0)
  247. *out = dt;
  248. return r;
  249. }
  250. case SYS_WM_ATTACH:
  251. return sys_wm_attach((struct wm_screen_info *)a1);
  252. case SYS_WM_INFO:
  253. return sys_wm_info((unsigned int)a1,
  254. (struct wm_window_info *)a2);
  255. case SYS_WM_MAP:
  256. return sys_wm_map((unsigned int)a1,
  257. (struct wm_map_info *)a2);
  258. case SYS_WM_ACK:
  259. return sys_wm_ack((unsigned int)a1, (unsigned int)a2);
  260. case SYS_WM_FOCUS:
  261. return sys_wm_focus((unsigned int)a1);
  262. case SYS_WM_SET_GEOM:
  263. return sys_wm_set_geom((unsigned int)a1,
  264. (const struct wm_geom *)a2);
  265. case SYS_WM_CREATE_TERM:
  266. return sys_wm_create_term();
  267. case SYS_WM_CLOSE:
  268. return sys_wm_close((unsigned int)a1);
  269. case SYS_WM_POLL:
  270. return sys_wm_poll((struct wm_status *)a1);
  271. case SYS_WM_BEGIN:
  272. return sys_wm_begin();
  273. case SYS_WM_PRESENT:
  274. return sys_wm_present((const struct wm_present_info *)a1);
  275. case SYS_WM_SYNC:
  276. return sys_wm_sync();
  277. case SYS_WIN_CREATE:
  278. return sys_win_create((const struct win_create *)a1,
  279. (struct win_info *)a2);
  280. case SYS_WIN_PRESENT:
  281. return sys_win_present((const struct wm_win_present *)a1);
  282. case SYS_WIN_CLOSE:
  283. return sys_win_close();
  284. case SYS_WM_RESIZE:
  285. return sys_wm_resize((unsigned int)a1,
  286. (const struct wm_size *)a2);
  287. case SYS_WIN_INFO:
  288. return sys_win_info((struct win_info *)a1);
  289. case SYS_WIN_ACK_RESIZE:
  290. return sys_win_ack_resize();
  291. case SYS_WIN_POINTER:
  292. return sys_win_pointer((struct win_pointer *)a1);
  293. case SYS_WIN_EVENT:
  294. return sys_win_event((struct win_event *)a1);
  295. case SYS_WIN_SCROLL:
  296. return sys_win_scroll((struct win_scroll *)a1);
  297. case SYS_MEM_ALLOC:
  298. return sys_mem_alloc((unsigned int)a1);
  299. case SYS_MEM_GROW:
  300. return sys_mem_grow((unsigned int)a1);
  301. case SYS_MEM_FREE:
  302. return sys_mem_free();
  303. case SYS_CPU_TEMP:
  304. if (!paging_user_range_ok(current_proc()->cr3, (unsigned int)a1,
  305. sizeof(struct sys_cputemp), 1))
  306. return -1;
  307. return sys_cputemp((struct sys_cputemp *)a1);
  308. case SYS_SENSORS:
  309. if (!paging_user_range_ok(current_proc()->cr3, (unsigned int)a1,
  310. sizeof(struct sys_sensors), 1))
  311. return -1;
  312. return sys_sensors((struct sys_sensors *)a1);
  313. case SYS_TPEC_SENSORS:
  314. if (!paging_user_range_ok(current_proc()->cr3, (unsigned int)a1,
  315. sizeof(struct sys_tpec_sensors), 1))
  316. return -1;
  317. return sys_tpec_sensors((struct sys_tpec_sensors *)a1);
  318. case SYS_CROS_EC_SENSORS:
  319. if (!paging_user_range_ok(current_proc()->cr3, (unsigned int)a1,
  320. sizeof(struct sys_cros_sensors), 1))
  321. return -1;
  322. return sys_cros_sensors((struct sys_cros_sensors *)a1);
  323. case SYS_POWER_INFO:
  324. if (!paging_user_range_ok(current_proc()->cr3, (unsigned int)a1,
  325. sizeof(struct sys_powerinfo), 1))
  326. return -1;
  327. return sys_powerinfo((struct sys_powerinfo *)a1,
  328. (unsigned int)a2);
  329. case SYS_BACKLIGHT:
  330. if (a1 == SYS_BACKLIGHT_GET)
  331. return backlight_percent();
  332. if (a1 == SYS_BACKLIGHT_SET) {
  333. backlight_set_percent(a2);
  334. return backlight_percent();
  335. }
  336. if (a1 == SYS_BACKLIGHT_STEP) {
  337. backlight_step(a2);
  338. return backlight_percent();
  339. }
  340. return -1;
  341. case SYS_CPUFREQ:
  342. if (a1 == SYS_CPUFREQ_GET)
  343. return power_cpufreq_mode();
  344. return power_cpufreq_set_mode(a1);
  345. case SYS_WIN_KEY_WAIT:
  346. return sys_win_key_wait((unsigned int)a1);
  347. case SYS_WIN_RESIZE_SELF:
  348. return sys_win_resize_self((unsigned int)a1, (unsigned int)a2);
  349. case SYS_WIN_SET_CURSOR:
  350. return sys_win_set_cursor((int)a1);
  351. case SYS_WM_SET_CURSOR:
  352. return sys_wm_set_cursor((int)a1);
  353. case SYS_WM_MOUSE_CAPTURE:
  354. return sys_wm_mouse_capture((int)a1);
  355. case SYS_WM_WALLPAPER:
  356. return sys_wm_wallpaper((int)a1);
  357. case SYS_WM_PREFS:
  358. return sys_wm_prefs((int)a1, (void *)a2);
  359. case SYS_WM_OPEN_SETTINGS:
  360. return sys_wm_open_settings((int)a1);
  361. case SYS_SCREEN_INFO: {
  362. struct sys_screen *out = (struct sys_screen *)a1;
  363. if (!paging_user_range_ok(current_proc()->cr3, (unsigned int)a1,
  364. sizeof(*out), 1))
  365. return -1;
  366. out->width = vga_fb_width();
  367. out->height = vga_fb_height();
  368. return 0;
  369. }
  370. case SYS_SCHEDINFO:
  371. if (!paging_user_range_ok(current_proc()->cr3, (unsigned int)a1,
  372. sizeof(struct sys_schedinfo), 1))
  373. return -1;
  374. return sched_snapshot((struct sys_schedinfo *)a1);
  375. case SYS_TTY_CREATE:
  376. return tty_create();
  377. case SYS_TTY_ALLOC:
  378. return tty_alloc();
  379. case SYS_TTY_WRITE: {
  380. int id = a1;
  381. const char *buf = (const char *)a2;
  382. unsigned int len = (unsigned int)a3;
  383. if (!tty_valid(id) || !buf || !len ||
  384. !paging_user_range_ok(current_proc()->cr3,
  385. (unsigned int)buf, len, 0))
  386. return -1;
  387. return tty_try_write(id, buf, len);
  388. }
  389. case SYS_TTY_CLOSE:
  390. return tty_close_owned(a1, current_proc()->pid);
  391. case SYS_TTY_READ: {
  392. int id = a1;
  393. char *buf = (char *)a2;
  394. unsigned int max = (unsigned int)a3;
  395. if (!tty_valid(id) || !buf || !max ||
  396. !paging_user_range_ok(current_proc()->cr3,
  397. (unsigned int)buf, max, 1))
  398. return -1;
  399. return tty_read(id, buf, max);
  400. }
  401. case SYS_IS_INIT:
  402. return init_server_pid() == current_proc()->pid;
  403. case SYS_SPAWN: {
  404. struct sys_spawn in;
  405. struct vfs_file f;
  406. struct vfs_mount *m = 0;
  407. struct process *self = current_proc();
  408. char path[VFS_PATH_MAX], arg[VFS_PATH_MAX], cwd[VFS_PATH_MAX];
  409. unsigned int parent_pid, cflags = 0;
  410. const char *name;
  411. int pid;
  412. int lr;
  413. if (!paging_user_range_ok(self->cr3,
  414. (unsigned int)a1, sizeof(in), 0))
  415. return -1;
  416. {
  417. const char *p = (const char *)a1;
  418. unsigned int i;
  419. unsigned char *d = (unsigned char *)&in;
  420. for (i = 0; i < sizeof(in); i++)
  421. d[i] = (unsigned char)p[i];
  422. }
  423. if (in.flags & ~SYS_SPAWN_DETACH)
  424. return -1;
  425. if (in.tty && !tty_valid((int)in.tty))
  426. return -1;
  427. if (copy_user_string(path, sizeof(path), in.path) != 0 ||
  428. copy_user_string(arg, sizeof(arg), in.arg) != 0 ||
  429. copy_user_string(cwd, sizeof(cwd), in.cwd) != 0)
  430. return -1;
  431. parent_pid = self ? self->pid : 0;
  432. if (in.flags & SYS_SPAWN_DETACH) {
  433. parent_pid = self ? self->parent_pid : 0;
  434. cflags = PROC_CREATE_DETACH;
  435. }
  436. /* A FAT load reads the floppy through IRQ 6, so open the
  437. * syscall's interrupts-off section for the duration (the same
  438. * window SYS_READ_FILE uses). */
  439. sys_fs_enter_path(path);
  440. lr = vfs_load_file(path, &f, &m);
  441. sys_fs_exit();
  442. if (lr != 0)
  443. return -1;
  444. name = path;
  445. {
  446. const char *q = path;
  447. while (*q) {
  448. if (*q == '/')
  449. name = q + 1;
  450. q++;
  451. }
  452. }
  453. pid = process_create_user_full(name, f.data, f.size, arg, cwd,
  454. in.tty, parent_pid, cflags);
  455. vfs_release_file(m, &f);
  456. return pid;
  457. }
  458. case SYS_SPAWN_KCMD: {
  459. char name[16], arg[VFS_PATH_MAX];
  460. if (copy_user_string(name, sizeof(name), (const char *)a1) != 0 ||
  461. copy_user_string(arg, sizeof(arg), (const char *)a2) != 0)
  462. return -1;
  463. if (a3 && !tty_valid(a3))
  464. return -1;
  465. return term_kcmd_spawn(name, arg, (unsigned int)a3);
  466. }
  467. case SYS_GETPID:
  468. return (int)current_proc()->pid;
  469. case SYS_WIFI:
  470. return sys_wifi(a1, a2, a3);
  471. case SYS_NET_DEVLIST: {
  472. struct sys_netdev list[8];
  473. unsigned int max = (unsigned int)a2, i;
  474. int n;
  475. if (max > 8)
  476. max = 8;
  477. if (!max || !paging_user_range_ok(current_proc()->cr3,
  478. (unsigned int)a1,
  479. max * sizeof(list[0]), 1))
  480. return -1;
  481. n = sys_net_devlist(list, max);
  482. if (n < 0)
  483. return -1;
  484. for (i = 0; i < (unsigned int)n; i++)
  485. ((struct sys_netdev *)a1)[i] = list[i];
  486. return n;
  487. }
  488. case SYS_NET_SELECT: {
  489. char name[16];
  490. if (copy_user_string(name, sizeof(name),
  491. (const char *)a1) != 0)
  492. return -1;
  493. return sys_net_select(name);
  494. }
  495. case SYS_ALIVE:
  496. return process_is_alive((unsigned int)a1);
  497. case SYS_KILL:
  498. return process_kill((unsigned int)a1);
  499. case SYS_BOOTLOG:
  500. if (a1 == SYS_BOOTLOG_STAT) {
  501. struct sys_bootlog *out = (struct sys_bootlog *)a2;
  502. if (!paging_user_range_ok(current_proc()->cr3,
  503. (unsigned int)out,
  504. sizeof(*out), 1))
  505. return -1;
  506. out->total = bootcon_scan_total();
  507. out->start = bootcon_scan_start();
  508. out->capacity = bootcon_scan_capacity();
  509. out->active = (unsigned int)bootcon_scan_running();
  510. return 0;
  511. }
  512. if (a1 == SYS_BOOTLOG_READ) {
  513. unsigned int off = (unsigned int)a2;
  514. unsigned int total = bootcon_scan_total();
  515. unsigned int n;
  516. if (off < bootcon_scan_start())
  517. return -1; /* ring wrapped; re-read the info */
  518. if (off >= total)
  519. return 0;
  520. n = total - off;
  521. if (n > SYS_BOOTLOG_CHUNK)
  522. n = SYS_BOOTLOG_CHUNK;
  523. if (!paging_user_range_ok(current_proc()->cr3,
  524. (unsigned int)a3, n, 1))
  525. return -1;
  526. return (int)bootcon_scan_read(off, (char *)a3, n);
  527. }
  528. return -1;
  529. case SYS_CHDIR: {
  530. char arg[VFS_PATH_MAX], abs[VFS_PATH_MAX];
  531. unsigned int size;
  532. int is_dir;
  533. if (copy_user_string(arg, sizeof(arg), (const char *)a1) != 0)
  534. return -1;
  535. if (vfs_join_path(current_proc()->cwd, arg[0] ? arg : ".",
  536. abs, sizeof(abs)) != 0)
  537. return -1;
  538. if (vfs_stat(abs, &size, &is_dir) != 0 || !is_dir)
  539. return -1;
  540. {
  541. unsigned int i;
  542. for (i = 0; abs[i] && i + 1 < sizeof(current_proc()->cwd); i++)
  543. current_proc()->cwd[i] = abs[i];
  544. current_proc()->cwd[i] = '\0';
  545. }
  546. return 0;
  547. }
  548. default:
  549. return -1;
  550. }
  551. }
  552. /* All ring-3 syscalls run under the big kernel lock. Blocking syscalls drop
  553. * it through sched_yield(); the lock is taken back before the dispatcher
  554. * resumes, so the rest of the kernel sees one syscall at a time. */
  555. int syscall_dispatch(int num, int a1, int a2, int a3)
  556. {
  557. struct process *p = current_proc();
  558. int r;
  559. /* A process killed while it was in ring 3 may reach the gate before its
  560. * CPU notices the DEAD state. Do not let it run one more syscall on
  561. * resources that may already be reused. */
  562. if (p && p->state == PROC_DEAD)
  563. process_exit();
  564. /* The clock is one aligned 32-bit read and needs no lock. It is the
  565. * hottest syscall (QuickJS's interrupt check, every poll loop), and
  566. * under the BKL a busy kernel holder made each call sleep for a
  567. * scheduler tick: the ION's browser ran its scripts 50x slower. */
  568. if (num == SYS_GET_TICKS_MS)
  569. return (int)get_ticks_ms();
  570. bkl_lock();
  571. r = syscall_dispatch_locked(num, a1, a2, a3);
  572. bkl_unlock();
  573. return r;
  574. }