[DevLog][PintOS] PRJ1 Threads/PintOS 스레드는 어떻게 돌아갈까?

Pintos Project 1: Threads

thread_init을 하면 main thread(initial_thread)가 만들어지고 실행된다. 스케줄링을 위해 thread_start를 실행하면, idle_thread를 만들고 돌린다. idle_thread는 인터럽트를 비활성화하고 자기 자신을 블락한 다음, sti; hlt; 명령어를 실행하여 인터럽트를 활성화하고, 인터럽트가 발생할 때까지 CPU를 대기 상태로 전환하는 일을 반복한다. create_thread는 스레드 이름, 우선순위를 인자로 받아 스레드를 초기화(init_thread)하고, 스레드 내부 intr_frame 구조체에 인자로 받은 실행 함수 (thread_func type)와 그 인자를 저장한 후 thread_unblock을 통해 status를 THREAD_READY로 바꾼 후 ready_list에 넣는다. 그러면 인터럽트마다 실행되는 함수인 thread_tick의 if(thread_tick >= TIME_SLICE) intr_yield_on_return(); 라인에 의해 thread_yield가 일어날 때 ready_list에서 꺼내어져서, thread_launch와 do_iret 함수에 의해 실질적인 context switching이 발생하여 실행되게 된다.

그러면 인터럽트는 누가 보내는 걸까? Programmable Interval Timer (PIT)인 8254 타이머가 보낸다. 이 타이머는 컴퓨터의 메인보드에 위치하여* , init_timer에서 세팅된 인터벌마다 PIC (Programmable Interrupt Controller, 전통적으로는 8259A)에 인터럽트를 발생시켜야 한다는 요청을 전달한다. 구체적으로는 IRQ0, Interrupt Request 0 라인을 통해 master PIC에 요청한다. x86아키텍처에서 IRQ의 값은 벡터값 0x08로 매핑되어 있다. 그런데 이것은 internal interrupt (CPU 예외)의 벡터값과 중복되기 때문에, PIC에서 0x08 벡터를 0x20으로 조정하여 CPU에 전달한다.

핀토스에서 인터럽트 핸들링의 엔트리는 intr-stubs.S에 정의되어 있다. 내부 또는 외부 인터럽트가 발생하면 CPU는 자동으로 rip, cs, eflag, rsp, ss를 스택에 푸시한다. 그리고 인터럽트 벡터값을 참조해 idt에서 실행할 stub 코드를 찾고 (이 idt 매핑은 interrupt.c의 register_handler() 함수가 한다) 실행한다. stub은 다음과 같이 정의되어 있다.

// intr-stubs.S

#define zero pushq $0;  // error code 0을 스택에 푸시한다
#define REAL            // cpu가 push한다

.section .data
.globl intr_stubs
intr_stubs:                     // stub의 배열

/* STUB 매크로를 정의한다 */
#define STUB(NUMBER, TYPE)
.section .text;                 // 데이터 섹션에 명령어를 위치시켜라
.globl intr##NUMBER##_stub;     // intr00_stub과 같은 전역 함수 선언
.func intr##NUMBER##_stub;      // 함수 정의 시작
intr##NUMBER##_stub:
    TYPE;                       // type (zero인 경우 pushq $0)  
    push $0x##NUMBER;           // $0x00과 같은 vec_no push
    jmp intr_entry;             // intr_entry 로 jump
.endfunc;
.section .data;                 // 데이터 섹션에
.quad intr##NUMBER##_stub;      // intr00_stub의 주소를 8바이트로 저장

/* 하나의 인터럽트 핸들러를 저장하는 STUB매크로 */
STUB(00, zero) STUB(01, zero) STUB(02, zero) ... 256

stub 코드는 순서대로 error_code, vector number를 스택에 push하고 intr_entry로 점프한다. 그러면 intr_entry는 뭘 할까?

.section .text
.func intr_entry
intr_entry:
    /* Save caller's registers. */
    subq $16,%rsp
    movw %ds,8(%rsp)
    movw %es,0(%rsp)
    subq $120,%rsp
    movq %rax,112(%rsp)
    movq %rbx,104(%rsp)
    movq %rcx,96(%rsp)
    movq %rdx,88(%rsp)
    movq %rbp,80(%rsp)
    movq %rdi,72(%rsp)
    movq %rsi,64(%rsp)
    movq %r8,56(%rsp)
    movq %r9,48(%rsp)
    movq %r10,40(%rsp)
    movq %r11,32(%rsp)
    movq %r12,24(%rsp)
    movq %r13,16(%rsp)
    movq %r14,8(%rsp)
    movq %r15,0(%rsp)
    cld                      /* String instructions go upward. */

    /* kernel data segement의 selector를 %rax에 저장 */
    movq $SEL_KDSEG, %rax

    /* 데이터 세그먼트 레지스터에 %ax 저장 */
    movw %ax, %ds         
    movw %ax, %es
    movw %ax, %ss
    movw %ax, %fs
    movw %ax, %gs

    /* %rdi가 intr_handler의 인자이다 */
    movq %rsp,%rdi        

    /* interrupt handler call */
    call intr_handler     
    movq 0(%rsp), %r15
    movq 8(%rsp), %r14
    movq 16(%rsp), %r13
    movq 24(%rsp), %r12
    movq 32(%rsp), %r11
    movq 40(%rsp), %r10
    movq 48(%rsp), %r9
    movq 56(%rsp), %r8
    movq 64(%rsp), %rsi
    movq 72(%rsp), %rdi
    movq 80(%rsp), %rbp
    movq 88(%rsp), %rdx
    movq 96(%rsp), %rcx
    movq 104(%rsp), %rbx
    movq 112(%rsp), %rax
    addq $120, %rsp
    movw 8(%rsp), %ds
    movw (%rsp), %es
    addq $32, %rsp
    iretq
.endfunc

현재의 레지스터값을 스택에 push하고, 세그먼트 레지스터에 $SEL_KDSEG, 즉 커널 데이터 세그먼트 선택자 (gdt의 인덱스)를 저장한다. 그리고 movq %rsp, %rdi로 스택 포인터를 %rdi 레지스터에 저장하는데, 이는 일반적으로 함수의 인자를 가리키는 레지스터다. 따라서, 스택 포인터를 인자로 하여 call intr_handler를 호출하는 것이다.

void intr_handler(struct intr_frame *frame);

intr_handler는 interrupt.c에 정의되어 있다. 즉, stack에 intr_frame 구조체에 해당하는 다음 값을 순차적으로 push하고, 스택 포인터를 인자로 넘긴다. intr_handler는 인자로 넘겨진 frame에서 vec_no를 찾아 현재 어떤 인터럽트가 발생했는지 인식하고, register_handler()에 의해 매핑된 인터럽트 처리 함수를 intr_handlers에서 벡터값으로 인덱싱해 찾아 실행한다. pintos의 타이머 인터럽트의 경우, 이 때 실행되는 함수가 timer.c의 timer_interrupt() 이다.

/* Interrupt stack frame. */
struct gp_registers { /* 8byte * 16 */
  uint64_t r15;
  uint64_t r14;
  uint64_t r13;
  uint64_t r12;
  uint64_t r11;
  uint64_t r10;
  uint64_t r9;
  uint64_t r8;
  uint64_t rsi;
  uint64_t rdi;
  uint64_t rbp;
  uint64_t rdx;
  uint64_t rcx;
  uint64_t rbx;
  uint64_t rax;
} __attribute__((packed));

struct intr_frame {
  /* Pushed by intr_entry in intr-stubs.S.
     These are the interrupted task's saved registers. */
  struct gp_registers R; /* rax to r15 (64bit registers) */
  uint16_t es;           /* segment register */
  uint16_t __pad1;       /* padding */
  uint32_t __pad2;       /* padding */
  uint16_t ds;           /* data segment */
  uint16_t __pad3;
  uint32_t __pad4;

  /* Pushed by intrNN_stub in intr-stubs.S. */
  uint64_t vec_no; /* Interrupt vector number.
                      인터럽트 벡터값, 이걸로 인터럽트 핸들러를 찾음 */

  uint64_t error_code;  /* Sometimes pushed by the CPU,
                      otherwise for consistency pushed as 0 by intrNN_stub.*/

  uintptr_t rip;   /* Instruction Pointer */
  uint16_t cs;     /* Code Segment */
  uint16_t __pad5; /* padding */
  uint32_t __pad6; /* padding */
  uint64_t eflags; /* EFLAG: CF, PF, AF, ZF, SF, TF, IF, DF, OF */
  uintptr_t rsp;   /* Stack Pointer */
  uint16_t ss;     /* Segment Register */
  uint16_t __pad7;
  uint32_t __pad8;
} __attribute__((packed));

intr_handler는 항상 인터럽트를 비활성화하고 시작하는데, 이는 일반적으로 하나의 인터럽트 핸들링은 다른 인터럽트에 의해 중단될 수 없기 때문이다. 인터럽트가 종료된 후에는, call intr_handler하기 전 stack에 push해두었던 다음 인스트럭션 주소를 pop해와서 %rip를 해당 인스트럭션의 주소로 바꾼다.

*현대 컴퓨터에서 타이머는 cpu에 있다. 1988 자료임을 잊자말자.

👀 PIC에서 왜 벡터값을 재매핑해야 할까?

애초에 설계 단계에서 잘 분리해뒀으면 안되는 걸까? 하지만 컴퓨터 아키텍처는 역사적으로 발전되어 왔으며, 시스템의 복잡성이 증가함에 따라 처리해야 할 인터럽트의 수가 점차 증가하기도 했다. 이에 따라 벡터값을 새로 다 할당하기보다는 소프트웨어적으로 재매핑하여 처리할 필요성이 생겨났다. 아키텍처란 역사적 산출물이므로.. 어느 한 순간에 완벽한 설계에 의해 탄생한 것은 아니다.

🤔 질문에 답해보자

1. %rip, %rsp register의 의미와 CPU 동작에서의 역할
   %rip는 현재 인스트럭션을 가리킨다. %rsp는 스택의 top을 가리킨다.
2. assembly 명령어 JMP와 CALL의 차이점 JMP는 특정 주소의 인스트럭션으로 이동한다. CALL은 다음에 실행되어야 할 인스트럭션 주소를 stack에 저장해두고 이동한다. stack에 어떻게 저장하는가? %rsp를 8 감소시켜서 스택 영역을 8byte 넓히고, 현재 %rip를 %rsp에 푸시한다.
3. JMP, CALL, RET, PUSH, POP, IRET 명령에서 %rip, %rsp는 어떻게 값이 변하는가?

• JMP 0xa를 하면 %rip는 0xa가 된다. %rsp는 변하지 않는다.
• CALL 0xa을 하면 %rip는 0xa가 된다. %rsp는 8 감소한다. (다음에 실행될 인스트럭션 주소 크기만큼)
• RET을 하면 %rip는 (%rsp) 가 된다. %rsp는 8 증가한다.
• PUSH a를 하면 %rsp는 a의 크기(8)만큼 감소한다. %rip는 변하지 않는다.
• POP을 하면 %rsp는 8만큼 증가시킨다. %rip는 변하지 않는다.
• IRET을 하면 %rsp는 8만큼 증가한다. %rip는 스택에서 pop된 값이다.

4. interrupt 발생 시 CPU는 어떻게 동작하는가? register 값 및 연관된 memory는? interrupt 발생하면 CPU는 해당 인터럽트 벡터값에 매핑된 interrupt handler를 idt에서 찾아 call한다. call을 하면 interrupt handler가 iret으로 반환된 이후 실행되어야 할 인스트럭션의 주소를 스택에 저장하고, interrupt handler의 주소로 %rip를 변경한다.
5. interrupt를 처리한 후에는 어떻게 되는가? inpterrupt처리가 완료된 후에는, call전에 stack에 push해두었던 주소를 찾아 실행한다.
6. interrupt는 어떻게 enable/disable 시킬 수 있는가? enable/disable 되면 뭐가 달라지는가? interrupt flag를 끄면 disable, 켜면 enable이다. interrupt flag는 EFLAG 레지스터의 9번째 비트에 위치하고 있어, 1인 경우 인터럽트를 허용, 0인 경우 인터럽트를 비허용한다. 어셈블리 명령어로는 sti (set interrupt flag)가 인터럽트를 허용하고, cli (clear interrupt flag)가 인터럽트를 비허용한다. sti는 인터럽트를 허용하지만, 바로 다음에 나오는 명령어까지는 인터럽트를 비허용한다. 즉, sti; hlt;를 하면 이들 명령어가 다 실행될 때까지는 인터럽트에 의해 방해받지 않고 아토믹하게 실행된다는 것이다.
7. NMI (Non-Maskable Interrupt)는 무엇인가? 인터럽트 마스킹이란, 핸들링 중인 인터럽트를 중단하고 발생한 인터럽트를 먼저 처리하는 것이다. Non Maskable Interrupt란 이렇게 중단될 수 없는 인터럽트를 말한다.
8. timer interrupt는 누가 발생시키는가? Pintos에서는 8254 Timer (Programmable Timer)가 있다. 이 타이머를 timer_init등으로 일정 간격마다 인터럽트를 발생시키도록 설정하면, 벡터값 0x20을 간격마다 CPU내 IPC 칩으로 보내서 인터럽트를 발생시킨다.
9. EFLAGS register는 무엇인가? 상태를 나타내는 정보를 담고 있는 레지스터이다. Interrupt 허용/비허용을 설정하는 Interrupt Flag (IF)가 이 레지스터에 있다.