메모리 관리 정리와 요구 페이징

  CalcLoadAddressRange(kernel_ehdr, &kernel_first_addr, &kernel_last_addr);
  CopyLoadSegments(kernel_ehdr);
  // ... 커널이후 사용하지 않는 메모리 정리

  status = gBS->ExitBootServices(image_handle, memmap.map_key);
  if (EFI_ERROR(status)) {
    status = GetMemoryMap(&memmap);
    _IfErrorHalt(L"failed to get memory map", status);

    status = gBS->ExitBootServices(image_handle, memmap.map_key);
    _IfErrorHalt(L"Could not exit boot service", status);
  }

  typedef void EntryPointType(const struct FrameBufferConfig*,
                              const struct MemoryMap*,
                              const VOID*, VOID* );
  entry_point(&config, &memmap, acpi_table, volume_image);

const size_t kPageDirectoryCount = 64;

namespace {
  const uint64_t kPageSize4K = 4096;
  const uint64_t kPageSize2M = 512 * kPageSize4K;
  const uint64_t kPageSize1G = 512 * kPageSize2M;

  alignas(kPageSize4K) std::array<uint64_t, 512> pml4_table;
  alignas(kPageSize4K) std::array<uint64_t, 512> pdp_table;
  // pdp_table을 채울 page_directory 64개
  alignas(kPageSize4K) std::array<std::array<uint64_t, 512>, kPageDirectoryCount> page_directory;
}

void InitializePaging() {
  SetupIdentityPageTable();
}

void SetupIdentityPageTable() {
  pml4_table[0] = reinterpret_cast<uint64_t>(&pdp_table[0]) | 0x0003;
  for (int i_pdpt = 0; i_pdpt < page_directory.size(); ++i_pdpt) {
    pdp_table[i_pdpt] = reinterpret_cast<uint64_t>(&page_directory[i_pdpt]) | 0x003;
    for (int i_pd = 0; i_pd < 512; ++i_pd) {
      page_directory[i_pdpt][i_pd] = i_pdpt * kPageSize1G + i_pd * kPageSize2M | 0x083;
    }
  }
  ResetCR3();
}

// 아래 세가지 상태만 할당 가능 메모리 공간으로 생각함
inline bool IsAvailable(MemoryType memory_type) {
  return
    memory_type == MemoryType::kEfiBootServicesCode ||
    memory_type == MemoryType::kEfiBootServicesData ||
    memory_type == MemoryType::kEfiConventionalMemory;
}

caddr_t program_break, program_break_end;

caddr_t sbrk(int incr) {
  // incr이 음수가 될 수 있기 때문에 하한 체크도 필요하다.
  if (program_break == 0 || program_break + incr >= program_break_end) {
    errno = ENOMEM;
    return (caddr_t)-1;
  }

  caddr_t prev_break = program_break;
  program_break += incr;
  return prev_break;
}

  Error InitializeHeap(BitmapMemoryManager& memory_manager) {
    const int kHeapFrames = 64 * 512;
    const auto heap_start = memory_manager.Allocate(kHeapFrames);
    if (heap_start.error) {
      return heap_start.error;
    }

    program_break = reinterpret_cast<caddr_t>(heap_start.value.ID() * kBytesPerFrame);
    program_break_end = program_break + kHeapFrames * kBytesPerFrame;
    return MAKE_ERROR(Error::kSuccess);
  }

const uint16_t kKernelCS = 1 << 3;   // | idx(13bit) : TI(1bit) : RPL(2bit) | 
const uint16_t kKernelSS = 2 << 3; 
const uint16_t kKernelDS = 0; 
const uint16_t kTSS = 5 << 3;

                                // user ss | RPL(3)    reto 명령에서 세팅됨
int ret = CallApp(argc.value, argv, 3 << 3 | 3, entry_addr,
                  stack_frame_addr.value + 4096 - 8,
                  &task.OSStackPointer());

  // 커널 테이블을 그대로 복사하고 cr3를 바꿔낀다. 
  auto pml4 = SetupPML4(task);
  LoadELF(elf_header);   // CopyLoadSegments 호출

  LinearAddress4Level stack_frame_addr{0xffff'ffff'ffff'e000};
  SetupPageMaps(stack_frame_addr, 1);

  LinearAddress4Level args_frame_addr{0xffff'ffff'ffff'f000};
  SetupPageMaps(args_frame_addr, 1);

                                  // user ss | RPL(3)
  int ret = CallApp(argc.value, argv, 3 << 3 | 3, entry_addr,
                    stack_frame_addr.value + 4096 - 8,
                    &task.OSStackPointer());

WithError<size_t> SetupPageMap(
    PageMapEntry* page_map, int page_map_level, LinearAddress4Level addr, size_t num_4kpages) {
  while (num_4kpages > 0) {
    const auto entry_index = addr.Part(page_map_level);

    auto [ child_map, err ] = SetNewPageMapIfNotPresent(page_map[entry_index]);
    if (err) {
      return { num_4kpages, err };
    }
    page_map[entry_index].bits.writable = 1;
    page_map[entry_index].bits.user = 1;

    if (page_map_level == 1) {
      --num_4kpages;
    } else {
      auto [ num_remain_pages, err ] = SetupPageMap(child_map, page_map_level - 1, addr, num_4kpages);
      if (err) {
        return { num_4kpages, err };
      }
      num_4kpages = num_remain_pages;
    }

    if (entry_index == 511) break;

    addr.SetPart(page_map_level, entry_index + 1);
    for (int level = page_map_level - 1; level >= 1; --level) {
      addr.SetPart(level, 0);
    }
  }
  return { num_4kpages, MAKE_ERROR(Error::kSuccess) };
}

WithError<PageMapEntry*> NewPageMap() {
  auto frame = memory_manager->Allocate(1);

  auto e = reinterpret_cast<PageMapEntry*>(frame.value.Frame());
  memset(e, 0, sizeof(uint64_t) * 512);
  return { e, MAKE_ERROR(Error::kSuccess) };
}

// 엔트리를 사용하고 있지 않다면 
WithError<PageMapEntry*> SetNewPageMapIfNotPresent(PageMapEntry& entry) {
  if (entry.bits.present) {
    return { entry.Pointer(), MAKE_ERROR(Error::kSuccess) };
  }

  auto [ child_map, err ] = NewPageMap();

  entry.SetPointer(child_map);
  entry.bits.present = 1;

  return { child_map, MAKE_ERROR(Error::kSuccess) };
}

__attribute__((interrupt))
void IntHandlerPF(InterruptFrame* frame, uint64_t error_code) {
  uint64_t cr2 = GetCR2();
  if (auto err = HandlePageFault(error_code, cr2); !err) {
    return;
  }
  KillApp(frame);
  PrintFrame(frame, "#PF");
  WriteString(*screen_writer, {500, 16*4}, "ERR", {0, 0, 0});
  PrintHex(error_code, 16, {500 + 8*4, 16*4});
  while (true) __asm__("hlt");
}

Error HandlePageFault(uint64_t error_code, uint64_t causal_addr) {
  auto& task = task_manager->CurrentTask();
  // P=1. 페이지레벨 권한 위반 예외. 이건 디맨드페이징 처리를 하면 안된다.
  if (error_code & 1) {
    return MAKE_ERROR(Error::kAlreadyAllocated);
  }
  if (causal_addr < task.DPagingBegin() || task.DPagingEnd() <= causal_addr) {
    return MAKE_ERROR(Error::kIndexOutOfRange);
  }
  return SetupPageMaps(LinearAddress4Level{causal_addr}, 1);
}

SYSCALL(DemandPages) {
  const size_t num_pages = arg1;
  // const int flags = arg2;
  __asm__("cli");
  auto& task = task_manager->CurrentTask();
  __asm__("sti");

  const uint64_t dp_end = task.DPagingEnd();
  task.SetDPagingEnd(dp_end + 4096 * numpages);
  return { dp_end, 0 };
}


Error Terminal::ExecuteFile(...) {
  // ... 
  const uint64_t elf_next_page = (elf_last_addr + 4095) & 0xffff'ffff'ffff'f000;
  task.SetDPagingBegin(elf_next_page);
  task.SetDPagingEnd(elf_next_page);

  auto entry_addr = elf_header->e_entry;
}

caddr_t sbrk(int incr) {
  static uint64_t dpage_end = 0;
  static uint64_t program_break = 0;

  if (dpage_end == 0 || dpage_end < program_break + incr) {
    int num_pages = (incr + 4095) / 4096;
    struct SyscallResult res = SyscallDemandPages(num_pages, 0);
    if (res.error) {
      errno = ENOMEM;
      return (caddr_t)-1;
    }
    program_break = res.value;
    dpage_end = res.value + 4096 * num_pages;
  }

  const uint64_t prev_break = program_break;
  program_break += incr;
  return (caddr_t)prev_break;
}

struct FileMapping {
  int fd;
  uint64_t vaddr_begin, vaddr_end;
};


Error Terminal::ExecuteFile(...) {
  task.SetDPagingEnd(elf_next_page);
  task.SetFileMapEnd(0xffff'ffff'ffff'e000);

  auto entry_addr = elf_header->e_entry;
  int ret = CallApp(...);

  task.Files().clear();
  task.FileMaps().clear();   // std::vector<FileMapping>& FileMaps();
}

// /apps/mmap
extern "C" void main(int argc, char** argv) {
  SyscallResult res = SyscallOpenFile("/memmap", O_RDONLY);
  size_t file_size;
  res = SyscallMapFile(fd, &file_size, 0);

  // 그냥 시스템콜 호출해서 얻은 주소에 랜덤액세스 하면 된다. 
  char* p = reinterpret_cast<char*>(res.value);
  for (size_t i = 0; i < file_size; ++i) {
    printf("%c", p[i]);
  }
}

// 시스템콜 구현
SYSCALL(MapFile) {
  const int fd = arg1;
  size_t* file_size = reinterpret_cast<size_t*>(arg2);
  // const int flags = arg3;

  __asm__("cli");
  auto& task = task_manager->CurrentTask();
  __asm__("sti");

  // 매핑할 파일이 open 되어있지 않은경우
  if (fd < 0 || task.Files().size() <= fd || !task.Files()[fd]) {
    return { 0, EBADF };
  }

  *file_size = task.Files()[fd]->Size();
  const uint64_t vaddr_end = task.FileMapEnd();
  // 파일을 결국 페이지단위로 정렬해서 배치해야함
  const uint64_t vaddr_begin = (vaddr_end - *file_size) & 0xffff'ffff'ffff'f000;
  // 다음 FileMapEnd
  task.SetFileMapEnd(vaddr_begin);
  task.FileMaps().push_back(FileMapping{fd, vaddr_begin, vaddr_end});
  return { vaddr_begin, 0 };
}

Error PreparePageCache(FileDescriptor& fd, const FileMapping& m,
                       uint64_t causal_vaddr) {
  LinearAddress4Level page_vaddr{causal_vaddr};
  // PF가 발생한 페이지 세팅 및 프레임 할당 (오프셋 값을 0으로세팅)
  page_vaddr.parts.offset = 0;
  if (auto err = SetupPageMaps(page_vaddr, 1)) {
    return err;
  }

  // 복사할 파일에서의 오프셋 구함  (접근한페이지주소 - 접근한주소의시작)
  const long file_offset = page_vaddr.value - m.vaddr_begin;
  void* page_cache = reinterpret_cast<void*>(page_vaddr.value);
  // 로드할 가상주소, 크기, 파일에서의 오프셋
  fd.Load(page_cache, 4096, file_offset);
  return MAKE_ERROR(Error::kSuccess);
}


Error HandlePageFault(uint64_t error_code, uint64_t causal_addr) {
  // 요구페이징 범위인 경우
  if (task.DPagingBegin() <= causal_addr && causal_addr < task.DPagingEnd()) {
    return SetupPageMaps(LinearAddress4Level{causal_addr}, 1);
  }
  // 매핑 요청된 파일인 경우
  if (auto m = FindFileMapping(task.FileMaps(), causal_addr)) {
    return PreparePageCache(*task.Files()[m->fd], *m, causal_addr);
  }
  return MAKE_ERROR(Error::kIndexOutOfRange);
}

size_t FileDescriptor::Load(void* buf, size_t len, size_t offset) {
  FileDescriptor fd{fat_entry_};
  // 파일 읽기 시작할 오프셋 지정 (접근한 파일에서의 오프셋)
  fd.rd_off_ = offset;

  // 클러스터에서의 위치 찾기
  unsigned long cluster = fat_entry_.FirstCluster();
  while (offset >= bytes_per_cluster) {
    offset -= bytes_per_cluster;
    cluster = NextCluster(cluster);
  }
  fd.rd_cluster_ = cluster;
  fd.rd_cluster_off_ = offset;

  // 클러스터 위치에서 읽어서 buf(mapped vaddr)에 쓰기. rd_off_는 len만큼 이동
  return fd.Read(buf, len);
}


size_t LoadFile(void* buf, size_t len, DirectoryEntry& entry) {
  return FileDescriptor{entry}.Read(buf, len);
}

struct AppLoadInfo {
  uint64_t vaddr_end, entry;
  PageMapEntry* pml4;
};

extern std::map<fat::DirectoryEntry*, AppLoadInfo>* apploads;


WithError<AppLoadInfo> LoadApp(fat::DirectoryEntry& file_entry, Task& task) {
  PageMapEntry* temp_pml4;
  // 커널의 PML4 테이블을 완전히 복사하고 cr3 교체
  if (auto [ pml4, err ] = SetupPML4(task); err) {
    return { {}, err };
  } else {
    temp_pml4 = pml4;
  }

  // 이미 관리중인 file_entry 라면 그 페이지를 복사해서 넘겨준다.
  if (auto it = app_loads->find(&file_entry); it != app_loads->end()) {
    AppLoadInfo app_load = it->second;
    // 페이지 테이블은 새로 만들지만, 기존 pml4를 얕은복사한다.
    // 커널 영역은 완전히 테이블까지 공유하지만 유저영역은(pml4[256:]) 물리주소(프레임)만 공유
    auto err = CopyPageMaps(temp_pml4, app_load.pml4, 4, 256);
    app_laod.pml4 = temp_pml4;
    return { app_load, err };
  }

  // 처음 로드되는 앱이라면
  // 원래 ELF 파일 로드할 때 하던 작업들. phdr에 맞춰서 메모리에 로드 + 페이징
  std::vector<uint8_t> file_buf(file_entry.file_size);
  fat::LoadFile(&file_buf[0], file_buf.size(), file_entry);

  auto elf_header = reinterpret_cast<Elf64_Ehdr*>(&file_buf[0]);
  if (memcmp(elf_header->e_ident, "\x7f" "ELF", 4) != 0) {
    return { {}, MAKE_ERROR(Error::kInvalidFile) };
  }

  auto [ last_addr, err_load ] = LoadELF(elf_header);
  if (err_load) {
    return { {}, err_load };
  }

  // 처음 로드되는 앱이기 때문에 파일 로드 정보에 기록 (temp_pml4 테이블은 앱에 할당하는게 아님)
  AppLoadInfo app_load{last_addr, elf_header->e_entry, temp_pml4};
  app_laods->insert(std::make_pair(&file_entry, app_load));

  // 기록용 pml4 테이블과 실제 앱에 적용할 pml4 테이블을 별도로 유지.
  if (auto [ pml4, err ] = SetupPML4(task); err) {
    return { app_load, err };
  } else {
    app_load.pml4 = pml4;
  }
  // 앱용 영역은 다시 얕은복사로 동일한 물리페이지를 가리키게한다. 
  auto err = CopyPageMaps(app_load.pml4, temp_pml422, 4, 256);
  return { app_load, err };
}

Error CopyPageMaps(PageMapEntry* dest, PageMapEntry* src, int part, int start) {
  // page_table[0:512] 세팅
  if (part == 1) {
    for (int i = start; i < 512; ++i) {
      if (!src[i].bits.present) {
        continue;
      }
      dest[i] = src[i];            // 물리주소 복사
      dest[i].bits.writable = 0;   // readonly 세팅
    }
    return MAKE_ERROR(Error::kSuccess);
  }

  // 처음들어오면 (part==4) pml4_table[start:512] 세팅
  // 재귀적으로 들어오면 pdpt_table[0:512], pd_table[0:512] 세팅
  for (int i = start; i < 512; ++i) {
    if (!src[i].bits.present) {
      continue;
    }
    // page_table(part==1)이 아니라면 새로운 페이지를 생성해서 연결
    auto [ table, err ] = NewPageMap();
    if (err) {
      return err;
    }
    dest[i] = src[i];          // src에서 속성까지 전부 복사
    dest[i].SetPointer(table); // 방금만든 페이지 물리 주소를 저장
    if (auto err = CopyPageMaps(table, src[i].Pointer(), part - 1, 0)) {
      return err;
    }
  }
  return MAKE_ERROR(Error::kSuccess);
}

Error HandlePageFault(uint64_t error_code, uint64_t causal_addr) {
  auto& task = task_manager->CurrentTask();
  const bool present = (error_code >> 0) & 1;
  const bool rw      = (error_code >> 1) & 1;
  const bool user    = (error_code >> 2) & 1;

  if (present && rw && user) {
    // 페이지가 있지만, write 로 권한에러 발생, user 앱인 경우. 페이지복사해줌
    return CopyOnePage(causal_addr);
  } else if (present) {
    // 페이지레벨 권한 위반 예외. 이건 디맨드페이징 처리를 하면 안된다.
    return MAKE_ERROR(Error::kAlreadyAllocated);
  }
  // ... 요구페이징처리 
}


Error CopyOnePage(uint64_t causal_addr) {
  auto [ p, err ] = NewPageMap();
  if (err) {
    return err;
  }
  // #PF 발생한 주소에 해당하는 페이지 찾음
  const auto aligned_addr = causal_addr & 0xffff'ffff'ffff'f000;
  // 새로운 페이지(=프레임)에 내용 전부 복사
  memcpy(p, reinterpret_cast<const void*>(aligned_addr), 4096);
  // 프레임을 현재 페이지테이블 말단에 세팅하면서 writable=1 로 세팅
  return SetPageContent(reinterpret_cast<PageMapEntry*>(GetCR3()), 4,
                        LinearAddress4Level{causal_addr}, p);
}

global InvalidateTLB  ; void InvalidateTLB(uint64_t addr);
InvalidateTLB:
    invlpg [rdi]
    ret


Error SetPageContent(PageMapEntry* table, int part,
                     LinearAddress4Level addr, PageMapEntry* content) {
  if (part == 1) {
    const auto i = addr.Part(part);
    table[i].SetPointer(content);
    table[i].bits.writable = 1;
    InvalidateTLB(addr.value);
    return MAKE_ERROR(Error::kSuccess);
  }

  const auto i = addr.Part(part);
  return SetPageContent(table[i].Pointer(), part - 1, addr, content);
}

// 커널의 페이지테이블 초기화함수 
void SetupIdentityPageTable() {
  pml4_table[0] = reinterpret_cast<uint64_t>(&pdp_table[0]) | 0x0003;
  for (int i_pdpt = 0; i_pdpt < page_directory.size(); ++i_pdpt) {
    pdp_table[i_pdpt] = reinterpret_cast<uint64_t>(&page_directory[i_pdpt]) | 0x003;
    for (int i_pd = 0; i_pd < 512; ++i_pd) {
      page_directory[i_pdpt][i_pd] = i_pdpt * kPageSize1G + i_pd * kPageSize2M | 0x083;
    }
  }
  ResetCR3();
  SetCR0(GetCR0() & 0xfffeffff); // Clear WP
}