Chapter 3

Author: rcy17

.github/workflows/github-autotest.yml

@@ -0,0 +1,44 @@
+name: auto-test
+
+on:
+  push:
+
+jobs:
+  base-test:
+    runs-on: ubuntu-latest
+    outputs:
+      points: ${{ steps.end.outputs.points}}
+    container:
+        image: duskmoon/dev-env:ucore-ci
+    steps:
+      - uses: actions/checkout@v3
+      - run: git clone https://github.com/LearningOS/uCore-Tutorial-Checker-2023S.git ucore-tutorial-ci
+      - run: git clone https://github.com/LearningOS/uCore-Tutorial-Test-2023S.git ucore-tutorial-ci/workplace/user
+      - name: run test
+        id: tester
+        run: cd ucore-tutorial-ci && make test passwd=${{ secrets.BASE_TEST_TOKEN }} CHAPTER=`echo ${GITHUB_REF##*/} | grep -oP 'ch\K[0-9]'` | tee ../output.txt
+      - name: end
+        id: end
+        run: cat output.txt | grep "Test passed" | grep -oP "\d{1,}/\d{1,}" | xargs -i echo "points={}" >> $GITHUB_OUTPUT
+  deploy:
+    if: github.repository != 'LearningOS/uCore-Tutorial-Code-2023S'
+    name: Deploy to pages
+    needs: base-test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        continue-on-error: true
+        with:
+          ref: 'gh-pages'
+      - name: Save Log File
+        uses: yfblock/multi-rank-log@main
+        with:
+          points: ${{ needs.base-test.outputs.points }}
+      - name: GitHub Pages
+        uses: crazy-max/ghaction-github-pages@v3
+        with:
+          target_branch: gh-pages
+          build_dir: ./public
+          keep_history: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Makefile

@@ -1,10 +1,7 @@
 .PHONY: clean build user
 all: build_kernel
 
-LOG ?= error
-
 K = os
-U = user
 
 TOOLPREFIX = riscv64-unknown-elf-
 CC = $(TOOLPREFIX)gcc
@@ -37,6 +34,9 @@ CFLAGS += -ffreestanding -fno-common -nostdlib -mno-relax
 CFLAGS += -I$K
 CFLAGS += $(shell $(CC) -fno-stack-protector -E -x c /dev/null >/dev/null 2>&1 && echo -fno-stack-protector)
 
+
+LOG ?= error
+
 ifeq ($(LOG), error)
 CFLAGS += -D LOG_LEVEL_ERROR
 else ifeq ($(LOG), warn)
@@ -89,7 +89,7 @@ build/kernel: $(OBJS) os/kernel_app.ld
 
 clean:
 	rm -rf $(BUILDDIR) os/kernel_app.ld os/link_app.S
-	make -C $(U) clean
+	make -C user clean
 
 # BOARD
 BOARD		?= qemu
@@ -118,8 +118,10 @@ debug: build/kernel .gdbinit
 
 CHAPTER ?= $(shell git rev-parse --abbrev-ref HEAD | grep -oP 'ch\K[0-9]')
 
+BASE ?= 0
+
 user:
-	make -C $(U) CHAPTER=$(CHAPTER) BASE=$(BASE)
+	make -C user CHAPTER=$(CHAPTER) BASE=$(BASE)
 
 test: user run
 

os/defs.h

@@ -4,6 +4,7 @@
 #include "const.h"
 #include "log.h"
 #include "printf.h"
+#include "proc.h"
 #include "riscv.h"
 #include "sbi.h"
 #include "string.h"

os/loader.c

@@ -2,45 +2,55 @@
 #include "defs.h"
 #include "trap.h"
 
-static int app_cur, app_num;
+static uint64 app_num;
 static uint64 *app_info_ptr;
-extern char _app_num[], userret[], boot_stack_top[], ekernel[];
+extern char _app_num[], ekernel[];
 
+// Count finished programs. If all apps exited, shutdown.
+int finished()
+{
+	static int fin = 0;
+	if (++fin >= app_num)
+		panic("all apps over");
+	return 0;
+}
+
+// Get user progs' infomation through pre-defined symbol in `link_app.S`
 void loader_init()
 {
 	if ((uint64)ekernel >= BASE_ADDRESS) {
 		panic("kernel too large...\n");
 	}
 	app_info_ptr = (uint64 *)_app_num;
-	app_cur = -1;
 	app_num = *app_info_ptr;
+	app_info_ptr++;
 }
 
-__attribute__((aligned(4096))) char user_stack[USER_STACK_SIZE];
-__attribute__((aligned(4096))) char trap_page[TRAP_PAGE_SIZE];
-
-int load_app(uint64 *info)
+// Load nth user app at
+// [BASE_ADDRESS + n * MAX_APP_SIZE, BASE_ADDRESS + (n+1) * MAX_APP_SIZE)
+int load_app(int n, uint64 *info)
 {
-	uint64 start = info[0], end = info[1], length = end - start;
-	memset((void *)BASE_ADDRESS, 0, MAX_APP_SIZE);
-	memmove((void *)BASE_ADDRESS, (void *)start, length);
+	uint64 start = info[n], end = info[n + 1], length = end - start;
+	memset((void *)BASE_ADDRESS + n * MAX_APP_SIZE, 0, MAX_APP_SIZE);
+	memmove((void *)BASE_ADDRESS + n * MAX_APP_SIZE, (void *)start, length);
 	return length;
 }
 
-int run_next_app()
+// load all apps and init the corresponding `proc` structure.
+int run_all_app()
 {
-	struct trapframe *trapframe = (struct trapframe *)trap_page;
-	app_cur++;
-	app_info_ptr++;
-	if (app_cur >= app_num) {
-		return -1;
+	for (int i = 0; i < app_num; ++i) {
+		struct proc *p = allocproc();
+		struct trapframe *trapframe = p->trapframe;
+		load_app(i, app_info_ptr);
+		uint64 entry = BASE_ADDRESS + i * MAX_APP_SIZE;
+		tracef("load app %d at %p", i, entry);
+		trapframe->epc = entry;
+		trapframe->sp = (uint64)p->ustack + USER_STACK_SIZE;
+		p->state = RUNNABLE;
+		/*
+		* LAB1: you may need to initialize your new fields of proc here
+		*/
 	}
-	infof("load and run app %d", app_cur);
-	uint64 length = load_app(app_info_ptr);
-	debugf("bin range = [%p, %p)", *app_info_ptr, *app_info_ptr + length);
-	memset(trapframe, 0, 4096);
-	trapframe->epc = BASE_ADDRESS;
-	trapframe->sp = (uint64)user_stack + USER_STACK_SIZE;
-	usertrapret(trapframe, (uint64)boot_stack_top);
 	return 0;
 }

os/loader.h

@@ -1,15 +1,16 @@
-#ifndef BATCH_H
-#define BATCH_H
+#ifndef LOADER_H
+#define LOADER_H
 
 #include "const.h"
 #include "types.h"
 
+int finished();
 void loader_init();
-int run_next_app();
+int run_all_app();
 
 #define BASE_ADDRESS (0x80400000)
 #define MAX_APP_SIZE (0x20000)
-#define USER_STACK_SIZE PAGE_SIZE
-#define TRAP_PAGE_SIZE PAGE_SIZE
+#define USER_STACK_SIZE (PAGE_SIZE)
+#define TRAP_PAGE_SIZE (PAGE_SIZE)
 
-#endif // BATCH_H
+#endif // LOADER_H

os/log.h

@@ -4,6 +4,7 @@
 extern void printf(char *, ...);
 extern int threadid();
 extern void dummy(int, ...);
+extern void shutdown();
 
 #if defined(LOG_LEVEL_ERROR)
 
@@ -113,6 +114,7 @@ enum LOG_COLOR {
 		int tid = threadid();                                          \
 		printf("\x1b[%dm[%s %d] %s:%d: " fmt "\x1b[0m\n", RED,         \
 		       "PANIC", tid, __FILE__, __LINE__, ##__VA_ARGS__);       \
+		shutdown();                                                    \
 	} while (0)
 
 #endif //! LOG_H

os/main.c

@@ -1,13 +1,9 @@
 #include "console.h"
 #include "defs.h"
 #include "loader.h"
+#include "timer.h"
 #include "trap.h"
 
-int threadid()
-{
-	return 0;
-}
-
 void clean_bss()
 {
 	extern char s_bss[];
@@ -18,8 +14,11 @@ void clean_bss()
 void main()
 {
 	clean_bss();
-	printf("hello wrold!\n");
-	trap_init();
+	proc_init();
 	loader_init();
-	run_next_app();
+	trap_init();
+	timer_init();
+	run_all_app();
+	infof("start scheduler!");
+	scheduler();
 }

os/proc.c

@@ -0,0 +1,125 @@
+#include "proc.h"
+#include "defs.h"
+#include "loader.h"
+#include "trap.h"
+
+struct proc pool[NPROC];
+char kstack[NPROC][PAGE_SIZE];
+__attribute__((aligned(4096))) char ustack[NPROC][PAGE_SIZE];
+__attribute__((aligned(4096))) char trapframe[NPROC][PAGE_SIZE];
+
+extern char boot_stack_top[];
+struct proc *current_proc;
+struct proc idle;
+
+int threadid()
+{
+	return curr_proc()->pid;
+}
+
+struct proc *curr_proc()
+{
+	return current_proc;
+}
+
+// initialize the proc table at boot time.
+void proc_init(void)
+{
+	struct proc *p;
+	for (p = pool; p < &pool[NPROC]; p++) {
+		p->state = UNUSED;
+		p->kstack = (uint64)kstack[p - pool];
+		p->ustack = (uint64)ustack[p - pool];
+		p->trapframe = (struct trapframe *)trapframe[p - pool];
+		/*
+		* LAB1: you may need to initialize your new fields of proc here
+		*/
+	}
+	idle.kstack = (uint64)boot_stack_top;
+	idle.pid = 0;
+	current_proc = &idle;
+}
+
+int allocpid()
+{
+	static int PID = 1;
+	return PID++;
+}
+
+// Look in the process table for an UNUSED proc.
+// If found, initialize state required to run in the kernel.
+// If there are no free procs, or a memory allocation fails, return 0.
+struct proc *allocproc(void)
+{
+	struct proc *p;
+	for (p = pool; p < &pool[NPROC]; p++) {
+		if (p->state == UNUSED) {
+			goto found;
+		}
+	}
+	return 0;
+
+found:
+	p->pid = allocpid();
+	p->state = USED;
+	memset(&p->context, 0, sizeof(p->context));
+	memset(p->trapframe, 0, PAGE_SIZE);
+	memset((void *)p->kstack, 0, PAGE_SIZE);
+	p->context.ra = (uint64)usertrapret;
+	p->context.sp = p->kstack + PAGE_SIZE;
+	return p;
+}
+
+// Scheduler never returns.  It loops, doing:
+//  - choose a process to run.
+//  - swtch to start running that process.
+//  - eventually that process transfers control
+//    via swtch back to the scheduler.
+void scheduler(void)
+{
+	struct proc *p;
+	for (;;) {
+		for (p = pool; p < &pool[NPROC]; p++) {
+			if (p->state == RUNNABLE) {
+				/*
+				* LAB1: you may need to init proc start time here
+				*/
+				p->state = RUNNING;
+				current_proc = p;
+				swtch(&idle.context, &p->context);
+			}
+		}
+	}
+}
+
+// Switch to scheduler.  Must hold only p->lock
+// and have changed proc->state. Saves and restores
+// intena because intena is a property of this
+// kernel thread, not this CPU. It should
+// be proc->intena and proc->noff, but that would
+// break in the few places where a lock is held but
+// there's no process.
+void sched(void)
+{
+	struct proc *p = curr_proc();
+	if (p->state == RUNNING)
+		panic("sched running");
+	swtch(&p->context, &idle.context);
+}
+
+// Give up the CPU for one scheduling round.
+void yield(void)
+{
+	current_proc->state = RUNNABLE;
+	sched();
+}
+
+// Exit the current process.
+void exit(int code)
+{
+	struct proc *p = curr_proc();
+	infof("proc %d exit with %d", p->pid, code);
+	p->state = UNUSED;
+	finished();
+	sched();
+}