# kernel.ld
BASE_ADDRESS = 0x80200000;
SECTIONS
{
   . = BASE_ADDRESS;
   skernel = .;

   stext = .;
   .text : {
      *(.text.entry)   # 第一行代码
      *(.text .text.*)
   }

   ...
}

enum LOG_COLOR {
	RED = 31,
	GREEN = 32,
	BLUE = 34,
	GRAY = 90,
	YELLOW = 93,
};

#if defined(USE_LOG_ERROR)
#define errorf(fmt, ...)                                               \
	do {                                                               \
		int tid = threadid();                                          \
		printf("\x1b[%dm[%s %d]" fmt "\x1b[0m\n", RED, "ERROR", tid,   \
		       ##__VA_ARGS__);                                         \
	} while (0)
#else

// uCore-Tutorial-Code-2023S/os/sbi.c
const uint64 SBI_CONSOLE_PUTCHAR = 1;

void console_putchar(int c)
{
	sbi_call(SBI_CONSOLE_PUTCHAR, c, 0, 0);
}

// uCore-Tutorial-Code-2023S/os/sbi.c
int inline sbi_call(uint64 which, uint64 arg0, uint64 arg1, uint64 arg2)
{
    // 使用寄存器变量来保存参数值和系统调用编号
    register uint64 a0 asm("a0") = arg0;  // 将 'arg0' 的值保存在寄存器 'a0' 中
    register uint64 a1 asm("a1") = arg1;  // 将 'arg1' 的值保存在寄存器 'a1' 中
    register uint64 a2 asm("a2") = arg2;  // 将 'arg2' 的值保存在寄存器 'a2' 中
    register uint64 a7 asm("a7") = which; // 将 'which' 的值保存在寄存器 'a7' 中
    // 内联汇编代码使用 ecall 指令进行系统调用
    asm volatile(
        "ecall"  // 使用 ecall 指令进行系统调用
        // 在这段代码中，指令 "ecall" 的输入参数是寄存器 a0 a1 a2 和 a7，输出参数是寄存器 a0
        : "=r"(a0)  // 输出操作数：将返回值存储在变量 'a0' 中
        : "r"(a0), "r"(a1), "r"(a2), "r"(a7)  // 输入操作数：传递参数和系统调用编号
        : "memory"  //  "memory" 标志告诉编译器，这条指令可能会修改内存中的数据，需要进行内存屏障操作来保证数据的正确性。 
    );
    return a0;  // 返回存储在变量 'a0' 中的值
}

//include/sbi/sbi_ecall.h
extern struct sbi_ecall_extension ecall_base;
extern struct sbi_ecall_extension ecall_legacy;
extern struct sbi_ecall_extension ecall_time;
extern struct sbi_ecall_extension ecall_rfence;
extern struct sbi_ecall_extension ecall_ipi;
extern struct sbi_ecall_extension ecall_vendor;
extern struct sbi_ecall_extension ecall_hsm;
extern struct sbi_ecall_extension ecall_srst;

int sbi_ecall_init(void)
{
	int ret;
	struct sbi_ecall_extension *ext;
	unsigned long i;

	for (i = 0; i < sbi_ecall_exts_size; i++) {
		ext = sbi_ecall_exts[i];
		ret = sbi_ecall_register_extension(ext);
		if (ret)
			return ret;
	}

	return 0;
}
int sbi_ecall_register_extension(struct sbi_ecall_extension *ext)
{
	struct sbi_ecall_extension *t;

	if (!ext || (ext->extid_end < ext->extid_start) || !ext->handle)
		return SBI_EINVAL;

	sbi_list_for_each_entry(t, &ecall_exts_list, head) {
		unsigned long start = t->extid_start;
		unsigned long end = t->extid_end;
		if (end < ext->extid_start || ext->extid_end < start)
			/* no overlap */;
		else
			return SBI_EINVAL;
	}

	SBI_INIT_LIST_HEAD(&ext->head);
	sbi_list_add_tail(&ext->head, &ecall_exts_list);

	return 0;
}

/**
 * Iterate over list of given type
 * @param pos the type * to use as a loop cursor.
 * @param head the head for your list.
 * @param member the name of the list_struct within the struct.
 */
#define sbi_list_for_each_entry(pos, head, member) \
	for (pos = sbi_list_entry((head)->next, typeof(*pos), member);	\
	     &pos->member != (head); 	\
	     pos = sbi_list_entry(pos->member.next, typeof(*pos), member))

// include/sbi/sbi_ecall.h: 23
struct sbi_ecall_extension {
	struct sbi_dlist head;
	unsigned long extid_start;
	unsigned long extid_end;
	int (* probe)(unsigned long extid, unsigned long *out_val);
	int (* handle)(unsigned long extid, unsigned long funcid,
		       const struct sbi_trap_regs *regs,
		       unsigned long *out_val,
		       struct sbi_trap_info *out_trap);
};

// lib/sbi/sbi_ecall_legacy.c
struct sbi_ecall_extension ecall_legacy = {
	.extid_start = SBI_EXT_0_1_SET_TIMER,
	.extid_end = SBI_EXT_0_1_SHUTDOWN,
	.handle = sbi_ecall_legacy_handler,
};

static int sbi_ecall_legacy_handler(unsigned long extid, unsigned long funcid,
				    const struct sbi_trap_regs *regs,
				    unsigned long *out_val,
				    struct sbi_trap_info *out_trap)
{
	int ret = 0;
	struct sbi_tlb_info tlb_info;
	u32 source_hart = current_hartid();
	ulong hmask = 0;

	switch (extid) {
	case SBI_EXT_0_1_SET_TIMER:
		sbi_timer_event_start((u64)regs->a0);
		break;
	case SBI_EXT_0_1_CONSOLE_PUTCHAR:
		sbi_putc(regs->a0);
		break;
	case SBI_EXT_0_1_CONSOLE_GETCHAR:
		ret = sbi_getc();
		break;
	// ...
	};

	return ret;
}

// include/sbi/sbi_ecall_interface.h
/* SBI Extension IDs */
#define SBI_EXT_0_1_CONSOLE_PUTCHAR		0x1

.PHONY: clean build user
# 设置伪目标clean、build和user，可以通过命令make来执行这些目标

all: build_kernel
# 默认目标为build_kernel，即执行build_kernel目标下的指令

LOG ?= error
# 定义一个变量LOG，默认值是error

K = os
TOOLPREFIX = riscv64-unknown-elf-

CC = $(TOOLPREFIX)gcc
AS = $(TOOLPREFIX)gcc
LD = $(TOOLPREFIX)ld
OBJCOPY = $(TOOLPREFIX)objcopy
OBJDUMP = $(TOOLPREFIX)objdump
PY = python3
GDB = $(TOOLPREFIX)gdb
CP = cp

MKDIR_P = mkdir -p

BUILDDIR = build

C_SRCS = $(wildcard $K/*.c)
# 定义一个变量C_SRCS，使用wildcard函数匹配所有以.c为后缀的文件，并存储在$K目录下

AS_SRCS = $(wildcard $K/*.S)
# 定义一个变量AS_SRCS，使用wildcard函数匹配所有以.S为后缀的文件，并存储在$K目录下

C_OBJS = $(addprefix $(BUILDDIR)/, $(addsuffix .o, $(basename $(C_SRCS))))
# 定义一个变量C_OBJS，通过addprefix和addsuffix函数将$(C_SRCS)中的路径替换为$(BUILDDIR)，并将后缀修改为.o

AS_OBJS = $(addprefix $(BUILDDIR)/, $(addsuffix .o, $(basename $(AS_SRCS))))
# 定义一个变量AS_OBJS，通过addprefix和addsuffix函数将$(AS_SRCS)中的路径替换为$(BUILDDIR)，并将后缀修改为.o

OBJS = $(C_OBJS) $(AS_OBJS)
# 定义一个变量OBJS，其值为$(C_OBJS)和$(AS_OBJS)的组合

HEADER_DEP = $(addsuffix .d, $(basename $(C_OBJS)))
# 定义一个变量HEADER_DEP，通过addsuffix函数将$(C_OBJS)中的后缀修改为.d

-include $(HEADER_DEP)
# 包含$(HEADER_DEP)中的.d文件

CFLAGS = -Wall -Werror -O -fno-omit-frame-pointer -ggdb
# 定义一个变量CFLAGS，并赋值为-Wall -Werror -O -fno-omit-frame-pointer -ggdb

CFLAGS += -MD
# 将-MD选项追加到CFLAGS变量中，用于自动生成依赖关系文件

CFLAGS += -mcmodel=medany
# 将-mcmodel=medany选项追加到CFLAGS变量中，用于指定内存模型

CFLAGS += -ffreestanding -fno-common -nostdlib -mno-relax
# 将-ffreestanding -fno-common -nostdlib -mno-relax选项追加到CFLAGS变量中，用于编译无操作系统环境下的程序

CFLAGS += -I$K
# 将-I$K选项追加到CFLAGS变量中，用于指定头文件搜索路径为$K目录下

CFLAGS += $(shell $(CC) -fno-stack-protector -E -x c /dev/null >/dev/null 2>&1 && echo -fno-stack-protector)
# 将$(CC) -fno-stack-protector -E -x c /dev/null >/dev/null 2>&1 && echo -fno-stack-protector命令执行结果追加到CFLAGS变量中，用于禁用栈保护机制

ifeq ($(LOG), error)
CFLAGS += -D LOG_LEVEL_ERROR
else ifeq ($(LOG), warn)
CFLAGS += -D LOG_LEVEL_WARN
else ifeq ($(LOG), info)
CFLAGS += -D LOG_LEVEL_INFO
else ifeq ($(LOG), debug)
CFLAGS += -D LOG_LEVEL_DEBUG
else ifeq ($(LOG), trace)
CFLAGS += -D LOG_LEVEL_TRACE
endif
# 根据$(LOG)变量的值，向CFLAGS变量追加相应的预处理器选项，相当于添加了一个宏定义，log.h中的LOG_LEVEL_ERROR等宏定义会根据这个宏定义来决定是否生效

# Disable PIE when possible (for Ubuntu 16.10 toolchain)
ifneq ($(shell $(CC) -dumpspecs 2>/dev/null | grep -e '[^f]no-pie'),)
CFLAGS += -fno-pie -no-pie
endif
ifneq ($(shell $(CC) -dumpspecs 2>/dev/null | grep -e '[^f]nopie'),)
CFLAGS += -fno-pie -nopie
endif
# 根据系统环境判断是否支持PIE（位置无关执行）选项，并根据情况向CFLAGS变量追加相应的选项

LDFLAGS = -z max-page-size=4096
# 定义一个变量LDFLAGS，并赋值为-z max-page-size=4096

$(AS_OBJS): $(BUILDDIR)/$K/%.o : $K/%.S
    @mkdir -p $(@D)
    $(CC) $(CFLAGS) -c $< -o $@
# 规则：生成$(AS_OBJS)目标所需的依赖文件$(BUILDDIR)/$K/%.o，依赖于$K/%.S，并通过$(CC)命令编译生成目标文件

$(C_OBJS): $(BUILDDIR)/$K/%.o : $K/%.c  $(BUILDDIR)/$K/%.d
    @mkdir -p $(@D)
    $(CC) $(CFLAGS) -c $< -o $@
# 规则：生成$(C_OBJS)目标所需的依赖文件$(BUILDDIR)/$K/%.o，依赖于$K/%.c和$(BUILDDIR)/$K/%.d，并通过$(CC)命令编译生成目标文件

$(HEADER_DEP): $(BUILDDIR)/$K/%.d : $K/%.c
    @mkdir -p $(@D)
    @set -e; rm -f $@; $(CC) -MM $< $(INCLUDEFLAGS) > $@.$$$$; \
        sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@; \
        rm -f $@.$$$$
# 规则：生成$(HEADER_DEP)目标所需的依赖文件$(BUILDDIR)/$K/%.d，依赖于$K/%.c，并通过$(CC)命令生成依赖关系文件

build: build/kernel
# 定义一个目标build，其依赖于build/kernel

build/kernel: $(OBJS)
    $(LD) $(LDFLAGS) -T os/kernel.ld -o $(BUILDDIR)/kernel $(OBJS)
    $(OBJDUMP) -S $(BUILDDIR)/kernel > $(BUILDDIR)/kernel.asm
    $(OBJDUMP) -t $(BUILDDIR)/kernel | sed '1,/SYMBOL TABLE/d; s/ .* / /; /^$$/d' > $(BUILDDIR)/kernel.sym
    @echo 'Build kernel done'
# 规则：生成build/kernel目标，依赖于$(OBJS)，通过$(LD)命令连接生成kernel，并通过$(OBJDUMP)命令生成汇编文件和符号表

clean:
    rm -rf $(BUILDDIR)

# BOARD
BOARD		?= qemu
SBI			?= rustsbi
BOOTLOADER	:= ./bootloader/rustsbi-qemu.bin

QEMU = qemu-system-riscv64
QEMUOPTS = \
	-nographic \
	-machine virt \
	-bios $(BOOTLOADER) \
	-kernel build/kernel	\

run: build/kernel
	$(QEMU) $(QEMUOPTS)

# QEMU's gdb stub command line changed in 0.11
QEMUGDB = $(shell if $(QEMU) -help | grep -q '^-gdb'; \
	then echo "-gdb tcp::15234"; \
	else echo "-s -p 15234"; fi)

# 启动QEMU并通过GDB调试，此时QEMu会进入后台运行，并暂停执行，等待GDB连接
# 连接的GDB端口为15234
debug: build/kernel .gdbinit
	$(QEMU) $(QEMUOPTS) -S $(QEMUGDB) &
	sleep 1
	$(GDB)

make run
make debug
make clean
# 编译测试用例的前四章
make user CHAPTER=4 LOG=trace
# 编译测试用例的第四章
make user CHAPTER=4_only LOG=trace
# 只运行测试用例的第四章
make test CHAPTER=4_only