upd: Intermediate save

Author: Rishies2010

ZenOS.vhd

@@ -30,3 +30,4 @@
 - [FIGlet](https://github.com/cmatsuoka/figlet) — Large ASCII text renderer
 - [BusyBox](https://busybox.net/) — The Swiss Army Knife of Embedded Linux
 - [DOOM](https://github.com/id-Software/DOOM), and the [generic platform layer](https://github.com/ozkl/doomgeneric) — 3D FPS action game.
+- [ClassiCube](https://classicube.net) — A clean-room remake of 2009 Minecraft Alpha.

docs/CREDITS.md

@@ -1,3 +1,27 @@
 ## Current issues in Zen:
 
-> No known issues as of now! Wanna go find out one?
+> ClassiCube closes upon clicking Singleplayer button in menu. Most probably the missing functionality thats needed to open another game window.
+
+> Providing an argument to ClassiCube skips menu and starts a world with that name. But mostly page faults, and rarely does work but the entire rendering engine looks messed up. Read following issues to get an idea why its messed up.
+
+> ClassiCube doesn't even launch from other real shells like ash and sh (BusyBox), other than ZenOS's shell, which works because it uses a custom spawn() instead of fork + exec. Infact launching classicube from one of these shells freezes the system.
+
+> All of this points to core memory issues. Other big clue of this is that launching nk_widgets, or classicube, or imgview, or other big apps (i.e big binary, or an app that loads a lot of memory at runtime), actually can mess up their own window buffer (this does not sound serious as obviously apps can access window buffer but its dangerous) but they can ALSO CORRUPT the window titlebars background and colors, and harp's bottom dock islands' blur and background with corrupt ahh pixel garbage.
+
+> imgview app almost never works correctly and always has some garbage pixel lines and artifacts in it, but imgview app itself is damn simple... its memory corruption too.
+
+---
+
+### What to do:
+
+> This is definitely a kernel-side or core userspace-side error.
+
+> Completely debug out, rewrite, and fix fork, and also check spawn() in the meanwhile.
+
+> Check and debug the core memory manager, PMM and VMM
+
+> Also need to consider edge cases of memory running out, heap, etc.
+
+> Shift the custom shell to use fork() again, and test ALL apps.
+
+> Make the fork, spawn, exec stuff better, idk atp

docs/ISSUES.md

@@ -1,5 +1,7 @@
 ## What I have planned next for Zen:
 
+> Finish ISSUES.md. Huge bugs on the way.
+
 > Getting more BusyBox applets.
 
 > Self-hosting, perhaps implies GCC porting

docs/TODO.md

@@ -20,6 +20,7 @@
 #include <sys/utsname.h>
 #include <termios.h>
 #include <unistd.h>
+#include <netinet/in.h>
 
 #include <frg/manual_box.hpp>
 #include <mlibc/all-sysdeps.hpp>
@@ -30,6 +31,17 @@
 
 namespace {
 
+static bool inet_sockets[64];
+
+static bool is_inet_socket(int fd) {
+	return fd >= 0 && static_cast<size_t>(fd) < (sizeof(inet_sockets) / sizeof(inet_sockets[0])) && inet_sockets[fd];
+}
+
+static void set_inet_socket(int fd, bool value) {
+	if(fd >= 0 && static_cast<size_t>(fd) < (sizeof(inet_sockets) / sizeof(inet_sockets[0])))
+		inet_sockets[fd] = value;
+}
+
 static int sc_error(long ret) {
 	return ret < 0 ? static_cast<int>(-ret) : 0;
 }
@@ -221,6 +233,14 @@ int sys_read_entries(int handle, void *buffer, size_t max_size, size_t *bytes_re
 }
 
 int sys_read(int fd, void *buf, size_t count, ssize_t *bytes_read) {
+	if(is_inet_socket(fd)) {
+		long ret = zenos_do_syscall4(ZENOS_SYSCALL_RECV, fd, reinterpret_cast<long>(buf), count, 0);
+		int e = sc_error(ret);
+		if(e)
+			return e;
+		*bytes_read = ret;
+		return 0;
+	}
 	long ret = zenos_do_syscall3(ZENOS_SYSCALL_READ, fd, reinterpret_cast<long>(buf), count);
 	int e = sc_error(ret);
 	if(e)
@@ -230,6 +250,15 @@ int sys_read(int fd, void *buf, size_t count, ssize_t *bytes_read) {
 }
 
 int sys_write(int fd, const void *buf, size_t count, ssize_t *bytes_written) {
+	if(is_inet_socket(fd)) {
+		long ret = zenos_do_syscall4(ZENOS_SYSCALL_SEND, fd, reinterpret_cast<long>(buf), count, 0);
+		int e = sc_error(ret);
+		if(e)
+			return e;
+		if(bytes_written)
+			*bytes_written = ret;
+		return 0;
+	}
 	long ret = zenos_do_syscall3(ZENOS_SYSCALL_WRITE, fd, reinterpret_cast<long>(buf), count);
 	int e = sc_error(ret);
 	if(e)
@@ -249,6 +278,11 @@ int sys_seek(int fd, off_t offset, int whence, off_t *new_offset) {
 }
 
 int sys_close(int fd) {
+	if(is_inet_socket(fd)) {
+		long ret = zenos_do_syscall1(ZENOS_SYSCALL_CLOSESOCKET, fd);
+		set_inet_socket(fd, false);
+		return sc_error(ret);
+	}
 	long ret = zenos_do_syscall1(ZENOS_SYSCALL_CLOSE, fd);
 	return sc_error(ret);
 }
@@ -792,7 +826,18 @@ int sys_clone(void *tcb, pid_t *pid_out, void *stack) {
 }
 
 int sys_socket(int domain, int type, int protocol, int *fd) {
-	(void)protocol;
+	int base_type = type & ~(SOCK_CLOEXEC | SOCK_NONBLOCK);
+	if(domain == AF_INET) {
+		if(base_type != SOCK_STREAM)
+			return EPROTONOSUPPORT;
+		if(protocol != 0 && protocol != IPPROTO_TCP)
+			return EPROTONOSUPPORT;
+		long ret = zenos_do_syscall3(ZENOS_SYSCALL_SOCKET, domain, base_type, protocol);
+		int e = finish_fd(ret, fd);
+		if(!e)
+			set_inet_socket(*fd, true);
+		return e;
+	}
 	long ret = zenos_do_syscall2(ZENOS_SYSCALL_UNIX_SOCKET, domain, type);
 	return finish_fd(ret, fd);
 }
@@ -816,17 +861,42 @@ int sys_accept(int fd, int *newfd, struct sockaddr *addr, socklen_t *addrlen, in
 }
 
 int sys_connect(int fd, const struct sockaddr *addr, socklen_t addrlen) {
-	(void)addrlen;
+	if((addr && addr->sa_family == AF_INET) || is_inet_socket(fd)) {
+		if(!addr || addrlen < sizeof(struct sockaddr_in))
+			return EINVAL;
+		long ret = zenos_do_syscall3(ZENOS_SYSCALL_CONNECT,
+				fd, reinterpret_cast<long>(addr), addrlen);
+		int e = sc_error(ret);
+		if(!e)
+			set_inet_socket(fd, true);
+		return e;
+	}
 	long ret = zenos_do_syscall2(ZENOS_SYSCALL_UNIX_CONNECT,
 			fd, reinterpret_cast<long>(addr));
 	return sc_error(ret);
 }
 
 int sys_msg_send(int fd, const struct msghdr *msg, int flags, ssize_t *bytes_written) {
-	(void)flags;
 	if (!msg || !msg->msg_iov || msg->msg_iovlen == 0)
 		return EINVAL;
 	ssize_t total = 0;
+	if(is_inet_socket(fd)) {
+		for (size_t i = 0; i < msg->msg_iovlen; i++) {
+			long ret = zenos_do_syscall4(ZENOS_SYSCALL_SEND,
+					fd,
+					reinterpret_cast<long>(msg->msg_iov[i].iov_base),
+					msg->msg_iov[i].iov_len,
+					flags);
+			int e = sc_error(ret);
+			if(e) return e;
+			total += ret;
+			if((size_t)ret < msg->msg_iov[i].iov_len)
+				break;
+		}
+		*bytes_written = total;
+		return 0;
+	}
+	(void)flags;
 	for (size_t i = 0; i < msg->msg_iovlen; i++) {
 		long ret = zenos_do_syscall4(ZENOS_SYSCALL_UNIX_SEND,
 				fd,
@@ -842,10 +912,26 @@ int sys_msg_send(int fd, const struct msghdr *msg, int flags, ssize_t *bytes_wri
 }
 
 int sys_msg_recv(int fd, struct msghdr *msg, int flags, ssize_t *bytes_read) {
-	(void)flags;
 	if (!msg || !msg->msg_iov || msg->msg_iovlen == 0)
 		return EINVAL;
 	ssize_t total = 0;
+	if(is_inet_socket(fd)) {
+		for (size_t i = 0; i < msg->msg_iovlen; i++) {
+			long ret = zenos_do_syscall4(ZENOS_SYSCALL_RECV,
+					fd,
+					reinterpret_cast<long>(msg->msg_iov[i].iov_base),
+					msg->msg_iov[i].iov_len,
+					flags);
+			int e = sc_error(ret);
+			if(e) return e;
+			total += ret;
+			if((size_t)ret < msg->msg_iov[i].iov_len)
+				break;
+		}
+		*bytes_read = total;
+		return 0;
+	}
+	(void)flags;
 	for (size_t i = 0; i < msg->msg_iovlen; i++) {
 		long ret = zenos_do_syscall5(ZENOS_SYSCALL_UNIX_RECV,
 				fd,
@@ -883,6 +969,10 @@ int sys_setsockopt(int fd, int layer, int number, const void *buffer, socklen_t
 }
 
 int sys_shutdown(int fd, int how) {
+	if(is_inet_socket(fd)) {
+		long ret = zenos_do_syscall2(ZENOS_SYSCALL_CLOSESOCKET, fd, how);
+		return sc_error(ret);
+	}
 	long ret = zenos_do_syscall2(ZENOS_SYSCALL_UNIX_SHUTDOWN, fd, how);
 	return sc_error(ret);
 }

mlibc/sysdeps/zenos/generic/generic.cpp

@@ -38,6 +38,12 @@
 #define ZENOS_SYSCALL_SIGACTION 58
 #define ZENOS_SYSCALL_SIGRETURN 59
 #define ZENOS_SYSCALL_SIGPROCMASK 60
+#define ZENOS_SYSCALL_SOCKET 61
+#define ZENOS_SYSCALL_CONNECT 62
+#define ZENOS_SYSCALL_SEND 63
+#define ZENOS_SYSCALL_RECV 64
+#define ZENOS_SYSCALL_CLOSESOCKET 65
+#define ZENOS_SYSCALL_GETHOSTBYNAME 66
 #define ZENOS_SYSCALL_FUTEX 67
 #define ZENOS_SYSCALL_IOCTL 69
 #define ZENOS_SYSCALL_ARCH_PRCTL 74

mlibc/sysdeps/zenos/generic/syscall.h

@@ -19,6 +19,7 @@
 #include "../libk/ports.h"
 #include "../libk/string.h"
 #include "../libk/debug/log.h"
+#include "../libk/debug/serial.h"
 #include "../drv/vga.h"
 #include "../kernel/sched.h"
 #include <stdint.h>
@@ -198,30 +199,31 @@ static void userspace_exception_report(registers_t *regs)
     task->userspace_faults++;
     task->last_userspace_fault = regs->int_no;
 
+    uint64_t cr2 = 0;
+    if (regs->int_no == PAGE_FAULT)
+        asm volatile("mov %%cr2, %0" : "=r"(cr2));
+
+    char msg[768];
+    if (regs->int_no == PAGE_FAULT) {
+        snprintf(msg, sizeof(msg),
+            "\n%s: %s in %s (pid %d)\n"
+            "  fault=0x%016lx rip=0x%016lx rsp=0x%016lx error=0x%016lx\n",
+            "ZenOS", exception_title(regs->int_no), task->name, task->pid,
+            cr2, regs->rip, regs->userrsp, regs->err_code);
+    } else {
+        snprintf(msg, sizeof(msg),
+            "\n%s: %s in %s (pid %d)\n"
+            "  rip=0x%016lx rsp=0x%016lx error=0x%016lx\n",
+            "ZenOS", exception_title(regs->int_no), task->name, task->pid,
+            regs->rip, regs->userrsp, regs->err_code);
+    }
+    serial_write_string(msg);
+
     fd_entry_t *err = NULL;
     if (task->fd_table && task->fd_table->entries[2].used)
         err = &task->fd_table->entries[2];
 
     if (err && err->type == FD_PTY_SLAVE && err->pty) {
-        uint64_t cr2 = 0;
-        if (regs->int_no == PAGE_FAULT)
-            asm volatile("mov %%cr2, %0" : "=r"(cr2));
-
-        char msg[768];
-        if (regs->int_no == PAGE_FAULT) {
-            snprintf(msg, sizeof(msg),
-                "\n%s: %s in %s (pid %d)\n"
-                "  fault=0x%016lx rip=0x%016lx rsp=0x%016lx error=0x%016lx\n",
-                "ZenOS", exception_title(regs->int_no), task->name, task->pid,
-                cr2, regs->rip, regs->userrsp, regs->err_code);
-        } else {
-            snprintf(msg, sizeof(msg),
-                "\n%s: %s in %s (pid %d)\n"
-                "  rip=0x%016lx rsp=0x%016lx error=0x%016lx\n",
-                "ZenOS", exception_title(regs->int_no), task->name, task->pid,
-                regs->rip, regs->userrsp, regs->err_code);
-        }
-        log(msg, 3, 0);
         pty_fault_write(err->pty, msg);
     }
 

src/cpu/isr.c

@@ -53,13 +53,13 @@ void ap_entry(struct limine_smp_info *info) {
 void smp_prepare(void)
 {
     struct limine_smp_response *smp = smp_request.response;
-    if (smp == NULL) {
+    if (smp == NULL) { // Limine fetch failed
         clr();
         log("Failed to fetch SMP (CPU) info.", 0, 1);
     }
-    if(smp->cpu_count > MAX_CPUS) {
+    if(smp->cpu_count > MAX_CPUS) { // Very unstable beyond 16.
         clr();
-        log("\n\nThis system cannot run ZenOS\n\n - This system does not meet the requirement of maximum 8 CPUs.\n\nConsider downgrading your CPU.\nDecrease CPUs available if on a VM.\n ", 0, 1);
+        log("\n\nThis system cannot run ZenOS\n\n - This system does not meet the requirement of maximum 16 CPUs.\n\nConsider downgrading your CPU.\nDecrease CPUs available if on a VM.\n ", 0, 1);
     }
 
     g_cpu_count = (uint32_t)smp->cpu_count;
@@ -83,7 +83,7 @@ void init_smp() {
             log("Starting CPU %lu (LAPIC ID %d)", 1, 0,
                 i, smp->cpus[i]->lapic_id);
             smp->cpus[i]->extra_argument = i;
-            smp->cpus[i]->goto_address = ap_entry;
+            smp->cpus[i]->goto_address = ap_entry; // CPU cores now end up at ap_entry, lets catch them there
         }
     }
     while (g_activeCpuCount < smp->cpu_count) {

src/cpu/smp.c

@@ -18,7 +18,7 @@
 #include "stdint.h"
 #include "acpi/acpi.h"
 
-#define MAX_CPUS 8
+#define MAX_CPUS 16
 
 typedef struct
 {

src/cpu/smp.h

@@ -705,20 +705,34 @@ void net_init(void)
 
 int tcp_connect(const uint8_t ip[4], uint16_t port)
 {
+    int id = tcp_socket();
+    if (id < 0)
+        return -1;
+    if (tcp_connect_socket(id, ip, port) < 0)
+        return -1;
+    return id;
+}
 
-    int id = -1;
+int tcp_socket(void)
+{
     for (int i = 0; i < MAX_TCP_CONNS; i++)
     {
         if (conns[i].state == TCP_STATE_CLOSED)
         {
-            id = i;
-            break;
+            memset(&conns[i], 0, sizeof(conns[i]));
+            conns[i].state = TCP_STATE_SOCKET;
+            return i;
         }
     }
-    if (id < 0)
+    return -1;
+}
+
+int tcp_connect_socket(int id, const uint8_t ip[4], uint16_t port)
+{
+    tcp_conn_t *c = conn_get(id);
+    if (!c || c->state != TCP_STATE_SOCKET)
         return -1;
 
-    tcp_conn_t *c = &conns[id];
     memset(c, 0, sizeof(*c));
     memcpy(c->remote_ip, ip, 4);
     c->remote_port = port;