Kernel Memory

 1EFI_STATUS GetMemoryMap(struct MemoryMap* map) {
 2  if (map->buffer == NULL) {
 3    return EFI_BUFFER_TOO_SMALL;
 4  }
 5
 6  map->map_size = map->buffer_size;
 7  return gBS->GetMemoryMap(
 8      &map->map_size,
 9      (EFI_MEMORY_DESCRIPTOR*)map->buffer,
10      &map->map_key,
11      &map->descriptor_size,
12      &map->descriptor_version);
13}

1  gBS->ExitBootServices(image_handle, memmap.map_key);
2
3  UINT64 entry_addr = *(UINT64*)(kernel_first_addr + 24);
4  typedef void EntryPointType(const struct FrameBufferConfig*,
5                              const struct MemoryMap*);
6  EntryPointType* entry_point = (EntryPointType*)entry_addr;
7  entry_point(&config, &memmap);

 1  printk("memory_map: %p\n", &memory_map);
 2  for (uintptr_t iter = reinterpret_cast<uintptr_t>(memory_map.buffer);
 3      iter < reinterpret_cast<uintptr_t>(memory_map.buffer) + memory_map.map_size;
 4      iter += memory_map.descriptor_size) {
 5    auto desc = reinterpret_cast<MemoryDescriptor*>(iter);
 6    for (int i = 0; i < available_memory_types.size(); ++i) {
 7      if (desc->type == available_memory_types[i]) {
 8        printk("type = %u, phys = %08lx - %08lx, pages = %lu, attr = %08lx\n",
 9            desc->type,
10            desc->physical_start,
11            desc->physical_start + desc->number_of_pages * 4096 - 1,
12            desc->number_of_pages,
13            desc->attribute
14        );
15      }
16    }
17  }

 1// main.cpp
 2// 주소가 16byte 로 정렬된 1MB 크기의 stack 공간.
 3alignas(16) uint8_t kernel_main_stack[1024 * 1024];
 4// EntryPoint는 KernelMain이기 때문에 이름을 바꿔준다.
 5extern "C" void KernelMainNewStack(const FrameBufferConfig& frame_buffer_config,
 6                           const MemoryMap& memory_map) {
 7
 8// asmfunc.asm
 9extern kernel_main_stack
10extern KernelMainNewStack
11
12global KernelMain
13KernelMain:
14    mov rsp, kernel_main_stack + 1024 * 1024    ; kernel_main_stack의 맨 끝 주소
15    call KernelMainNewStack        ; 어차피 매개변수는 이미 레지스터에 세팅되어 있다.
16.fin
17    hlt           ; 커널이 리턴되지 않아서 의미 없지만 멈추도록 구현
18    jmp .fin

 1union SegmentDescriptor {
 2  uint64_t data;
 3  struct {
 4    uint64_t limit_low : 16;     // limit & 0xffffu;
 5    uint64_t base_low : 16;      // base & 0xffffu;
 6    uint64_t base_middle : 8;    // (base >> 16) & 0xffu;
 7    DescriptorType type : 4;
 8    uint64_t system_segment : 1;
 9    uint64_t descriptor_privilege_level : 2;
10    uint64_t present : 1;
11    uint64_t limit_high : 4;     // (limit >> 16) & 0x0fu;
12    uint64_t available : 1;
13    uint64_t long_mode : 1;      // 64bit 'code' segment 인 경우 1
14    uint64_t default_operation_size : 1;   
15    uint64_t granularity : 1;    
16    uint64_t base_high : 8;      // (base >> 24) & 0xffu;
17  } __attribute__((packed)) bits;
18} __attribute__((packed));

 1global LoadGDT  ; void LoadGDT(uint16_t limit, uint64_t offset);
 2LoadGDT:
 3    push rbp
 4    mov rbp, rsp
 5    sub rsp, 10
 6    mov [rsp], di       ; limit
 7    mov [rsp + 2], rsi  ; offset
 8    lgdt [rsp]
 9    mov rsp, rbp
10    pop rbp
11    ret
12
13global SetCSSS  ; void SetCSSS(uint16_t cs, uint16_t ss);
14SetCSSS:
15    push rbp
16    mov rbp, rsp
17    mov ss, si  ; ss
18    mov rax, .next
19    push rdi    ; cs
20    push rax    ; .next
21    o64 retf    ; o64: 64bit mode prefix. retf = pop ip; pop cs
22.next:
23    mov rsp, rbp
24    pop rbp
25    ret
26
27global SetDSAll  ; void SetDSAll(uint16_t value);
28SetDSAll:
29    mov ds, di
30    mov es, di
31    mov fs, di
32    mov gs, di
33    ret

 1void SetupSegments() {
 2  gdt[0].data = 0;
 3  SetCodeSegment(gdt[1], DescriptorType::kExecuteRead, 0, 0, 0xfffff);
 4  SetDataSegment(gdt[2], DescriptorType::kReadWrite, 0, 0, 0xfffff);
 5  LoadGDT(sizeof(gdt) - 1, reinterpret_cast<uintptr_t>(&gdt[0]));
 6}
 7
 8extern "C" void KernelMainNewStack(const FrameBufferConfig& frame_buffer_config,
 9                           const MemoryMap& memory_map) {
10  SetupSegments();
11  const uint16_t kernel_cs = 1 << 3;    // GDT의 인덱스가 8byte 단위라서 << 3 함
12  const uint16_t kernel_ss = 2 << 3;
13  SetDSAll(0);
14  SetCSSS(kernel_cs, kernel_ss);
15}

 1// CR3 값을 세팅하는 함수
 2global SetCR3   ; void SetCR3(uint64_t value);
 3SetCR3:
 4    mov cr3, rdi
 5    ret
 6
 7// paging.cpp
 8namespace {
 9  const uint64_t kPageSize4K = 4096;
10  const uint64_t kPageSize2M = 512 * kPageSize4K;
11  const uint64_t kPageSize1G = 512 * kPageSize2M;
12
13  // page directory pointer 512개를 저장할 수 있는 pml4 테이블
14  alignas(kPageSize4K) std::array<uint64_t, 512> pml4_table;    
15  // page directory 512개를 저장할 수 있는 pdp 테이블 한개 
16  alignas(kPageSize4K) std::array<uint64_t, 512> pdp_table;     
17  // 내부적으로 8*512(4K)바이트 크기의 pd 테이블 64(kPageDirectoryCount)개
18  alignas(kPageSize4K) std::array<std::array<uint64_t, 512>, kPageDirectoryCount> page_directory; 
19
20void SetupIdentityPageTable() {
21  // 0번 pml4 에 pdp table 한개를 Identity Mapped 방식으로 세팅한다. 
22  // pdp_table은 4K로 align되어 주소가 000으로 끝나며, 이 12bit는 플래그로 사용된다. 
23  // 0x0003 플래그는 Present(1) + RW(1) 로 세팅해서 유효한 페이지이며 RW 가 가능하다는 의미를 담는다. 
24  pml4_table[0] = reinterpret_cast<uint64_t>(&pdp_table[0]) | 0x0003;
25  // pdpt 중에 64(kPageDirectoryCount)개만 세팅
26  for (int i_pdpt = 0; i_pdpt < page_directory.size(); ++i_pdpt) {
27    // 각 pdp_table에 4K 크기의 pd 하나씩 총 64개 저장. 마찬가지로 P(1) + RW(1)
28    pdp_table[i_pdpt] = reinterpret_cast<uint64_t>(&page_directory[i_pdpt]) | 0x003;
29    for (int i_pd = 0; i_pd < 512; ++i_pd) {
30      // 각 pd에 2M 짜리 페이지 512개를 넣는다.
31      // 2MB 씩 512개이기 때문에 pdpt당 1GB 씩 저장할 수 있으며 총 64개가 저장되기 때문에 64GB 주소를 매핑했다.
32      // 0x80 플래그는 1로 세팅되면 2Mib (huge page)
33      page_directory[i_pdpt][i_pd] = i_pdpt * kPageSize1G + i_pd * kPageSize2M | 0x083;
34    }
35  }
36  // CR3은 pml4 테이블의 베이스 주소를 지정하면서 방금 만든 페이지 테이블이 사용되기 시작한다.
37  SetCR3(reinterpret_cast<uint64_t>(&pml4_table[0]));
38}

 11. 0x4567890a       // 가상주소
 22. 00...00 01000101 01100111 10001001 00001010  // 2진법으로
 33. offset(12)=100100001010 (0x90a)   // 페이지 테이블 적용
 4   pt_off(9)=001111000 (120=0x78)    // huge page라서 여기서부터 오프셋. 
 5                                     // 0x7890a 가 오프셋이 된다. 
 6   pd_off(9)=000101011 (43)
 7   pdpt_off(9)=01
 8   pml4_off(9)=0  
 94. 1*1GiB (0x40000000) 
10   + 43*2MiB (0x5600000) 
11   + 120*4KiB (0x78000) 
12   + 0x90a 
13   = 0x4567890a     // 물리주소

 1namespace {
 2  // 사용자 정의 리터럴. 리터럴 suffix 를 오버로딩하는 c++11 문법이다.
 3  // KB = 1000byte, KiB = 1024byte   (사실 다 KB로 쓰기도한다.)
 4  constexpr unsigned long long operator""_KiB(unsigned long long kib) {
 5    return kib * 1024;
 6  }
 7  constexpr unsigned long long operator""_MiB(unsigned long long mib) {
 8    return mib * 1024_KiB;
 9  }
10  constexpr unsigned long long operator""_GiB(unsigned long long gib) {
11    return gib * 1024_MiB;
12  }
13}
14
15// 각 프레임(페이지)는 4KiB 크기이다. 
16static const auto kBytesPerFrame{4_KiB};
17
18class FrameID {
19public:
20  explicit FrameID(size_t id) : id_{id} {}
21  size_t ID() const { return id_; }
22  // 각 id_는 메모리에서 페이지 프레임 마다 순차적으로 증가하는 인덱스이다.
23  void* Frame() const { return reinterpret_cast<void*>(id_ * kBytesPerFrame); }
24
25private:
26  size_t id_;
27};
28
29// 정의되지 않은 프레임번호의 의미하는 상수값이다. 
30// 페이지 프레임 탐색 함수에서 찾지 못했을 때의 리턴값
31static const FrameID kNullFrame{std::numeric_limits<size_t>::max()};

 1class BitmapMemoryManager {
 2public:
 3  static const auto kMaxPhysicalMemoryBytes{128_GiB};
 4  static const auto kFrameCount{kMaxPhysicalMemoryBytes / kBytesPerFrame};
 5  // 페이지 프레임 비트 라인의 타입
 6  using MapLineType = unsigned long;
 7  // 각 라인당 비트 수
 8  static const size_t kBitsPerMapLine{8 * sizeof(MapLineType)};
 9
10  BitmapMemoryManager();
11
12  WithError<FrameID> Allocate(size_t num_frames);
13  Error Free(FrameID start_frame, size_t num_frames);
14
15  // FrameID에 해당하는 비트를 할당됨(1)로 세팅한다. 
16  void MarkAllocated(FrameID start_frame, size_t num_frames);
17  // 그냥 시작 FrameID, 끝 FrameID 를 전달해서 초기화한다. 
18  void SetMemoryRange(FrameID range_begin, FrameID range_end);
19
20private:
21  // 비트맵. 1차원 배열이지만, 사실 자료형 크기만큼 2차원 비트배열인 것이다. 
22  std::array<MapLineType, kFrameCount / kBitsPerMapLine> alloc_map_;
23  FrameID range_begin_;
24  FrameID range_end_;
25
26  bool GetBit(FrameID frame) const;
27  void SetBit(FrameID frame, bool allocated);
28};
29
30
31// FrameID 에 해당되는 사용가능 여부를 비트맵에 세팅한다. 
32void BitmapMemoryManager::SetBit(FrameID frame, bool allocated) {
33  // 프레임은 선형적으로 0번부터 시작할 것이기 때문에 x,y 좌표 세팅
34  auto line_index = frame.ID() / kBitsPerMapLine;
35  auto bit_index = frame.ID() % kBitsPerMapLine;
36
37  // 사용불가면 1을 해당 좌표에 세팅. 사용 가능이라면 1을 해당 좌표에서 제외
38  if (allocated) {
39    alloc_map_[line_index] |= (static_cast<MapLineType>(1) << bit_index);
40  } else {
41    alloc_map_[line_index] &= ~(static_cast<MapLineType>(1) << bit_index);
42  }
43}
44
45// 해당되는 프레임 범위는 전부 true로 세팅
46void BitmapMemoryManager::MarkAllocated(FrameID start_frame, size_t num_frames) {
47  for (size_t i = 0; i < num_frames; ++i) {
48    SetBit(FrameID{start_frame.ID() + i}, true);
49  }
50}
51
52void BitmapMemoryManager::SetMemoryRange(FrameID range_begin, FrameID range_end) {
53  range_begin_ = range_begin;
54  range_end_ = range_end;
55}

 1extern "C" void KernelMainNewStack(const FrameBufferConfig& frame_buffer_config_ref,
 2                           const MemoryMap& memory_map_ref) {
 3  printk("memory_map: %p\n", &memory_map);
 4  ::memory_manager = new(memory_manager_buf) BitmapMemoryManager;
 5
 6  // memory_map을 physical_addr 오름차순으로 InPlace 정렬
 7  SortMemoryMapInPlace(memory_map);
 8
 9  const auto memory_map_base = reinterpret_cast<uintptr_t>(memory_map.buffer);
10  // 체크해야되는 메모리 프레임 시작 주소
11  uintptr_t check_offset = 0;
12  for (uintptr_t iter = memory_map_base;
13      iter < memory_map_base + memory_map.map_size;
14      iter += memory_map.descriptor_size) {
15
16    auto desc = reinterpret_cast<const MemoryDescriptor*>(iter);
17    // 메모리 디스크립터에 포함되지 않은 (GAP) 메모리가 있는경우
18    // 마지막 검증 끝낸 메모리부터 현재 위치까지 사용불가 마킹
19    if (check_offset < desc->physical_start) {
20      memory_manager->MarkAllocated(
21        FrameID{check_offset / kBytesPerFrame},
22        (desc->physical_start - check_offset) / kBytesPerFrame
23      );
24    }
25
26    const auto physical_end = desc->physical_start + desc->number_of_pages * kUEFIPageSize;
27    // 현재 메모리 공간 (physical_start 부터) 사용가능 여부에 따라 마킹
28    if (!IsAvailable(static_cast<MemoryType>(desc->type))){
29      memory_manager->MarkAllocated(
30        FrameID{desc->physical_start / kBytesPerFrame},
31        desc->number_of_pages * kUEFIPageSize / kBytesPerFrame
32      );
33    }
34    // check_offset 은 GAP 페이지 프레임을 검사하기 위해 마지막 체크한 영역을 업데이트한다.
35    check_offset = physical_end;
36  }
37
38  // 물리메모리의 페이지 프레임 범위를 지정하는 함수이다. 
39  // 1번 프레임부터 메모리맵 마지막 프레임 사이에서만 사용하기로 한다. 
40  memory_manager->SetMemoryRange(FrameID{1}, FrameID{check_offset - 1 / kBytesPerFrame});
41}

 1// 전달된 프레임 수 만큼 연속된 메모리를 찾아준다. 
 2WithError<FrameID> BitmapMemoryManager::Allocate(size_t num_frames) {
 3  // 그냥 무한루프 돌면서 빈 곳 찾음
 4  size_t start_frame_id = range_begin_.ID();
 5  while (true) {
 6    size_t i = 0;
 7    // 연속으로 할당 가능한 곳 찾기
 8    for(; i < num_frames; ++i) {
 9      // range_end_ 를 넘은 경우
10      if (start_frame_id + i >= range_end_.ID()) {
11        return {kNullFrame, MAKE_ERROR(Error::kNoEnoughMemory)};
12      }
13      // 이미 할당되어 사용할 수 없는 메모리를 발견한 경우
14      if (GetBit(FrameID{start_frame_id + i})) {
15        break;
16      }
17    }
18    // 원하는 페이지 프레임 수에 맞다면
19    if (i == num_frames) {
20      MarkAllocated(FrameID{start_frame_id}, num_frames);
21      return {
22        FrameID{start_frame_id},
23        MAKE_ERROR(Error::kSuccess);
24      };
25    }
26    // 검사한 위치(i)는 점프하고 다음프레임
27    start_frame_id += i + 1;
28  }
29}
30
31// Free는 그냥 원하는 범위 전부 false로 세팅하는 함수이다. 
32Error BitmapMemoryManager::Free(FrameID start_frame, size_t num_frames) {
33  for (size_t i = 0; i < num_frames; ++i) {
34    SetBit(FrameID{start_frame.ID() + i}, false);
35  }
36  return MAKE_ERROR(Error::kSuccess);
37}

 1// newlib_support.c
 2caddr_t program_break, program_break_end;
 3
 4caddr_t sbrk(int incr) {
 5  // incr이 음수가 될 수 있기 때문에 하한 체크도 필요하다.
 6  if (program_break == 0 || program_break + incr >= program_break_end) {
 7    errno = ENOMEM;
 8    return (caddr_t)-1;
 9  }
10
11  caddr_t prev_break = program_break;
12  program_break += incr;
13  return prev_break;
14}
15
16// memory_manager.cpp
17// 힙 초기화 함수 구현. 힙 영역 할당 및 program_break, program_break_end 를 초기화한다.
18extern "C" caddr_t program_break, program_break_end;
19
20Error InitializeHeap(BitmapMemoryManager& memory_manager) {
21  // 사용할 힙 사이즈. 연속된 공간이 할당돼야 한다.
22  const int kHeapFrames = 64 * 512;
23  // 할당된 힙 시작프레임
24  const auto heap_start = memory_manager.Allocate(kHeapFrames);
25  if (heap_start.error) {
26    return heap_start.error;
27  }
28  // 메모리 프레임의 ID 값은 0번(널 프레임)부터 관리하는 프레임 순서대로 부여됐고
29  // 페이지 프레임 크기를 곱하면 해당 위치의 페이지 주소가 된다. 
30  program_break = reinterpret_cast<caddr_t>(heap_start.value.ID() * kBytesPerFrame);
31  program_break_end = program_break + kHeapFrames * kBytesPerFrame;
32  return MAKE_ERROR(Error::kSuccess);
33}