System Call

// rpn.cpp
...
#include "../../kernel/graphics.hpp"
#include "../../kernel/font.hpp"

// 커널의 주소를 그대로 가져와서 호출
auto& printk = *reinterpret_cast<int (*)(const char*, ...)>(0x00000000001108e0);
auto& fill_rect = *reinterpret_cast<decltype(FillRectangle)*>(0x0000000000148e10);
auto& write_str = *reinterpret_cast<decltype(WriteString)*>(0x0000000000148d30);
auto& scrn_writer = *reinterpret_cast<decltype(screen_writer)*>(0x00000000002630c8);

...
extern "C" int main(int argc, char** argv) {
  ...
  fill_rect(*scrn_writer, Vector2D<int>{100, 10}, Vector2D<int>{200, 200}, ToColor(0x66ff66));
  write_str(*scrn_writer, Vector2D<int>{100 + 50, 10 + 50}, "Hello RPN World!", ToColor(0xff66ff));

  return static_cast<int>(Pop());
}

void SetupSegments() {
  gdt[0].data = 0;
  SetCodeSegment(gdt[1], DescriptorType::kExecuteRead, 0, 0, 0xfffff);
  SetDataSegment(gdt[2], DescriptorType::kReadWrite, 0, 0, 0xfffff);
                                                   // DPL
  SetCodeSegment(gdt[3], DescriptorType::kExecuteRead, 3, 0, 0xfffff);
  SetDataSegment(gdt[4], DescriptorType::kReadWrite, 3, 0, 0xfffff);
  LoadGDT(sizeof(gdt) - 1, reinterpret_cast<uintptr_t>(&gdt[0]));
}

global CallApp  ; void CallApp(int argc, char** argv, uint16_t cs, uint16_t ss, uint64_t rip, uint64_t rsp);
CallApp:
    push rbp
    mov rbp, rsp
    push rcs    ; SS
    push r9     ; RSP
    push rdx    ; CS
    push r8     ; RIP
    o64 retf

page_map[entry_index].bits.user = 1;

  LinearAddress4Level stack_frame_addr{0xffff'ffff'ffff'e000};
  if (auto err = SetupPageMaps(stack_frame_addr, 1)) {
    return err;
  }

  LinearAddress4Level args_frame_addr{0xffff'ffff'ffff'f000};
  if (auto err = SetupPageMaps(args_frame_addr, 1)) {
    return err;
  }

  // 0xf000                       0xf100                              0xffff
  // |-- char* argv[32] (256 byte) --|----... argbuf (0xf00 byte) ...----|
  auto argv = reinterpret_cast<char**>(args_frame_addr.value)
  int argv_len = 32;  // argv = sizeof(char**) * 32 = 256bytes
  auto argbuf = reinterpret_cast<char*>(args_frame_addr.value + sizeof(char**) * argv_len);
  int argbuf_len = 4096 - sizeof(char**) * argv_len;
  auto argc = MakeArgVector(command, first_arg, argv, argv_len, argbuf, argbuf_len);
  if (argc.error) {
    return argc.error;
  }

  auto entry_addr = elf_header->e_entry;
  CallApp(argc.value, argv, 3 << 3 | 3, 4 << 3 | 3, entry_addr,
      stack_frame_addr.value + 4096 - 8);

global LoadTR
LoadTR: ; void LoadTR(uint16_t sel);
    ltr di
    ret

const uint16_t kTSS = 5 << 3;

void SetSystemSegment(SegmentDescriptor& desc,
                      DescriptorType type,
                      uint32_t base,
                      uint32_t limit) {
  SetCodeSegment(desc, type, descriptor_privilege_level, base, limit);
  desc.bits.system_segment = 0;
  desc.bits.long_mode = 0;
}

void InitializeTSS() {
  const int kRSP0Frames = 8;   // 32kb
  auto [ stack0, err ] = memory_manager->Allocate(kRSP0Frames);
  if (err) {
    Log(kError, "failed to allocate rsp0: %s\n", err.Name());
    exit(1);
  }
  uint64_t rsp0 =
    reinterpret_cast<uint64_t>(stack0.Frame()) + kRSP0Frames * 4096;
  // tss의 0x4:0xC 영역에 rsp0 주소 저장
  tss[1] = rsp0 & 0xffffffff;
  tss[2] = rsp0 >> 32;

  // tss 주소를 연속된 두개의 GDT 엔트리 슬롯에 나눠서 저장
  uint64_t tss_addr = reinterpret_cast<uint64_t>(&tss[0]);
  SetSystemSegment(gdt[kTSS >> 3], DescriptorType::kTSSAvailable, 0,
    tss_addr & 0xffffffff, sizeof(tss) - 1);
  gdt[(kTSS >> 3) + 1].data = tss_addr >> 32;
  LoadTR(kTSS);
}

extern "C" void LAPICTimerOnInterrupt(const TaskContext& ctx_stack) {
  const bool task_timer_timeout = timer_manager->Tick();
  NotifyEndOfInterrupt();

  if (task_timer_timeout) {
    task_manager->SwitchTask(ctx_stack);
  }
}

global IntHandlerLAPICTimer
IntHandlerLAPICTimer:  ; void IntHandlerLAPICTimer();
    push rbp
    mov rbp, rsp

    ; TaskContext 형태에 맞춰서 스택에 push해두고 LAPICTimerOnInterrupt 함수 호출
    sub rsp, 512
    fxsave [rsp]
    push r15
    ...
    push r8
    push qword [rbp]         ; RBP
    push qword [rbp + 0x20]  ; RSP
    push rsi
    ...
    push rax

    mov ax, fs
    mov bx, gs
    mov rcx, cr3

    ; 인터럽트 발생 시점에 push된 레지스터들은 rbp를 통해 가져온다.
    push rbx                 ; GS
    push rax                 ; FS
    push qword [rbp + 0x28]  ; SS
    push qword [rbp + 0x10]  ; CS
    push rbp                 ; reserved1
    push qword [rbp + 0x18]  ; RFLAGS
    push qword [rbp + 0x08]  ; RIP
    push rcx                 ; CR3

    ; rsp를 ctx_stack으로 지정함. void LAPICTimerOnInterrupt(const TaskContext& ctx_stack)
    mov rdi, rsp
    call LAPICTimerOnInterrupt

    add rsp, 8*8  ; CR3 부터 GS 까지 무시
    pop rax
    ...
    pop rsi
    add rsp, 16   ; RSP, RBP를 무시
    pop r8
    ...
    pop r15
    fxrstor [rsp]

    mov rsp, rbp
    pop rbp
    iretq

void TaskManager::SwitchTask(const TaskContext& current_ctx) {
  // 실행중이던 컨텍스트 값 업데이트. (task_ctx는 과거의 값임)
  TaskContext& task_ctx = task_manager->CurrentTask().Context();
  memcpy(&task_ctx, &current_ctx, sizeof(TaskContext));

  // 이전 SwitchTask 작업. 작업 큐 로테이트해서 새로운 태스크 할당 (없으면 그대로)
  Task* current_task = RotateCurrentRunQueue(false);
  // CurrentTask()는 로테이트 이후라서 실행할 태스크, current_task는 로테이트 전 태스크
  if (&CurrentTask() != current_task) {
    // CurrentTask의 컨텍스트를 CPU에 복원
    RestoreContext(&CurrentTask().Context());
  }
}

bits 64
section .text

global SyscallLogString
SyscallLogString:
    mov eax, 0x80000000
    mov r10, rcx
    syscall
    ret

global WriteMSR
WriteMSR:        // void WriteMSR(uint32_t msr, uint64_t value);
  mov rdx, rsi
  shr rdx, 32    // edx에 rsi(value) 상위비트
  mov eax, esi   // eax에 rsi 하위비트(esi)
  mov ecx, edi   // ecx에 msr 저장
  wrmsr
  ret

static constexpr uint32_t kIA32_EFER  = 0xc0000080;
static constexpr uint32_t kIA32_STAR  = 0xc0000081;
static constexpr uint32_t kIA32_LSTAR = 0xc0000082;
static constexpr uint32_t kIA32_FMASK = 0xc0000084;

void InitializeSyscall() {
  // LMA(0x400) | LME(0x100) | syscall 명령 사용(0x1)
  WriteMSR(kIA32_EFER, 0x0501u);

  // IA32_LSTAR 레지스터: syscall이 실행됐을때 호출되는 엔트리함수를 등록
  WriteMSR(kIA32_LSTAR, reinterpret_cast<uint64_t>(SyscallEntry));

  // syscall, sysret 시 커널용 CS, SS과 스위칭하기 위한 값을 설정하는 레지스터
  // syscall 은 value에서 [47:32]의 값이 CS, [47:32]+8 의 값이 SS에 기록된다.
  // sysret도 이런 자체 규칙이라 자세한건 생략한다. 
  WriteMSR(kIA32_STAR, static_cast<uint64_t>(8) << 32 |
                       static_cast<uint64_t>(16 | 3) << 48);

  // syscall을 호출할때 RFLAGS 에서 지워버릴 비트
  // 보통 인터럽트 플래그를 지워서 시스템콜 실행중에는 인터럽트가 걸리지않도록 한다.
  WriteMSR(kIA32_FMASK, 0);
}

extern syscall_table
global SyscallEntry
SyscallEntry:
    push rbp
    push rcx  ; original RIP
    push r11  ; original RFLAGS

    mov rcx, r10
    and eax, 0x7fffffff
    ; 시스템콜 번호는 0x80000000 부터 시작하는데
    ; 값을 그대로 쓰면 table크기가 부담돼서 마스킹한다. -> 0 부터 시작
    mov rbp, rsp
    and rsp, 0xfffffffffffffff0
    ; 그냥 스택포인터가 무조건 16의 배수여야 한다는 System V AMD64 규약을 지키는것

    call [syscall_table + 8 * eax]
    ; rbx, r12-r15는 callee-saved라서 유지하지 않는다.
    ; rax는 반환값이라서 유지하지 않는다. 

    ; 내가 수정했던것만 다시 되돌려놓는다. 
    mov rsp, rbp

    pop r11
    pop rcx
    pop rbp
    o64 sysret    ; ret 하면서 RIP(RCX), RFLAGS(R11), SS 복원

namespace syscall {

#define SYSCALL(name) \
  int64_t name( \
    uint64_t arg1, uint64_t arg2, uint64_t arg3, \
    uint64_t arg4, uint64_t arg5, uint64_t arg6)

SYSCALL(LogString) {
  if (arg1 != kError && arg1 != kWarn && arg1 != kInfo && arg1 != kDebug) {
    return -1;
  }

  const char* s = reinterpret_cast<const char*>(arg2);
  if (strlen(s) > 1024) {
    return -1;
  }
  Log(static_cast<LogLevel>(arg1), "%s", s);
  return 0;
}

#undef SYSCALL      // 실수로 사용하지 못하게

} // namespace syscall

using SyscallFuncType = int64_t (uint64_t, uint64_t, uint64_t,
                                 uint64_t, uint64_t, uint64_t);

extern "C" std::array<SyscallFuncType*, 1> syscall_table {
  /* 0x00 */ syscall::LogString,
};

// Timer 인터럽트용 IST는 TSS.IST1 이다. 
const int kISTForTimer = 1;

void InitializeTSS() {
  SetTSS(1, AllocateStackArea(8));    // TSS.RSP0 세팅 (8*4k 짜리)
  SetTSS(7 + 2 * kISTForTimer, AllocateStackArea(8));   // TSS.IST1 주소할당 (8*4k 짜리)
  ...
}

void InitializeInterrupt() {
  SetIDTEntry(idt[InterruptVector::kLAPICTimer],
              MakeIDTAttr(DescriptorType::kInterruptGate, 0 /* DPL */,
                          true /* present */, kISTForTimer /* IST */),
              reinterpret_cast<uint64_t>(IntHandlerLAPICTimer),
              kKernelCS);
  ... // 다른 인터럽트 추가 
}

kdh@DESKTOP-MHEA7GE:~/min-os/devenv/x86_64-elf/lib$ nm libc.a | grep -B 10 -A 10 _write_r
lib_a-vdprintf.o:
                 U _free_r
                 U _impure_ptr
                 U _vasnprintf_r
0000000000000000 T _vdprintf_r
                 U _write_r
0000000000000080 T vdprintf

lib_a-writer.o:
0000000000000000 T _write_r
                 U errno
                 U write

// call CallApp 에서 리턴주소가 스택에 저장된다. (exit때 이쪽으로 복귀)
                                // user ss | RPL(3)
int ret = CallApp(argc.value, argv, 3 << 3 | 3, entry_addr,
                  stack_frame_addr.value + 4096 - 8,
                  &task.OSStackPointer());   // CallApp() 에서 저장


global CallApp
CallApp:  ; int CallApp(int argc, char** argv, uint16_t ss,
          ;             uint64_t rip, uint64_t rsp, uint64_t* os_stack_ptr);
    push rbx
    push rbp

    push r12
    push r13
    push r14
    push r15
    mov [r9], rsp   ; param_6(r9): *os_stack_ptr = RSP

    push rdx        ; SS
    push r8         ; RSP (애플리케이션 스택)
    add rdx, 8      ; 어차피 SS와 CS가 붙어있음
    push rdx        ; CS
    push rcx        ; RIP
    o64 retf        ; 애플리케이션으로 진입


global SyscallEntry
SyscallEntry:
    ...
.exit:
    mov rsp, rax  ; syscall은 스택을 변경하지 않아서 직접 커널스택을 가리키게 해야한다. 
    mov eax, edx

    pop r15
    pop r14
    pop r13
    pop r12
    pop rbp
    pop rbx
    ret      ; CallApp의 다음줄로 점프한다. (CallApp에서 RIP를 push해둠)

  __attribute__((interrupt))
  void IntHandlerXHCI(InterruptFrame* frame) {
    task_manager->SendMessage(1, Message{Message::kInterruptXHCI});
    NotifyEndOfInterrupt();
  }

void InitializeInterrupt() {
  set_idt_entry(InterruptVector::kXHCI, IntHandlerXHCI);
  ...
}

  // event loop
  while (true) {
    __asm__("cli");
    const auto tick = timer_manager->CurrentTick();
    __asm__("sti");

    sprintf(str, "%010lu", tick);
    FillRectangle(*main_window->InnerWriter(), {20, 44}, {8 * 10, 16}, {0xc6, 0xc6, 0xc6});
    WriteString(*main_window->InnerWriter(), {20, 44}, str, {0, 0, 0});
    layer_manager->Draw(main_window_layer_id);

    __asm__("cli");
    auto msg = main_task.ReceiveMessage();
    if (!msg) {
      main_task.Sleep();
      __asm__("sti");
      continue;
    }
    __asm__("sti");

    switch (msg->type) {
    case Message::kInterruptXHCI:
      usb::xhci::ProcessEvents();
      break;

// default_observer 함수 등록. Message::kInterruptXHCI 처리과정에서 실행
void InitializeMouse() {
  ...
  usb::HIDMouseDriver::default_observer =
    [mouse](uint8_t buttons, int8_t displacement_x, int8_t displacement_y) {
      mouse->OnInterrupt(buttons, displacement_x, displacement_y);
    };
  ...
}

void Mouse::OnInterrupt(uint8_t buttons, int8_t displacement_x, int8_t displacement_y) {
  ...
  if (drag_layer_id_ == 0) {
    SendMouseMessage(newpos, posdiff, buttons, previous_buttons_);
  }

  previous_buttons_ = buttons;
}


// 마우스 메시지로 변경 후 태스크에 전달
void SendMouseMessage(Vector2D<int> newpos, Vector2D<int> posdiff,
                      uint8_t buttons, uint8_t previous_buttons) {
  // 현재 마우스가 올라가있는 레이어 태스크에 메시지를 전달해준다. 
  const auto act = active_layer->GetActive();
  const auto layer = layer_manager->FindLayer(act);
  const auto task_it = layer_task_map->find(act);

  // Message::kMouseMove 메시지 전송
  const auto relpos = newpos - layer->GetPosition();
  if (posdiff.x != 0 || posdiff.y != 0) {
    Message msg{Message::kMouseMove};
    msg.arg.mouse_move.x = relpos.x;
    msg.arg.mouse_move.y = relpos.y;
    msg.arg.mouse_move.dx = posdiff.x;
    msg.arg.mouse_move.dy = posdiff.y;
    msg.arg.mouse_move.buttons = buttons;
    task_manager->SendMessage(task_it->second, msg);
  }

  // Message::kMouseButton 메시지 전송
  if (previous_buttons != buttons) {
    const auto diff = previous_buttons ^ buttons;
    for (int i = 0; i < 8; ++i) {
      if ((diff >> i) & 1) {
        Message msg{Message::kMouseButton};
        msg.arg.mouse_button.x = relpos.x;
        msg.arg.mouse_button.y = relpos.y;
        msg.arg.mouse_button.press = (buttons >> i) & 1;
        msg.arg.mouse_button.button = i;
        task_manager->SendMessage(task_it->second, msg);
      }
    }
  }
}

SYSCALL(ReadEvent) {
  const auto app_events = reinterpret_cast<AppEvent*>(arg1);
  const size_t len = arg2;

  auto& task = task_manager->CurrentTask();
  while (i < len) {
    __asm__("cli");
    auto msg = task.ReceiveMessage();
    if (!msg && i == 0) {
      task.Sleep();
      continue;
    }
    __asm__("sti");

    switch (msg->type) {
    case Message::kMouseMove:
      app_events[i].type = AppEvent::kMouseMove;
      app_events[i].arg.mouse_move.x = msg->arg.mouse_move.x;
      app_events[i].arg.mouse_move.y = msg->arg.mouse_move.y;
      app_events[i].arg.mouse_move.dx = msg->arg.mouse_move.dx;
      app_events[i].arg.mouse_move.dy = msg->arg.mouse_move.dy;
      app_events[i].arg.mouse_move.buttons = msg->arg.mouse_move.buttons;
      ++i;
      break;
  ...
}

extern GetCurrentTaskOSStackPointer
extern syscall_table
global SyscallEntry
SyscallEntry:
    push rbp
    push rcx  ; original RIP
    push r11  ; original RFLAGS

    push rax  ; 시스템콜의 번호를 저장해둔다. (시스템콜 호출 후 아래에서 비교)

    mov rcx, r10
    and eax, 0x7fffffff
    mov rbp, rsp

    ; 시스템콜을 커널스택에서 실행하기 위한 준비 
    and rsp, 0xfffffffffffffff0
    push rax    ; 반환값용 레지스터 rax, rdx
    push rdx
    cli
    call GetCurrentTaskOSStackPointer
    sti
    mov rdx, [rsp + 0]  ; RDX
    mov [rax - 16], rdx
    mov rdx, [rsp + 8]  ; RAX
    mov [rax - 8], rdx

    lea rsp, [rax - 16]
    pop rdx
    pop rax
    and rsp, 0xfffffffffffffff0

    call [syscall_table + 8 * eax]
    ...