diff options
| author | dzwdz | 2023-01-25 20:16:22 +0100 |
|---|---|---|
| committer | dzwdz | 2023-01-25 20:16:22 +0100 |
| commit | 17bfb0ef0a48330b1d54e61fe3c30d83528d2d90 (patch) | |
| tree | b3d4aed1f408edcb17fe5c86fccaeacaa2a5a48a /src/user | |
| parent | 2ad6ee8ed15d1bf898645a16dbc06991a3c1425e (diff) | |
style: typedef structs, shorter namespaces
I've wanted to do this for a while, and since I've just had a relatively
large refactor commit (pcpy), this is as good of a time as any.
Typedefing structs was mostly inspired by Plan 9's coding style. It makes
some lines of code much shorter at basically no expense.
Everything related to userland kept old-style struct definitions, so as not
to force that style onto other people.
I also considered changing SCREAMING_ENUM_FIELDS to NicerLookingCamelcase,
but I didn't, just in case that'd be confusing.
Diffstat (limited to 'src/user')
61 files changed, 448 insertions, 448 deletions
diff --git a/src/user/app/drawmouse/drawmouse.c b/src/user/app/drawmouse/drawmouse.c index 6e2a881..24aa55e 100644 --- a/src/user/app/drawmouse/drawmouse.c +++ b/src/user/app/drawmouse/drawmouse.c @@ -50,7 +50,7 @@ struct packet { int main(void) { char buf[64]; - handle_t fd = camellia_open("/kdev/ps2/mouse", OPEN_READ); + hid_t fd = camellia_open("/kdev/ps2/mouse", OPEN_READ); if (fd < 0) { eprintf("couldn't open mouse"); return 1; @@ -64,7 +64,7 @@ int main(void) { for (;;) { - int len = _syscall_read(fd, buf, sizeof buf, 0); + int len = _sys_read(fd, buf, sizeof buf, 0); if (len == 0) break; ring_put(&r, buf, len); while (ring_used(&r) >= 3) { diff --git a/src/user/app/dvd/dvd.c b/src/user/app/dvd/dvd.c index f880782..70adc8b 100644 --- a/src/user/app/dvd/dvd.c +++ b/src/user/app/dvd/dvd.c @@ -36,7 +36,7 @@ int main(void) { y += dy; draw_rect(x, y, w, h, col++); dirty_flush(&dirty, &fb); - _syscall_sleep(1000 / 60); + _sys_sleep(1000 / 60); } return 1; diff --git a/src/user/app/ext2fs/main.c b/src/user/app/ext2fs/main.c index 65e7460..678d189 100644 --- a/src/user/app/ext2fs/main.c +++ b/src/user/app/ext2fs/main.c @@ -21,10 +21,10 @@ struct handle { static int my_read(void *fp, void *buf, size_t len, size_t off); static int my_write(void *fp, const void *buf, size_t len, size_t off); -static void do_open(struct ext2 *fs, handle_t reqh, struct ufs_request *req, char *buf); -static void do_read(struct ext2 *fs, handle_t reqh, struct ufs_request *req, char *buf, size_t buflen); -static void do_write(struct ext2 *fs, handle_t reqh, struct ufs_request *req, char *buf); -static void do_getsize(struct ext2 *fs, handle_t reqh, struct ufs_request *req); +static void do_open(struct ext2 *fs, hid_t reqh, struct ufs_request *req, char *buf); +static void do_read(struct ext2 *fs, hid_t reqh, struct ufs_request *req, char *buf, size_t buflen); +static void do_write(struct ext2 *fs, hid_t reqh, struct ufs_request *req, char *buf); +static void do_getsize(struct ext2 *fs, hid_t reqh, struct ufs_request *req); static int my_read(void *fp, void *buf, size_t len, size_t off) @@ -51,61 +51,61 @@ my_write(void *fp, const void *buf, size_t len, size_t off) } static void -do_open(struct ext2 *fs, handle_t reqh, struct ufs_request *req, char *buf) +do_open(struct ext2 *fs, hid_t reqh, struct ufs_request *req, char *buf) { bool is_dir = req->len == 0 || buf[req->len-1] == '/'; uint32_t n = ext2c_walk(fs, buf, req->len); if (n == 0) { if (is_dir) { - _syscall_fs_respond(reqh, NULL, -ENOSYS, 0); + _sys_fs_respond(reqh, NULL, -ENOSYS, 0); return; } /* buf[0] == '/', strrchr != NULL */ char *name = strrchr(buf, '/') + 1; uint32_t dir_n = ext2c_walk(fs, buf, name - buf); if (dir_n == 0) { - _syscall_fs_respond(reqh, NULL, -ENOENT, 0); + _sys_fs_respond(reqh, NULL, -ENOENT, 0); return; } n = ext2_alloc_inode(fs, 0100700); if (n == 0) { - _syscall_fs_respond(reqh, NULL, -1, 0); + _sys_fs_respond(reqh, NULL, -1, 0); return; } if (ext2_link(fs, dir_n, name, n, 1) < 0) { - _syscall_fs_respond(reqh, NULL, -1, 0); + _sys_fs_respond(reqh, NULL, -1, 0); return; } } else { struct ext2d_inode *inode = ext2_req_inode(fs, n); if (!inode) { - _syscall_fs_respond(reqh, NULL, -ENOENT, 0); + _sys_fs_respond(reqh, NULL, -ENOENT, 0); return; } int type = (inode->perms >> 12) & 0xF; ext2_dropreq(fs, inode, false); if ((type == 0x8 && is_dir) || (type == 0x4 && !is_dir)) { - _syscall_fs_respond(reqh, NULL, -ENOENT, 0); + _sys_fs_respond(reqh, NULL, -ENOENT, 0); return; } else if (type != 0x8 && type != 0x4) { - _syscall_fs_respond(reqh, NULL, -ENOSYS, 0); + _sys_fs_respond(reqh, NULL, -ENOSYS, 0); return; } } struct handle *h = malloc(sizeof *h); if (!h) { - _syscall_fs_respond(reqh, NULL, -1, 0); + _sys_fs_respond(reqh, NULL, -1, 0); return; } h->n = n; h->dir = is_dir; - _syscall_fs_respond(reqh, h, 0, 0); + _sys_fs_respond(reqh, h, 0, 0); } static void -do_read(struct ext2 *fs, handle_t reqh, struct ufs_request *req, char *buf, size_t buflen) +do_read(struct ext2 *fs, hid_t reqh, struct ufs_request *req, char *buf, size_t buflen) { struct handle *h = req->id; if (!h->dir) { @@ -116,7 +116,7 @@ do_read(struct ext2 *fs, handle_t reqh, struct ufs_request *req, char *buf, size void *b = ext2_req_file(fs, h->n, &req->capacity, req->offset); if (!b) goto err; - _syscall_fs_respond(reqh, b, req->capacity, 0); + _sys_fs_respond(reqh, b, req->capacity, 0); ext2_dropreq(fs, b, false); } else { struct dirbuild db; @@ -142,15 +142,15 @@ do_read(struct ext2 *fs, handle_t reqh, struct ufs_request *req, char *buf, size dir_appendl(&db, iter.ent->name, iter.ent->namelen_lower); } } - _syscall_fs_respond(reqh, buf, dir_finish(&db), 0); + _sys_fs_respond(reqh, buf, dir_finish(&db), 0); } return; err: - _syscall_fs_respond(reqh, NULL, -1, 0); + _sys_fs_respond(reqh, NULL, -1, 0); } static void -do_write(struct ext2 *fs, handle_t reqh, struct ufs_request *req, char *buf) +do_write(struct ext2 *fs, hid_t reqh, struct ufs_request *req, char *buf) { struct handle *h = req->id; if (h->dir) goto err; @@ -169,24 +169,24 @@ do_write(struct ext2 *fs, handle_t reqh, struct ufs_request *req, char *buf) inode = NULL; int ret = ext2_write(fs, h->n, buf, req->len, req->offset); - _syscall_fs_respond(reqh, NULL, ret, 0); + _sys_fs_respond(reqh, NULL, ret, 0); return; err: - _syscall_fs_respond(reqh, NULL, -1, 0); + _sys_fs_respond(reqh, NULL, -1, 0); } static void -do_getsize(struct ext2 *fs, handle_t reqh, struct ufs_request *req) { +do_getsize(struct ext2 *fs, hid_t reqh, struct ufs_request *req) { struct handle *h = req->id; if (h->dir) goto err; struct ext2d_inode *inode = ext2_req_inode(fs, h->n); if (!inode) goto err; - _syscall_fs_respond(reqh, NULL, inode->size_lower, 0); + _sys_fs_respond(reqh, NULL, inode->size_lower, 0); ext2_dropreq(fs, inode, false); return; err: - _syscall_fs_respond(reqh, NULL, -1, 0); + _sys_fs_respond(reqh, NULL, -1, 0); } int @@ -208,7 +208,7 @@ main(int argc, char **argv) char *buf = malloc(buflen); struct ufs_request req; for (;;) { - handle_t reqh = ufs_wait(buf, buflen, &req); + hid_t reqh = ufs_wait(buf, buflen, &req); struct handle *h = req.id; if (reqh < 0) break; switch (req.op) { @@ -226,10 +226,10 @@ main(int argc, char **argv) break; case VFSOP_CLOSE: free(h); - _syscall_fs_respond(reqh, NULL, -1, 0); + _sys_fs_respond(reqh, NULL, -1, 0); break; default: - _syscall_fs_respond(reqh, NULL, -1, 0); + _sys_fs_respond(reqh, NULL, -1, 0); break; } } diff --git a/src/user/app/httpd/httpd.c b/src/user/app/httpd/httpd.c index 02f9e6b..668e534 100644 --- a/src/user/app/httpd/httpd.c +++ b/src/user/app/httpd/httpd.c @@ -20,7 +20,7 @@ static void handle(FILE *c) { char *end = strchr(path, ' '); if (end) *end = '\0'; - handle_t h = _syscall_open(path, strlen(path), OPEN_READ); + hid_t h = _sys_open(path, strlen(path), OPEN_READ); if (h < 0) { fprintf(c, "HTTP/1.1 404 Not Found\r\n\r\n"); return; @@ -65,9 +65,9 @@ static void handle(FILE *c) { int main(int argc, char **argv) { const char *path = (argc > 1) ? argv[1] : "/net/listen/0.0.0.0/tcp/80"; - handle_t conn; + hid_t conn; for (;;) { - conn = _syscall_open(path, strlen(path), OPEN_RW); + conn = _sys_open(path, strlen(path), OPEN_RW); if (conn < 0) errx(1, "open('%s') failed, errno %d", path, -conn); FILE *f = fdopen(conn, "a+"); diff --git a/src/user/app/init/driver/driver.h b/src/user/app/init/driver/driver.h index fc9f51b..98c18f1 100644 --- a/src/user/app/init/driver/driver.h +++ b/src/user/app/init/driver/driver.h @@ -1,7 +1,7 @@ #pragma once #include <camellia/types.h> -void initctl_drv(handle_t killswitch); +void initctl_drv(hid_t killswitch); void ps2_drv(void); void tmpfs_drv(void); diff --git a/src/user/app/init/driver/initctl.c b/src/user/app/init/driver/initctl.c index 67c8ade..fed71b7 100644 --- a/src/user/app/init/driver/initctl.c +++ b/src/user/app/init/driver/initctl.c @@ -6,7 +6,7 @@ #include <string.h> #include <camellia/compat.h> -void initctl_drv(handle_t killswitch) { +void initctl_drv(hid_t killswitch) { struct ufs_request res; char buf[64]; const size_t buflen = sizeof buf; @@ -28,10 +28,10 @@ void initctl_drv(handle_t killswitch) { } } if (!strcmp(buf, "halt")) { - _syscall_write(killswitch, "halt", 4, 0, 0); + _sys_write(killswitch, "halt", 4, 0, 0); } if (!strcmp(buf, "intr")) { - _syscall_write(killswitch, "intr", 4, 0, 0); + _sys_write(killswitch, "intr", 4, 0, 0); } c0_fs_respond(NULL, res.len, 0); break; diff --git a/src/user/app/init/driver/ps2.c b/src/user/app/init/driver/ps2.c index 1accbfc..a5cdb07 100644 --- a/src/user/app/init/driver/ps2.c +++ b/src/user/app/init/driver/ps2.c @@ -32,7 +32,7 @@ static const char keymap_upper[] = { static volatile uint8_t backlog_buf[16]; static volatile ring_t backlog = {(void*)backlog_buf, sizeof backlog_buf, 0, 0}; -static handle_t fd; +static hid_t fd; static bool keys[0x80] = {0}; @@ -63,7 +63,7 @@ static void main_loop(void) { case VFSOP_READ: while (ring_used((void*)&backlog) == 0) { /* read raw input until we have something to output */ - int len = _syscall_read(fd, buf, sizeof buf, 0); + int len = _sys_read(fd, buf, sizeof buf, 0); if (len == 0) break; for (int i = 0; i < len; i++) parse_scancode(buf[i]); @@ -80,7 +80,7 @@ static void main_loop(void) { } void ps2_drv(void) { - fd = _syscall_open("/kdev/ps2/kb", 12, 0); + fd = _sys_open("/kdev/ps2/kb", 12, 0); if (fd < 0) exit(1); main_loop(); diff --git a/src/user/app/init/driver/termcook.c b/src/user/app/init/driver/termcook.c index 8845839..a76f3a8 100644 --- a/src/user/app/init/driver/termcook.c +++ b/src/user/app/init/driver/termcook.c @@ -10,21 +10,21 @@ enum tstate { CSI, }; -static void w_output(handle_t output, const char *buf, size_t len) { +static void w_output(hid_t output, const char *buf, size_t len) { size_t pos = 0; while (pos < len) { - int ret = _syscall_write(output, buf + pos, len - pos, pos, 0); + int ret = _sys_write(output, buf + pos, len - pos, pos, 0); if (ret < 0) break; pos += ret; } } -static void line_editor(handle_t input, handle_t output) { +static void line_editor(hid_t input, hid_t output) { char readbuf[16], linebuf[256]; size_t linepos = 0; enum tstate state = Normal; for (;;) { - int readlen = _syscall_read(input, readbuf, sizeof readbuf, -1); + int readlen = _sys_read(input, readbuf, sizeof readbuf, -1); if (readlen < 0) return; for (int i = 0; i < readlen; i++) { char c = readbuf[i]; @@ -39,13 +39,13 @@ static void line_editor(handle_t input, handle_t output) { } break; case 3: /* C-c */ - _syscall_exit(1); + _sys_exit(1); case 4: /* EOT, C-d */ if (linepos > 0) { w_output(output, linebuf, linepos); linepos = 0; } else { - _syscall_write(output, NULL, 0, 0, 0); /* EOF */ + _sys_write(output, NULL, 0, 0, 0); /* EOF */ } break; case '\n': @@ -82,14 +82,14 @@ static void line_editor(handle_t input, handle_t output) { } void termcook(void) { - handle_t stdin_pipe[2] = {-1, -1}; - if (_syscall_pipe(stdin_pipe, 0) < 0) + hid_t stdin_pipe[2] = {-1, -1}; + if (_sys_pipe(stdin_pipe, 0) < 0) return; if (!fork()) { /* the caller continues in a child process, * so it can be killed when the line editor quits */ - _syscall_dup(stdin_pipe[0], 0, 0); + _sys_dup(stdin_pipe[0], 0, 0); close(stdin_pipe[0]); close(stdin_pipe[1]); return; @@ -99,5 +99,5 @@ void termcook(void) { line_editor(0, stdin_pipe[1]); exit(0); } - exit(_syscall_await()); + exit(_sys_await()); } diff --git a/src/user/app/init/init.c b/src/user/app/init/init.c index d872b24..8346a31 100644 --- a/src/user/app/init/init.c +++ b/src/user/app/init/init.c @@ -26,18 +26,18 @@ void redirect(const char *exe, const char *out, const char *in) { termcook(); execv(exe, (void*)argv); fprintf(stderr, "init: couldn't start %s\n", exe); - _syscall_sleep(5000); + _sys_sleep(5000); exit(1); } - _syscall_await(); - _syscall_intr(); + _sys_await(); + _sys_intr(); } } } int main(void) { const char *teststr = "I am teststr.\n"; - handle_t killswitch_pipe[2]; + hid_t killswitch_pipe[2]; freopen("/kdev/com1", "a+", stdout); freopen("/kdev/com1", "a+", stderr); @@ -86,7 +86,7 @@ int main(void) { execv(argv[0], (void*)argv); } - if (_syscall_pipe(killswitch_pipe, 0) < 0) { + if (_sys_pipe(killswitch_pipe, 0) < 0) { printf("couldn't create the killswitch pipe, quitting...\n"); return 1; } @@ -106,20 +106,20 @@ int main(void) { char buf[128]; for (;;) { - if (_syscall_read(killswitch_pipe[0], buf, 128, 0) != 4) { + if (_sys_read(killswitch_pipe[0], buf, 128, 0) != 4) { break; } if (memcmp(buf, "intr", 4) == 0) { - _syscall_intr(); + _sys_intr(); } else if (memcmp(buf, "halt", 4) == 0) { break; } } printf("[init] intr\n"); - _syscall_intr(); - _syscall_sleep(1000); + _sys_intr(); + _sys_sleep(1000); printf("[init] filicide\n"); - _syscall_filicide(); + _sys_filicide(); printf("[init] goodbye\n"); return 0; } diff --git a/src/user/app/iochk/iochk.c b/src/user/app/iochk/iochk.c index e4b0346..9703919 100644 --- a/src/user/app/iochk/iochk.c +++ b/src/user/app/iochk/iochk.c @@ -13,7 +13,7 @@ static bool verbose = false; #define eprintf(fmt, ...) fprintf(stderr, "iochk: "fmt"\n" __VA_OPT__(,) __VA_ARGS__) -void check(handle_t h) { +void check(hid_t h) { const size_t buflen = 4096; const size_t offsets[] = { 0, 1, 2, 3, 4, 5, 6, 7, @@ -28,7 +28,7 @@ void check(handle_t h) { } long offlast = 0; - long retlast = _syscall_read(h, buflast, buflen, offlast); + long retlast = _sys_read(h, buflast, buflen, offlast); if (retlast < 0) { eprintf("error %d when reading at offset %d", retlast, offlast); goto end; @@ -41,7 +41,7 @@ void check(handle_t h) { assert(diff >= 0); if (retlast < diff) break; - long retcur = _syscall_read(h, bufcur, buflen, offcur); + long retcur = _sys_read(h, bufcur, buflen, offcur); if (retcur < 0) { eprintf("error %d when reading at offset %d", retlast, offcur); break; @@ -85,7 +85,7 @@ int main(int argc, char **argv) { for (; optind < argc; optind++) { const char *path = argv[optind]; verbosef("checking %s...\n", path); - handle_t h = camellia_open(path, OPEN_READ); + hid_t h = camellia_open(path, OPEN_READ); if (h < 0) { eprintf("couldn't open %s", path); continue; diff --git a/src/user/app/iostress/iostress.c b/src/user/app/iostress/iostress.c index 2f15471..3a3a23c 100644 --- a/src/user/app/iostress/iostress.c +++ b/src/user/app/iostress/iostress.c @@ -26,9 +26,9 @@ int main(int argc, char **argv) { for (long i = 0; i < num_runs; i++) { uint64_t time = __rdtsc(); for (long j = 0; j < num_calls; j++) - _syscall_write(1, inbuf, num_bytes, -1, 0); + _sys_write(1, inbuf, num_bytes, -1, 0); results[i] = __rdtsc() - time; - _syscall_write(1, "\n", 1, -1, 0); + _sys_write(1, "\n", 1, -1, 0); } uint64_t total = 0; diff --git a/src/user/app/logfs/logfs.c b/src/user/app/logfs/logfs.c index 14a8f2a..a50d530 100644 --- a/src/user/app/logfs/logfs.c +++ b/src/user/app/logfs/logfs.c @@ -11,7 +11,7 @@ _Noreturn void fs(void) { if (!buf) err(1, "malloc"); for (;;) { struct ufs_request req; - handle_t reqh = ufs_wait(buf, buflen, &req); + hid_t reqh = ufs_wait(buf, buflen, &req); if (reqh < 0) errx(1, "ufs_wait error"); switch (req.op) { @@ -23,7 +23,7 @@ _Noreturn void fs(void) { /* Unsupported vfs operation. * Currently if you never create your own file descriptors you won't receive * anything but VFSOP_OPEN, but it's idiomatic to handle this anyways. */ - _syscall_fs_respond(reqh, NULL, -1, 0); + _sys_fs_respond(reqh, NULL, -1, 0); break; } } diff --git a/src/user/app/login/login.c b/src/user/app/login/login.c index a348254..0f9e8b7 100644 --- a/src/user/app/login/login.c +++ b/src/user/app/login/login.c @@ -36,23 +36,23 @@ static void drv(const char *user) { char *buf = malloc(PATH_MAX); for (;;) { struct ufs_request req; - handle_t reqh = ufs_wait(buf, PATH_MAX, &req); + hid_t reqh = ufs_wait(buf, PATH_MAX, &req); if (reqh < 0) break; switch (req.op) { case VFSOP_OPEN: if (segcmp(buf, 1, "Users") && segcmp(buf, 2, user)) { // /Users/$user/** forward_open(reqh, buf, req.len, req.flags); } else if (segcmp(buf, 1, "Users") && segcmp(buf, 3, "private")) { // /Users/*/private/** - _syscall_fs_respond(reqh, NULL, -EACCES, 0); + _sys_fs_respond(reqh, NULL, -EACCES, 0); } else if (!OPEN_WRITEABLE(req.flags)) { forward_open(reqh, buf, req.len, req.flags); } else { - _syscall_fs_respond(reqh, NULL, -EACCES, 0); + _sys_fs_respond(reqh, NULL, -EACCES, 0); } break; default: - _syscall_fs_respond(reqh, NULL, -1, 0); + _sys_fs_respond(reqh, NULL, -1, 0); break; } } diff --git a/src/user/app/netdog/nd.c b/src/user/app/netdog/nd.c index 93e1d3a..fdc8361 100644 --- a/src/user/app/netdog/nd.c +++ b/src/user/app/netdog/nd.c @@ -6,15 +6,15 @@ #define eprintf(fmt, ...) fprintf(stderr, "netdog: "fmt"\n" __VA_OPT__(,) __VA_ARGS__) -handle_t conn; +hid_t conn; void send_stdin(void *arg) { (void)arg; static char buf[4096]; for (;;) { // TODO define STDIN_FILENO - long ret = _syscall_read(0, buf, sizeof buf, -1); + long ret = _sys_read(0, buf, sizeof buf, -1); if (ret <= 0) return; /* instead of sending an empty packet, quit. */ - ret = _syscall_write(conn, buf, ret, -1, 0); + ret = _sys_write(conn, buf, ret, -1, 0); if (ret < 0) return; } } @@ -22,9 +22,9 @@ void send_stdin(void *arg) { (void)arg; void recv_stdout(void *arg) { (void)arg; static char buf[4096]; for (;;) { - long ret = _syscall_read(conn, buf, sizeof buf, -1); + long ret = _sys_read(conn, buf, sizeof buf, -1); if (ret < 0) return; - ret = _syscall_write(1, buf, ret, -1, 0); + ret = _sys_write(1, buf, ret, -1, 0); if (ret < 0) return; } } @@ -43,6 +43,6 @@ int main(int argc, char **argv) { thread_create(0, send_stdin, NULL); thread_create(0, recv_stdout, NULL); - _syscall_await(); + _sys_await(); return 0; } diff --git a/src/user/app/netstack/arp.c b/src/user/app/netstack/arp.c index 6c230b3..3a1c8da 100644 --- a/src/user/app/netstack/arp.c +++ b/src/user/app/netstack/arp.c @@ -107,7 +107,7 @@ int arpcache_get(uint32_t ip, mac_t *mac) { return -1; } -void arp_fsread(handle_t h, long offset) { +void arp_fsread(hid_t h, long offset) { const char *fmt = "%08x\t%02x:%02x:%02x:%02x:%02x:%02x\n"; long linelen = snprintf(NULL, 0, fmt, 0, 1, 2, 3, 4, 5, 6) + 1; char buf[28]; @@ -129,10 +129,10 @@ void arp_fsread(handle_t h, long offset) { cur->mac[3], cur->mac[4], cur->mac[5]); - _syscall_fs_respond(h, buf + offset, linelen - offset, 0); + _sys_fs_respond(h, buf + offset, linelen - offset, 0); return; err: - _syscall_fs_respond(h, NULL, -1, 0); + _sys_fs_respond(h, NULL, -1, 0); } long arp_fswrite(const char *buf, long len, long offset) { diff --git a/src/user/app/netstack/ether.c b/src/user/app/netstack/ether.c index 20d16ab..52abac2 100644 --- a/src/user/app/netstack/ether.c +++ b/src/user/app/netstack/ether.c @@ -19,7 +19,7 @@ void ether_parse(const uint8_t *buf, size_t len) { for (struct ethq **iter = ðer_queue; iter && *iter; ) { struct ethq *qe = *iter; - _syscall_fs_respond(qe->h, buf, len, 0); + _sys_fs_respond(qe->h, buf, len, 0); /* remove entry */ /* yes, doing it this way here doesn't make sense. i'm preparing for filtering */ *iter = qe->next; @@ -54,6 +54,6 @@ uint8_t *ether_start(size_t len, struct ethernet ether) { void ether_finish(uint8_t *pkt) { uint8_t *buf = pkt - Payload - fhoff; size_t len = *(size_t*)buf; - _syscall_write(state.raw_h, buf + fhoff, len, 0, 0); + _sys_write(state.raw_h, buf + fhoff, len, 0, 0); free(buf); } diff --git a/src/user/app/netstack/fs.c b/src/user/app/netstack/fs.c index ad6c23c..6d51c35 100644 --- a/src/user/app/netstack/fs.c +++ b/src/user/app/netstack/fs.c @@ -43,14 +43,14 @@ struct handle { size_t readcap; } tcp; bool dead; - handle_t reqh; + hid_t reqh; }; static void tcp_listen_callback(struct tcp_conn *c, void *arg) { struct handle *h = arg; h->tcp.c = c; - _syscall_fs_respond(h->reqh, h, 0, 0); + _sys_fs_respond(h->reqh, h, 0, 0); h->reqh = -1; } @@ -63,7 +63,7 @@ static void tcp_recv_callback(void *arg) { h->tcp.readcap = sizeof buf; size_t len = tcpc_tryread(h->tcp.c, buf, h->tcp.readcap); if (len > 0) { - _syscall_fs_respond(h->reqh, buf, len, 0); + _sys_fs_respond(h->reqh, buf, len, 0); h->reqh = -1; } } @@ -73,7 +73,7 @@ static void tcp_close_callback(void *arg) { struct handle *h = arg; h->dead = true; if (h->reqh >= 0) { - _syscall_fs_respond(h->reqh, NULL, -ECONNRESET, 0); + _sys_fs_respond(h->reqh, NULL, -ECONNRESET, 0); h->reqh = -1; return; } @@ -82,14 +82,14 @@ static void tcp_close_callback(void *arg) { static void udp_listen_callback(struct udp_conn *c, void *arg) { struct handle *h = arg; h->udp.c = c; - _syscall_fs_respond(h->reqh, h, 0, 0); + _sys_fs_respond(h->reqh, h, 0, 0); h->reqh = -1; } static void udp_recv_callback(const void *buf, size_t len, void *arg) { struct handle *h = arg; if (h->reqh >= 0) { - _syscall_fs_respond(h->reqh, buf, len, 0); + _sys_fs_respond(h->reqh, buf, len, 0); h->reqh = -1; return; } @@ -106,14 +106,14 @@ static void udp_recv_callback(const void *buf, size_t len, void *arg) { } } -static void recv_enqueue(struct handle *h, handle_t reqh, size_t readcap) { +static void recv_enqueue(struct handle *h, hid_t reqh, size_t readcap) { if (h->reqh > 0) { // TODO queue - _syscall_fs_respond(reqh, NULL, -1, 0); + _sys_fs_respond(reqh, NULL, -1, 0); return; } if (h->type == H_UDP && h->udp.rx) { - _syscall_fs_respond(reqh, h->udp.rx->buf, h->udp.rx->len, 0); + _sys_fs_respond(reqh, h->udp.rx->buf, h->udp.rx->len, 0); h->udp.rx = h->udp.rx->next; free(h->udp.rx); return; @@ -125,8 +125,8 @@ static void recv_enqueue(struct handle *h, handle_t reqh, size_t readcap) { } } -static void fs_open(handle_t reqh, char *path, int flags) { -#define respond(buf, val) do{ _syscall_fs_respond(reqh, buf, val, 0); return; }while(0) +static void fs_open(hid_t reqh, char *path, int flags) { +#define respond(buf, val) do{ _sys_fs_respond(reqh, buf, val, 0); return; }while(0) struct handle *h; if (*path != '/') respond(NULL, -1); path++; @@ -241,7 +241,7 @@ void fs_thread(void *arg) { (void)arg; char *buf = malloc(buflen); for (;;) { struct ufs_request res; - handle_t reqh = _syscall_fs_wait(buf, buflen, &res); + hid_t reqh = _sys_fs_wait(buf, buflen, &res); if (reqh < 0) break; struct handle *h = res.id; long ret; @@ -251,12 +251,12 @@ void fs_thread(void *arg) { (void)arg; buf[res.len] = '\0'; fs_open(reqh, buf, res.flags); } else { - _syscall_fs_respond(reqh, NULL, -1, 0); + _sys_fs_respond(reqh, NULL, -1, 0); } break; case VFSOP_READ: if (h->dead) { - _syscall_fs_respond(reqh, NULL, -ECONNRESET, 0); + _sys_fs_respond(reqh, NULL, -ECONNRESET, 0); break; } switch (h->type) { @@ -275,44 +275,44 @@ void fs_thread(void *arg) { (void)arg; arp_fsread(reqh, res.offset); break; default: - _syscall_fs_respond(reqh, NULL, -1, 0); + _sys_fs_respond(reqh, NULL, -1, 0); } break; case VFSOP_WRITE: if (h->dead) { - _syscall_fs_respond(reqh, NULL, -ECONNRESET, 0); + _sys_fs_respond(reqh, NULL, -ECONNRESET, 0); break; } switch (h->type) { case H_ETHER: - ret = _syscall_write(state.raw_h, buf, res.len, 0, 0); - _syscall_fs_respond(reqh, NULL, ret, 0); + ret = _sys_write(state.raw_h, buf, res.len, 0, 0); + _sys_fs_respond(reqh, NULL, ret, 0); break; case H_TCP: tcpc_send(h->tcp.c, buf, res.len); - _syscall_fs_respond(reqh, NULL, res.len, 0); + _sys_fs_respond(reqh, NULL, res.len, 0); break; case H_UDP: udpc_send(h->udp.c, buf, res.len); - _syscall_fs_respond(reqh, NULL, res.len, 0); + _sys_fs_respond(reqh, NULL, res.len, 0); break; case H_ARP: - _syscall_fs_respond(reqh, NULL, arp_fswrite(buf, res.len, res.offset), 0); + _sys_fs_respond(reqh, NULL, arp_fswrite(buf, res.len, res.offset), 0); break; default: - _syscall_fs_respond(reqh, NULL, -1, 0); + _sys_fs_respond(reqh, NULL, -1, 0); } break; case VFSOP_CLOSE: // TODO remove entries in queue - // TODO why does close even have _syscall_fs_respond? + // TODO why does close even have _sys_fs_respond? if (h->type == H_TCP) tcpc_close(h->tcp.c); if (h->type == H_UDP) udpc_close(h->udp.c); free(h); - _syscall_fs_respond(reqh, NULL, -1, 0); + _sys_fs_respond(reqh, NULL, -1, 0); break; default: - _syscall_fs_respond(reqh, NULL, -1, 0); + _sys_fs_respond(reqh, NULL, -1, 0); break; } } diff --git a/src/user/app/netstack/netstack.c b/src/user/app/netstack/netstack.c index 405be09..c2e9223 100644 --- a/src/user/app/netstack/netstack.c +++ b/src/user/app/netstack/netstack.c @@ -17,7 +17,7 @@ void network_thread(void *arg) { (void)arg; const size_t buflen = 4096; char *buf = malloc(buflen); for (;;) { - long ret = _syscall_read(state.raw_h, buf, buflen, -1); + long ret = _sys_read(state.raw_h, buf, buflen, -1); if (ret < 0) break; ether_parse((void*)buf, ret); } @@ -49,6 +49,6 @@ int main(int argc, char **argv) { arp_request(state.gateway); thread_create(0, network_thread, NULL); thread_create(0, fs_thread, NULL); - _syscall_await(); + _sys_await(); return 0; } diff --git a/src/user/app/netstack/proto.h b/src/user/app/netstack/proto.h index 4d881ca..8ea11ac 100644 --- a/src/user/app/netstack/proto.h +++ b/src/user/app/netstack/proto.h @@ -10,7 +10,7 @@ extern struct net_state { mac_t mac; uint32_t ip, gateway; - handle_t raw_h; + hid_t raw_h; } state; enum { /* ethertype */ @@ -51,7 +51,7 @@ struct icmp { * will break if i implement a scheduler*/ struct ethq { struct ethq *next; - handle_t h; + hid_t h; }; extern struct ethq *ether_queue; @@ -59,7 +59,7 @@ void arp_parse(const uint8_t *buf, size_t len); void arp_request(uint32_t ip); /* 0 on success, -1 on failure */ int arpcache_get(uint32_t ip, mac_t *mac); -void arp_fsread(handle_t h, long offset); +void arp_fsread(hid_t h, long offset); long arp_fswrite(const char *buf, long len, long offset); void icmp_parse(const uint8_t *buf, size_t len, struct ipv4 ip); diff --git a/src/user/app/shell/builtins.c b/src/user/app/shell/builtins.c index 870a6af..e0f848e 100644 --- a/src/user/app/shell/builtins.c +++ b/src/user/app/shell/builtins.c @@ -58,13 +58,13 @@ static void cmd_echo(int argc, char **argv) { void cmd_getsize(int argc, char **argv) { if (argc < 2) errx(1, "no arguments"); for (int i = 1; i < argc; i++) { - handle_t h = camellia_open(argv[i], OPEN_READ); + hid_t h = camellia_open(argv[i], OPEN_READ); if (h < 0) { warn("error opening %s", argv[i]); continue; } - printf("%s: %d\n", argv[i], (int)_syscall_getsize(h)); - _syscall_close(h); + printf("%s: %d\n", argv[i], (int)_sys_getsize(h)); + _sys_close(h); } } @@ -205,7 +205,7 @@ static void cmd_rm(int argc, char **argv) { static void cmd_sleep(int argc, char **argv) { if (argc < 2) errx(1, "no arguments"); - _syscall_sleep(strtol(argv[1], NULL, 0) * 1000); + _sys_sleep(strtol(argv[1], NULL, 0) * 1000); } static void cmd_touch(int argc, char **argv) { diff --git a/src/user/app/shell/shell.c b/src/user/app/shell/shell.c index 564daa8..5808de1 100644 --- a/src/user/app/shell/shell.c +++ b/src/user/app/shell/shell.c @@ -50,14 +50,14 @@ void run_args(int argc, char **argv, struct redir *redir) { if (argc < 2) { fprintf(stderr, "shadow: missing path\n"); } else { - _syscall_mount(HANDLE_NULLFS, argv[1], strlen(argv[1])); + _sys_mount(HANDLE_NULLFS, argv[1], strlen(argv[1])); } } else if (!strcmp(argv[0], "procmnt")) { if (argc < 2) { fprintf(stderr, "procmnt: missing mountpoint\n"); return; } - _syscall_mount(HANDLE_PROCFS, argv[1], strlen(argv[1])); + _sys_mount(HANDLE_PROCFS, argv[1], strlen(argv[1])); if (!fork2_n_mount("/")) { fs_dir_inject(argv[1]); exit(1); @@ -79,7 +79,7 @@ void run_args(int argc, char **argv, struct redir *redir) { } if (fork()) { - _syscall_await(); + _sys_await(); return; } @@ -91,18 +91,18 @@ void run_args(int argc, char **argv, struct redir *redir) { /* a workaround for file offsets not being preserved across exec()s. * TODO document that weird behaviour of exec() */ - handle_t p[2]; - if (_syscall_pipe(p, 0) < 0) { + hid_t p[2]; + if (_sys_pipe(p, 0) < 0) { errx(1, "couldn't create redirection pipe"); } - if (!_syscall_fork(FORK_NOREAP, NULL)) { + if (!_sys_fork(FORK_NOREAP, NULL)) { /* the child forwards data from the pipe to the file */ const size_t buflen = 512; char *buf = malloc(buflen); if (!buf) err(1, "when redirecting"); close(p[1]); for (;;) { - long len = _syscall_read(p[0], buf, buflen, 0); + long len = _sys_read(p[0], buf, buflen, 0); if (len < 0) exit(0); fwrite(buf, 1, len, f); if (ferror(f)) exit(0); @@ -111,7 +111,7 @@ void run_args(int argc, char **argv, struct redir *redir) { fclose(f); close(p[0]); - if (_syscall_dup(p[1], 1, 0) < 0) { + if (_sys_dup(p[1], 1, 0) < 0) { errx(1, "dup() failed when redirecting"); } } diff --git a/src/user/app/tests/kernel/fdlimit.c b/src/user/app/tests/kernel/fdlimit.c index d22af13..f332357 100644 --- a/src/user/app/tests/kernel/fdlimit.c +++ b/src/user/app/tests/kernel/fdlimit.c @@ -4,10 +4,10 @@ #include <unistd.h> static void test_fdlimit_pipe(void) { - handle_t ends[2]; - handle_t h[2] = {-1, -1}; + hid_t ends[2]; + hid_t h[2] = {-1, -1}; for (;;) { - handle_t cur = _syscall_open("/", 1, OPEN_READ); + hid_t cur = _sys_open("/", 1, OPEN_READ); if (cur == -EMFILE) break; test(cur >= 0); h[0] = h[1]; @@ -15,31 +15,31 @@ static void test_fdlimit_pipe(void) { } test(h[0] >= 0); /* we need at least two handles */ - test(_syscall_pipe(ends, 0) == -EMFILE); - test(_syscall_open("/", 1, OPEN_READ) == -EMFILE); + test(_sys_pipe(ends, 0) == -EMFILE); + test(_sys_open("/", 1, OPEN_READ) == -EMFILE); close(h[1]); - test(_syscall_pipe(ends, 0) == -EMFILE); - test(_syscall_open("/", 1, OPEN_READ) == h[1]); - test(_syscall_open("/", 1, OPEN_READ) == -EMFILE); + test(_sys_pipe(ends, 0) == -EMFILE); + test(_sys_open("/", 1, OPEN_READ) == h[1]); + test(_sys_open("/", 1, OPEN_READ) == -EMFILE); close(h[0]); close(h[1]); - test(_syscall_pipe(ends, 0) == 0); + test(_sys_pipe(ends, 0) == 0); } static void test_fdlimit_fork(void) { for (;;) { - handle_t cur = _syscall_open("/", 1, OPEN_READ); + hid_t cur = _sys_open("/", 1, OPEN_READ); if (cur == -EMFILE) break; test(cur >= 0); } - if (!_syscall_fork(0, NULL)) _syscall_exit(123); + if (!_sys_fork(0, NULL)) _sys_exit(123); - test(_syscall_fork(FORK_NEWFS, NULL) == -EMFILE); - test(_syscall_await() == 123); - test(_syscall_await() == ~0); + test(_sys_fork(FORK_NEWFS, NULL) == -EMFILE); + test(_sys_await() == 123); + test(_sys_await() == ~0); } void r_k_fdlimit(void) { diff --git a/src/user/app/tests/kernel/fs.c b/src/user/app/tests/kernel/fs.c index 6669c41..b5684d7 100644 --- a/src/user/app/tests/kernel/fs.c +++ b/src/user/app/tests/kernel/fs.c @@ -5,34 +5,34 @@ #include <string.h> static void test_unfinished_req(void) { - handle_t h = -1; - int ret = _syscall_fork(FORK_NEWFS, &h); + hid_t h = -1; + int ret = _sys_fork(FORK_NEWFS, &h); test(0 <= ret); if (ret == 0) { // TODO make a similar test with all 0s passed to fs_wait struct ufs_request res; - _syscall_fs_wait(NULL, 0, &res); + _sys_fs_wait(NULL, 0, &res); // TODO second fs_wait exit(0); } else { test(0 <= h); - test(_syscall_mount(h, "/", 1) == 0); - int ret = _syscall_open("/", 1, 0); + test(_sys_mount(h, "/", 1) == 0); + int ret = _sys_open("/", 1, 0); test(ret < 0); // the handler quits while handling that call - but this syscall should return anyways } } static void test_orphaned_fs(void) { - handle_t h = -1; - int ret = _syscall_fork(FORK_NEWFS, &h); + hid_t h = -1; + int ret = _sys_fork(FORK_NEWFS, &h); test(0 <= ret); if (ret == 0) { exit(0); } else { test(0 <= h); - test(_syscall_mount(h, "/", 1) == 0); - int ret = _syscall_open("/", 1, 0); + test(_sys_mount(h, "/", 1) == 0); + int ret = _sys_open("/", 1, 0); test(ret < 0); } } @@ -41,32 +41,32 @@ static void test_fs_cleanup(void) { const char *msg = "success"; int msglen = 8; char buf[16]; - handle_t ends[2]; - test(_syscall_pipe(ends, 0) >= 0); - if (!_syscall_fork(0, NULL)) { - handle_t h = -1; - if (_syscall_fork(FORK_NEWFS, &h) == 0) { + hid_t ends[2]; + test(_sys_pipe(ends, 0) >= 0); + if (!_sys_fork(0, NULL)) { + hid_t h = -1; + if (_sys_fork(FORK_NEWFS, &h) == 0) { for (;;) { struct ufs_request req; - handle_t reqh = _syscall_fs_wait(buf, sizeof buf, &req); + hid_t reqh = _sys_fs_wait(buf, sizeof buf, &req); if (reqh < 0) break; - _syscall_fs_respond(reqh, NULL, 0, 0); /* success */ + _sys_fs_respond(reqh, NULL, 0, 0); /* success */ } /* this is the test: does it break out of the loop * when it should cleanup */ - _syscall_write(ends[1], msg, msglen, -1, 0); + _sys_write(ends[1], msg, msglen, -1, 0); exit(0); } else { - test(_syscall_mount(h, "/", 1) == 0); - h = _syscall_open("/", 1, 0); + test(_sys_mount(h, "/", 1) == 0); + h = _sys_open("/", 1, 0); test(h >= 0); - _syscall_close(h); + _sys_close(h); // TODO another test without the delay - _syscall_sleep(0); + _sys_sleep(0); exit(0); } } else { - test(_syscall_read(ends[0], buf, sizeof buf, 0) == msglen); + test(_sys_read(ends[0], buf, sizeof buf, 0) == msglen); test(memcmp(buf, msg, msglen) == 0); } } diff --git a/src/user/app/tests/kernel/misc.c b/src/user/app/tests/kernel/misc.c index f6a8feb..b60ebc0 100644 --- a/src/user/app/tests/kernel/misc.c +++ b/src/user/app/tests/kernel/misc.c @@ -16,7 +16,7 @@ static void test_fault_kill(void) { } int await_cnt = 0; - while (_syscall_await() != ~0) await_cnt++; + while (_sys_await() != ~0) await_cnt++; test(await_cnt == 2); } @@ -24,32 +24,32 @@ static void test_efault(void) { const char *str = "o, 16 characters"; char str2[16]; char *invalid = (void*)0x1000; - handle_t h; + hid_t h; memcpy(str2, str, 16); - test((h = _syscall_open(TMPFILEPATH, strlen(TMPFILEPATH), OPEN_CREATE | OPEN_WRITE)) >= 0); - test(_syscall_write(h, str, 16, 0, 0) == 16); - test(_syscall_write(h, str2, 16, 0, 0) == 16); + test((h = _sys_open(TMPFILEPATH, strlen(TMPFILEPATH), OPEN_CREATE | OPEN_WRITE)) >= 0); + test(_sys_write(h, str, 16, 0, 0) == 16); + test(_sys_write(h, str2, 16, 0, 0) == 16); - test(_syscall_write(h, invalid, 16, 0, 0) == -EFAULT); + test(_sys_write(h, invalid, 16, 0, 0) == -EFAULT); /* x64 non-canonical pointers */ - test(_syscall_write(h, (void*)((uintptr_t)str ^ 0x8000000000000000), 16, 0, 0) == -EFAULT); - test(_syscall_write(h, (void*)((uintptr_t)str ^ 0x1000000000000000), 16, 0, 0) == -EFAULT); - test(_syscall_write(h, (void*)((uintptr_t)str ^ 0x0100000000000000), 16, 0, 0) == -EFAULT); - test(_syscall_write(h, (void*)((uintptr_t)str ^ 0x0010000000000000), 16, 0, 0) == -EFAULT); - test(_syscall_write(h, (void*)((uintptr_t)str ^ 0x0001000000000000), 16, 0, 0) == -EFAULT); - test(_syscall_write(h, (void*)((uintptr_t)str ^ 0x0000800000000000), 16, 0, 0) == -EFAULT); + test(_sys_write(h, (void*)((uintptr_t)str ^ 0x8000000000000000), 16, 0, 0) == -EFAULT); + test(_sys_write(h, (void*)((uintptr_t)str ^ 0x1000000000000000), 16, 0, 0) == -EFAULT); + test(_sys_write(h, (void*)((uintptr_t)str ^ 0x0100000000000000), 16, 0, 0) == -EFAULT); + test(_sys_write(h, (void*)((uintptr_t)str ^ 0x0010000000000000), 16, 0, 0) == -EFAULT); + test(_sys_write(h, (void*)((uintptr_t)str ^ 0x0001000000000000), 16, 0, 0) == -EFAULT); + test(_sys_write(h, (void*)((uintptr_t)str ^ 0x0000800000000000), 16, 0, 0) == -EFAULT); - test(_syscall_write(h, (void*)((uintptr_t)str2 ^ 0x8000000000000000), 16, 0, 0) == -EFAULT); - test(_syscall_write(h, (void*)((uintptr_t)str2 ^ 0x1000000000000000), 16, 0, 0) == -EFAULT); - test(_syscall_write(h, (void*)((uintptr_t)str2 ^ 0x0100000000000000), 16, 0, 0) == -EFAULT); - test(_syscall_write(h, (void*)((uintptr_t)str2 ^ 0x0010000000000000), 16, 0, 0) == -EFAULT); - test(_syscall_write(h, (void*)((uintptr_t)str2 ^ 0x0001000000000000), 16, 0, 0) == -EFAULT); - test(_syscall_write(h, (void*)((uintptr_t)str2 ^ 0x0000800000000000), 16, 0, 0) == -EFAULT); + test(_sys_write(h, (void*)((uintptr_t)str2 ^ 0x8000000000000000), 16, 0, 0) == -EFAULT); + test(_sys_write(h, (void*)((uintptr_t)str2 ^ 0x1000000000000000), 16, 0, 0) == -EFAULT); + test(_sys_write(h, (void*)((uintptr_t)str2 ^ 0x0100000000000000), 16, 0, 0) == -EFAULT); + test(_sys_write(h, (void*)((uintptr_t)str2 ^ 0x0010000000000000), 16, 0, 0) == -EFAULT); + test(_sys_write(h, (void*)((uintptr_t)str2 ^ 0x0001000000000000), 16, 0, 0) == -EFAULT); + test(_sys_write(h, (void*)((uintptr_t)str2 ^ 0x0000800000000000), 16, 0, 0) == -EFAULT); - test(_syscall_write(h, str, 16, 0, 0) == 16); + test(_sys_write(h, str, 16, 0, 0) == 16); close(h); } diff --git a/src/user/app/tests/kernel/miscsyscall.c b/src/user/app/tests/kernel/miscsyscall.c index 58a9afb..c90560e 100644 --- a/src/user/app/tests/kernel/miscsyscall.c +++ b/src/user/app/tests/kernel/miscsyscall.c @@ -17,7 +17,7 @@ static void test_await(void) { if (!fork()) exit(i); - while ((ret = _syscall_await()) != ~0) { + while ((ret = _sys_await()) != ~0) { test(0 <= ret && ret < 16); counts[ret]++; } @@ -30,114 +30,114 @@ static void test_await2(void) { /* hangs on failure */ if (!fork()) { if (!fork()) { - for (;;) _syscall_sleep(1000000000); + for (;;) _sys_sleep(1000000000); } else { exit(123); } } - test(_syscall_await() == 123); - test(_syscall_await() == ~0); /* don't wait for tombstone */ - _syscall_filicide(); + test(_sys_await() == 123); + test(_sys_await() == ~0); /* don't wait for tombstone */ + _sys_filicide(); } static void test_pipe(void) { const char *pipe_msgs[2] = {"hello", "world"}; - handle_t ends[2]; + hid_t ends[2]; char buf[16]; /* test regular reads / writes */ - test(_syscall_pipe(ends, 0) >= 0); + test(_sys_pipe(ends, 0) >= 0); if (!fork()) { /* those repeated asserts ensure that you can't read/write to the wrong ends */ - test(_syscall_read(ends[1], buf, 16, 0) < 0); - test(_syscall_write(ends[0], buf, 16, 0, 0) < 0); + test(_sys_read(ends[1], buf, 16, 0) < 0); + test(_sys_write(ends[0], buf, 16, 0, 0) < 0); - test(5 == _syscall_write(ends[1], pipe_msgs[0], 5, -1, 0)); + test(5 == _sys_write(ends[1], pipe_msgs[0], 5, -1, 0)); - test(_syscall_read(ends[1], buf, 16, 0) < 0); - test(_syscall_write(ends[0], buf, 16, 0, 0) < 0); + test(_sys_read(ends[1], buf, 16, 0) < 0); + test(_sys_write(ends[0], buf, 16, 0, 0) < 0); - test(5 == _syscall_write(ends[1], pipe_msgs[1], 5, -1, 0)); + test(5 == _sys_write(ends[1], pipe_msgs[1], 5, -1, 0)); exit(0); } else { - test(_syscall_read(ends[1], buf, 16, 0) < 0); - test(_syscall_write(ends[0], buf, 16, 0, 0) < 0); + test(_sys_read(ends[1], buf, 16, 0) < 0); + test(_sys_write(ends[0], buf, 16, 0, 0) < 0); - test(5 == _syscall_read(ends[0], buf, 16, 0)); + test(5 == _sys_read(ends[0], buf, 16, 0)); test(!memcmp(buf, pipe_msgs[0], 5)); - test(_syscall_read(ends[1], buf, 16, 0) < 0); - test(_syscall_write(ends[0], buf, 16, 0, 0) < 0); + test(_sys_read(ends[1], buf, 16, 0) < 0); + test(_sys_write(ends[0], buf, 16, 0, 0) < 0); - test(5 == _syscall_read(ends[0], buf, 16, 0)); + test(5 == _sys_read(ends[0], buf, 16, 0)); test(!memcmp(buf, pipe_msgs[1], 5)); - _syscall_await(); + _sys_await(); } close(ends[0]); close(ends[1]); /* writing to pipes with one end closed */ - test(_syscall_pipe(ends, 0) >= 0); + test(_sys_pipe(ends, 0) >= 0); for (int i = 0; i < 16; i++) { if (!fork()) { close(ends[1]); - test(_syscall_read(ends[0], buf, 16, 0) < 0); + test(_sys_read(ends[0], buf, 16, 0) < 0); exit(0); } } close(ends[1]); for (int i = 0; i < 16; i++) - _syscall_await(); + _sys_await(); close(ends[0]); - test(_syscall_pipe(ends, 0) >= 0); + test(_sys_pipe(ends, 0) >= 0); for (int i = 0; i < 16; i++) { if (!fork()) { close(ends[0]); - test(_syscall_write(ends[1], buf, 16, 0, 0) < 0); + test(_sys_write(ends[1], buf, 16, 0, 0) < 0); exit(0); } } close(ends[0]); for (int i = 0; i < 16; i++) - _syscall_await(); + _sys_await(); close(ends[1]); /* queueing */ - test(_syscall_pipe(ends, 0) >= 0); + test(_sys_pipe(ends, 0) >= 0); for (int i = 0; i < 16; i++) { if (!fork()) { - test(_syscall_write(ends[1], pipe_msgs[0], 5, -1, 0) == 5); + test(_sys_write(ends[1], pipe_msgs[0], 5, -1, 0) == 5); exit(0); } } close(ends[1]); for (int i = 0; i < 16; i++) { - test(_syscall_read(ends[0], buf, sizeof buf, 0) == 5); - _syscall_await(); + test(_sys_read(ends[0], buf, sizeof buf, 0) == 5); + _sys_await(); } - test(_syscall_read(ends[0], buf, sizeof buf, 0) < 0); + test(_sys_read(ends[0], buf, sizeof buf, 0) < 0); close(ends[0]); - test(_syscall_pipe(ends, 0) >= 0); + test(_sys_pipe(ends, 0) >= 0); for (int i = 0; i < 16; i++) { if (!fork()) { memset(buf, 0, sizeof buf); - test(_syscall_read(ends[0], buf, 5, -1) == 5); + test(_sys_read(ends[0], buf, 5, -1) == 5); test(!memcmp(buf, pipe_msgs[1], 5)); exit(0); } } close(ends[0]); for (int i = 0; i < 16; i++) { - test(_syscall_write(ends[1], pipe_msgs[1], 5, -1, 0) == 5); - _syscall_await(); + test(_sys_write(ends[1], pipe_msgs[1], 5, -1, 0) == 5); + _sys_await(); } - test(_syscall_write(ends[1], pipe_msgs[1], 5, -1, 0) < 0); + test(_sys_write(ends[1], pipe_msgs[1], 5, -1, 0) < 0); close(ends[1]); @@ -147,65 +147,65 @@ static void test_pipe(void) { static void test_memflag(void) { void *page = (void*)0x77777000; - _syscall_memflag(page, 4096, MEMFLAG_PRESENT); // allocate page + _sys_memflag(page, 4096, MEMFLAG_PRESENT); // allocate page memset(page, 77, 4096); // write to it - _syscall_memflag(page, 4096, 0); // free it + _sys_memflag(page, 4096, 0); // free it if (!fork()) { memset(page, 11, 4096); // should segfault exit(0); } else { - test(_syscall_await() != 0); // test if the process crashed + test(_sys_await() != 0); // test if the process crashed } char *pages[4]; for (size_t i = 0; i < 4; i++) { - pages[i] = _syscall_memflag(NULL, 4096, MEMFLAG_FINDFREE); - test(pages[i] == _syscall_memflag(NULL, 4096, MEMFLAG_FINDFREE | MEMFLAG_PRESENT)); + pages[i] = _sys_memflag(NULL, 4096, MEMFLAG_FINDFREE); + test(pages[i] == _sys_memflag(NULL, 4096, MEMFLAG_FINDFREE | MEMFLAG_PRESENT)); if (i > 0) test(pages[i] != pages[i-1]); *pages[i] = 0x77; } for (size_t i = 0; i < 4; i++) - _syscall_memflag(pages, 4096, MEMFLAG_PRESENT); + _sys_memflag(pages, 4096, MEMFLAG_PRESENT); } static void test_dup(void) { - handle_t pipe[2]; - handle_t h1, h2; - test(_syscall_pipe(pipe, 0) >= 0); + hid_t pipe[2]; + hid_t h1, h2; + test(_sys_pipe(pipe, 0) >= 0); if (!fork()) { close(pipe[0]); - h1 = _syscall_dup(pipe[1], -1, 0); + h1 = _sys_dup(pipe[1], -1, 0); test(h1 >= 0); test(h1 != pipe[1]); - h2 = _syscall_dup(h1, -1, 0); + h2 = _sys_dup(h1, -1, 0); test(h2 >= 0); test(h2 != pipe[1] && h2 != h1); - _syscall_write(pipe[1], "og", 2, 0, 0); - _syscall_write(h1, "h1", 2, 0, 0); - _syscall_write(h2, "h2", 2, 0, 0); + _sys_write(pipe[1], "og", 2, 0, 0); + _sys_write(h1, "h1", 2, 0, 0); + _sys_write(h2, "h2", 2, 0, 0); close(pipe[1]); - _syscall_write(h1, "h1", 2, 0, 0); - _syscall_write(h2, "h2", 2, 0, 0); + _sys_write(h1, "h1", 2, 0, 0); + _sys_write(h2, "h2", 2, 0, 0); - test(_syscall_dup(h1, pipe[1], 0) == pipe[1]); - test(_syscall_dup(h2, pipe[1], 0) == pipe[1]); - test(_syscall_dup(h1, pipe[1], 0) == pipe[1]); - test(_syscall_dup(h2, pipe[1], 0) == pipe[1]); + test(_sys_dup(h1, pipe[1], 0) == pipe[1]); + test(_sys_dup(h2, pipe[1], 0) == pipe[1]); + test(_sys_dup(h1, pipe[1], 0) == pipe[1]); + test(_sys_dup(h2, pipe[1], 0) == pipe[1]); close(h1); close(h2); - test(_syscall_dup(pipe[1], h2, 0) == h2); - _syscall_write(h2, "h2", 2, 0, 0); + test(_sys_dup(pipe[1], h2, 0) == h2); + _sys_write(h2, "h2", 2, 0, 0); close(h2); - test(_syscall_dup(pipe[1], h1, 0) == h1); - _syscall_write(h1, "h1", 2, 0, 0); + test(_sys_dup(pipe[1], h1, 0) == h1); + _sys_write(h1, "h1", 2, 0, 0); close(h1); exit(0); @@ -213,10 +213,10 @@ static void test_dup(void) { char buf[16]; size_t count = 0; close(pipe[1]); - while (_syscall_read(pipe[0], buf, sizeof buf, 0) >= 0) + while (_sys_read(pipe[0], buf, sizeof buf, 0) >= 0) count++; test(count == 7); - _syscall_await(); + _sys_await(); } @@ -226,47 +226,47 @@ static void test_dup(void) { static void test_execbuf(void) { if (!fork()) { uint64_t buf[] = { - EXECBUF_SYSCALL, _SYSCALL_EXIT, 123, 0, 0, 0, 0, + EXECBUF_SYSCALL, _SYS_EXIT, 123, 0, 0, 0, 0, }; - _syscall_execbuf(buf, sizeof buf); + _sys_execbuf(buf, sizeof buf); test_fail(); } else { - test(_syscall_await() == 123); + test(_sys_await() == 123); } } static void test_sleep(void) { - handle_t reader; + hid_t reader; FILE *writer; if (!forkpipe(&writer, &reader)) { if (!fork()) { if (!fork()) { - _syscall_sleep(100); + _sys_sleep(100); fprintf(writer, "1"); - _syscall_sleep(200); + _sys_sleep(200); fprintf(writer, "3"); - _syscall_sleep(200); + _sys_sleep(200); fprintf(writer, "5"); - _syscall_exit(0); + _sys_exit(0); } if (!fork()) { fprintf(writer, "0"); - _syscall_sleep(200); + _sys_sleep(200); fprintf(writer, "2"); - _syscall_sleep(200); + _sys_sleep(200); fprintf(writer, "4"); /* get killed while asleep * a peaceful death, i suppose. */ - for (;;) _syscall_sleep(1000000000); + for (;;) _sys_sleep(1000000000); } - _syscall_await(); - _syscall_filicide(); - _syscall_exit(0); + _sys_await(); + _sys_filicide(); + _sys_exit(0); } /* this part checks if, after killing an asleep process, * other processes can still wake up */ - _syscall_sleep(600); + _sys_sleep(600); fprintf(writer, "6"); exit(0); } else { @@ -275,7 +275,7 @@ static void test_sleep(void) { size_t pos = 0; for (;;) { char buf[128]; - long ret = _syscall_read(reader, buf, sizeof buf, 0); + long ret = _sys_read(reader, buf, sizeof buf, 0); if (ret < 0) break; test(pos + ret <= target); test(memcmp(buf, expected + pos, ret) == 0); @@ -286,8 +286,8 @@ static void test_sleep(void) { } static void test_badopen(void) { - test(_syscall_open(TMPFILEPATH, strlen(TMPFILEPATH), OPEN_CREATE | OPEN_WRITE) >= 0); - test(_syscall_open(TMPFILEPATH, strlen(TMPFILEPATH), OPEN_CREATE) == -EINVAL); + test(_sys_open(TMPFILEPATH, strlen(TMPFILEPATH), OPEN_CREATE | OPEN_WRITE) >= 0); + test(_sys_open(TMPFILEPATH, strlen(TMPFILEPATH), OPEN_CREATE) == -EINVAL); } void r_k_miscsyscall(void) { diff --git a/src/user/app/tests/kernel/path.c b/src/user/app/tests/kernel/path.c index 2bce344..5392681 100644 --- a/src/user/app/tests/kernel/path.c +++ b/src/user/app/tests/kernel/path.c @@ -94,11 +94,11 @@ static void test_mount_resolve(void) { for (size_t i = 0; i < sizeof(testcases) / sizeof(testcases[0]); i++) { const char *input = testcases[i][0]; const char *expected = testcases[i][1]; - handle_t h = _syscall_open(input, strlen(input), 0); + hid_t h = _sys_open(input, strlen(input), 0); test(h >= 0); - int len = _syscall_read(h, buf, sizeof buf, 0); + int len = _sys_read(h, buf, sizeof buf, 0); test(len == (int)strlen(expected) && !memcmp(expected, buf, len)); - _syscall_close(h); + _sys_close(h); } } diff --git a/src/user/app/tests/kernel/threads.c b/src/user/app/tests/kernel/threads.c index cb7111d..abca41c 100644 --- a/src/user/app/tests/kernel/threads.c +++ b/src/user/app/tests/kernel/threads.c @@ -18,13 +18,13 @@ static void test_basic_thread(void) { test(global_n == 10); } -handle_t global_h; +hid_t global_h; static void shared_handle(void *sem) { - handle_t ends[2]; - test(_syscall_pipe(ends, 0) >= 0); + hid_t ends[2]; + test(_sys_pipe(ends, 0) >= 0); global_h = ends[0]; esem_signal(sem); - _syscall_write(ends[1], "Hello!", 7, -1, 0); + _sys_write(ends[1], "Hello!", 7, -1, 0); } static void test_shared_handle(void) { struct evil_sem *sem = esem_new(0); @@ -34,7 +34,7 @@ static void test_shared_handle(void) { esem_wait(sem); test(global_h >= 0); - test(_syscall_read(global_h, buf, sizeof buf, 0) == 7); + test(_sys_read(global_h, buf, sizeof buf, 0) == 7); test(!strcmp("Hello!", buf)); } @@ -44,7 +44,7 @@ static void many_thread(void *arg) { static void test_many_threads(void) { uint64_t n = 0; for (int i = 0; i < 10; i++) thread_create(0, many_thread, &n); - for (int i = 0; i < 10; i++) _syscall_await(); + for (int i = 0; i < 10; i++) _sys_await(); test(n == 100); } diff --git a/src/user/app/tests/libc/esemaphore.c b/src/user/app/tests/libc/esemaphore.c index f1856ff..2f1d4bc 100644 --- a/src/user/app/tests/libc/esemaphore.c +++ b/src/user/app/tests/libc/esemaphore.c @@ -6,37 +6,37 @@ #include <unistd.h> #include <user/lib/esemaphore.h> -static void odd(handle_t out, struct evil_sem *sem1, struct evil_sem *sem2) { - _syscall_write(out, "1", 1, -1, 0); +static void odd(hid_t out, struct evil_sem *sem1, struct evil_sem *sem2) { + _sys_write(out, "1", 1, -1, 0); esem_signal(sem1); esem_wait(sem2); - _syscall_write(out, "3", 1, -1, 0); + _sys_write(out, "3", 1, -1, 0); esem_signal(sem1); esem_wait(sem2); - _syscall_write(out, "5", 1, -1, 0); + _sys_write(out, "5", 1, -1, 0); esem_signal(sem1); } -static void even(handle_t out, struct evil_sem *sem1, struct evil_sem *sem2) { +static void even(hid_t out, struct evil_sem *sem1, struct evil_sem *sem2) { esem_wait(sem1); - _syscall_write(out, "2", 1, -1, 0); + _sys_write(out, "2", 1, -1, 0); esem_signal(sem2); esem_wait(sem1); - _syscall_write(out, "4", 1, -1, 0); + _sys_write(out, "4", 1, -1, 0); esem_signal(sem2); esem_wait(sem1); - _syscall_write(out, "6", 1, -1, 0); + _sys_write(out, "6", 1, -1, 0); esem_signal(sem2); } static void test_semaphore(void) { struct evil_sem *sem1, *sem2; - handle_t pipe[2]; - test(_syscall_pipe(pipe, 0) >= 0); + hid_t pipe[2]; + test(_sys_pipe(pipe, 0) >= 0); if (!fork()) { sem1 = esem_new(0); @@ -47,12 +47,12 @@ static void test_semaphore(void) { exit(69); } else { even(pipe[1], sem1, sem2); - test(_syscall_await() == 69); + test(_sys_await() == 69); } esem_free(sem1); esem_free(sem2); - _syscall_write(pipe[1], "|", 1, -1, 0); + _sys_write(pipe[1], "|", 1, -1, 0); sem1 = esem_new(0); sem2 = esem_new(0); @@ -62,13 +62,13 @@ static void test_semaphore(void) { exit(69); } else { odd(pipe[1], sem1, sem2); - test(_syscall_await() == 69); - _syscall_await(); + test(_sys_await() == 69); + _sys_await(); } esem_free(sem1); esem_free(sem2); - _syscall_filicide(); + _sys_filicide(); exit(0); } else { close(pipe[1]); @@ -76,7 +76,7 @@ static void test_semaphore(void) { char buf[16]; size_t pos = 0; for (;;) { - int ret = _syscall_read(pipe[0], buf + pos, sizeof(buf) - pos, 0); + int ret = _sys_read(pipe[0], buf + pos, sizeof(buf) - pos, 0); if (ret < 0) break; pos += ret; } @@ -86,7 +86,7 @@ static void test_semaphore(void) { test_fail(); } - _syscall_await(); + _sys_await(); } } diff --git a/src/user/app/tests/stress.c b/src/user/app/tests/stress.c index 1df462a..1ef018c 100644 --- a/src/user/app/tests/stress.c +++ b/src/user/app/tests/stress.c @@ -11,7 +11,7 @@ static void run_forked(void (*fn)()) { } else { /* successful tests must return 0 * TODO add a better fail msg */ - if (_syscall_await() != 0) test_fail(); + if (_sys_await() != 0) test_fail(); } } @@ -19,7 +19,7 @@ static void run_forked(void (*fn)()) { static void stress_fork(void) { for (size_t i = 0; i < 2048; i++) { if (!fork()) exit(0); - _syscall_await(); + _sys_await(); } } diff --git a/src/user/app/tests/tests.c b/src/user/app/tests/tests.c index f2f9aa5..7139fc7 100644 --- a/src/user/app/tests/tests.c +++ b/src/user/app/tests/tests.c @@ -10,19 +10,19 @@ FILE *fail_trig; void run_test(void (*fn)()) { if (!fork()) { fn(); - _syscall_filicide(); + _sys_filicide(); exit(0); } else { /* successful tests must return 0 */ - if (_syscall_await() != 0) { + if (_sys_await() != 0) { test_failf("%p, base %p", (void*)fn - (void*)_image_base, _image_base); } } } -int forkpipe(FILE **f, handle_t *h) { - handle_t ends[2]; - if (_syscall_pipe(ends, 0) < 0) { +int forkpipe(FILE **f, hid_t *h) { + hid_t ends[2]; + if (_sys_pipe(ends, 0) < 0) { fprintf(stderr, "couldn't create pipe\n"); exit(1); } @@ -40,7 +40,7 @@ int forkpipe(FILE **f, handle_t *h) { } int main(void) { - handle_t reader; + hid_t reader; if (!forkpipe(&fail_trig, &reader)) { r_k_miscsyscall(); r_k_fs(); @@ -57,7 +57,7 @@ int main(void) { } else { for (;;) { char buf[128]; - long ret = _syscall_read(reader, buf, sizeof buf, 0); + long ret = _sys_read(reader, buf, sizeof buf, 0); if (ret < 0) break; printf("\033[31mFAIL\033[0m "); fwrite(buf, ret, 1, stdout); diff --git a/src/user/app/tests/tests.h b/src/user/app/tests/tests.h index e93653e..5037e1a 100644 --- a/src/user/app/tests/tests.h +++ b/src/user/app/tests/tests.h @@ -21,7 +21,7 @@ void r_s_ringbuf(void); extern FILE *fail_trig; -int forkpipe(FILE **f, handle_t *h); +int forkpipe(FILE **f, hid_t *h); #define argify(str) str, sizeof(str) - 1 #define test_fail() do { \ diff --git a/src/user/app/tmpfs/tmpfs.c b/src/user/app/tmpfs/tmpfs.c index c55da59..6d58790 100644 --- a/src/user/app/tmpfs/tmpfs.c +++ b/src/user/app/tmpfs/tmpfs.c @@ -123,14 +123,14 @@ int main(void) { for (;;) { struct ufs_request req; - handle_t reqh = ufs_wait(buf, buflen, &req); + hid_t reqh = ufs_wait(buf, buflen, &req); struct node *ptr = req.id; if (reqh < 0) break; switch (req.op) { case VFSOP_OPEN: ptr = tmpfs_open(buf, &req); - _syscall_fs_respond(reqh, ptr, ptr ? 0 : -ENOENT, 0); + _sys_fs_respond(reqh, ptr, ptr ? 0 : -ENOENT, 0); break; case VFSOP_READ: @@ -140,16 +140,16 @@ int main(void) { for (struct node *iter = ptr->child; iter; iter = iter->sibling) { dir_appendl(&db, iter->name, iter->namelen); } - _syscall_fs_respond(reqh, buf, dir_finish(&db), 0); + _sys_fs_respond(reqh, buf, dir_finish(&db), 0); } else { fs_normslice(&req.offset, &req.len, ptr->size, false); - _syscall_fs_respond(reqh, ptr->buf + req.offset, req.len, 0); + _sys_fs_respond(reqh, ptr->buf + req.offset, req.len, 0); } break; case VFSOP_WRITE: if (ptr->directory) { - _syscall_fs_respond(reqh, NULL, -ENOSYS, 0); + _sys_fs_respond(reqh, NULL, -ENOSYS, 0); break; } @@ -163,7 +163,7 @@ int main(void) { if ((req.flags & WRITE_TRUNCATE) || ptr->size < req.offset + req.len) { ptr->size = req.offset + req.len; } - _syscall_fs_respond(reqh, NULL, req.len, 0); + _sys_fs_respond(reqh, NULL, req.len, 0); break; case VFSOP_GETSIZE: @@ -174,23 +174,23 @@ int main(void) { for (struct node *iter = ptr->child; iter; iter = iter->sibling) { dir_append(&db, iter->name); } - _syscall_fs_respond(reqh, NULL, dir_finish(&db), 0); + _sys_fs_respond(reqh, NULL, dir_finish(&db), 0); } else { - _syscall_fs_respond(reqh, NULL, ptr->size, 0); + _sys_fs_respond(reqh, NULL, ptr->size, 0); } break; case VFSOP_REMOVE: - _syscall_fs_respond(reqh, NULL, node_remove(ptr), 0); + _sys_fs_respond(reqh, NULL, node_remove(ptr), 0); break; case VFSOP_CLOSE: node_close(ptr); - _syscall_fs_respond(reqh, NULL, -1, 0); + _sys_fs_respond(reqh, NULL, -1, 0); break; default: - _syscall_fs_respond(reqh, NULL, -1, 0); + _sys_fs_respond(reqh, NULL, -1, 0); break; } } diff --git a/src/user/bootstrap/entry.S b/src/user/bootstrap/entry.S index ecd60dd..04b4238 100644 --- a/src/user/bootstrap/entry.S +++ b/src/user/bootstrap/entry.S @@ -9,14 +9,14 @@ .global _start .type _start, @function _start: - mov $_SYSCALL_MEMFLAG, %rdi + mov $_SYS_MEMFLAG, %rdi mov $(STACK_TOP & ~0xFFF - (STACK_PAGES - 1) * 0x1000), %rsi mov $(STACK_PAGES * 0x1000), %rdx mov $MEMFLAG_PRESENT, %r10 syscall mov $(STACK_TOP & ~0xF), %rsp - mov $_SYSCALL_MEMFLAG, %rdi + mov $_SYS_MEMFLAG, %rdi mov $_bss_start, %rsi mov $_bss_end, %rdx sub $_bss_start, %rdx diff --git a/src/user/bootstrap/main.c b/src/user/bootstrap/main.c index 577f1d8..f2938b9 100644 --- a/src/user/bootstrap/main.c +++ b/src/user/bootstrap/main.c @@ -14,7 +14,7 @@ extern char _initrd; __attribute__((section(".text"))) _Noreturn void main(void) { - _syscall_memflag(_libc_psdata, 1, MEMFLAG_PRESENT); + _sys_memflag(_libc_psdata, 1, MEMFLAG_PRESENT); setprogname("bootstrap"); setproctitle(NULL); @@ -25,7 +25,7 @@ _Noreturn void main(void) { fs_whitelist(l); } - _syscall_mount(HANDLE_PROCFS, "/proc/", strlen("/proc/")); + _sys_mount(HANDLE_PROCFS, "/proc/", strlen("/proc/")); MOUNT_AT("/") { fs_dir_inject("/proc/"); } MOUNT_AT("/init/") { tar_driver(&_initrd); } @@ -40,5 +40,5 @@ _Noreturn void main(void) { } else { _klogf("couldn't find init.elf"); } - _syscall_exit(1); + _sys_exit(1); } diff --git a/src/user/lib/_start2.c b/src/user/lib/_start2.c index 2cf8667..648c0c6 100644 --- a/src/user/lib/_start2.c +++ b/src/user/lib/_start2.c @@ -26,14 +26,14 @@ _Noreturn void _start2(struct execdata *ed) { elf_selfreloc(); /* done first so it isn't allocated elsewhere by accident */ - _syscall_memflag(_libc_psdata, 1, MEMFLAG_PRESENT); + _sys_memflag(_libc_psdata, 1, MEMFLAG_PRESENT); if (ed->argv[0]) { strcpy(_libc_psdata, ed->argv[0]); } else { strcpy(_libc_psdata, "?"); } - _syscall_intr_set(intr_trampoline); + _sys_intr_set(intr_trampoline); intr_set(intr_default); __setinitialcwd(ed->cwd); diff --git a/src/user/lib/assert.c b/src/user/lib/assert.c index f42d696..0c46450 100644 --- a/src/user/lib/assert.c +++ b/src/user/lib/assert.c @@ -4,5 +4,5 @@ _Noreturn void __badassert(const char *func, const char *file, int line) { fprintf(stderr, "assertion failure %s:%s:%u\n", file, func, line); - _syscall_exit(1); + _sys_exit(1); } diff --git a/src/user/lib/camellia.c b/src/user/lib/camellia.c index 1aa8402..4e092e4 100644 --- a/src/user/lib/camellia.c +++ b/src/user/lib/camellia.c @@ -5,8 +5,8 @@ #include <string.h> #include <unistd.h> -handle_t camellia_open(const char *path, int flags) { - handle_t ret; +hid_t camellia_open(const char *path, int flags) { + hid_t ret; char *buf; size_t len; @@ -20,7 +20,7 @@ handle_t camellia_open(const char *path, int flags) { if (!buf) return -errno; absolutepath(buf, path, len); - ret = _syscall_open(buf, strlen(buf), flags); + ret = _sys_open(buf, strlen(buf), flags); free(buf); if (ret < 0) diff --git a/src/user/lib/compat.c b/src/user/lib/compat.c index 4634f57..3ec47f9 100644 --- a/src/user/lib/compat.c +++ b/src/user/lib/compat.c @@ -4,17 +4,17 @@ #define eprintf(fmt, ...) fprintf(stderr, "user/lib/compat: "fmt"\n" __VA_OPT__(,) __VA_ARGS__) -static handle_t h = -1; +static hid_t h = -1; long c0_fs_wait(char *buf, long len, struct ufs_request *res) { if (h != -1) { eprintf("didn't respond to request!"); c0_fs_respond(NULL, -1, 0); } - h = _syscall_fs_wait(buf, len, res); + h = _sys_fs_wait(buf, len, res); return h >= 0 ? 0 : -1; } long c0_fs_respond(void *buf, long ret, int flags) { - ret = _syscall_fs_respond(h, buf, ret, flags); + ret = _sys_fs_respond(h, buf, ret, flags); h = -1; return ret; } diff --git a/src/user/lib/draw/draw.c b/src/user/lib/draw/draw.c index 95a8921..3fb6a99 100644 --- a/src/user/lib/draw/draw.c +++ b/src/user/lib/draw/draw.c @@ -43,11 +43,11 @@ int fb_setup(struct framebuf *fb, const char *base) { fb->bpp = strtol(spec, &spec, 0); if (fb->bpp != 32) return -EINVAL; - fb->len = _syscall_getsize(fb->fd); + fb->len = _sys_getsize(fb->fd); fb->pitch = fb->len / fb->height; fb->b = malloc(fb->len); - _syscall_read(fb->fd, fb->b, fb->len, 0); + _sys_read(fb->fd, fb->b, fb->len, 0); return 0; } diff --git a/src/user/lib/draw/draw.h b/src/user/lib/draw/draw.h index 98316fe..5e614be 100644 --- a/src/user/lib/draw/draw.h +++ b/src/user/lib/draw/draw.h @@ -8,7 +8,7 @@ struct framebuf { uint8_t bpp; char *b; - handle_t fd; + hid_t fd; }; struct rect { uint32_t x1, y1, x2, y2; }; diff --git a/src/user/lib/draw/flush.c b/src/user/lib/draw/flush.c index 060fdaf..3b4a978 100644 --- a/src/user/lib/draw/flush.c +++ b/src/user/lib/draw/flush.c @@ -5,7 +5,7 @@ static void flush_combined(struct rect pix, struct framebuf *fb) { size_t low = fb->pitch * pix.y1 + 4 * pix.x1; size_t high = fb->pitch * pix.y2 + 4 * pix.y2 + 4; - _syscall_write(fb->fd, fb->b + low, high - low, low, 0); + _sys_write(fb->fd, fb->b + low, high - low, low, 0); } static void flush_split(struct rect pix, struct framebuf *fb) { @@ -21,14 +21,14 @@ static void flush_split(struct rect pix, struct framebuf *fb) { size_t high = fb->pitch * y + 4 * pix.x2 + 4; execbuf[epos++] = EXECBUF_SYSCALL; - execbuf[epos++] = _SYSCALL_WRITE; + execbuf[epos++] = _SYS_WRITE; execbuf[epos++] = fb->fd; execbuf[epos++] = (uintptr_t)fb->b + low; execbuf[epos++] = high - low; execbuf[epos++] = low; execbuf[epos++] = 0; } - _syscall_execbuf(execbuf, epos * sizeof(uint64_t)); + _sys_execbuf(execbuf, epos * sizeof(uint64_t)); } void dirty_flush(struct rect *d, struct framebuf *fb) { diff --git a/src/user/lib/elfload.S b/src/user/lib/elfload.S index 0f15c06..78d5b3c 100644 --- a/src/user/lib/elfload.S +++ b/src/user/lib/elfload.S @@ -15,6 +15,6 @@ _freejmp_chstack: // _Noreturn void execbuf_chstack(void *stack, void __user *buf, size_t len); execbuf_chstack: mov %rdi, %rsp - mov $_SYSCALL_EXECBUF, %rdi + mov $_SYS_EXECBUF, %rdi syscall hlt // if execbuf failed we might as well crash diff --git a/src/user/lib/elfload.c b/src/user/lib/elfload.c index a4ee91e..cb7ce58 100644 --- a/src/user/lib/elfload.c +++ b/src/user/lib/elfload.c @@ -46,7 +46,7 @@ static bool load_phdr(const void *elf, void *exebase, size_t idx) { } // TODO overlap check // TODO don't ignore flags - _syscall_memflag(exebase + phdr->p_vaddr, phdr->p_memsz, MEMFLAG_PRESENT); + _sys_memflag(exebase + phdr->p_vaddr, phdr->p_memsz, MEMFLAG_PRESENT); // TODO check that filesz <= memsz memcpy(exebase + phdr->p_vaddr, elf + phdr->p_offset, phdr->p_filesz); return true; @@ -122,8 +122,8 @@ void _freejmp(void *entry, void *low, size_t imglen, const char **argv, char **e uintptr_t high = (uintptr_t)low + imglen; uint64_t buf[] = { - EXECBUF_SYSCALL, _SYSCALL_MEMFLAG, 0, (uintptr_t)low, 0, 0, 0, - EXECBUF_SYSCALL, _SYSCALL_MEMFLAG, high, ~0 - 0xF000 - high, 0, 0, 0, + EXECBUF_SYSCALL, _SYS_MEMFLAG, 0, (uintptr_t)low, 0, 0, 0, + EXECBUF_SYSCALL, _SYS_MEMFLAG, high, ~0 - 0xF000 - high, 0, 0, 0, EXECBUF_JMP, (uintptr_t)entry, }; execbuf_chstack(stack, buf, sizeof buf); @@ -137,7 +137,7 @@ static void *elf_loadmem(struct Elf64_Ehdr *ehdr) { exebase = (void*)0; break; case ET_DYN: - exebase = _syscall_memflag((void*)0x1000, spread, MEMFLAG_FINDFREE); + exebase = _sys_memflag((void*)0x1000, spread, MEMFLAG_FINDFREE); if (!exebase) return NULL; break; @@ -146,7 +146,7 @@ static void *elf_loadmem(struct Elf64_Ehdr *ehdr) { } for (size_t phi = 0; phi < ehdr->e_phnum; phi++) { if (!load_phdr((void*)ehdr, exebase, phi)) { - _syscall_memflag(exebase, spread, 0); + _sys_memflag(exebase, spread, 0); return NULL; } } @@ -160,7 +160,7 @@ void elf_exec(void *base, char **argv, char **envp) { void *exebase = elf_loadmem(ehdr); if (!exebase) return; - void *newstack = _syscall_memflag((void*)0x11000, 0x1000, MEMFLAG_FINDFREE | MEMFLAG_PRESENT); + void *newstack = _sys_memflag((void*)0x11000, 0x1000, MEMFLAG_FINDFREE | MEMFLAG_PRESENT); if (!newstack) return; _freejmp_chstack(exebase + ehdr->e_entry, exebase, elf_spread(ehdr) + 0x1000, (const char**)argv, envp, newstack); diff --git a/src/user/lib/esemaphore.c b/src/user/lib/esemaphore.c index f58b510..3a3aa7f 100644 --- a/src/user/lib/esemaphore.c +++ b/src/user/lib/esemaphore.c @@ -5,27 +5,27 @@ #include <user/lib/esemaphore.h> void esem_signal(struct evil_sem *sem) { - _syscall_write(sem->signal, NULL, 0, 0, 0); + _sys_write(sem->signal, NULL, 0, 0, 0); } void esem_wait(struct evil_sem *sem) { - _syscall_read(sem->wait, NULL, 0, 0); + _sys_read(sem->wait, NULL, 0, 0); } struct evil_sem *esem_new(int value) { - handle_t ends_wait[2], ends_signal[2]; + hid_t ends_wait[2], ends_signal[2]; struct evil_sem *sem; if (value < 0) return NULL; - if (_syscall_pipe(ends_wait, 0) < 0) return NULL; - if (_syscall_pipe(ends_signal, 0) < 0) goto fail_signal; + if (_sys_pipe(ends_wait, 0) < 0) return NULL; + if (_sys_pipe(ends_signal, 0) < 0) goto fail_signal; if (!(sem = malloc(sizeof *sem))) goto fail_malloc; - if (!_syscall_fork(FORK_NOREAP, NULL)) { + if (!_sys_fork(FORK_NOREAP, NULL)) { close(ends_signal[1]); - while (_syscall_read(ends_signal[0], NULL, 0, 0) >= 0) { - if (!_syscall_fork(FORK_NOREAP, NULL)) { - _syscall_write(ends_wait[1], NULL, 0, 0, 0); + while (_sys_read(ends_signal[0], NULL, 0, 0) >= 0) { + if (!_sys_fork(FORK_NOREAP, NULL)) { + _sys_write(ends_wait[1], NULL, 0, 0, 0); exit(0); } } diff --git a/src/user/lib/esemaphore.h b/src/user/lib/esemaphore.h index 4a16c2e..9cc85e0 100644 --- a/src/user/lib/esemaphore.h +++ b/src/user/lib/esemaphore.h @@ -2,7 +2,7 @@ #include <camellia/types.h> struct evil_sem { - handle_t wait, signal; + hid_t wait, signal; }; void esem_signal(struct evil_sem *sem); diff --git a/src/user/lib/fs/dir.c b/src/user/lib/fs/dir.c index 71b2209..b7f840d 100644 --- a/src/user/lib/fs/dir.c +++ b/src/user/lib/fs/dir.c @@ -45,13 +45,13 @@ bool dir_appendl(struct dirbuild *db, const char *name, size_t len) { return false; } -bool dir_append_from(struct dirbuild *db, handle_t h) { +bool dir_append_from(struct dirbuild *db, hid_t h) { if (db->error) return true; if (db->buf && db->bpos == db->blen) return false; int ret; if (db->buf) { - ret = _syscall_read(h, db->buf + db->bpos, db->blen - db->bpos, db->offset); + ret = _sys_read(h, db->buf + db->bpos, db->blen - db->bpos, db->offset); if (ret < 0) { db->error = ret; return true; @@ -63,7 +63,7 @@ bool dir_append_from(struct dirbuild *db, handle_t h) { } /* else ret == 0, EOF, need getsize */ } - ret = _syscall_getsize(h); + ret = _sys_getsize(h); if (ret < 0) { db->error = ret; return true; diff --git a/src/user/lib/fs/misc.c b/src/user/lib/fs/misc.c index ee0b54c..c68d2be 100644 --- a/src/user/lib/fs/misc.c +++ b/src/user/lib/fs/misc.c @@ -11,9 +11,9 @@ #include <camellia/fs/misc.h> bool fork2_n_mount(const char *path) { - handle_t h; - if (_syscall_fork(FORK_NEWFS, &h) > 0) { /* parent */ - _syscall_mount(h, path, strlen(path)); + hid_t h; + if (_sys_fork(FORK_NEWFS, &h) > 0) { /* parent */ + _sys_mount(h, path, strlen(path)); close(h); return true; } @@ -34,7 +34,7 @@ static int dir_seglen(const char *path) { return len; } -void forward_open(handle_t reqh, const char *path, long len, int flags) { +void forward_open(hid_t reqh, const char *path, long len, int flags) { // TODO use threads // TODO solve for more complex cases, e.g. fs_union /* done in a separate thread/process because open() can block, @@ -43,8 +43,8 @@ void forward_open(handle_t reqh, const char *path, long len, int flags) { * for example, running `httpd` in one term would prevent you from doing * basically anything on the second term, because fs_dir_inject would be * stuck on open()ing the socket */ - if (!_syscall_fork(FORK_NOREAP, NULL)) { - _syscall_fs_respond(reqh, NULL, _syscall_open(path, len, flags), FSR_DELEGATE); + if (!_sys_fork(FORK_NOREAP, NULL)) { + _sys_fs_respond(reqh, NULL, _sys_open(path, len, flags), FSR_DELEGATE); exit(0); } close(reqh); @@ -58,13 +58,13 @@ void fs_passthru(const char *prefix) { for (;;) { struct ufs_request res; - handle_t reqh = _syscall_fs_wait(buf, buflen, &res); + hid_t reqh = _sys_fs_wait(buf, buflen, &res); if (reqh < 0) break; switch (res.op) { case VFSOP_OPEN: if (prefix) { if (prefix_len + res.len > buflen) { - _syscall_fs_respond(reqh, NULL, -1, 0); + _sys_fs_respond(reqh, NULL, -1, 0); break; } @@ -76,7 +76,7 @@ void fs_passthru(const char *prefix) { break; default: - _syscall_fs_respond(reqh, NULL, -1, 0); + _sys_fs_respond(reqh, NULL, -1, 0); break; } } @@ -114,7 +114,7 @@ void fs_union(const char **list) { char *path = post - prefixlen; memcpy(path, prefix, prefixlen); - ret = _syscall_open(path, prefixlen + res.len, res.flags); + ret = _sys_open(path, prefixlen + res.len, res.flags); post[res.len] = '\0'; } @@ -134,10 +134,10 @@ void fs_union(const char **list) { size_t prefixlen = strlen(prefix); // TODO only open the directories once // TODO ensure trailing slash - handle_t h = _syscall_open(prefix, prefixlen, OPEN_READ); + hid_t h = _sys_open(prefix, prefixlen, OPEN_READ); if (h < 0) continue; end = end || dir_append_from(&db, h); - _syscall_close(h); + _sys_close(h); } c0_fs_respond(target, dir_finish(&db), 0); break; @@ -163,7 +163,7 @@ void fs_dir_inject(const char *path) { for (;;) { struct ufs_request res; - handle_t reqh = _syscall_fs_wait(buf, buflen, &res); + hid_t reqh = _sys_fs_wait(buf, buflen, &res); if (reqh < 0) break; struct fs_dir_handle *data = res.id; switch (res.op) { @@ -174,10 +174,10 @@ void fs_dir_inject(const char *path) { { /* opening a directory that we're injecting into */ data = malloc(sizeof *data); - data->delegate = _syscall_open(buf, res.len, res.flags); + data->delegate = _sys_open(buf, res.len, res.flags); data->inject = path + res.len; data->inject_len = dir_seglen(data->inject); - _syscall_fs_respond(reqh, data, 0, 0); + _sys_fs_respond(reqh, data, 0, 0); } else { forward_open(reqh, buf, res.len, res.flags); } @@ -187,7 +187,7 @@ void fs_dir_inject(const char *path) { if (data->delegate >= 0) close(data->delegate); free(data); - _syscall_fs_respond(reqh, NULL, 0, 0); + _sys_fs_respond(reqh, NULL, 0, 0); break; case VFSOP_READ: @@ -199,25 +199,25 @@ void fs_dir_inject(const char *path) { dir_appendl(&db, data->inject, data->inject_len); if (data->delegate >= 0) dir_append_from(&db, data->delegate); - _syscall_fs_respond(reqh, target, dir_finish(&db), 0); + _sys_fs_respond(reqh, target, dir_finish(&db), 0); break; default: - _syscall_fs_respond(reqh, NULL, -1, 0); + _sys_fs_respond(reqh, NULL, -1, 0); break; } } exit(0); } -handle_t ufs_wait(char *buf, size_t len, struct ufs_request *req) { - handle_t reqh; +hid_t ufs_wait(char *buf, size_t len, struct ufs_request *req) { + hid_t reqh; for (;;) { - reqh = _syscall_fs_wait(buf, len, req); + reqh = _sys_fs_wait(buf, len, req); if (reqh < 0) break; if (req->op == VFSOP_OPEN) { if (req->len == len) { - _syscall_fs_respond(reqh, NULL, -ENAMETOOLONG, 0); + _sys_fs_respond(reqh, NULL, -ENAMETOOLONG, 0); continue; } buf[req->len] = '\0'; diff --git a/src/user/lib/fs/whitelist.c b/src/user/lib/fs/whitelist.c index 5612d9a..54a79c3 100644 --- a/src/user/lib/fs/whitelist.c +++ b/src/user/lib/fs/whitelist.c @@ -43,7 +43,7 @@ void fs_whitelist(const char **whitelist) { if (!buf) exit(1); for (;;) { struct ufs_request res; - handle_t reqh = _syscall_fs_wait(buf, buflen, &res); + hid_t reqh = _sys_fs_wait(buf, buflen, &res); if (reqh < 0) break; char *ipath = res.id; /* the path of the open()ed directory */ @@ -70,7 +70,7 @@ void fs_whitelist(const char **whitelist) { } } if (error) { - _syscall_fs_respond(reqh, NULL, -EACCES, 0); + _sys_fs_respond(reqh, NULL, -EACCES, 0); } else if (passthru) { forward_open(reqh, buf, res.len, res.flags); } else if (inject) { @@ -78,9 +78,9 @@ void fs_whitelist(const char **whitelist) { ipath = malloc(res.len + 1); memcpy(ipath, buf, res.len); ipath[res.len] = '\0'; - _syscall_fs_respond(reqh, ipath, 0, 0); + _sys_fs_respond(reqh, ipath, 0, 0); } else { - _syscall_fs_respond(reqh, NULL, -1, 0); + _sys_fs_respond(reqh, NULL, -1, 0); } break; } @@ -96,16 +96,16 @@ void fs_whitelist(const char **whitelist) { if (ilen < elen && !memcmp(ipath, *entry, ilen)) dir_appendl(&db, *entry + ilen, dir_seglen2(*entry + ilen, elen - ilen)); } - _syscall_fs_respond(reqh, target, dir_finish(&db), 0); + _sys_fs_respond(reqh, target, dir_finish(&db), 0); break; } case VFSOP_CLOSE: { free(ipath); - _syscall_fs_respond(reqh, NULL, 0, 0); + _sys_fs_respond(reqh, NULL, 0, 0); break; } default: { - _syscall_fs_respond(reqh, NULL, -1, 0); + _sys_fs_respond(reqh, NULL, -1, 0); break; } } diff --git a/src/user/lib/include/camellia.h b/src/user/lib/include/camellia.h index f9b9f00..2e4998b 100644 --- a/src/user/lib/include/camellia.h +++ b/src/user/lib/include/camellia.h @@ -2,4 +2,4 @@ #include <camellia/flags.h> #include <camellia/types.h> -handle_t camellia_open(const char *path, int flags); +hid_t camellia_open(const char *path, int flags); diff --git a/src/user/lib/include/camellia/fs/dir.h b/src/user/lib/include/camellia/fs/dir.h index c3bbfe7..d34a652 100644 --- a/src/user/lib/include/camellia/fs/dir.h +++ b/src/user/lib/include/camellia/fs/dir.h @@ -13,5 +13,5 @@ struct dirbuild { void dir_start(struct dirbuild *db, long offset, char *buf, size_t buflen); bool dir_append(struct dirbuild *db, const char *name); bool dir_appendl(struct dirbuild *db, const char *name, size_t len); -bool dir_append_from(struct dirbuild *db, handle_t h); +bool dir_append_from(struct dirbuild *db, hid_t h); long dir_finish(struct dirbuild *db); diff --git a/src/user/lib/include/camellia/fs/misc.h b/src/user/lib/include/camellia/fs/misc.h index 35184e1..c84c5b6 100644 --- a/src/user/lib/include/camellia/fs/misc.h +++ b/src/user/lib/include/camellia/fs/misc.h @@ -4,7 +4,7 @@ bool fork2_n_mount(const char *path); -void forward_open(handle_t reqh, const char *path, long len, int flags); +void forward_open(hid_t reqh, const char *path, long len, int flags); void fs_passthru(const char *prefix); void fs_whitelist(const char **list); @@ -16,8 +16,8 @@ bool mount_at_pred(const char *path); // TODO separate fs drivers and wrappers around syscalls -/** like _syscall_fs_wait, but ensures *buf is a null terminated string on VFSOP_OPEN */ -handle_t ufs_wait(char *buf, size_t len, struct ufs_request *req); +/** like _sys_fs_wait, but ensures *buf is a null terminated string on VFSOP_OPEN */ +hid_t ufs_wait(char *buf, size_t len, struct ufs_request *req); /** Mounts something and injects its path into the fs */ #define MOUNT_AT(path) for (; mount_at_pred(path); exit(1)) diff --git a/src/user/lib/include/stdio.h b/src/user/lib/include/stdio.h index 5ee0878..a030f13 100644 --- a/src/user/lib/include/stdio.h +++ b/src/user/lib/include/stdio.h @@ -21,7 +21,7 @@ #define BUFSIZ 1024 /* stop fread() from trying to fill the entire buffer before returning - * i.e. it will call _syscall_read() exactly once */ + * i.e. it will call _sys_read() exactly once */ #define FEXT_NOFILL 1 int printf(const char *restrict fmt, ...); diff --git a/src/user/lib/include/unistd.h b/src/user/lib/include/unistd.h index d13767b..c55cd29 100644 --- a/src/user/lib/include/unistd.h +++ b/src/user/lib/include/unistd.h @@ -1,9 +1,9 @@ #pragma once -#include <camellia/types.h> // TODO only needed because of handle_t +#include <camellia/types.h> // TODO only needed because of hid_t #include <user/lib/vendor/getopt/getopt.h> int fork(void); -int close(handle_t h); +int close(hid_t h); _Noreturn void _exit(int); int unlink(const char *path); diff --git a/src/user/lib/mman.c b/src/user/lib/mman.c index b41b8ff..32eeb2a 100644 --- a/src/user/lib/mman.c +++ b/src/user/lib/mman.c @@ -13,12 +13,12 @@ void *mmap(void *addr, size_t len, int prot, int flags, int fd, off_t off) { return NULL; } - void *p = _syscall_memflag(addr, len, MEMFLAG_FINDFREE | MEMFLAG_PRESENT); + void *p = _sys_memflag(addr, len, MEMFLAG_FINDFREE | MEMFLAG_PRESENT); if (!p) errno = ENOMEM; return p; } int munmap(void *addr, size_t len) { - _syscall_memflag(addr, len, 0); + _sys_memflag(addr, len, 0); return 0; } diff --git a/src/user/lib/printf.c b/src/user/lib/printf.c index a2f21d8..ad1fd06 100644 --- a/src/user/lib/printf.c +++ b/src/user/lib/printf.c @@ -51,6 +51,6 @@ int _klogf(const char *fmt, ...) { va_start(argp, fmt); ret = vsnprintf(buf, sizeof buf, fmt, argp); va_end(argp); - _syscall_debug_klog(buf, ret); + _sys_debug_klog(buf, ret); return ret; } diff --git a/src/user/lib/stdio/file.c b/src/user/lib/stdio/file.c index 531d44b..49ff861 100644 --- a/src/user/lib/stdio/file.c +++ b/src/user/lib/stdio/file.c @@ -18,7 +18,7 @@ FILE *const stderr = &_stderr_null; FILE *fopen(const char *path, const char *mode) { FILE *f; - handle_t h; + hid_t h; int flags = 0; if (!path) { errno = 1; @@ -48,7 +48,7 @@ FILE *fopen(const char *path, const char *mode) { if (h < 0) return NULL; if (mode[0] == 'w') - _syscall_write(h, NULL, 0, 0, WRITE_TRUNCATE); + _sys_write(h, NULL, 0, 0, WRITE_TRUNCATE); f = fdopen(h, mode); if (!f) close(h); @@ -65,7 +65,7 @@ FILE *fopen(const char *path, const char *mode) { if (f->fd == f2->fd) { f2->fd = -1; } else { - if (_syscall_dup(f2->fd, f->fd, 0) < 0) goto fail2; + if (_sys_dup(f2->fd, f->fd, 0) < 0) goto fail2; } f->pos = f2->pos; f->eof = f2->eof; @@ -92,7 +92,7 @@ FILE *fdopen(int fd, const char *mode) { } FILE *file_clone(const FILE *f, const char *mode) { - handle_t h = _syscall_dup(f->fd, -1, 0); + hid_t h = _sys_dup(f->fd, -1, 0); FILE *f2; if (h < 0) return NULL; @@ -159,7 +159,7 @@ size_t fread(void *restrict ptr, size_t size, size_t nitems, FILE *restrict f) { return 0; while (pos < total) { - long res = _syscall_read(f->fd, buf + pos, total - pos, f->pos); + long res = _sys_read(f->fd, buf + pos, total - pos, f->pos); if (res < 0) { f->error = true; errno = -res; @@ -187,7 +187,7 @@ size_t fwrite(const void *restrict ptr, size_t size, size_t nitems, FILE *restri return 0; while (pos < total) { - long res = _syscall_write(f->fd, buf + pos, total - pos, f->pos, 0); + long res = _sys_write(f->fd, buf + pos, total - pos, f->pos, 0); if (res < 0) { f->error = true; errno = -res; @@ -253,7 +253,7 @@ int fseeko(FILE *f, off_t offset, int whence) { base = f->pos; break; case SEEK_END: - base = _syscall_getsize(f->fd); + base = _sys_getsize(f->fd); if (base < 0) base = -1; break; diff --git a/src/user/lib/stdlib.c b/src/user/lib/stdlib.c index 4e471ba..85afb25 100644 --- a/src/user/lib/stdlib.c +++ b/src/user/lib/stdlib.c @@ -6,7 +6,7 @@ #include <user/lib/panic.h> _Noreturn void abort(void) { - _syscall_exit(1); + _sys_exit(1); } static const char *progname; @@ -32,7 +32,7 @@ void setproctitle(const char *fmt, ...) { int mkstemp(char *template) { // TODO randomize template - handle_t h = camellia_open(template, OPEN_CREATE | OPEN_RW); + hid_t h = camellia_open(template, OPEN_CREATE | OPEN_RW); if (h < 0) { errno = -h; return -1; diff --git a/src/user/lib/syscall.c b/src/user/lib/syscall.c index d42c2ee..f7eaddb 100644 --- a/src/user/lib/syscall.c +++ b/src/user/lib/syscall.c @@ -5,88 +5,88 @@ #include <camellia/syscalls.h> -_Noreturn void _syscall_exit(long ret) { - _syscall(_SYSCALL_EXIT, ret, 0, 0, 0, 0); +_Noreturn void _sys_exit(long ret) { + _syscall(_SYS_EXIT, ret, 0, 0, 0, 0); __builtin_unreachable(); } -long _syscall_await(void) { - return _syscall(_SYSCALL_AWAIT, 0, 0, 0, 0, 0); +long _sys_await(void) { + return _syscall(_SYS_AWAIT, 0, 0, 0, 0, 0); } -long _syscall_fork(int flags, handle_t __user *fs_front) { - return _syscall(_SYSCALL_FORK, (long)flags, (long)fs_front, 0, 0, 0); +long _sys_fork(int flags, hid_t __user *fs_front) { + return _syscall(_SYS_FORK, (long)flags, (long)fs_front, 0, 0, 0); } -handle_t _syscall_open(const char __user *path, long len, int flags) { - return (handle_t)_syscall(_SYSCALL_OPEN, (long)path, len, (long)flags, 0, 0); +hid_t _sys_open(const char __user *path, long len, int flags) { + return (hid_t)_syscall(_SYS_OPEN, (long)path, len, (long)flags, 0, 0); } -long _syscall_mount(handle_t h, const char __user *path, long len) { - return _syscall(_SYSCALL_MOUNT, (long)h, (long)path, len, 0, 0); +long _sys_mount(hid_t h, const char __user *path, long len) { + return _syscall(_SYS_MOUNT, (long)h, (long)path, len, 0, 0); } -handle_t _syscall_dup(handle_t from, handle_t to, int flags) { - return (handle_t)_syscall(_SYSCALL_DUP, (long)from, (long)to, (long)flags, 0, 0); +hid_t _sys_dup(hid_t from, hid_t to, int flags) { + return (hid_t)_syscall(_SYS_DUP, (long)from, (long)to, (long)flags, 0, 0); } -long _syscall_read(handle_t h, void __user *buf, size_t len, long offset) { - return _syscall(_SYSCALL_READ, (long)h, (long)buf, (long)len, offset, 0); +long _sys_read(hid_t h, void __user *buf, size_t len, long offset) { + return _syscall(_SYS_READ, (long)h, (long)buf, (long)len, offset, 0); } -long _syscall_write(handle_t h, const void __user *buf, size_t len, long offset, int flags) { - return _syscall(_SYSCALL_WRITE, (long)h, (long)buf, (long)len, offset, (long)flags); +long _sys_write(hid_t h, const void __user *buf, size_t len, long offset, int flags) { + return _syscall(_SYS_WRITE, (long)h, (long)buf, (long)len, offset, (long)flags); } -long _syscall_getsize(handle_t h) { - return _syscall(_SYSCALL_GETSIZE, (long)h, 0, 0, 0, 0); +long _sys_getsize(hid_t h) { + return _syscall(_SYS_GETSIZE, (long)h, 0, 0, 0, 0); } -long _syscall_remove(handle_t h) { - return _syscall(_SYSCALL_REMOVE, (long)h, 0, 0, 0, 0); +long _sys_remove(hid_t h) { + return _syscall(_SYS_REMOVE, (long)h, 0, 0, 0, 0); } -long _syscall_close(handle_t h) { - return _syscall(_SYSCALL_CLOSE, (long)h, 0, 0, 0, 0); +long _sys_close(hid_t h) { + return _syscall(_SYS_CLOSE, (long)h, 0, 0, 0, 0); } -handle_t _syscall_fs_wait(char __user *buf, long max_len, struct ufs_request __user *res) { - return (handle_t)_syscall(_SYSCALL_FS_WAIT, (long)buf, max_len, (long)res, 0, 0); +hid_t _sys_fs_wait(char __user *buf, long max_len, struct ufs_request __user *res) { + return (hid_t)_syscall(_SYS_FS_WAIT, (long)buf, max_len, (long)res, 0, 0); } -long _syscall_fs_respond(handle_t hid, const void __user *buf, long ret, int flags) { - return _syscall(_SYSCALL_FS_RESPOND, (long)hid, (long)buf, ret, (long)flags, 0); +long _sys_fs_respond(hid_t hid, const void __user *buf, long ret, int flags) { + return _syscall(_SYS_FS_RESPOND, (long)hid, (long)buf, ret, (long)flags, 0); } -void __user *_syscall_memflag(void __user *addr, size_t len, int flags) { - return (void __user *)_syscall(_SYSCALL_MEMFLAG, (long)addr, (long)len, (long)flags, 0, 0); +void __user *_sys_memflag(void __user *addr, size_t len, int flags) { + return (void __user *)_syscall(_SYS_MEMFLAG, (long)addr, (long)len, (long)flags, 0, 0); } -long _syscall_pipe(handle_t __user user_ends[2], int flags) { - return _syscall(_SYSCALL_PIPE, (long)user_ends, (long)flags, 0, 0, 0); +long _sys_pipe(hid_t __user user_ends[2], int flags) { + return _syscall(_SYS_PIPE, (long)user_ends, (long)flags, 0, 0, 0); } -void _syscall_sleep(long ms) { - return (void)_syscall(_SYSCALL_SLEEP, ms, 0, 0, 0, 0); +void _sys_sleep(long ms) { + return (void)_syscall(_SYS_SLEEP, ms, 0, 0, 0, 0); } -void _syscall_filicide(void) { - return (void)_syscall(_SYSCALL_FILICIDE, 0, 0, 0, 0, 0); +void _sys_filicide(void) { + return (void)_syscall(_SYS_FILICIDE, 0, 0, 0, 0, 0); } -void _syscall_intr(void) { - return (void)_syscall(_SYSCALL_INTR, 0, 0, 0, 0, 0); +void _sys_intr(void) { + return (void)_syscall(_SYS_INTR, 0, 0, 0, 0, 0); } -void _syscall_intr_set(void __user *ip) { - return (void)_syscall(_SYSCALL_INTR_SET, (long)ip, 0, 0, 0, 0); +void _sys_intr_set(void __user *ip) { + return (void)_syscall(_SYS_INTR_SET, (long)ip, 0, 0, 0, 0); } -long _syscall_execbuf(void __user *buf, size_t len) { - return _syscall(_SYSCALL_EXECBUF, (long)buf, (long)len, 0, 0, 0); +long _sys_execbuf(void __user *buf, size_t len) { + return _syscall(_SYS_EXECBUF, (long)buf, (long)len, 0, 0, 0); } -void _syscall_debug_klog(const void __user *buf, size_t len) { - return (void)_syscall(_SYSCALL_DEBUG_KLOG, (long)buf, (long)len, 0, 0, 0); +void _sys_debug_klog(const void __user *buf, size_t len) { + return (void)_syscall(_SYS_DEBUG_KLOG, (long)buf, (long)len, 0, 0, 0); } diff --git a/src/user/lib/syscall.c.awk b/src/user/lib/syscall.c.awk index 192df6a..591a6f0 100644 --- a/src/user/lib/syscall.c.awk +++ b/src/user/lib/syscall.c.awk @@ -14,7 +14,7 @@ BEGIN { sub(/;/, " {"); print $0; - name = substr($0, match($0, /_syscall_[^(]+/), RLENGTH); + name = substr($0, match($0, /_sys_[^(]+/), RLENGTH); rets = substr($0, 0, RSTART - 1); sub(/ *$/, "", rets) diff --git a/src/user/lib/thread.S b/src/user/lib/thread.S index 1a27c30..2900544 100644 --- a/src/user/lib/thread.S +++ b/src/user/lib/thread.S @@ -18,7 +18,7 @@ thread_creates: mov %rdi, %rsi or $(FORK_SHAREMEM | FORK_SHAREHANDLE), %rsi - mov $_SYSCALL_FORK, %rdi + mov $_SYS_FORK, %rdi xor %rdx, %rdx syscall @@ -34,7 +34,7 @@ thread_creates: mov %r13, %rdi call *%r12 - mov $_SYSCALL_EXIT, %rdi + mov $_SYS_EXIT, %rdi xor %rsi, %rsi syscall hlt /* if all else fails... */ diff --git a/src/user/lib/unistd.c b/src/user/lib/unistd.c index cb862f8..f8edd25 100644 --- a/src/user/lib/unistd.c +++ b/src/user/lib/unistd.c @@ -11,22 +11,22 @@ int errno = 0; int fork(void) { - return _syscall_fork(0, NULL); + return _sys_fork(0, NULL); } -int close(handle_t h) { - return _syscall_close(h); +int close(hid_t h) { + return _sys_close(h); } _Noreturn void exit(int c) { - _syscall_exit(c); + _sys_exit(c); } _Noreturn void _exit(int c) { exit(c); }; int unlink(const char *path) { - handle_t h = camellia_open(path, OPEN_WRITE); + hid_t h = camellia_open(path, OPEN_WRITE); if (h < 0) return errno = -h, -1; - long ret = _syscall_remove(h); + long ret = _sys_remove(h); if (ret < 0) return errno = -ret, -1; return 0; } @@ -79,7 +79,7 @@ static const char *getrealcwd(void) { } int chdir(const char *path) { - handle_t h; + hid_t h; char *tmp; size_t len = absolutepath(NULL, path, 0) + 1; /* +1 for the trailing slash */ if (cwdcapacity < len) { |