433 lines
9.6 KiB
C++
433 lines
9.6 KiB
C++
#include <euler/syscall.hpp>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
extern "C" void __euler_do_syscall(
|
|
uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx);
|
|
|
|
namespace euler::syscall {
|
|
|
|
encoded_color encode_color(
|
|
uint8_t r, uint8_t g, uint8_t b) {
|
|
|
|
uint64_t rax = 0;
|
|
uint64_t rdi = (uint32_t)r | ((uint32_t)g << 8) | ((uint32_t)b << 16);
|
|
uint64_t rsi;
|
|
uint64_t rdx;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
return (encoded_color)(rax & 0xffffffff);
|
|
|
|
}
|
|
|
|
void get_framebuffer(
|
|
encoded_color *&buffer_out, uint32_t &width_out,
|
|
uint32_t &height_out, uint32_t &pitch_out) {
|
|
|
|
uint64_t rax = 1;
|
|
uint64_t rdi;
|
|
uint64_t rsi;
|
|
uint64_t rdx;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
|
|
buffer_out = (encoded_color *)rax;
|
|
width_out = rdi & 0xffffffff;
|
|
height_out = rdi >> 32;
|
|
pitch_out = rsi & 0xffffffff;
|
|
|
|
}
|
|
|
|
stream_result open_file(
|
|
const std::string &file_path, bool allow_creation,
|
|
bool only_allow_creation, stream_handle &handle_out) {
|
|
|
|
uint64_t rax = 2;
|
|
uint64_t rdi = (uint64_t)file_path.data();
|
|
uint64_t rsi = file_path.size();
|
|
uint64_t rdx =
|
|
( allow_creation ? 0x1 : 0x0) |
|
|
(only_allow_creation ? 0x2 : 0x0);
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
|
|
handle_out = rdi;
|
|
return (stream_result)rax;
|
|
|
|
}
|
|
|
|
[[noreturn]] void end_this_thread(int32_t exit_code) {
|
|
|
|
uint64_t rax = 3;
|
|
uint64_t rdi = (uint32_t)exit_code;
|
|
uint64_t rsi;
|
|
uint64_t rdx;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
__builtin_unreachable();
|
|
|
|
}
|
|
|
|
void *get_new_pages(uint64_t n_pages) {
|
|
|
|
uint64_t rax = 4;
|
|
uint64_t rdi = n_pages;
|
|
uint64_t rsi;
|
|
uint64_t rdx;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
return (void *)rax;
|
|
|
|
}
|
|
|
|
std::variant<mouse_packet, key_packet> get_input_packet() {
|
|
|
|
uint64_t rax = 5;
|
|
uint64_t rdi;
|
|
uint64_t rsi;
|
|
uint64_t rdx;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
|
|
if (rax & 0x80)
|
|
return (mouse_packet){
|
|
. left_button_down = (rax & 0x01) != 0,
|
|
. right_button_down = (rax & 0x02) != 0,
|
|
.middle_button_down = (rax & 0x04) != 0,
|
|
.x_changed = (int16_t)(rdi & 0xffff),
|
|
.y_changed = (int16_t)(rsi & 0xffff)
|
|
};
|
|
|
|
return (key_packet){
|
|
.was_key_up_event = (rdi & 0x40000) != 0,
|
|
. num_lock = (rdi & 0x20000) != 0,
|
|
. caps_lock = (rdi & 0x10000) != 0,
|
|
. right_win = (rdi & 0x8000) != 0,
|
|
. left_win = (rdi & 0x4000) != 0,
|
|
. right_alt = (rdi & 0x2000) != 0,
|
|
. left_alt = (rdi & 0x1000) != 0,
|
|
. right_ctrl = (rdi & 0x800) != 0,
|
|
. left_ctrl = (rdi & 0x400) != 0,
|
|
. right_shift = (rdi & 0x200) != 0,
|
|
. left_shift = (rdi & 0x100) != 0,
|
|
. key_code = (uint8_t)(rdi & 0xff)
|
|
};
|
|
|
|
}
|
|
|
|
void create_private_socket(
|
|
stream_handle &end_1_out, stream_handle &end_2_out) {
|
|
|
|
uint64_t rax = 6;
|
|
uint64_t rdi;
|
|
uint64_t rsi;
|
|
uint64_t rdx;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
|
|
end_1_out = rax;
|
|
end_2_out = rdi;
|
|
|
|
}
|
|
|
|
stream_result create_socket_listener(
|
|
const std::string &id, listener_handle &handle_out) {
|
|
|
|
uint64_t rax = 7;
|
|
uint64_t rdi = (uint64_t)id.data();
|
|
uint64_t rsi = id.size();
|
|
uint64_t rdx;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
|
|
handle_out = rdi;
|
|
return (stream_result)rax;
|
|
|
|
}
|
|
|
|
void stop_socket_listener(listener_handle handle) {
|
|
|
|
uint64_t rax = 8;
|
|
uint64_t rdi = handle;
|
|
uint64_t rsi;
|
|
uint64_t rdx;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
|
|
}
|
|
|
|
stream_result accept_socket_connection(
|
|
listener_handle listener, stream_handle &stream_out) {
|
|
|
|
uint64_t rax = 9;
|
|
uint64_t rdi = listener;
|
|
uint64_t rsi;
|
|
uint64_t rdx;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
|
|
stream_out = rdi;
|
|
return (stream_result)rax;
|
|
|
|
}
|
|
|
|
stream_result connect_to_socket(
|
|
const std::string &id, stream_handle &handle_out) {
|
|
|
|
uint64_t rax = 10;
|
|
uint64_t rdi = (uint64_t)id.data();
|
|
uint64_t rsi = id.size();
|
|
uint64_t rdx;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
|
|
handle_out = rdi;
|
|
return (stream_result)rax;
|
|
|
|
}
|
|
|
|
void close_stream(stream_handle handle) {
|
|
|
|
uint64_t rax = 11;
|
|
uint64_t rdi = handle;
|
|
uint64_t rsi;
|
|
uint64_t rdx;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
|
|
}
|
|
|
|
stream_result seek_stream(
|
|
stream_handle handle, seek_from from, int64_t offset) {
|
|
|
|
uint64_t rax = 12;
|
|
uint64_t rdi = (uint64_t)handle;
|
|
uint64_t rsi = (uint8_t)from;
|
|
uint64_t rdx = (uint64_t)offset;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
return (stream_result)rax;
|
|
|
|
}
|
|
|
|
stream_result read_from_stream(
|
|
stream_handle handle, uint64_t bytes, void *into) {
|
|
|
|
uint64_t rax = 13;
|
|
uint64_t rdi = (uint64_t)handle;
|
|
uint64_t rsi = bytes;
|
|
uint64_t rdx = (uint64_t)into;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
return (stream_result)rax;
|
|
|
|
}
|
|
|
|
stream_result write_to_stream(
|
|
stream_handle handle, uint64_t bytes, const void *from) {
|
|
|
|
uint64_t rax = 14;
|
|
uint64_t rdi = (uint64_t)handle;
|
|
uint64_t rsi = bytes;
|
|
uint64_t rdx = (uint64_t)from;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
return (stream_result)rax;
|
|
|
|
}
|
|
|
|
stream_result get_stream_length(
|
|
stream_handle handle, uint64_t &length_out) {
|
|
|
|
uint64_t rax = 15;
|
|
uint64_t rdi = (uint64_t)handle;
|
|
uint64_t rsi;
|
|
uint64_t rdx;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
|
|
length_out = rdi;
|
|
return (stream_result)rax;
|
|
|
|
}
|
|
|
|
stream_result start_process(
|
|
const std::string &file_path,
|
|
const std::vector<std::pair<std::string, std::string>> &environment_variables,
|
|
const std::vector<std::pair<stream_handle, stream_result>> &gifted_streams,
|
|
process_handle &handle_out) {
|
|
|
|
std::vector<uint64_t> ev_structs(environment_variables.size() * 4);
|
|
for (size_t i = 0; i < environment_variables.size(); ++i) {
|
|
ev_structs[i * 4] = environment_variables[i]. first.size();
|
|
ev_structs[i * 4 + 1] = (uint64_t)environment_variables[i]. first.data();
|
|
ev_structs[i * 4 + 2] = environment_variables[i].second.size();
|
|
ev_structs[i * 4 + 3] = (uint64_t)environment_variables[i].second.data();
|
|
}
|
|
|
|
std::vector<uint64_t> gs_structs(gifted_streams.size() * 2);
|
|
for (size_t i = 0; i < environment_variables.size(); ++i) {
|
|
gs_structs[i * 2] = (uint64_t)gifted_streams[i]. first;
|
|
gs_structs[i * 2 + 1] = (uint64_t)gifted_streams[i].second;
|
|
}
|
|
|
|
uint64_t psi_struct[] = {
|
|
file_path.size(), (uint64_t) file_path.data(),
|
|
environment_variables.size(), (uint64_t)ev_structs.data(),
|
|
gifted_streams.size(), (uint64_t)gs_structs.data()
|
|
};
|
|
|
|
uint64_t rax = 16;
|
|
uint64_t rdi = (uint64_t)psi_struct;
|
|
uint64_t rsi;
|
|
uint64_t rdx;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
|
|
handle_out = rdi;
|
|
return (stream_result)rax;
|
|
|
|
}
|
|
|
|
[[noreturn]] void end_this_process(int32_t exit_code) {
|
|
|
|
uint64_t rax = 17;
|
|
uint64_t rdi = (uint32_t)exit_code;
|
|
uint64_t rsi;
|
|
uint64_t rdx;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
__builtin_unreachable();
|
|
|
|
}
|
|
|
|
stream_result set_stream_length(
|
|
stream_handle handle, uint64_t new_length) {
|
|
|
|
uint64_t rax = 18;
|
|
uint64_t rdi = (uint64_t)handle;
|
|
uint64_t rsi = new_length;
|
|
uint64_t rdx;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
return (stream_result)rax;
|
|
|
|
}
|
|
|
|
stream_result get_other_end_process_handle(
|
|
stream_handle stream, process_handle &process_out) {
|
|
|
|
uint64_t rax = 19;
|
|
uint64_t rdi = (uint64_t)stream;
|
|
uint64_t rsi;
|
|
uint64_t rdx;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
|
|
process_out = (process_handle)rdi;
|
|
return (stream_result)rax;
|
|
|
|
}
|
|
|
|
//entry_point must not return
|
|
void start_thread(void (*entry_point)(uint64_t), uint64_t arg) {
|
|
|
|
uint64_t rax = 20;
|
|
uint64_t rdi = (uint64_t)entry_point;
|
|
uint64_t rsi = arg;
|
|
uint64_t rdx;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
|
|
}
|
|
|
|
//entry_point must not return
|
|
void start_thread(void (*entry_point)()) {
|
|
|
|
uint64_t rax = 20;
|
|
uint64_t rdi = (uint64_t)entry_point;
|
|
uint64_t rsi = 0;
|
|
uint64_t rdx;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
|
|
}
|
|
|
|
//return value is number of bytes cleared
|
|
uint64_t clear_socket_read_queue(stream_handle handle) {
|
|
|
|
uint64_t rax = 21;
|
|
uint64_t rdi = handle;
|
|
uint64_t rsi;
|
|
uint64_t rdx;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
return rax;
|
|
|
|
}
|
|
|
|
//this function has a race condition if the variable is changed
|
|
//or unset by another thread between the two syscalls.
|
|
std::optional<std::string> try_get_environment_variable(
|
|
const std::string &name) {
|
|
|
|
uint64_t rax = 22;
|
|
uint64_t rdi = (uint64_t)name.data();
|
|
uint64_t rsi = name.size();
|
|
uint64_t rdx;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
|
|
if (rax == (uint64_t)-1)
|
|
return {};
|
|
|
|
std::string s;
|
|
s.resize(rax);
|
|
|
|
rax = 23;
|
|
rdi = (uint64_t)name.data();
|
|
rsi = name.size();
|
|
rdx = (uint64_t)s.data();
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
//do i need to tell gcc that s is modified?
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
void set_thread_name(const std::string &name) {
|
|
|
|
uint64_t rax = 24;
|
|
uint64_t rdi = (uint64_t)name.data();
|
|
uint64_t rsi = name.size();
|
|
uint64_t rdx;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
|
|
}
|
|
|
|
void sleep(uint64_t mibiseconds) {
|
|
|
|
uint64_t rax = 25;
|
|
uint64_t rdi = mibiseconds;
|
|
uint64_t rsi;
|
|
uint64_t rdx;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
|
|
}
|
|
|
|
uint64_t get_time() {
|
|
|
|
uint64_t rax = 26;
|
|
uint64_t rdi;
|
|
uint64_t rsi;
|
|
uint64_t rdx;
|
|
|
|
__euler_do_syscall(rax, rdi, rsi, rdx);
|
|
return rax;
|
|
|
|
}
|
|
|
|
}
|