/* Syscall dispatcher: services int 0x80 requests from ring-3. */ #include "syscall.h" #include "backlight.h" #include "bootcon.h" #include "io.h" #include "paging.h" #include "power.h" #include "process.h" #include "rtc.h" #include "serial.h" #include "sys_fs.h" #include "sys_info.h" #include "sys_mem.h" #include "sys_net.h" #include "sys_wm.h" #include "terminal.h" #include "timer.h" #include "tty.h" #include "vfs.h" #include "vga.h" #include "wifi.h" static int copy_user_string(char *dst, unsigned int max, const char *src) { unsigned int i; if (!src || !max || !paging_user_range_ok(current_proc()->cr3, (unsigned int)src, max, 0)) return -1; for (i = 0; i + 1 < max && src[i]; i++) dst[i] = src[i]; dst[i] = '\0'; return 0; } static int syscall_dispatch_locked(int num, int a1, int a2, int a3) { switch (num) { case SYS_PUTSTR: io_putstr((const char *)a1); return 0; case SYS_GET_TICKS_MS: return (int)get_ticks_ms(); case SYS_SLEEP_MS: process_sleep_ms((unsigned int)a1); return 0; case SYS_EXIT: process_exit(); /* never returns */ return 0; case SYS_READ_FILE: return sys_read_file((const char *)a1, (void *)a2, (unsigned int)a3); case SYS_WRITE_FILE: return sys_write_file((const char *)a1, (const void *)a2, (unsigned int)a3); case SYS_LIST_DIR: return sys_list_dir((const char *)a1, (unsigned int)a2, (struct sys_dirent *)a3); case SYS_UNLINK: return sys_unlink((const char *)a1); case SYS_MKDIR: return sys_mkdir((const char *)a1); case SYS_RMDIR: return sys_rmdir((const char *)a1); case SYS_LIST_MOUNTS: return sys_list_mounts((unsigned int)a1, (struct sys_mount *)a2); case SYS_FS_STAT: return sys_stat_path((const char *)a1, (struct sys_stat *)a2); case SYS_MEMINFO: return sys_meminfo((struct sys_meminfo *)a1); case SYS_E820: return sys_e820((unsigned int)a1, (struct sys_e820 *)a2); case SYS_MOUSEINFO: return sys_mouseinfo((struct sys_mouseinfo *)a1); case SYS_STORAGE_INFO: return sys_storage_info((struct sys_storage_info *)a1); case SYS_BLKDEV: return sys_blkdev((unsigned int)a1, (struct sys_blkdev *)a2); case SYS_BLK_READ: return sys_blk_read((unsigned int)a1, (unsigned int)a2, (void *)a3); case SYS_MOUNT_CTL: return sys_mount_ctl(a1, a2, a3); case SYS_NET_INFO: return sys_net_info((struct sys_netinfo *)a1); case SYS_NET_PRINT_INFO: return sys_net_print_info(); case SYS_NET_ACQUIRE: return sys_net_acquire(); case SYS_NET_RELEASE: return sys_net_release(); case SYS_NET_MAC: return sys_net_mac((unsigned char *)a1); case SYS_NET_GET_IP: sys_net_get_ip((unsigned char *)a1); return 0; case SYS_NET_SET_IP: sys_net_set_ip((const unsigned char *)a1); return 0; case SYS_NET_GET_MASK: sys_net_get_mask((unsigned char *)a1); return 0; case SYS_NET_GET_GW: sys_net_get_gw((unsigned char *)a1); return 0; case SYS_NET_GET_DNS: sys_net_get_dns((unsigned char *)a1); return 0; case SYS_NET_SET_DNS: sys_net_set_dns((const unsigned char *)a1); return 0; case SYS_NET_TX: return sys_net_tx((const unsigned char *)a1, (unsigned int)a2); case SYS_NET_RX: return sys_net_rx((unsigned char *)a1, (unsigned int)a2); case SYS_NET_DECODE: sys_net_decode((const unsigned char *)a1, (unsigned int)a2); return 0; case SYS_NET_REPLY: return sys_net_reply((const unsigned char *)a1, (unsigned int)a2, (unsigned char *)a3); case SYS_NET_LOOPBACK: return sys_net_loopback(a1); case SYS_NET_REGS: return sys_net_regs(); case SYS_NET_RESET: return sys_net_reset(); case SYS_NET_SPEED: return sys_net_speed((unsigned int)a1); case SYS_NET_MAC_SET: return sys_net_mac_set((const unsigned char *)a1); case SYS_DHCP_RUN: return sys_dhcp_run((unsigned int)a1); case SYS_DHCP_INFO: return sys_dhcp_info((unsigned char *)a1, (unsigned int *)a2); case SYS_DNS_RESOLVE: return sys_dns_resolve((const char *)a1, (unsigned char *)a2); case SYS_NETLOG: return sys_netlog((const char *)a1); case SYS_NETLOG_CONF: return sys_netlog_conf(a1, (const unsigned char *)a2); case SYS_TCP_CONNECT: return sys_tcp_connect((const unsigned char *)a1, (const unsigned char *)a2, (unsigned int)a3); case SYS_TCP_PEER_MSS: return sys_tcp_peer_mss(); case SYS_TCP_SEND: return sys_tcp_send((const void *)a1, (unsigned int)a2); case SYS_TCP_RECV: return sys_tcp_recv((void *)a1, (unsigned int)a2, (unsigned int)a3); case SYS_TCP_CLOSE: sys_tcp_close(); return 0; case SYS_TCP_LISTEN: return sys_tcp_listen((unsigned int)a1); case SYS_TCP_ACCEPT: return sys_tcp_accept(); case SYS_TCP_SRV_RECV: return sys_tcp_srv_recv((void *)a1, (unsigned int)a2, (unsigned int)a3); case SYS_TCP_SRV_SEND: return sys_tcp_srv_send((const void *)a1, (unsigned int)a2); case SYS_TCP_SRV_CLOSE: sys_tcp_srv_close(); return 0; case SYS_TCP_PEER: return sys_tcp_peer((unsigned char *)a1, (unsigned int *)a2); case SYS_NET_NEXT_HOP: return sys_net_next_hop((const unsigned char *)a1, (unsigned char *)a2); case SYS_NET_ARP: return sys_net_arp((const unsigned char *)a1, (unsigned char *)a2); case SYS_NET_CONFIGURED: return sys_net_configured(); case SYS_GETCWD: { const char *cwd = current_proc()->cwd; char *out = (char *)a1; unsigned int i = 0, max = (unsigned int)a2; if (!cwd || max == 0) return -1; for (i = 0; cwd[i] && i + 1 < max; i++) out[i] = cwd[i]; out[i] = '\0'; return 0; } case SYS_PROCINFO: return process_procinfo((unsigned int)a1, (struct sys_procinfo *)a2); case SYS_KEY_POLL: return sys_wm_key_poll(); case SYS_RTC_HMS: { struct sys_time *out = (struct sys_time *)a1; unsigned int h, m, s; if (!out) return -1; rtc_read_hms(&h, &m, &s); out->hour = h; out->minute = m; out->second = s; return 0; } case SYS_RTC_DATETIME: { char buf[20]; char *out = (char *)a1; unsigned int i; if ((unsigned int)a2 < sizeof(buf) || !paging_user_range_ok(current_proc()->cr3, (unsigned int)out, sizeof(buf), 1)) return -1; rtc_read_datetime(buf); for (i = 0; i < sizeof(buf); i++) out[i] = buf[i]; return 0; } case SYS_RTC_GET: { struct sys_datetime dt; struct sys_datetime *out = (struct sys_datetime *)a1; if (!paging_user_range_ok(current_proc()->cr3, (unsigned int)out, sizeof(dt), 1)) return -1; rtc_read_datetime_full(&dt); *out = dt; return 0; } case SYS_RTC_SET: { struct sys_datetime dt; const unsigned char *in = (const unsigned char *)a1; unsigned char *d = (unsigned char *)&dt; unsigned int i; if (!paging_user_range_ok(current_proc()->cr3, (unsigned int)in, sizeof(dt), 0)) return -1; for (i = 0; i < sizeof(dt); i++) d[i] = in[i]; return rtc_set_datetime(&dt); } case SYS_NTP_SYNC: { struct sys_datetime dt; struct sys_datetime *out = (struct sys_datetime *)a3; char server[64]; int r; if (!paging_user_range_ok(current_proc()->cr3, (unsigned int)out, sizeof(dt), 1)) return -1; if (copy_user_string(server, sizeof(server), (const char *)a1) != 0) return -1; r = sys_ntp_sync(server, (unsigned int)a2, &dt); if (r == 0) *out = dt; return r; } case SYS_WM_ATTACH: return sys_wm_attach((struct wm_screen_info *)a1); case SYS_WM_INFO: return sys_wm_info((unsigned int)a1, (struct wm_window_info *)a2); case SYS_WM_MAP: return sys_wm_map((unsigned int)a1, (struct wm_map_info *)a2); case SYS_WM_ACK: return sys_wm_ack((unsigned int)a1, (unsigned int)a2); case SYS_WM_FOCUS: return sys_wm_focus((unsigned int)a1); case SYS_WM_SET_GEOM: return sys_wm_set_geom((unsigned int)a1, (const struct wm_geom *)a2); case SYS_WM_CREATE_TERM: return sys_wm_create_term(); case SYS_WM_CLOSE: return sys_wm_close((unsigned int)a1); case SYS_WM_POLL: return sys_wm_poll((struct wm_status *)a1); case SYS_WM_BEGIN: return sys_wm_begin(); case SYS_WM_PRESENT: return sys_wm_present((const struct wm_present_info *)a1); case SYS_WM_SYNC: return sys_wm_sync(); case SYS_WIN_CREATE: return sys_win_create((const struct win_create *)a1, (struct win_info *)a2); case SYS_WIN_PRESENT: return sys_win_present((const struct wm_win_present *)a1); case SYS_WIN_CLOSE: return sys_win_close(); case SYS_WM_RESIZE: return sys_wm_resize((unsigned int)a1, (const struct wm_size *)a2); case SYS_WIN_INFO: return sys_win_info((struct win_info *)a1); case SYS_WIN_ACK_RESIZE: return sys_win_ack_resize(); case SYS_WIN_POINTER: return sys_win_pointer((struct win_pointer *)a1); case SYS_WIN_EVENT: return sys_win_event((struct win_event *)a1); case SYS_WIN_SCROLL: return sys_win_scroll((struct win_scroll *)a1); case SYS_MEM_ALLOC: return sys_mem_alloc((unsigned int)a1); case SYS_MEM_GROW: return sys_mem_grow((unsigned int)a1); case SYS_MEM_FREE: return sys_mem_free(); case SYS_CPU_TEMP: if (!paging_user_range_ok(current_proc()->cr3, (unsigned int)a1, sizeof(struct sys_cputemp), 1)) return -1; return sys_cputemp((struct sys_cputemp *)a1); case SYS_SENSORS: if (!paging_user_range_ok(current_proc()->cr3, (unsigned int)a1, sizeof(struct sys_sensors), 1)) return -1; return sys_sensors((struct sys_sensors *)a1); case SYS_TPEC_SENSORS: if (!paging_user_range_ok(current_proc()->cr3, (unsigned int)a1, sizeof(struct sys_tpec_sensors), 1)) return -1; return sys_tpec_sensors((struct sys_tpec_sensors *)a1); case SYS_CROS_EC_SENSORS: if (!paging_user_range_ok(current_proc()->cr3, (unsigned int)a1, sizeof(struct sys_cros_sensors), 1)) return -1; return sys_cros_sensors((struct sys_cros_sensors *)a1); case SYS_POWER_INFO: if (!paging_user_range_ok(current_proc()->cr3, (unsigned int)a1, sizeof(struct sys_powerinfo), 1)) return -1; return sys_powerinfo((struct sys_powerinfo *)a1, (unsigned int)a2); case SYS_BACKLIGHT: if (a1 == SYS_BACKLIGHT_GET) return backlight_percent(); if (a1 == SYS_BACKLIGHT_SET) { backlight_set_percent(a2); return backlight_percent(); } if (a1 == SYS_BACKLIGHT_STEP) { backlight_step(a2); return backlight_percent(); } return -1; case SYS_CPUFREQ: if (a1 == SYS_CPUFREQ_GET) return power_cpufreq_mode(); return power_cpufreq_set_mode(a1); case SYS_WIN_KEY_WAIT: return sys_win_key_wait((unsigned int)a1); case SYS_WIN_RESIZE_SELF: return sys_win_resize_self((unsigned int)a1, (unsigned int)a2); case SYS_WIN_SET_CURSOR: return sys_win_set_cursor((int)a1); case SYS_WM_SET_CURSOR: return sys_wm_set_cursor((int)a1); case SYS_WM_MOUSE_CAPTURE: return sys_wm_mouse_capture((int)a1); case SYS_SCREEN_INFO: { struct sys_screen *out = (struct sys_screen *)a1; if (!paging_user_range_ok(current_proc()->cr3, (unsigned int)a1, sizeof(*out), 1)) return -1; out->width = vga_fb_width(); out->height = vga_fb_height(); return 0; } case SYS_SCHEDINFO: if (!paging_user_range_ok(current_proc()->cr3, (unsigned int)a1, sizeof(struct sys_schedinfo), 1)) return -1; return sched_snapshot((struct sys_schedinfo *)a1); case SYS_TTY_CREATE: return tty_create(); case SYS_TTY_READ: { int id = a1; char *buf = (char *)a2; unsigned int max = (unsigned int)a3; if (!tty_valid(id) || !buf || !max || !paging_user_range_ok(current_proc()->cr3, (unsigned int)buf, max, 1)) return -1; return tty_read(id, buf, max); } case SYS_SPAWN: { struct sys_spawn in; struct vfs_file f; struct vfs_mount *m = 0; char path[VFS_PATH_MAX], arg[VFS_PATH_MAX], cwd[VFS_PATH_MAX]; const char *name; int pid; int lr; if (!paging_user_range_ok(current_proc()->cr3, (unsigned int)a1, sizeof(in), 0)) return -1; { const char *p = (const char *)a1; unsigned int i; unsigned char *d = (unsigned char *)∈ for (i = 0; i < sizeof(in); i++) d[i] = (unsigned char)p[i]; } if (in.tty && !tty_valid((int)in.tty)) return -1; if (copy_user_string(path, sizeof(path), in.path) != 0 || copy_user_string(arg, sizeof(arg), in.arg) != 0 || copy_user_string(cwd, sizeof(cwd), in.cwd) != 0) return -1; /* A FAT load reads the floppy through IRQ 6, so open the * syscall's interrupts-off section for the duration (the same * window SYS_READ_FILE uses). */ sys_fs_enter_path(path); lr = vfs_load_file(path, &f, &m); sys_fs_exit(); if (lr != 0) return -1; name = path; { const char *q = path; while (*q) { if (*q == '/') name = q + 1; q++; } } pid = process_create_user_tty(name, f.data, f.size, arg, cwd, in.tty); vfs_release_file(m, &f); return pid; } case SYS_SPAWN_KCMD: { char name[16], arg[VFS_PATH_MAX]; if (copy_user_string(name, sizeof(name), (const char *)a1) != 0 || copy_user_string(arg, sizeof(arg), (const char *)a2) != 0) return -1; if (a3 && !tty_valid(a3)) return -1; return term_kcmd_spawn(name, arg, (unsigned int)a3); } case SYS_GETPID: return (int)current_proc()->pid; case SYS_WIFI: return sys_wifi(a1, a2, a3); case SYS_NET_DEVLIST: { struct sys_netdev list[8]; unsigned int max = (unsigned int)a2, i; int n; if (max > 8) max = 8; if (!max || !paging_user_range_ok(current_proc()->cr3, (unsigned int)a1, max * sizeof(list[0]), 1)) return -1; n = sys_net_devlist(list, max); if (n < 0) return -1; for (i = 0; i < (unsigned int)n; i++) ((struct sys_netdev *)a1)[i] = list[i]; return n; } case SYS_NET_SELECT: { char name[16]; if (copy_user_string(name, sizeof(name), (const char *)a1) != 0) return -1; return sys_net_select(name); } case SYS_ALIVE: return process_is_alive((unsigned int)a1); case SYS_KILL: return process_kill((unsigned int)a1); case SYS_BOOTLOG: if (a1 == SYS_BOOTLOG_STAT) { struct sys_bootlog *out = (struct sys_bootlog *)a2; if (!paging_user_range_ok(current_proc()->cr3, (unsigned int)out, sizeof(*out), 1)) return -1; out->total = bootcon_scan_total(); out->start = bootcon_scan_start(); out->capacity = bootcon_scan_capacity(); out->active = (unsigned int)bootcon_scan_running(); return 0; } if (a1 == SYS_BOOTLOG_READ) { unsigned int off = (unsigned int)a2; unsigned int total = bootcon_scan_total(); unsigned int n; if (off < bootcon_scan_start()) return -1; /* ring wrapped; re-read the info */ if (off >= total) return 0; n = total - off; if (n > SYS_BOOTLOG_CHUNK) n = SYS_BOOTLOG_CHUNK; if (!paging_user_range_ok(current_proc()->cr3, (unsigned int)a3, n, 1)) return -1; return (int)bootcon_scan_read(off, (char *)a3, n); } return -1; case SYS_CHDIR: { char arg[VFS_PATH_MAX], abs[VFS_PATH_MAX]; unsigned int size; int is_dir; if (copy_user_string(arg, sizeof(arg), (const char *)a1) != 0) return -1; if (vfs_join_path(current_proc()->cwd, arg[0] ? arg : ".", abs, sizeof(abs)) != 0) return -1; if (vfs_stat(abs, &size, &is_dir) != 0 || !is_dir) return -1; { unsigned int i; for (i = 0; abs[i] && i + 1 < sizeof(current_proc()->cwd); i++) current_proc()->cwd[i] = abs[i]; current_proc()->cwd[i] = '\0'; } return 0; } default: return -1; } } /* All ring-3 syscalls run under the big kernel lock. Blocking syscalls drop * it through sched_yield(); the lock is taken back before the dispatcher * resumes, so the rest of the kernel sees one syscall at a time. */ int syscall_dispatch(int num, int a1, int a2, int a3) { struct process *p = current_proc(); int r; /* A process killed while it was in ring 3 may reach the gate before its * CPU notices the DEAD state. Do not let it run one more syscall on * resources that may already be reused. */ if (p && p->state == PROC_DEAD) process_exit(); bkl_lock(); r = syscall_dispatch_locked(num, a1, a2, a3); bkl_unlock(); return r; }