266 lines
7.5 KiB
C++
266 lines
7.5 KiB
C++
#include <mercury/kernel/application.hpp>
|
|
#include <mercury/kernel/paging.hpp>
|
|
|
|
//TODO - scheduling.
|
|
|
|
namespace mercury::kernel::application {
|
|
|
|
app_instance::app_instance() : state(app_state::paused) {
|
|
|
|
framebuffer_vaddr = 0;
|
|
|
|
uint64_t p3_paddr;
|
|
uint64_t p2_paddr;
|
|
|
|
uint64_t p4_vaddr;
|
|
uint64_t p3_vaddr;
|
|
uint64_t p2_vaddr;
|
|
|
|
paging::map_new_kernel_page(p4_vaddr, p4_paddr);
|
|
paging::map_new_kernel_page(p3_vaddr, p3_paddr);
|
|
paging::map_new_kernel_page(p2_vaddr, p2_paddr);
|
|
|
|
p4 = (uint64_t *)p4_vaddr;
|
|
p3 = (uint64_t *)p3_vaddr;
|
|
p2 = (uint64_t *)p2_vaddr;
|
|
|
|
for (int i = 1; i < 511; ++i)
|
|
p4[i] = 0;
|
|
p4[511] = paging::kernel_p4e;
|
|
p4[0] = paging::encode_pte(p3_paddr, true, true, true, false);
|
|
|
|
for (int i = 1; i < 512; ++i)
|
|
p3[i] = 0;
|
|
p3[0] = paging::encode_pte(p2_paddr, true, true, true, false);
|
|
|
|
for (int i = 0; i < 512; ++i)
|
|
p2[i] = 0;
|
|
|
|
p2es_to_free_on_exit = new bool[512];
|
|
|
|
}
|
|
|
|
app_instance::~app_instance() {
|
|
|
|
for (int i = 1; i < 512; ++i)
|
|
if (p2[i] != 0 && p2es_to_free_on_exit[i]) {
|
|
uint64_t paddr = p2[i] & ~0x1fffffULL;
|
|
paging::mark_pram_region_free(paddr, paddr + 0x200000);
|
|
}
|
|
|
|
delete[] p2es_to_free_on_exit;
|
|
|
|
uint64_t p2_paddr = p3[0] & ~0x1fffffULL;
|
|
paging::unmap_kernel_page((uint64_t)p2);
|
|
paging::mark_pram_region_free(p2_paddr, p2_paddr + 4096);
|
|
|
|
uint64_t p3_paddr = p4[0] & ~0x1fffffULL;
|
|
paging::unmap_kernel_page((uint64_t)p3);
|
|
paging::mark_pram_region_free(p3_paddr, p3_paddr + 4096);
|
|
|
|
paging::unmap_kernel_page((uint64_t)p4);
|
|
paging::mark_pram_region_free(p4_paddr, p4_paddr + 4096);
|
|
|
|
}
|
|
|
|
void app_instance::map_page(uint64_t vaddr, uint64_t paddr,
|
|
bool write, bool execute, bool free_pram_on_exit
|
|
) {
|
|
uint64_t i = vaddr / 0x200000;
|
|
p2[i] = paging::encode_pte(paddr, true, write, execute, true);
|
|
p2es_to_free_on_exit[i] = free_pram_on_exit;
|
|
}
|
|
|
|
uint64_t app_instance::get_free_vaddr_pages(uint64_t count) {
|
|
uint64_t start = 1;
|
|
uint64_t length = 0;
|
|
while (start + length < 510) {
|
|
if (length == count)
|
|
return start * 0x200000;
|
|
if (p2[start + length] == 0)
|
|
++length;
|
|
else {
|
|
start += length + 1;
|
|
length = 0;
|
|
}
|
|
}
|
|
//TODO: handle out of memory
|
|
return 0;
|
|
}
|
|
|
|
void app_instance::create_stack() {
|
|
uint64_t stack_paddr = paging::take_2mib_pram_page();
|
|
map_page(0x3fe00000, stack_paddr, true, false, true);
|
|
for (int i = 0; i < 512; ++i) {
|
|
uint64_t vaddr = paging::find_unmapped_vram_region(1);
|
|
paging::map_kernel_page(stack_paddr + 512 * i, vaddr, true, false);
|
|
for (int j = 0; j < 4096 / 8; ++j)
|
|
*(uint64_t *)(vaddr + j * 8) = 0;
|
|
paging::unmap_kernel_page(vaddr);
|
|
}
|
|
saved_regs.rsp = 0x40000000;
|
|
}
|
|
|
|
void app_instance::set_instruction_pointer(uint64_t vaddr) {
|
|
saved_regs.rip = vaddr;
|
|
}
|
|
|
|
uint64_t app_instance::count_mapped_vram_pages() {
|
|
uint64_t count = 0;
|
|
for (int i = 1; i < 512; ++i)
|
|
if (p2[i] != 0)
|
|
++count;
|
|
return count;
|
|
}
|
|
|
|
app_instance *running_app;
|
|
|
|
static uint8_t correct_magic[16] = {
|
|
0x7f, 0x45, 0x4c, 0x46, 0x02, 0x01, 0x01, 0x00,
|
|
0x02, 0x00, 0x3e, 0x00, 0x01, 0x00, 0x00, 0x00
|
|
};
|
|
|
|
#define READ(a, b, c) \
|
|
{ \
|
|
storage::fs_result _result = file.read_file(a, b, c); \
|
|
if (_result == storage::fs_result::device_error) \
|
|
return create_app_result::device_error; \
|
|
if (_result == storage::fs_result::fs_corrupt) \
|
|
return create_app_result::fs_corrupt; \
|
|
}
|
|
|
|
struct load_info {
|
|
uint64_t foffset;
|
|
uint64_t fsize;
|
|
uint64_t vaddr;
|
|
uint64_t vpages;
|
|
bool writable;
|
|
bool executable;
|
|
};
|
|
|
|
create_app_result create_app(const vfile::vfile &file, app_instance *&out) {
|
|
|
|
uint8_t magic[16];
|
|
if (file.dir_entry.length < 64)
|
|
return create_app_result::app_corrupt;
|
|
READ(0, 8, magic)
|
|
READ(16, 8, magic + 8)
|
|
for (int i = 0; i < 16; ++i)
|
|
if (magic[i] != correct_magic[i])
|
|
return create_app_result::app_corrupt;
|
|
|
|
uint64_t entry_point;
|
|
uint64_t phead_start;
|
|
uint16_t phead_entry_size;
|
|
uint16_t phead_entry_count;
|
|
|
|
READ(24, 8, &entry_point)
|
|
READ(32, 8, &phead_start)
|
|
READ(54, 2, &phead_entry_size)
|
|
READ(56, 2, &phead_entry_count)
|
|
|
|
if (file.dir_entry.length <
|
|
phead_start + phead_entry_size * phead_entry_count)
|
|
return create_app_result::app_corrupt;
|
|
|
|
utility::vector<load_info> load_infos;
|
|
|
|
for (uint16_t i = 0; i < phead_entry_count; ++i) {
|
|
|
|
uint64_t entry_start = phead_start + phead_entry_size * i;
|
|
|
|
uint32_t seg_type;
|
|
READ(entry_start, 4, &seg_type)
|
|
if (seg_type != 1)
|
|
continue;
|
|
|
|
uint64_t foffset;
|
|
uint64_t vaddr;
|
|
uint64_t fsize;
|
|
uint64_t vsize;
|
|
uint32_t flags;
|
|
|
|
READ(entry_start + 8, 8, &foffset)
|
|
READ(entry_start + 16, 8, &vaddr)
|
|
READ(entry_start + 32, 8, &fsize)
|
|
READ(entry_start + 40, 8, &vsize)
|
|
READ(entry_start + 4, 4, &flags)
|
|
|
|
if (vaddr & 0x1fffff)
|
|
return create_app_result::app_corrupt;
|
|
if (file.dir_entry.length < foffset + fsize)
|
|
return create_app_result::app_corrupt;
|
|
if (fsize > vsize)
|
|
return create_app_result::app_corrupt;
|
|
if (vaddr == 0)
|
|
return create_app_result::app_corrupt;
|
|
|
|
uint64_t vpages = (vsize - 1) / 0x200000 + 1;
|
|
|
|
if (vaddr + vpages * 0x200000 > ((1 << 30) - (4 << 20)))
|
|
return create_app_result::app_corrupt;
|
|
|
|
load_info info = {
|
|
.foffset = foffset,
|
|
.fsize = fsize,
|
|
.vaddr = vaddr,
|
|
.vpages = vpages,
|
|
.writable = (flags & 2) == 2,
|
|
.executable = (flags & 1) == 1
|
|
};
|
|
load_infos.add_end(info);
|
|
|
|
}
|
|
|
|
out = new app_instance();
|
|
|
|
for (unsigned i = 0; i < load_infos.count; ++i) {
|
|
const auto &info = load_infos.buffer[i];
|
|
for (uint64_t j = 0; j < info.vpages; ++j) {
|
|
uint64_t paddr = paging::take_2mib_pram_page();
|
|
out->map_page(info.vaddr + j * 0x200000, paddr,
|
|
info.writable, info.executable, true);
|
|
for (int k = 0; k < 512; ++k) {
|
|
uint64_t offset_in_segment = j * 0x200000 + k * 4096;
|
|
uint64_t kvaddr = paging::find_unmapped_vram_region(1);
|
|
paging::map_kernel_page(paddr + k * 4096, kvaddr, true, false);
|
|
storage::fs_result result = storage::fs_result::success;
|
|
if (info.fsize > offset_in_segment) {
|
|
if (info.fsize >= offset_in_segment + 4096)
|
|
result = file.read_file(
|
|
info.foffset + offset_in_segment, 4096, (void *)kvaddr);
|
|
else {
|
|
int to_read = info.fsize - offset_in_segment;
|
|
result = file.read_file(
|
|
info.foffset + offset_in_segment, to_read, (void *)kvaddr);
|
|
uint8_t *blank = (uint8_t *)(kvaddr + to_read);
|
|
for (int i = 0; i < 4096 - to_read; ++i)
|
|
blank[i] = 0;
|
|
}
|
|
}
|
|
else {
|
|
uint8_t *blank = (uint8_t *)kvaddr;
|
|
for (int i = 0; i < 4096; ++i)
|
|
blank[i] = 0;
|
|
}
|
|
paging::unmap_kernel_page(kvaddr);
|
|
if (result == storage::fs_result::device_error) {
|
|
delete out;
|
|
return create_app_result::device_error;
|
|
}
|
|
if (result == storage::fs_result::fs_corrupt) {
|
|
delete out;
|
|
return create_app_result::fs_corrupt;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
out->create_stack();
|
|
out->set_instruction_pointer(entry_point);
|
|
|
|
return create_app_result::success;
|
|
|
|
}
|
|
|
|
}
|