From f2b4acb2fe6a366288b19843e0d2678b8590bdf4 Mon Sep 17 00:00:00 2001 From: Marvin Borner Date: Sun, 25 Apr 2021 13:43:14 +0200 Subject: Chu chuu, using the bus for everything now! Well, I know: bus != train. But I like trains. So I don't care. Go away! --- kernel/Makefile | 1 + kernel/features/bus.c | 52 +++++++++++++++++++++++++++++++++--------- kernel/features/io.c | 22 +++++++++++++++++- kernel/features/logger.c | 42 ++++++++++++++++++++++++++++++++++ kernel/features/proc.c | 57 +++-------------------------------------------- kernel/features/syscall.c | 5 +++++ kernel/inc/io.h | 9 ++++---- kernel/inc/logger.h | 8 +++++++ kernel/inc/proc.h | 10 --------- 9 files changed, 126 insertions(+), 80 deletions(-) create mode 100644 kernel/features/logger.c create mode 100644 kernel/inc/logger.h (limited to 'kernel') diff --git a/kernel/Makefile b/kernel/Makefile index 2b75415..17a89b7 100644 --- a/kernel/Makefile +++ b/kernel/Makefile @@ -17,6 +17,7 @@ COBJS = main.o \ features/fs.o \ features/io.o \ features/bus.o \ + features/logger.o \ features/load.o \ features/proc.o \ features/proc_asm.o \ diff --git a/kernel/features/bus.c b/kernel/features/bus.c index f8a561c..4a09fc0 100644 --- a/kernel/features/bus.c +++ b/kernel/features/bus.c @@ -19,6 +19,7 @@ struct bus_conn { u32 bus; // Bus name hash u32 conn; + u32 pid; // Client pid struct stack *in; // Queue of bus owner struct stack *out; // Queue of other client }; @@ -85,6 +86,7 @@ static void bus_add_conn(u32 hash, u32 conn) { struct bus_conn *bus_conn = zalloc(sizeof(*bus_conn)); bus_conn->bus = hash; + bus_conn->pid = proc_current()->pid; bus_conn->conn = conn; bus_conn->in = stack_new(); bus_conn->out = stack_new(); @@ -113,7 +115,7 @@ static res bus_register(const char *name) return EOK; } -static res bus_connect(const char *bus, u32 *conn) +static res bus_connect_bus(const char *bus, u32 *conn) { if (!memory_readable(bus) || !memory_writable(conn)) return -EFAULT; @@ -137,7 +139,25 @@ static res bus_connect(const char *bus, u32 *conn) return EOK; } -static res bus_send(u32 conn, void *buf, u32 count) +static res bus_connect_conn(u32 conn) +{ + struct bus_conn *bus_conn = bus_find_conn(conn); + if (!bus_conn) + return -ENOENT; + + struct bus *bus = bus_find_bus(bus_conn->bus); + if (!bus) + return -ENOENT; + + if (bus_conn->pid != proc_current()->pid && bus->pid != proc_current()->pid) + return -EACCES; + + proc_current()->bus_conn = conn; + + return EOK; +} + +static res bus_send(u32 conn, const void *buf, u32 count) { if (!count) return EOK; @@ -160,10 +180,13 @@ static res bus_send(u32 conn, void *buf, u32 count) msg->conn = conn; msg->size = count; - if (bus->pid == proc_current()->pid) - stack_push_bot(bus_conn->in, msg); - else + if (bus->pid == proc_current()->pid) { stack_push_bot(bus_conn->out, msg); + io_unblock_pid(bus_conn->pid); + } else { + stack_push_bot(bus_conn->in, msg); + io_unblock_pid(bus->pid); + } return count; } @@ -176,16 +199,20 @@ static res bus_conn_receive(struct bus_conn *bus_conn, void *buf, u32 offset, u3 struct bus_message *msg = NULL; if (bus->pid == proc_current()->pid) - msg = stack_pop(bus_conn->out); + msg = stack_pop(bus_conn->in); else msg = stack_pop(bus_conn->out); if (!msg) return -EIO; - memcpy_user(buf, (u8 *)msg->data + offset, MIN(count, msg->size)); + struct bus_header h = { .conn = bus_conn->conn }; + memcpy_user(buf, &h, sizeof(h)); + memcpy_user((u8 *)buf + sizeof(h), (u8 *)msg->data + offset, MIN(count, msg->size)); + free(msg->data); free(msg); + return MIN(count, msg->size); } @@ -230,8 +257,11 @@ static res bus_control(u32 request, void *arg1, void *arg2, void *arg3) UNUSED(arg3); switch (request) { - case IOCTL_BUS_CONNECT: { - return bus_connect(arg1, arg2); + case IOCTL_BUS_CONNECT_BUS: { + return bus_connect_bus(arg1, arg2); + } + case IOCTL_BUS_CONNECT_CONN: { + return bus_connect_conn((u32)arg1); } case IOCTL_BUS_REGISTER: { return bus_register(arg1); @@ -242,7 +272,7 @@ static res bus_control(u32 request, void *arg1, void *arg2, void *arg3) } } -static res bus_write(void *buf, u32 offset, u32 count) +static res bus_write(const void *buf, u32 offset, u32 count) { if (offset) return -EINVAL; @@ -263,7 +293,7 @@ static res bus_conn_ready(struct bus_conn *bus_conn) u8 ready = 0; if (bus->pid == proc_current()->pid) - ready = !stack_empty(bus_conn->out); + ready = !stack_empty(bus_conn->in); else ready = !stack_empty(bus_conn->out); diff --git a/kernel/features/io.c b/kernel/features/io.c index c48eb62..fbae5cf 100644 --- a/kernel/features/io.c +++ b/kernel/features/io.c @@ -8,6 +8,7 @@ #include #include #include +#include #include #include #include @@ -117,7 +118,7 @@ res io_control(enum io_type io, u32 request, void *arg1, void *arg2, void *arg3) return dev->control(request, arg1, arg2, arg3); } -res io_write(enum io_type io, void *buf, u32 offset, u32 count) +res io_write(enum io_type io, const void *buf, u32 offset, u32 count) { if (!memory_readable(buf)) return -EFAULT; @@ -182,6 +183,24 @@ void io_unblock(enum io_type io) } } +void io_unblock_pid(u32 pid) +{ + for (u32 io = IO_MIN; io < IO_MAX; io++) { + struct node *iterator = io_listeners[io]->head; + while (iterator) { + struct io_listener *listener = iterator->data; + struct proc *proc = listener->proc; + proc_state(proc, PROC_RUNNING); + struct node *next = iterator->next; + if (proc->pid == pid) { + list_remove(io_listeners[io], iterator); + free(listener); + } + iterator = next; + } + } +} + CLEAR void io_install(struct boot_info *boot) { for (u32 i = 0; i < IO_MAX; i++) @@ -200,6 +219,7 @@ CLEAR void io_install(struct boot_info *boot) } timer_install(); + logger_install(); fb_install(boot->vid); bus_install(); } diff --git a/kernel/features/logger.c b/kernel/features/logger.c new file mode 100644 index 0000000..7db9a82 --- /dev/null +++ b/kernel/features/logger.c @@ -0,0 +1,42 @@ +// MIT License, Copyright (c) 2021 Marvin Borner + +#include +#include +#include +#include +#include +#include +#include +#include + +static res logger_write(const void *buf, u32 offset, u32 count) +{ + if (offset) + return -EINVAL; + + if (!count) + return EOK; + + print_prefix(); + + u32 i; + stac(); + for (i = 0; i < count; i++) { + if (!((const u8 *)buf)[i]) + break; + + serial_put(((const u8 *)buf)[i]); + } + clac(); + + serial_print("\x1B[0m"); + + return i; +} + +void logger_install(void) +{ + struct io_dev *dev = zalloc(sizeof(*dev)); + dev->write = logger_write; + io_add(IO_LOGGER, dev); +} diff --git a/kernel/features/proc.c b/kernel/features/proc.c index cada97d..4cf4005 100644 --- a/kernel/features/proc.c +++ b/kernel/features/proc.c @@ -251,21 +251,6 @@ static const char *procfs_parse_path(const char **path, u32 *pid) return *path; } -static enum stream_defaults procfs_stream(const char *path) -{ - if (!memcmp_user(path, "in", 3)) { - return STREAM_IN; - } else if (!memcmp_user(path, "out", 4)) { - return STREAM_OUT; - } else if (!memcmp_user(path, "err", 4)) { - return STREAM_ERR; - } else if (!memcmp_user(path, "log", 4)) { - return STREAM_LOG; - } else { - return STREAM_UNKNOWN; - } -} - struct procfs_message { u8 *data; u32 size; @@ -273,39 +258,12 @@ struct procfs_message { static res procfs_write(const char *path, void *buf, u32 offset, u32 count, struct vfs_dev *dev) { + UNUSED(path); + UNUSED(buf); UNUSED(offset); + UNUSED(count); UNUSED(dev); - u32 pid = 0; - procfs_parse_path(&path, &pid); - if (pid) { - struct proc *p = proc_from_pid(pid); - stac(); - if (!p || path[0] != '/') { - clac(); - return -ENOENT; - } - clac(); - - path++; - if (!memcmp_user(path, "io/", 3)) { - path += 3; - enum stream_defaults id = procfs_stream(path); - if (id == STREAM_UNKNOWN) - return -ENOENT; - - // Put proc log/err messages to serial console for debugging - if (id == STREAM_LOG || id == STREAM_ERR) - print_app(id, p->name, (char *)buf); - - struct stream *stream = &p->streams[id]; - assert(stream->offset_write + count < STREAM_MAX_SIZE); // TODO: Resize - memcpy_user((char *)(stream->data + stream->offset_write), buf, count); - stream->offset_write += count; - return count; - } - } - return -ENOENT; } @@ -338,15 +296,6 @@ static res procfs_read(const char *path, void *buf, u32 offset, u32 count, struc const char *status = p->state == PROC_RUNNING ? "running" : "sleeping"; memcpy_user(buf, status + offset, count); return count; - } else if (!memcmp_user(path, "io/", 3)) { - path += 3; - enum stream_defaults id = procfs_stream(path); - if (id == STREAM_UNKNOWN) - return -ENOENT; - struct stream *stream = &p->streams[id]; - memcpy_user(buf, stream->data + stream->offset_read, count); - stream->offset_read += count; - return count; } } diff --git a/kernel/features/syscall.c b/kernel/features/syscall.c index 94ea778..23c8d37 100644 --- a/kernel/features/syscall.c +++ b/kernel/features/syscall.c @@ -132,6 +132,11 @@ static void syscall_handler(struct regs *r) break; } + case SYS_MIN: + case SYS_MAX: + r->eax = -EINVAL; + break; + // TODO: Reimplement network functions using VFS default: { r->eax = -EINVAL; diff --git a/kernel/inc/io.h b/kernel/inc/io.h index e0b817b..ed7920e 100644 --- a/kernel/inc/io.h +++ b/kernel/inc/io.h @@ -1,7 +1,7 @@ // MIT License, Copyright (c) 2021 Marvin Borner -#ifndef DEV_H -#define DEV_H +#ifndef IO_H +#define IO_H #include #include @@ -11,7 +11,7 @@ struct io_dev { res (*read)(void *buf, u32 offset, u32 count) NONNULL; - res (*write)(void *buf, u32 offset, u32 count) NONNULL; + res (*write)(const void *buf, u32 offset, u32 count) NONNULL; res (*control)(u32 request, void *arg1, void *arg2, void *arg3); res (*ready)(void); }; @@ -21,12 +21,13 @@ void io_add(enum io_type io, struct io_dev *dev) NONNULL; // No NONNULL on syscalls res io_control(enum io_type io, u32 request, void *arg1, void *arg2, void *arg3); -res io_write(enum io_type io, void *buf, u32 offset, u32 count); +res io_write(enum io_type io, const void *buf, u32 offset, u32 count); res io_read(enum io_type io, void *buf, u32 offset, u32 count); res io_poll(u32 *devs); res io_ready(enum io_type io); void io_block(enum io_type io, struct proc *proc) NONNULL; void io_unblock(enum io_type io); +void io_unblock_pid(u32 pid); #endif diff --git a/kernel/inc/logger.h b/kernel/inc/logger.h new file mode 100644 index 0000000..61ec576 --- /dev/null +++ b/kernel/inc/logger.h @@ -0,0 +1,8 @@ +// MIT License, Copyright (c) 2021 Marvin Borner + +#ifndef LOGGER_H +#define LOGGER_H + +void logger_install(void); + +#endif diff --git a/kernel/inc/proc.h b/kernel/inc/proc.h index 1e3f037..5b8fbea 100644 --- a/kernel/inc/proc.h +++ b/kernel/inc/proc.h @@ -22,25 +22,15 @@ #define RING(regs) ((regs->cs) & 3) -#define STREAM_MAX_SIZE 4096 -enum stream_defaults { STREAM_IN, STREAM_OUT, STREAM_ERR, STREAM_LOG, STREAM_UNKNOWN = -1 }; - enum proc_priv { PROC_PRIV_NONE, PROC_PRIV_ROOT, PROC_PRIV_KERNEL }; enum proc_state { PROC_RUNNING, PROC_BLOCKED }; -struct stream { - u32 offset_read; - u32 offset_write; - char data[STREAM_MAX_SIZE]; -}; - struct proc { u32 pid; u32 entry; char name[64]; char dir[64]; - struct stream streams[4]; struct page_dir *page_dir; struct regs regs; enum proc_priv priv; -- cgit v1.2.3