코드 1000줄로 운영체제(OS) 만들기 - 1

1
2
3
4
5
6
7

# install tools
brew install llvm lld qemu

# set enviroment vars
$ export PATH="$PATH:$(brew --prefix)/opt/llvm/bin"
$ which llvm-objcopy
/opt/homebrew/opt/llvm/bin/llvm-objcopy

1
2
3
4
5

#instamm tools
sudo apt update && sudo apt install -y clang llvm lld qemu-system-riscv32 curl

# download opensbi
curl -LO https://github.com/qemu/qemu/raw/v8.0.4/pc-bios/opensbi-riscv32-generic-fw_dynamic.bin

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

/* kernel.ld */
/* ELF 바이너리의 시작 지점으로 boot 심볼(함수)를 지정 */
ENTRY(boot)

SECTIONS {

    /* 현재 위치를 0x80200000 으로 설정 */
    /* 이후 섹션은 이 주소를 기준으로 오프셋이 계산 */
    /* 0x80200000 주소는 커널이나 부트로더가 적재되는 주소로 자주 사용 */
    /* 1024 * 1024 *2 = 2,097,152 = 0x20000 즉 2MB 의 여유 */
    . = 0x80200000;

    /* 코드 영역 */
    .text :{
        KEEP(*(.text.boot));
        /* .text와 .text.로 시작하는 모든 섹션을 해당 위치에 배치 */
        *(.text .text.*);
    }

    /* 읽기 전용 데이터 영역, 상수 or const */
    /* 4bytes 정렬 */
    .rodata : ALIGN(4) {
        *(.rodata .rodata.*);
    }

    /* 읽기 쓰기 가능한 데이터 영역 */
    .data : ALIGN(4) {
        *(.data .data.*);
    }

    /* 읽기 쓰기 가능한 전역 변수 영역 */
    /* 시작주소 __bss, 끝 주소  */
    /* . 은 현재 주소를 의미 __xxx 는 심볼 표시 */
    /* 심볼은 c에서 extern 으로 참조 가능 */
    .bss : ALIGN(4) {
        __bss = .;
        *(.bss .bss.* .sbss .sbss.*);
        __bss_end = .;
    }

    /* 스택 공간 확보 */
    /* 커서 정렬 후 4bytes 정렬, 128kb 공간 확보 */
    /* __stack_top 심볼은 스택 포인터 초기화용으로 호출 가능 */
    . = ALIGN(4);
    . += 128 * 1024; /* 128KB */
    __stack_top = .;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

// kernel.c
typedef unsigned char uint8_t;
typedef unsigned int uint32_t;
typedef uint32_t size_t;

// 링커스크립트 ld 에서 정의되는 메모리 주소 심볼
extern char __bss[], __bss_end[], __stack_top[];

// 메모리 초기화 함수
void *memset(void *buf, char c, size_t n) {
    uint8_t *p = (uint8_t *) buf;
    while (n--)
        *p++ = c;
    return buf;
}

// 커널 시작점
// bss 영역 메모리 초기화
// 추후 장치 초기화, 메모리 맵, 인터럽트 등 구성 가능능
void kernel_main(void) {
    memset(__bss, 0, (size_t) __bss_end - (size_t) __bss);

    for (;;);
}

// GNU 확장 인라인 어셈블리 문법
// __asm__ __volatile__ (
//     "assembly instructions"
//     : output_operands
//     : input_operands
//     : clobbered_registers
// );

// __attribute__((naked)): 컴파일러가 인라인 어셈블리 외에 다른 코드를 생성 x
// 또 프롤로그/에필로그 없이 컴파일.
// 즉, push ra, save s0~s11, ret 같은 함수 호출 시 자동 삽입되는 코드가 생략
// section(".text.boot"): 
// boot 함수를 링커 스크립트의 .text.boot에 위치하도록 명시
// mv sp ,%[stack_top]: 스택 포인터를 __stack_top으로 설정
// j kernel_main: kernel_main으로 jump
// : 출력값 x
// : [stack_top] "r" (__stack_top) 
// "r" 일반 목적 레지스터에 담아서 전달하라는 의미
// __stack_top(ld에 선언된 심볼) 값을 임의 레지스터에 입력
// stack_top 이라 alias 를 붙임 %[stack_top] 로 사용
__attribute__((section(".text.boot")))
__attribute__((naked))
void boot(void) {
    __asm__ __volatile__(
        "mv sp, %[stack_top]\n" // Set the stack pointer
        "j kernel_main\n"       // Jump to the kernel main function
        :
        : [stack_top] "r" (__stack_top) // 입력 피연산자
    );
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#!/bin/bash
set -xue

QEMU=qemu-system-riscv32

# clang 경로와 컴파일 옵션
# 현재 필자는 clang이 환경변수에 등록돼있으므로 컴파일로 위치는 clang으로 충분하다
# 만약 동작하지 않는다면 which clang 명령어로 정확한 위치를 확인해보자.
CC=clang
CFLAGS="-std=c11 -O2 -g3 -Wall -Wextra --target=riscv32-unknown-elf -fno-stack-protector -ffreestanding -nostdlib"

# 커널 빌드
$CC $CFLAGS -Wl,-Tkernel.ld -Wl,-Map=kernel.map -o kernel.elf kernel.c

# QEMU 실행
$QEMU -machine virt -bios default -nographic -serial mon:stdio --no-reboot -kernel kernel.elf

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

원본 결과 

kernel.elf:	file format elf32-littleriscv

Disassembly of section .text:

80200000 <boot>:
80200000: 37 05 22 80  	lui	a0, 0x80220
80200004: 13 05 c5 04  	addi	a0, a0, 0x4c
80200008: 2a 81        	mv	sp, a0
8020000a: 6f 00 a0 01  	j	0x80200024 <kernel_main>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

내 결과

80200024 <kernel_main>:
80200024: 37 05 20 80  	lui	a0, 0x80200
80200028: 13 05 c5 04  	addi	a0, a0, 0x4c
8020002c: b7 05 20 80  	lui	a1, 0x80200
80200030: 93 85 c5 04  	addi	a1, a1, 0x4c
80200034: 33 86 a5 40  	sub	a2, a1, a0
80200038: 01 ca        	beqz	a2, 0x80200048 <kernel_main+0x24>
8020003a: 13 06 15 00  	addi	a2, a0, 0x1
8020003e: 23 00 05 00  	sb	zero, 0x0(a0)
80200042: 32 85        	mv	a0, a2
80200044: e3 1b b6 fe  	bne	a2, a1, 0x8020003a <kernel_main+0x16>
80200048: 01 a0        	j	0x80200048 <kernel_main+0x24>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

#include "kernel.h"

typedef unsigned char uint8_t;
typedef unsigned int uint32_t;
typedef uint32_t size_t;

// new
// Supervisor Binary Interface(SBI)를 통해 ecall 요청 코드
// fid: Function ID Extension 내의 세부 기능 식별
// eid: extension ID 어떤 SBI Extension을 호출할지
// eid 1 : Console I/O 확장 기능, fid 0 : 문자 1개 출력 함수
struct sbiret sbi_call(long arg0, long arg1, long arg2, long arg3, long arg4,
                       long arg5, long fid, long eid) {
    register long a0 __asm__("a0") = arg0;
    register long a1 __asm__("a1") = arg1;
    register long a2 __asm__("a2") = arg2;
    register long a3 __asm__("a3") = arg3;
    register long a4 __asm__("a4") = arg4;
    register long a5 __asm__("a5") = arg5;
    register long a6 __asm__("a6") = fid;
    register long a7 __asm__("a7") = eid;

    // ecall 명령어, SBI 함수 호출
    // ecall: RISC-V 에서 System Call을 트리거
    // "=r"(a0), "=r"(a1) 을 출력하는데, c에서 리턴하고있음.
    // : "memory": 메모리를 클로버, 메모리에 영향을 미침을 알림
    // 컴파일러에게 알려주는 역할
    __asm__ __volatile__("ecall"
                         : "=r"(a0), "=r"(a1)
                         : "r"(a0), "r"(a1), "r"(a2), "r"(a3), "r"(a4), "r"(a5),
                           "r"(a6), "r"(a7)
                         : "memory");
    return (struct sbiret){.error = a0, .value = a1};
}

// new
void putchar(char ch) {
    // fid 0, eid 1 호출
    sbi_call(ch, 0, 0, 0, 0, 0, 0, 1 /* Console Putchar */);
}

void *memset(void *buf, char c, size_t n) {
    uint8_t *p = (uint8_t *) buf;
    while (n--)
        *p++ = c;
    return buf;
}

void kernel_main(void) {

    // new
    const char *s = "\n\nHello World!\n";
    for (int i = 0; s[i] != '\0'; i++) {
        putchar(s[i]);
    }

    // new, cpu를 wfi 상태로 대기
    for (;;) {
        __asm__ __volatile__("wfi");
    }
}

__attribute__((section(".text.boot")))
__attribute__((naked))
void boot(void) {
    __asm__ __volatile__(
        "mv sp, %[stack_top]\n" // Set the stack pointer
        "j kernel_main\n"       // Jump to the kernel main function
        :
        : [stack_top] "r" (__stack_top) // Pass the stack top address as %[stack_top]
    );
}

1
2
3
4
5
6
7

//kernel.h
#pragma once

struct sbiret {
    long error;
    long value;
};

1
2
3
4
5
6

#include<stdio.h>
int main()
{
    printf("hello world!");
    return 0
}

1
2
3
4
5
6
7
8
9

//common.h
#pragma once

#define va_list  __builtin_va_list
#define va_start __builtin_va_start
#define va_end   __builtin_va_end
#define va_arg   __builtin_va_arg

void printf(const char *fmt, ...);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

// common.c
#include "common.h"

void printf(const char *fmt, ...) {
    va_list vargs;
    va_start(vargs, fmt);

    while (*fmt) {
        if (*fmt == '%') {
            fmt++; // Skip '%'
            switch (*fmt) { // Read the next character
                case '\0': // '%' at the end of the format string
                    putchar('%');
                    goto end;
                case '%': // Print '%'
                    putchar('%');
                    break;
                case 's': { // Print a NULL-terminated string.
                    const char *s = va_arg(vargs, const char *);
                    while (*s) {
                        putchar(*s);
                        s++;
                    }
                    break;
                }
                case 'd': { // Print an integer in decimal.
                    int value = va_arg(vargs, int);
                    unsigned magnitude = value; // https://github.com/nuta/operating-system-in-1000-lines/issues/64
                    if (value < 0) {
                        putchar('-');
                        magnitude = -magnitude;
                    }

                    unsigned divisor = 1;
                    while (magnitude / divisor > 9)
                        divisor *= 10;

                    while (divisor > 0) {
                        putchar('0' + magnitude / divisor);
                        magnitude %= divisor;
                        divisor /= 10;
                    }

                    break;
                }
                case 'x': { // Print an integer in hexadecimal.
                    unsigned value = va_arg(vargs, unsigned);
                    for (int i = 7; i >= 0; i--) {
                        unsigned nibble = (value >> (i * 4)) & 0xf;
                        putchar("0123456789abcdef"[nibble]);
                    }
                }
            }
        } else {
            putchar(*fmt);
        }

        fmt++;
    }

end:
    va_end(vargs);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// kernel.c

#include "kernel.h"
#include "common.h"

// ... 중간 생략

void kernel_main(void) {
    
    //new
    printf("\nHello %s\n", "World!\n");
    printf("1 + 2 = %d, %x \n", 1+2, 0x1234abcd);

    for (;;) {
        __asm__ __volatile__("wfi");
    }
}

// .. 뒤 생략

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#!/bin/bash
set -xue

QEMU=qemu-system-riscv32

# clang 경로와 컴파일 옵션
CC=clang  # Ubuntu 등 환경에 따라 경로 조정: CC=clang
CFLAGS="-std=c11 -O2 -g3 -Wall -Wextra --target=riscv32-unknown-elf -fno-stack-protector -ffreestanding -nostdlib"

# 커널 빌드, common.c 추가
$CC $CFLAGS -Wl,-Tkernel.ld -Wl,-Map=kernel.map -o kernel.elf kernel.c common.c

# QEMU 실행
$QEMU -machine virt -bios default -nographic -serial mon:stdio --no-reboot -kernel kernel.elf

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

//common.h
typedef int bool;
typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
typedef unsigned long long uint64_t;
typedef uint32_t size_t;
typedef uint32_t paddr_t;
typedef uint32_t vaddr_t;

#define true  1
#define false 0
#define NULL  ((void *) 0)
#define align_up(value, align)   __builtin_align_up(value, align)
#define is_aligned(value, align) __builtin_is_aligned(value, align)
#define offsetof(type, member)   __builtin_offsetof(type, member)
#define va_list  __builtin_va_list
#define va_start __builtin_va_start
#define va_end   __builtin_va_end
#define va_arg   __builtin_va_arg

void *memset(void *buf, char c, size_t n);
void *memcpy(void *dst, const void *src, size_t n);
char *strcpy(char *dst, const char *src);
int strcmp(const char *s1, const char *s2);
void printf(const char *fmt, ...);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

// 메모리 복사
void *memcpy(void *dst, const void *src, size_t n) {
    uint8_t *d = (uint8_t *) dst;
    const uint8_t *s = (const uint8_t *) src;
    while (n--)
        *d++ = *s++;
    return dst;
}

// 메모리 초기화
void *memset(void *buf, char c, size_t n) {
    uint8_t *p = (uint8_t *) buf;
    while (n--)
        *p++ = c;
    return buf;
}

// 문자열 복사
char *strcpy(char *dst, const char *src) {
    char *d = dst;
    while (*src)
        *d++ = *src++;
    *d = '\0';
    return dst;
}

// 문자열 비교
int strcmp(const char *s1, const char *s2) {
    while (*s1 && *s2) {
        if (*s1 != *s2)
            break;
        s1++;
        s2++;
    }

    return *(unsigned char *)s1 - *(unsigned char *)s2;
}

1
2
3
4
5
6
7
8

//kernel.h

// 커널 패닉 발생 시 파일 명과 라인을 출력
#define PANIC(fmt, ...)                                                        \
    do {                                                                       \
        printf("PANIC: %s:%d: " fmt "\n", __FILE__, __LINE__, ##__VA_ARGS__);  \
        while (1) {}                                                           \
    } while (0)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// kernel.c

// ... 중간 생략

void kernel_main(void) {
    ...
    PANIC("booted!");
    printf("unreachable here!\n");
}

// ... 뒤도 생략

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

// kernel.c
__attribute__((naked))
__attribute__((aligned(4)))
void kernel_entry(void) {
    
    __asm__ __volatile__(
        // sscratch에 현재 스택포인터(sp) 저장
        "csrw sscratch, sp\n"
        // aligned(4)이므로 -4 * 31만큼 스택 포인터 위치 변경
        // 스택은 높은 주소에서 낮은주소로 이동하기때문에 -
        "addi sp, sp, -4 * 31\n"
        // sw: store word, 32 bits(4 bytes) 값을 메모리에 저장
        "sw ra,  4 * 0(sp)\n"
        "sw gp,  4 * 1(sp)\n"
        "sw tp,  4 * 2(sp)\n"
        "sw t0,  4 * 3(sp)\n"
        "sw t1,  4 * 4(sp)\n"
        "sw t2,  4 * 5(sp)\n"
        "sw t3,  4 * 6(sp)\n"
        "sw t4,  4 * 7(sp)\n"
        "sw t5,  4 * 8(sp)\n"
        "sw t6,  4 * 9(sp)\n"
        "sw a0,  4 * 10(sp)\n"
        "sw a1,  4 * 11(sp)\n"
        "sw a2,  4 * 12(sp)\n"
        "sw a3,  4 * 13(sp)\n"
        "sw a4,  4 * 14(sp)\n"
        "sw a5,  4 * 15(sp)\n"
        "sw a6,  4 * 16(sp)\n"
        "sw a7,  4 * 17(sp)\n"
        "sw s0,  4 * 18(sp)\n"
        "sw s1,  4 * 19(sp)\n"
        "sw s2,  4 * 20(sp)\n"
        "sw s3,  4 * 21(sp)\n"
        "sw s4,  4 * 22(sp)\n"
        "sw s5,  4 * 23(sp)\n"
        "sw s6,  4 * 24(sp)\n"
        "sw s7,  4 * 25(sp)\n"
        "sw s8,  4 * 26(sp)\n"
        "sw s9,  4 * 27(sp)\n"
        "sw s10, 4 * 28(sp)\n"
        "sw s11, 4 * 29(sp)\n"
        // csrr: Control and Status Register: 특정 CSR 값을 읽는 명령
        // a0에 ssaratch 값  저장, 여기서는 스택포인터 값을 a0에 저장
        // sscratch 에는 -4 * 31 하기 전 원래 sp 값이 저장되어 있음
        "csrr a0, sscratch\n"
        // ap 의 값을 다시 메모리에 저장
        "sw a0, 4 * 30(sp)\n"

        // 현재 sp ( sp_original - 4*31 ) 을 a0에 저장하고 handle_trap 함수에 전달
        "mv a0, sp\n"
        // handle_trap 함수 호출
        "call handle_trap\n"

        // 아마 load word, handle_trap 처리가 끝다고 메모리에 저장된 값 로드
        "lw ra,  4 * 0(sp)\n"
        "lw gp,  4 * 1(sp)\n"
        "lw tp,  4 * 2(sp)\n"
        "lw t0,  4 * 3(sp)\n"
        "lw t1,  4 * 4(sp)\n"
        "lw t2,  4 * 5(sp)\n"
        "lw t3,  4 * 6(sp)\n"
        "lw t4,  4 * 7(sp)\n"
        "lw t5,  4 * 8(sp)\n"
        "lw t6,  4 * 9(sp)\n"
        "lw a0,  4 * 10(sp)\n"
        "lw a1,  4 * 11(sp)\n"
        "lw a2,  4 * 12(sp)\n"
        "lw a3,  4 * 13(sp)\n"
        "lw a4,  4 * 14(sp)\n"
        "lw a5,  4 * 15(sp)\n"
        "lw a6,  4 * 16(sp)\n"
        "lw a7,  4 * 17(sp)\n"
        "lw s0,  4 * 18(sp)\n"
        "lw s1,  4 * 19(sp)\n"
        "lw s2,  4 * 20(sp)\n"
        "lw s3,  4 * 21(sp)\n"
        "lw s4,  4 * 22(sp)\n"
        "lw s5,  4 * 23(sp)\n"
        "lw s6,  4 * 24(sp)\n"
        "lw s7,  4 * 25(sp)\n"
        "lw s8,  4 * 26(sp)\n"
        "lw s9,  4 * 27(sp)\n"
        "lw s10, 4 * 28(sp)\n"
        "lw s11, 4 * 29(sp)\n"
        // sp(스택 포인터)에 원래 주소값 저장
        "lw sp,  4 * 30(sp)\n"
        // return
        "sret\n"
    );
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// kernel.c

// handle_trap 함수 구현체
void handle_trap(struct trap_frame *f) {
    // scause, stval, sepc는 모두 레지스터 
    // scause는 trap (예외 or 인터럽트)의 원인 코드를 담고 있음
    uint32_t scause = READ_CSR(scause);
    // stval에는 trap 당시의 메모리 주소가 저장됨
    uint32_t stval = READ_CSR(stval);
    // sepc는는 trap 당시의 porgram counter 가 저장됨
    uint32_t user_pc = READ_CSR(sepc);

    // 즉 결론적으로 커널 패닉 메시지로 원인코드, 메모리주소, pc를 출력함
    PANIC("unexpected trap scause=%x, stval=%x, sepc=%x\n", scause, stval, user_pc);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

// kernel.h

struct trap_frame {
    uint32_t ra;
    uint32_t gp;
    uint32_t tp;
    uint32_t t0;
    uint32_t t1;
    uint32_t t2;
    uint32_t t3;
    uint32_t t4;
    uint32_t t5;
    uint32_t t6;
    uint32_t a0;
    uint32_t a1;
    uint32_t a2;
    uint32_t a3;
    uint32_t a4;
    uint32_t a5;
    uint32_t a6;
    uint32_t a7;
    uint32_t s0;
    uint32_t s1;
    uint32_t s2;
    uint32_t s3;
    uint32_t s4;
    uint32_t s5;
    uint32_t s6;
    uint32_t s7;
    uint32_t s8;
    uint32_t s9;
    uint32_t s10;
    uint32_t s11;
    uint32_t sp;
} __attribute__((packed));

// csrr: Control and Status Register Read, reg 값을 읽어 __tmp로 리턴
// 전처리에서 #연산자를 통해 입력문자열을 동적으로 처리 #reg
#define READ_CSR(reg)                                                          \
    ({                                                                         \
        unsigned long __tmp;                                                   \
        __asm__ __volatile__("csrr %0, " #reg : "=r"(__tmp));                  \
        __tmp;                                                                 \
    })

// csrr: Control and Status Register Write, 입력 값을 reg에 할당
// 이 코드 실행 결과는 다음 어셈블리와 같다
// li a0, 0xdeadbeef
// csrw sepc, a0  
// __tmp는 임의의 일반 레지스터에 할당한다는 의미
// __asm__은 인라인 어셈블리 명령 다음 문자열을 assembly로 그대로 컴파일러에 삽임
// __volatilie__은 최적화 방지 플래그, 컴파일러가 자동으로 최적화하지 않도록함
// :: "r"(__tmp)
// 이건 GCC 인라인 어셈블리 제약 조건 부분입니다.

// : 앞이 없음 → 출력 없음
// :: → 입력만 있음
// "r" → 레지스터에 담아달라는 뜻 (즉, __tmp는 일반 레지스터에 값을 할당)
// 즉, 컴파일러가 __tmp 값을 적절한 레지스터 (예: a0, t0)에 자동 배치해주고,
// 어셈블리 안에서는 %0으로 그 레지스터를 참조하게 됨.

#define WRITE_CSR(reg, value)                                                  \
    do {                                                                       \
        uint32_t __tmp = (value);                                              \
        __asm__ __volatile__("csrw " #reg ", %0" ::"r"(__tmp));                \
    } while (0)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

//kernel.c
void kernel_main(void) {
    memset(__bss, 0, (size_t) __bss_end - (size_t) __bss);
    
    // new
    // stvec를 설정 후 
    // stvec: trap 발생 시 어디로 점프할지 지정하는 코드, 위에서 정의한 kernel_entry 함수로 점프한다.
    WRITE_CSR(stvec, (uint32_t) kernel_entry); // new
    // 커널 패닉을 일으키는 코드, unimp 명령의 고의 에러를 일으킨다.
    __asm__ __volatile__("unimp"); // new
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

ENTRY(boot)

SECTIONS {

    . = 0x80200000;

    .text :{
        KEEP(*(.text.boot));
        *(.text .text.*);
    }

    .rodata : ALIGN(4) {
        *(.rodata .rodata.*);
    }

    .data : ALIGN(4) {
        *(.data .data.*);
    }

    .bss : ALIGN(4) {
        __bss = .;
        *(.bss .bss.* .sbss .sbss.*);
        __bss_end = .;
    }

    . = ALIGN(4);
    . += 128 * 1024; /* 128KB */
    __stack_top = .;

    /* new */
    . = ALIGN(4096);
    __free_ram = .;
    . += 64 * 1024 * 1024; /* 64MB */
    __free_ram_end = .;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// kernel.c
extern char __free_ram[], __free_ram_end[];

paddr_t alloc_pages(uint32_t n) {
    static paddr_t next_paddr = (paddr_t) __free_ram;
    paddr_t paddr = next_paddr;
    next_paddr += n * PAGE_SIZE;

    if (next_paddr > (paddr_t) __free_ram_end)
        PANIC("out of memory");

    memset((void *) paddr, 0, n * PAGE_SIZE);
    return paddr;
}

1
2

//common.h
#define PAGE_SIZE 4096

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// kernel.c
void kernel_main(void) {
    memset(__bss, 0, (size_t) __bss_end - (size_t) __bss);

    paddr_t paddr0 = alloc_pages(2);
    paddr_t paddr1 = alloc_pages(1);
    printf("alloc_pages test: paddr0=%x\n", paddr0);
    printf("alloc_pages test: paddr1=%x\n", paddr1);

    PANIC("booted!");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

//kernel.h
#define PROCS_MAX 8       // 최대 프로세스 개수

#define PROC_UNUSED   0   // 사용되지 않는 프로세스 구조체
#define PROC_RUNNABLE 1   // 실행 가능한(runnable) 프로세스

struct process {
    int pid;             // 프로세스 ID
    int state;           // 프로세스 상태: PROC_UNUSED 또는 PROC_RUNNABLE
    vaddr_t sp;          // 스택 포인터
    uint8_t stack[8192]; // 커널 스택
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

__attribute__((naked)) void switch_context(uint32_t *prev_sp,
                                           uint32_t *next_sp) {
    __asm__ __volatile__(
        // 현재 프로세스의 스택에 callee-saved 레지스터를 저장
        "addi sp, sp, -13 * 4\n" // 13개(4바이트씩) 레지스터 공간 확보
        "sw ra,  0  * 4(sp)\n"   // callee-saved 레지스터만 저장
        "sw s0,  1  * 4(sp)\n"
        "sw s1,  2  * 4(sp)\n"
        "sw s2,  3  * 4(sp)\n"
        "sw s3,  4  * 4(sp)\n"
        "sw s4,  5  * 4(sp)\n"
        "sw s5,  6  * 4(sp)\n"
        "sw s6,  7  * 4(sp)\n"
        "sw s7,  8  * 4(sp)\n"
        "sw s8,  9  * 4(sp)\n"
        "sw s9,  10 * 4(sp)\n"
        "sw s10, 11 * 4(sp)\n"
        "sw s11, 12 * 4(sp)\n"

        // 스택 포인터 교체
        "sw sp, (a0)\n"         // *prev_sp = sp
        "lw sp, (a1)\n"         // sp를 다음 프로세스의 값으로 변경

        // 다음 프로세스 스택에서 callee-saved 레지스터 복원
        "lw ra,  0  * 4(sp)\n"  
        "lw s0,  1  * 4(sp)\n"
        "lw s1,  2  * 4(sp)\n"
        "lw s2,  3  * 4(sp)\n"
        "lw s3,  4  * 4(sp)\n"
        "lw s4,  5  * 4(sp)\n"
        "lw s5,  6  * 4(sp)\n"
        "lw s6,  7  * 4(sp)\n"
        "lw s7,  8  * 4(sp)\n"
        "lw s8,  9  * 4(sp)\n"
        "lw s9,  10 * 4(sp)\n"
        "lw s10, 11 * 4(sp)\n"
        "lw s11, 12 * 4(sp)\n"
        "addi sp, sp, 13 * 4\n" 
        "ret\n"
    );
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

//kernel.c
struct process procs[PROCS_MAX]; // 모든 프로세스 제어 구조체 배열

struct process *create_process(uint32_t pc) {
    // 미사용(UNUSED) 상태의 프로세스 구조체 찾기
    struct process *proc = NULL;
    int i;
    for (i = 0; i < PROCS_MAX; i++) {
        if (procs[i].state == PROC_UNUSED) {
            proc = &procs[i];
            break;
        }
    }

    if (!proc)
        PANIC("no free process slots");
   // 첫 컨텍스트 스위치 시, switch_context에서 이 값들을 복원함
   // 스택 프레임 구성
   // stack은 높은 주소에서 낮은 주소로 자라므로 --
    uint32_t *sp = (uint32_t *) &proc->stack[sizeof(proc->stack)];
    *--sp = 0;                      // s11
    *--sp = 0;                      // s10
    *--sp = 0;                      // s9
    *--sp = 0;                      // s8
    *--sp = 0;                      // s7
    *--sp = 0;                      // s6
    *--sp = 0;                      // s5
    *--sp = 0;                      // s4
    *--sp = 0;                      // s3
    *--sp = 0;                      // s2
    *--sp = 0;                      // s1
    *--sp = 0;                      // s0
    // 현재 Program Counter(PC) 저장, 프로세스 실행 시 jump 할 주소
    *--sp = (uint32_t) pc;          // ra (처음 실행 시 점프할 주소)
    // 커널 스택에 callee-saved 레지스터 공간을 미리 준비
 

    // process 구조체 필드 초기화
    proc->pid = i + 1;
    proc->state = PROC_RUNNABLE;
    proc->sp = (uint32_t) sp;
    return proc;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

// kernel.c
// delay에 원본 글보다 0을 하나 추가했는데, 만약 너무 느리다면 수치르 좀 줄여주자
void delay(void) {
    for (int i = 0; i < 300000000; i++)
        __asm__ __volatile__("nop"); // do nothing
}

struct process *proc_a;
struct process *proc_b;

void proc_a_entry(void) {
    printf("starting process A\n");
    while (1) {
        putchar('A');
        switch_context(&proc_a->sp, &proc_b->sp);
        delay();
    }
}

void proc_b_entry(void) {
    printf("starting process B\n");
    while (1) {
        putchar('B');
        switch_context(&proc_b->sp, &proc_a->sp);
        delay();
    }
}

void kernel_main(void) {
    memset(__bss, 0, (size_t) __bss_end - (size_t) __bss);

    // trap 발생 시 jump 할 위치 지정
    WRITE_CSR(stvec, (uint32_t) kernel_entry);

    // 함수의 시작 주소를 인자로 전달한다. 
    proc_a = create_process((uint32_t) proc_a_entry);
    proc_b = create_process((uint32_t) proc_b_entry);
    proc_a_entry();

    PANIC("unreachable here!");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// kernel.c
struct process *current_proc; // 현재 실행 중인 프로세스
struct process *idle_proc;    // Idle 프로세스

void yield(void) {
    // 실행 가능한 프로세스를 탐색
    struct process *next = idle_proc;
    for (int i = 0; i < PROCS_MAX; i++) {
        // Round Robin(RR) 스케쥴링
        struct process *proc = &procs[(current_proc->pid + i) % PROCS_MAX];
        if (proc->state == PROC_RUNNABLE && proc->pid > 0) {
            next = proc;
            break;
        }
    }

    // 현재 프로세스 말고는 실행 가능한 프로세스가 없으면, 그냥 리턴
    if (next == current_proc)
        return;

    // 컨텍스트 스위칭
    struct process *prev = current_proc;
    current_proc = next;

    // context switch 시 stack 변경
    __asm__ __volatile__(
        "csrw sscratch, %[sscratch]\n"
        :
        : [sscratch] "r" ((uint32_t) &next->stack[sizeof(next->stack)])
          
    );

    switch_context(&prev->sp, &next->sp);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

void kernel_entry(void) {
    __asm__ __volatile__(
        //fix
        "csrrw sp, sscratch, sp\n"

        "addi sp, sp, -4 * 31\n"
        "sw ra,  4 * 0(sp)\n"
        // ... 중간 생략
        "sw s11, 4 * 29(sp)\n"

        "csrr a0, sscratch\n"
        "sw a0,  4 * 30(sp)\n"

        // NEW
        // Reset the kernel stack.
        "addi a0, sp, 4 * 31\n"
        "csrw sscratch, a0\n"

        "mv a0, sp\n"
        "call handle_trap\n"

        // ~ continue
}

1
2
3

temp = sp;
sp = sscratch;
sscratch = temp;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

void kernel_main(void) {
    memset(__bss, 0, (size_t) __bss_end - (size_t) __bss);

    printf("\n\n");

    WRITE_CSR(stvec, (uint32_t) kernel_entry);

    // idle 프로세스를 0번으로 실행
    idle_proc = create_process((uint32_t) NULL);
    idle_proc->pid = 0; // idle
    current_proc = idle_proc;

    proc_a = create_process((uint32_t) proc_a_entry);
    proc_b = create_process((uint32_t) proc_b_entry);

    // 프로세스 생성 후 yield 호출로 프로세스 스케쥴링 시작
    yield();
    PANIC("switched to idle process");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

void proc_a_entry(void) {
    printf("starting process A\n");
    while (1) {
        putchar('A');
        // 원본 글에는 delay가 없지만 너무 빨라서 추가해줬다.
        delay();
        yield();
    }
}

void proc_b_entry(void) {
    printf("starting process B\n");
    while (1) {
        putchar('B');
        // 원본 글에는 delay가 없지만 너무 빨라서 추가해줬다.
        delay();
        yield();
    }
}

1
2
3
4
5
6
7

// kernel.h
#define SATP_SV32 (1u << 31)
#define PAGE_V    (1 << 0)   // "Valid" 비트 (엔트리가 유효함을 의미)
#define PAGE_R    (1 << 1)   // 읽기 가능
#define PAGE_W    (1 << 2)   // 쓰기 가능
#define PAGE_X    (1 << 3)   // 실행 가능
#define PAGE_U    (1 << 4)   // 사용자 모드 접근 가능

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39