어플리케이션

TARGET = onlyhlt

.PHONY: all
all: $(TARGET)

onlyhlt: onlyhlt.asm Makefile
	nasm -f bin -o $@ $<

bits 64
section .text

loop:
    hlt
    jmp loop

void Terminal::ExecuteLine() {
  char* command = &linebuf_[0];
  if (strcmp(command, "echo") == 0) {
     // ...
  } else if (command[0] != 0) {
    auto file_entry = fat::FindFile(command);
    if (!file_entry) {
      Print("no such command: ");
      Print(command);
      Print("\n");
    } else {
      ExecuteFile(*file_entry);
    }
  }
}

void Terminal::ExecuteFile(const fat::DirectoryEntry& file_entry) {
  auto cluster = file_entry.FirstCluster();
  auto remain_bytes = file_entry.file_size;

  std::vector<uint8_t> file_buf(remain_bytes);
  auto p = &file_buf[0];

  while (cluster != 0 && cluster != fat::kEndOfClusterchain) {
    const auto copy_bytes = fat::bytes_per_cluster < remain_bytes ?
      fat::bytes_per_cluster : remain_bytes;
    memcpy(p, fat::GetSectorByCluster<uint8_t>(cluster), copy_bytes);
    
    remain_bytes -= copy_bytes;
    p += copy_bytes;
    cluster = fat::NextCluster(cluster);
  }

  using Func = void ();
  auto f = reinterpret_cast<Func*>(&file_buf[0]);
  f();
}

void Terminal::ExecuteFile(const fat::DirectoryEntry& file_entry, char* command, char* first_arg) {
  auto cluster = file_entry.FirstCluster();
  auto remain_bytes = file_entry.file_size;

  std::vector<uint8_t> file_buf(remain_bytes);
  auto p = &file_buf[0];

  while (cluster != 0 && cluster != fat::kEndOfClusterchain) {
    const auto copy_bytes = fat::bytes_per_cluster < remain_bytes ?
      fat::bytes_per_cluster : remain_bytes;
    memcpy(p, fat::GetSectorByCluster<uint8_t>(cluster), copy_bytes);
    
    remain_bytes -= copy_bytes;
    p += copy_bytes;
    cluster = fat::NextCluster(cluster);
  }

  auto elf_header = reinterpret_cast<Elf64_Ehdr*>(&file_buf[0]);
  if (memcmp(elf_header->e_ident, "\x7f" "ELF", 4) != 0) {
    using Func = void ();
    auto f = reinterpret_cast<Func*>(&file_buf[0]);
    f();
    return;
  }

  // ELF인 경우 파싱 후 실행
  auto argv = MakeArgVector(command, first_arg);
  auto entry_addr = elf_header->e_entry;
  entry_addr += reinterpret_cast<uintptr_t>(&file_buf[0]);
  using Func = int (int, char**);
  auto f = reinterpret_cast<Func*>(entry_addr);
  auto ret = f(argv.size(), &argv[0]);

  char s[64];
  sprintf(s, "app exited. ret = %d\n", ret);
  Print(s);
}

CPPFLAGS += -I.
CXXFLAGS += -O2 -Wall -g --target=x86_64-elf -ffreestanding \
						-fno-exceptions -fno-rtti -std=c++17
LDFLAGS  += --entry main -z norelro --image-base 0 --static

rpn: rpn.o Makefile
	ld.lld $(LDFLAGS) -o rpn rpn.o

%.o: %.cpp Makefile
	clang++ $(CPPFLAGS) $(CXXFLAGS) -c $< -o $@

pwndbg> disassemble Terminal::ExecuteFile
   0x000000000016e8fd <+493>:   mov    rsi,rax
   0x000000000016e900 <+496>:   mov    rax,QWORD PTR [rbp-0x108]
   0x000000000016e907 <+503>:   call   rax                ; here!!
pwndbg> b 0x000000000016e907
pwndbg> c
pwndbg> list
250       auto entry_addr = elf_header->e_entry;
251       entry_addr += reinterpret_cast<uintptr_t>(&file_buf[0]);
252       using Func = int (int, char**);
253       auto f = reinterpret_cast<Func*>(entry_addr);
254       auto ret = f(argv.size(), &argv[0]);            // same here!!

pwndbg> x/10i entry_addr
   0x1437400:   add    DWORD PTR [rax],eax
   0x1437402:   add    BYTE PTR [rax],al
pwndbg> x/10gx entry_addr
0x1437400:      0x0000000000000001      0x0000000000000001
0x1437410:      0x00000002000000a2      0x0000000000000000

pwndbg> x/30gx &file_buf[0]
0x14361e0:      0x00010102464c457f      0x0000000000000000
0x14361f0:      0x00000001003e0002      0x0000000000001220
pwndbg> p (char*) elf_header->e_entry
$7 = 0x1220 ""

pwndbg> x/100i (char*)(0x14361e0 + 0x1220 - 0x1000)
   0x1436400:   push   rbp
   0x1436401:   mov    rbp,rsp
   0x1436404:   cmp    edi,0x1
   0x1436407:   jle    0x14364de
   0x143640d:   mov    r8d,edi

# Usage: source buildenv.sh

BASEDIR="$HOME/min-os/devenv/x86_64-elf"
EDK2DIR="$HOME/min-os/devenv/edk2"

if [ ! -d $BASEDIR ]
then
    echo "$BASEDIR が存在しません。"
    echo "以下のファイルを手動でダウンロードし、$(dirname $BASEDIR)に展開してください。"
    echo "https://github.com/uchan-nos/mikanos-build/releases/download/v2.0/x86_64-elf.tar.gz "
else
    export CPPFLAGS="\
    -I$BASEDIR/include/c++/v1 -I$BASEDIR/include -I$BASEDIR/include/freetype2 \
    -I$EDK2DIR/MdePkg/Include -I$EDK2DIR/MdePkg/Include/X64 \
    -nostdlibinc -D__ELF__ -D_LDBL_EQ_DBL -D_GNU_SOURCE -D_POSIX_TIMERS \
    -DEFIAPI='__attribute__((ms_abi))'"
    export LDFLAGS="-L$BASEDIR/lib"
fi

# clang++ -I/home/kdh/min-os/devenv/x86_64-elf/include/c++/v1 -I/home/kdh/min-os/devenv/x86_64-elf/include \ 
#     -I/home/kdh/min-os/devenv/x86_64-elf/include/freetype2     -I/home/kdh/min-os/devenv/edk2/MdePkg/Include \ 
#     -I/home/kdh/min-os/devenv/edk2/MdePkg/Include/X64 \   
#     -nostdlibinc -D__ELF__ -D_LDBL_EQ_DBL -D_GNU_SOURCE -D_POSIX_TIMERS     -DEFIAPI='__attribute__((ms_abi))' 
#     -I. -O2 -Wall -g --target=x86_64-elf -ffreestanding -fno-exceptions -fno-rtti \ 
#     -std=c++17 -c rpn.cpp -o rpn.o

# ld.lld -L/home/kdh/min-os/devenv/x86_64-elf/lib --entry main -z norelro --image-base 0 \
#     --static -o rpn rpn.o -lc -lc++ -lc++abi

### -O2 빌드
# 전부 최적화돼서 main 함수에서 바로 비교한다.
    1272:       3c 2d                   cmp    $0x2d,%al    # '-'
    1274:       74 2a                   je     12a0 <main+0x80>
    1276:       3c 2b                   cmp    $0x2b,%al    # '+'
    1278:       75 2c                   jne    12a6 <main+0x86>


### -O0 빌드
kdh@DESKTOP-MHEA7GE:~/min-os/apps/rpn$ hexdump -C -s 0x158 -n 4 rpn
00000158  2d 00 2b 00                                       |-.+.|
0000015c

    131a:       48 8b 3c c8             mov    (%rax,%rcx,8),%rdi
    131e:       48 be 5a 01 00 00 00    movabs $0x15a,%rsi
    1325:       00 00 00
    1328:       e8 33 fe ff ff          call   1160 <_Z6strcmpPKcS0_>

# 런타임에 rpn 어플리케이션 main 들어간 직후
pwndbg> x/2s 0x14374e0-0x2f0            # rpn의 ELF헤더
0x14371f0:      "\177ELF\002\001\001"
0x14371f8:      ""
pwndbg> x/2s 0x14374e0-0x2f0+0x158      # 리터럴 문자열 위치
0x1437348:      "-"
0x143734a:      "+"

Error Terminal::ExecuteFile(const fat::DirectoryEntry& file_entry, char* command, char* first_arg) {
  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 (auto err = LoadELF(elf_header)) 
  { return error; }

  auto argv = MakeArgVector(command, first_arg);
  auto entry_addr = elf_header->e_entry;
  using Func = int (int, char**);
  auto f = reinterpret_cast<Func*>(entry_addr); 
  auto ret = f(argv.size(), &argv[0]);
}

Elf64_Phdr* GetProgramHeader(Elf64_Ehdr* ehdr) {
  return reinterpret_cast<Elf64_Phdr*>(
    reinterpret_cast<uintptr_t>(ehdr) + ehdr->e_phoff);
}

uintptr_t GetFirstLoadAddress(Elf64_Ehdr* ehdr) {
  auto phdr = GetProgramHeader(ehdr);
  for (int i = 0; i < ehdr->e_phnum; ++i) {
    if (phdr[i].p_type != PT_LOAD) continue;
    return phdr[i].p_vaddr;
  }
  return 0;
}

Error LoadELF(Elf64_Ehdr* ehdr) {
  if (ehdr->e_type != ET_EXEC) {
    return MAKE_ERROR(Error::kInvalidFormat);
  }
  const auto addr_first = GetFirstLoadAddress(ehdr);
  if (addr_first < 0xffff'8000'0000'0000) {
    return MAKE_ERROR(Error::kInvalidFormat);
  }

  if (auto err = CopyLoadSegments(ehdr)) {
    return err;
  }

  return MAKE_ERROR(Error::kSuccess);
}

Error CopyLoadSegments(Elf64_Ehdr* ehdr) {
  auto phdr = GetProgramHeader(ehdr);
  for (int i = 0; i < ehdr->e_phnum; ++i) {
    if (phdr[i].p_type != PT_LOAD) continue;

    LinearAddress4Level dest_addr;
    dest_addr.value = phdr[i].p_vaddr;
    // p_vaddr이 해당 페이지의 무조건 0에서 시작하는게 아니다.
    // p_vaddr이 0x2b00 에서 시작하고, p_memsz가 0x0c00 인 경우 page가 2개 필요하다.
    const auto num_4kpages = (phdr[i].p_vaddr % 4096
                               + phdr[i].p_memsz + 4095) / 4096;

    if (auto err = SetupPageMaps(dest_addr, num_4kpages)) {
      return err;
    }

    const auto src = reinterpret_cast<uint8_t*>(ehdr) + phdr[i].p_offset;
    const auto dst = reinterpret_cast<uint8_t*>(phdr[i].p_vaddr);
    memcpy(dst, src, phdr[i].p_filesz);
    memset(dst + phdr[i].p_filesz, 0, phdr[i].p_memsz - phdr[i].p_filesz);
  }
  return MAKE_ERROR(Error::kSuccess);
}

union LinearAddress4Level {
  uint64_t value;

  struct {
    uint64_t offset : 12;
    uint64_t page : 9;
    uint64_t dir : 9;
    uint64_t pdp : 9;
    uint64_t pml4 : 9;
    uint64_t : 16;
  } __attribute__((packed)) parts;

  int Part(int page_map_level) const {
    switch (page_map_level) {
    case 0: return parts.offset;
    case 1: return parts.page;
    case 2: return parts.dir;
    case 3: return parts.pdp;
    case 4: return parts.pml4;
    default: return 0;
    }
  }

  // void SetPart(int page_map_level, int value)
}

union PageMapEntry {
  uint64_t data;

  struct {
    uint64_t present : 1;
    uint64_t writable : 1;
    uint64_t user : 1;
    uint64_t write_through : 1;
    uint64_t cache_disable : 1;
    uint64_t accessed : 1;
    uint64_t dirty : 1;
    uint64_t huge_page : 1;
    uint64_t global : 1;
    uint64_t : 3;

    uint64_t addr : 40;
    uint64_t : 12;
  } __attribute__((packed)) bits;

  PageMapEntry* Pointer() const {
    return reinterpret_cast<PageMapEntry*>(bits.addr << 12);
  }

  void SetPointer(PageMapEntry* p) {
    bits.addr = reinterpret_cast<uint64_t>(p) >> 12;
  }
};

// 프로그램 헤더에서 하나의 시그먼트를 가져옴
// CopyLoadSegments 함수 내부...
//    LinearAddress4Level dest_addr;
//    dest_addr.value = phdr[i].p_vaddr;
//    SetupPageMaps(dest_addr, num_4kpages)

// 일단은 현재 CR3 레지스터에 있는 페이지테이블을 가져온다.
Error SetupPageMaps(LinearAddress4Level addr, size_t num_4kpages) {
  auto pml4_table = reinterpret_cast<PageMapEntry*>(GetCR3());
  return SetupPageMap(pml4_table, 4, addr, num_4kpages).error;
}

// page_map: pml4_table , page_map_level: 4  부터 시작
WithError<size_t> SetupPageMap(
    PageMapEntry* page_map, int page_map_level, LinearAddress4Level addr, size_t num_4kpages) {
  // 페이지 전부 할당될 때 까지 반복
  while (num_4kpages > 0) {
    // 가상주소에서 현재 레벨에 해당하는 인덱스를 가져오고, 
    // 테이블에 엔트리(하위테이블)가 없다면(not present) 하나 할당한다.
    // 엔트리도 `8byte * 512 = 4k` 이고, 페이지도 `4k` 이다
    const auto entry_index = addr.Part(page_map_level);
    auto [ child_map, err ] = SetNewPageMapIfNotPresent(page_map[entry_index]);
    
    // 재귀적으로 가상주소에 맞는 다음 테이블에도 계속해서 세팅한다.
    // page_map_level 이 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;
    }

    // 엔트리가 테이블 크기보다 넘어가면 break 후 상위 테이블에서 기록한다.
    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);
  if (frame.error) {
    return { nullptr, frame.error };
  }

  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();
  if (err) { return { nullptr, err }; }

  // 새로 만든건 하위테이블 혹은 페이지이다.
  entry.SetPointer(child_map);
  entry.bits.present = 1;

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

Error CleanPageMap(PageMapEntry* page_map, int page_map_level) {
  for (int i = 0; i < 512; ++i) {
    auto entry = page_map[i];
    if (!entry.bits.present) {
      continue;
    }

    if (page_map_level > 1) {
      if (auto err = CleanPageMap(entry.Pointer(), page_map_level - 1)) {
        return err;
      }
    }
    const auto entry_addr = reinterpret_cast<uintptr_t>(entry.Pointer());
    const FrameID map_frame{entry_addr / kBytesPerFrame};
    if (auto err = memory_manager->Free(map_frame, 1)) {
      return err;
    }
    page_map[i].data = 0;
  }

  return MAKE_ERROR(Error::kSuccess);
}

Error CleanPageMaps(LinearAddress4Level addr) {
  auto pml4_table = reinterpret_cast<PageMapEntry*>(GetCR3());
  auto pdp_table = pml4_table[addr.parts.pml4].Pointer();
  pml4_table[addr.parts.pml4].data = 0;
  if (auto err = CleanPageMap(pdp_table, 3)) {
    return err;
  }

  const auto pdp_addr = reinterpret_cast<uintptr_t>(pdp_table);
  const FrameID pdp_frame{pdp_addr / kBytesPerFrame};
  return memory_manager->Free(pdp_frame, 1);
}