Take good code

.editorconfig

@@ -0,0 +1,14 @@
+# EditorConfig is awesome: http://EditorConfig.org
+
+root = true
+
+[*]
+end_of_line = lf
+# Do not trim everywhere: makefiles, configs are not usually follows this policy
+#trim_trailing_whitespace = true
+
+[c,h]
+indent_style = tab
+indent_size = 8
+trim_trailing_whitespace = true
+

.github/workflows/test.yml

@@ -13,8 +13,7 @@ jobs:
       fail-fast: false
       matrix:
         test:
-          - batch
-          - pool
+          - multithread
 
     steps:
     - uses: actions/checkout@v2

.gitignore

@@ -3,6 +3,8 @@
 *.o
 *.o.d
 /main
+/rootfs.cpio
+*.app
 
 # IDE and tooling
 /tags

Makefile

@@ -1,8 +1,26 @@
-CFLAGS = -g
+CFLAGS = -g -MMD -MT $@ -MF [email protected]
+ASFLAGS = $(CFLAGS)
 
-all : main
+KERNEL_START := 0xf00000000
+USERSPACE_START := 0x400000
 
-main : $(patsubst %.c,%.o,$(wildcard *.c))
+CFLAGS += -DIKERNEL_START=$(KERNEL_START) -DIUSERSPACE_START=$(USERSPACE_START)
+
+all : main rootfs.cpio
+
+main : $(patsubst %.c,%.o,$(patsubst %.S,%.o,$(filter-out %.app.c,$(wildcard *.[cS]))))
+	$(CC) $(LDFLAGS) $^ $(LOADLIBES) $(LDLIBS) -o $@
+
+APPS = $(patsubst %.app.c,%.app,$(wildcard *.app.c))
+
+$(APPS) : %.app : %.app.c
+	$(CC) -fno-stack-protector -fno-pic -Wl,-Ttext-segment=$(USERSPACE_START) -nostdlib -e main -static -x c $< -o $@
+
+rootfs.cpio : $(APPS)
+	ls -1 $^ | cpio -o -H bin > $@
 
 clean :
-	rm -f *.o main
+	rm -f *.[od] main rootfs.cpio *.app
+
+-include $(wildcard *.d)
+

main.c → apps.c

@@ -1,18 +1,23 @@
 
 #include <stdbool.h>
+#include <stdarg.h>
 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
+#include <unistd.h>
 
+#include <time.h>
+#include <sys/time.h>
+
+#include "sched.h"
+#include "usyscall.h"
 #include "pool.h"
 
 static int g_retcode;
 
 #define APPS_X(X) \
         X(echo) \
         X(retcode) \
-        X(pooltest) \
-
 
 #define DECLARE(X) static int X(int, char *[]);
 APPS_X(DECLARE)
@@ -27,15 +32,26 @@ static const struct app {
 #undef ELEM
 };
 
+static int os_printf(const char *fmt, ...) {
+	char buf[128];
+	va_list ap;
+	va_start(ap, fmt);
+	int ret = vsnprintf(buf, sizeof(buf), fmt, ap);
+	va_end(ap);
+	return os_write(1, buf, ret);
+}
+
 static int echo(int argc, char *argv[]) {
 	for (int i = 1; i < argc; ++i) {
 		printf("%s%c", argv[i], i == argc - 1 ? '\n' : ' ');
 	}
+	fflush(stdout);
 	return argc - 1;
 }
 
 static int retcode(int argc, char *argv[]) {
 	printf("%d\n", g_retcode);
+	fflush(stdout);
 	return 0;
 }
 
@@ -57,39 +73,19 @@ static int exec(int argc, char *argv[]) {
 	return g_retcode;
 }
 
-static int pooltest(int argc, char *argv[]) {
-	struct obj {
-		void *field1;
-		void *field2;
-	};
-	static struct obj objmem[4];
-	static struct pool objpool = POOL_INITIALIZER_ARRAY(objmem);
-
-	if (!strcmp(argv[1], "alloc")) {
-		struct obj *o = pool_alloc(&objpool);
-		printf("alloc %d\n", o ? (o - objmem) : -1);
-		return 0;
-	} else if (!strcmp(argv[1], "free")) {
-		int iobj = atoi(argv[2]);
-		printf("free %d\n", iobj);
-		pool_free(&objpool, objmem + iobj);
-		return 0;
-	}
-}
-
 int shell(int argc, char *argv[]) {
 	char line[256];
 	while (fgets(line, sizeof(line), stdin)) {
 		const char *comsep = "\n;";
 		char *stcmd;
 		char *cmd = strtok_r(line, comsep, &stcmd);
 		while (cmd) {
-			const char *argsep = " ";
+			const char *argsep = " \t";
 			char *starg;
 			char *arg = strtok_r(cmd, argsep, &starg);
 			char *argv[256];
 			int argc = 0;
-			while (arg) {
+			while (arg && arg[0] != '#') {
 				argv[argc++] = arg;
 				arg = strtok_r(NULL, argsep, &starg);
 			}
@@ -106,8 +102,3 @@ int shell(int argc, char *argv[]) {
 	}
 	return 0;
 }
-
-
-int main(int argc, char *argv[]) {
-	shell(0, NULL);
-}

ctx.c

@@ -0,0 +1,13 @@
+#include <string.h>
+
+#include "ctx.h"
+
+void ctx_make(struct ctx *ctx, void *entry, void *stack, int alignment) {
+        memset(ctx, 0, sizeof(*ctx));
+
+        if(alignment == STANDARD) stack = (void*)(((unsigned long)stack & ~0xf) - 8);
+        ctx->rsp = (unsigned long) stack;
+        ctx->rsp -= 8;
+        *(unsigned long *)ctx->rsp = (unsigned long) entry;
+}
+

ctx.h

@@ -0,0 +1,23 @@
+#pragma once
+
+enum Alignment {
+    NONE,
+    STANDARD
+};
+
+
+struct ctx {
+	unsigned long rbx;
+	unsigned long r12;
+	unsigned long r13;
+	unsigned long r14;
+	unsigned long r15;
+	unsigned long rsp;
+	unsigned long rbp;
+	unsigned long rip;
+};
+
+extern void ctx_make(struct ctx *ctx, void *entry, void *stack, int alignment);
+
+extern void ctx_switch(struct ctx *old, struct ctx *new);
+

ctx_switch.S

@@ -0,0 +1,21 @@
+
+.text
+.global ctx_switch
+ctx_switch:
+	mov %rbx, 0*8(%rdi)
+	mov %r12, 1*8(%rdi)
+	mov %r13, 2*8(%rdi)
+	mov %r14, 3*8(%rdi)
+	mov %r15, 4*8(%rdi)
+	mov %rsp, 5*8(%rdi)
+	mov %rbp, 6*8(%rdi)
+
+	mov 0*8(%rsi), %rbx
+	mov 1*8(%rsi), %r12
+	mov 2*8(%rsi), %r13
+	mov 3*8(%rsi), %r14
+	mov 4*8(%rsi), %r15
+	mov 5*8(%rsi), %rsp
+	mov 6*8(%rsi), %rbp
+
+	ret

grep.app.c

@@ -0,0 +1,62 @@
+#include "usyscall.h"
+
+char *strstr(const char *where, const char *what) {
+	int a = 0;
+	int b;
+
+	do {
+		b = 0;
+		while (what[b] && what[b] == where[a + b]) {
+			++b;
+		}
+		if (!what[b]) {
+			return (char*)(where + a);
+		}
+	} while (where[a++ + b]);
+	return (char*)0;
+}
+
+void *memchr(const void *str, int c, long unsigned n) {
+	const char *s = str;
+	const char *e = str + n;
+	while (s < e) {
+		if (*s == c) {
+			return (void*)s;
+		}
+		++s;
+	}
+	return (void*)0;
+}
+
+void *memmove(void *dst, const void *src, long unsigned n) {
+	const char *f = src;
+	char *t = dst;
+	while (n--) {
+		*t++ = *f++;
+	}
+	return dst;
+}
+
+int main(int argc, char* argv[]) {
+	char buf[5];
+	int len;
+	int o = 0;
+	while (0 < (len = os_read(0, buf + o, sizeof(buf) - o))) {
+		len += o;
+		char *p = buf;
+		char *p2 = memchr(p, '\n', len);
+		while (p2) {
+			*p2 = '\0';
+			if (strstr(p, argv[1])) {
+				os_write(1, p, p2 - p);
+				os_write(1, "\n", 1);
+			}
+			p = p2 + 1;
+			p2 = memchr(p, '\n', len - (p - buf));
+		}
+		o = len - (p - buf);
+		memmove(buf, p, o);
+	}
+
+	os_exit(0);
+}

init.app.c

@@ -0,0 +1,40 @@
+#include "usyscall.h"
+
+long unsigned strlen(const char *str) {
+	const char *e = str;
+	while (*e) {
+		++e;
+	}
+	return e - str;
+}
+
+int os_print(int fd, const char *str) {
+	int len = strlen(str);
+	return os_write(fd, str, len);
+}
+
+int main(int argc, char* argv[]) {
+	os_write(1, "start\n", 6);
+
+	int pipe[2];
+	int ret = os_pipe(pipe);
+	if (ret < 0) {
+		os_print(2, "cannot create pipe\n");
+		os_exit(1);
+	}
+	int pid = os_fork();
+	if (pid) {
+		os_close(1);
+		os_dup(pipe[1]);
+		const char *arg[] = { "seq", "100", (char*)0 };
+		os_exec("seq", (char**)arg);
+	} else {
+		os_close(0);
+		os_dup(pipe[0]);
+		const char *arg[] = { "grep", "2", (char*)0 };
+		os_exec("grep", (char**)arg);
+	}
+
+	os_print(2, "should not reach here\n");
+	os_exit(1);
+}

pool.c

@@ -4,11 +4,31 @@
 #include "pool.h"
 
 void pool_init(struct pool *p, void *mem, unsigned long nmemb, unsigned long membsz) {
+	p->mem = mem;
+	p->membsz = membsz;
+	p->freestart = mem;
+	p->freeend = p->freestart + nmemb * membsz;
+	p->freehead = NULL;
 }
 
 void *pool_alloc(struct pool *p) {
+	if (p->freestart < p->freeend) {
+		void *r = p->freestart;
+		p->freestart += p->membsz;
+		return r;
+	}
+
+	struct pool_free_block *fb = p->freehead;
+	if (fb) {
+		p->freehead = fb->next;
+		return fb;
+	}
+
 	return NULL;
 }
 
 void pool_free(struct pool *p, void *ptr) {
+	struct pool_free_block *fb = ptr;
+	fb->next = p->freehead;
+	p->freehead = fb;
 }

pool.h

@@ -2,11 +2,24 @@
 
 #include "util.h"
 
-struct pool {
+struct pool_free_block {
+	struct pool_free_block *next;
+};
 
+struct pool {
+	char *mem;
+	unsigned long membsz;
+	char *freestart;
+	char *freeend;
+	struct pool_free_block *freehead;
 };
 
 #define POOL_INITIALIZER(_mem, _nmemb, _membsz) { \
+	.mem = (char*)(_mem), \
+	.membsz	= (_membsz), \
+	.freehead = NULL, \
+	.freestart = (char*)(_mem), \
+	.freeend = (char*)(_mem) + (_nmemb) * (_membsz), \
 }
 
 #define POOL_INITIALIZER_ARRAY(_array) \