【Create my OS】5 内核线程

// kernel/context.h

// 线程运行上下文
typedef struct {
    usize ra;
    usize satp;
    usize s[12];
    InterruptContext ic;
} ThreadContext;

// kernel/thread.h

// 线程结构定义
typedef struct {
    // 线程上下文存储的地址
    usize contextAddr;
    // 线程栈底地址
    usize kstack;
} Thread;

// kernel/thread.c

/*
 * 该函数用于切换上下文，保存当前函数的上下文，并恢复目标函数的上下文
 * 输入：线程上下文存储的地址（由于目标线程切换前最后是保存在栈上的，所以该地址即栈顶地址）
 * 输出：函数返回时即返回到了新线程的运行位置
 * naked 防止 gcc 在函数执行前后自动插入开场白和结束语，函数调用保存寄存器和栈指针这部分我们自行设计
 * noinline 防止 gcc 将函数内联，有些编译器为了避免跳转、返回，会将函数优化为内联，上下文切换借助了函数调用返回，不应内联
 */
__attribute__((naked, noinline)) void
switchContext(usize *self, usize *target)
{
    asm volatile(".include \"kernel/switch.asm\"");     // 调用汇编指令切换线程
}

// 线程切换
void
switchThread(Thread *self, Thread *target)
{
    switchContext(&self->contextAddr, &target->contextAddr);
}

.equ XLENB, 8   # 寄存器字节数为8

    addi  sp, sp, (-XLENB*14)   # 分配栈空间
    sd sp, 0(a0)                # a0为传入的“当前线程上下文存储地址“，栈指针移动后更新上下文地址
    sd ra, 0*XLENB(sp)          # 将寄存器 ra 保存到栈上
    sd s0, 2*XLENB(sp)          # s0-s11
    sd s1, 3*XLENB(sp)
    sd s2, 4*XLENB(sp)
    sd s3, 5*XLENB(sp)
    sd s4, 6*XLENB(sp)
    sd s5, 7*XLENB(sp)
    sd s6, 8*XLENB(sp)
    sd s7, 9*XLENB(sp)
    sd s8, 10*XLENB(sp)
    sd s9, 11*XLENB(sp)
    sd s10, 12*XLENB(sp)
    sd s11, 13*XLENB(sp)
    csrr  s11, satp
    sd s11, 1*XLENB(sp)         # satp

    ld sp, 0(a1)                # 将“目标线程上下文存储地址”传入sp
    ld s11, 1*XLENB(sp)         
    csrw satp, s11              # 恢复 satp
    sfence.vma                  # 刷新TLB，使新配置页表生效
    ld ra, 0*XLENB(sp)          # 恢复 ra
    ld s0, 2*XLENB(sp)          # 恢复s0-s11
    ld s1, 3*XLENB(sp)
    ld s2, 4*XLENB(sp)
    ld s3, 5*XLENB(sp)
    ld s4, 6*XLENB(sp)
    ld s5, 7*XLENB(sp)
    ld s6, 8*XLENB(sp)
    ld s7, 9*XLENB(sp)
    ld s8, 10*XLENB(sp)
    ld s9, 11*XLENB(sp)
    ld s10, 12*XLENB(sp)
    ld s11, 13*XLENB(sp)
    addi sp, sp, (XLENB*14)     # 释放目标线程存储寄存器的栈空间

    sd zero, 0(a1)              # 清除a1寄存器
    ret

// kernel/consts.h

#define KERNEL_STACK_SIZE   0x80000             /* 内核栈大小 128M */

// kernel/thread.c
/* 
 * 构建内核线程的内核栈
 * 输出栈空间的起始地址
*/
usize
newKernelStack()
{
    /* 将内核线程的线程栈分配在内核堆中 */
    usize bottom = (usize)kalloc(KERNEL_STACK_SIZE);    // 在内核堆上分配内存
    return bottom;
}

// kernel/thread.c

/*
 * 将线程上下文依次压入栈顶
 * 并返回新的栈顶地址，即线程上下文地址
*/
usize
pushContextToStack(ThreadContext self, usize stackTop)
{
    // 分配栈空间 -> 转换指针类型
    ThreadContext *ptr = (ThreadContext *)(stackTop - sizeof(ThreadContext));
    *ptr = self;
    return (usize)ptr;
}

/*
 * 创建新的内核线程上下文，并将线程上下文入栈
 * 借助中断恢复机制进行线程的初始化工作，即从中断恢复结束时即跳转到sepc，就是线程的入口点
 * 输入：线程入口点；内核线程线程栈顶；内核线程页表
 * 输出：线程上下文地址
*/
usize
newKernelThreadContext(usize entry, usize kernelStackTop, usize satp)
{
    InterruptContext ic;
    ic.x[2] = kernelStackTop;       // 设置sp寄存器为内核栈顶
    ic.sepc = entry;                // 中断返回地址为线程入口点
    ic.sstatus = r_sstatus();
    /* 内核线程，返回后特权级为 S-Mode */
    ic.sstatus |= SSTATUS_SPP;
    /* 开启新线程异步中断使能 */
    ic.sstatus |= SSTATUS_SPIE;     // 中断处理发生前的SIE值
    ic.sstatus &= ~SSTATUS_SIE;     // 禁用SIE，不想立即开启中断
    // 创建新线程上下文
    ThreadContext tc;
    // 借助中断的恢复机制，来初始化新线程的每个寄存器，从 Context 中恢复所有寄存器
    extern void __restore(); tc.ra = (usize)__restore;
    tc.satp = satp;                 // 设置页表
    tc.ic = ic;
    return pushContextToStack(tc, kernelStackTop);
}

// kernel/thread.c

// 为线程传入初始化参数
// 我们利用中断恢复过程来填充寄存器，所以将参数保存到ic
void
appendArguments(Thread *thread, usize args[8])
{
    ThreadContext *ptr = (ThreadContext *)thread->contextAddr;
    ptr->ic.x[10] = args[0];
    ptr->ic.x[11] = args[1];
    ptr->ic.x[12] = args[2];
    ptr->ic.x[13] = args[3];
    ptr->ic.x[14] = args[4];
    ptr->ic.x[15] = args[5];
    ptr->ic.x[16] = args[6];
    ptr->ic.x[17] = args[7];
}

// kernel/thread.c

/*
 * 创建新的内核线程
 * 创建内核栈，创建上下文
*/
Thread
newKernelThread(usize entry)
{
    // 构建内核线程的内核栈
    usize stackBottom = newKernelStack();
    // 创建新的内核线程上下文
    usize contextAddr = newKernelThreadContext(
        entry,                              // 线程入口点
        stackBottom + KERNEL_STACK_SIZE,    // 内核栈顶
        r_satp()                            // 创建的内核线程与启动线程同属于一个进程，所以直接获取satp赋值
    );
    Thread t = {    // 线程上下文地址， 线程栈底地址
        contextAddr, stackBottom
    };
    return t;
}

// kernle/riscv.h

static inline uint64
r_satp()
{
    uint64 x;
    asm volatile("csrr %0, satp" : "=r" (x) );
    return x;
}

// kernel/thread.c

// 测试函数，作为新线程入口点
void
tempThreadFunc(Thread *from, Thread *current, usize c)
{
    printf("The char passed by is ");
    consolePutchar(c);              // 向终端输出字符
    consolePutchar('\n');
    printf("Hello world from tempThread!\n");
    switchThread(current, from);    // 手动线程切换回去
}

// 构造空结构Thread表示当前启动线程
// 在调用 switchThread() 函数时，会将当前线程的上下文信息保存到这个线程结构中
Thread
newBootThread()
{
    Thread t = {
        0L, 0L
    };
    return t;
}

// kernel/thread.c

// 测试线程切换
void
initThread()
{
    // 构建新的启动线程
    Thread bootThread = newBootThread();    
    // 构建新内核线程，入口点为测试函数
    Thread tempThread = newKernelThread((usize)tempThreadFunc); 
    usize args[8];
    args[0] = (usize)&bootThread;
    args[1] = (usize)&tempThread;
    args[2] = (long)'M';
    // 新内核线程参数初始化，将参数传入到tc.ic，switchContext恢复完后会借助中断初始化恢复寄存器，实现传参
    appendArguments(&tempThread, args);     
    switchThread(&bootThread, &tempThread); // 线程切换，即线程栈和上下文切换
    printf("I'm back from tempThread!\n");
}

==== Init Interrupt ====
***** Init Memory *****
***** Remap Kernel *****
Safe and sound!
The char passed by is M
Hello world from tempThread!
I'm back from tempThread!
** TICKS = 100 **
** TICKS = 200 **
....