vdso

kernel/vdso/archctl.c

@@ -0,0 +1,8 @@
+#include <zinnia/archctl.h>
+#include <kernel/vdso.h>
+
+zn_status_t zn_archctl(zn_archctl_t op, void* value) {
+    return zn_syscall2(op, value, ZN_SYSCALL_ARCHCTL);
+}
+
+VDSO_SYMBOL(zn_archctl);

kernel/vdso/channel.c

@@ -0,0 +1,43 @@
+#include <zinnia/channel.h>
+#include <kernel/vdso.h>
+
+zn_status_t zn_channel_create(enum zn_channel_flags flags, zn_handle_t* endpoint0, zn_handle_t* endpoint1) {
+    return zn_syscall3(flags, endpoint0, endpoint1, ZN_SYSCALL_CHANNEL_CREATE);
+}
+
+VDSO_SYMBOL(zn_channel_create);
+
+zn_status_t zn_channel_write(
+    zn_handle_t channel,
+    const zn_handle_t* handles,
+    const void* bytes,
+    size_t num_handles,
+    size_t num_bytes
+) {
+    return zn_syscall5(channel, handles, bytes, num_handles, num_bytes, ZN_SYSCALL_CHANNEL_WRITE);
+}
+
+VDSO_SYMBOL(zn_channel_write);
+
+zn_status_t zn_channel_read(
+    zn_handle_t channel,
+    zn_handle_t* handles,
+    void* bytes,
+    size_t num_handles,
+    size_t num_bytes,
+    size_t* read_handles,
+    size_t* read_bytes
+) {
+    return zn_syscall7(
+        channel,
+        handles,
+        bytes,
+        num_handles,
+        num_bytes,
+        read_handles,
+        read_bytes,
+        ZN_SYSCALL_CHANNEL_READ
+    );
+}
+
+VDSO_SYMBOL(zn_channel_read);

kernel/vdso/data.c

@@ -0,0 +1,7 @@
+#include <common/compiler.h>
+#include <kernel/vdso.h>
+
+[[__used, __section(".vdso_data")]]
+const volatile struct vdso_kernel_data vdso_data = {0};
+
+static_assert(sizeof(vdso_data) <= 0x1000);

kernel/vdso/futex.c

@@ -0,0 +1,14 @@
+#include <zinnia/futex.h>
+#include <kernel/vdso.h>
+
+zn_status_t zn_futex_wait(int32_t* addr, int32_t expected) {
+    return zn_syscall2(addr, expected, ZN_SYSCALL_FUTEX_WAIT);
+}
+
+VDSO_SYMBOL(zn_futex_wait);
+
+zn_status_t zn_futex_wake(int32_t* addr, int32_t count) {
+    return zn_syscall2(addr, count, ZN_SYSCALL_FUTEX_WAKE);
+}
+
+VDSO_SYMBOL(zn_futex_wake);

kernel/vdso/handle.c

@@ -0,0 +1,20 @@
+#include <zinnia/handle.h>
+#include <kernel/vdso.h>
+
+zn_status_t zn_handle_validate(zn_handle_t handle) {
+    return zn_syscall1(handle, ZN_SYSCALL_HANDLE_VALIDATE);
+}
+
+VDSO_SYMBOL(zn_handle_validate);
+
+zn_status_t zn_handle_drop(zn_handle_t handle) {
+    return zn_syscall1(handle, ZN_SYSCALL_HANDLE_DROP);
+}
+
+VDSO_SYMBOL(zn_handle_drop);
+
+zn_status_t zn_handle_clone(zn_handle_t handle, zn_rights_t cloned_rights, zn_handle_t* cloned) {
+    return zn_syscall3(handle, cloned_rights, cloned, ZN_SYSCALL_HANDLE_CLONE);
+}
+
+VDSO_SYMBOL(zn_handle_clone);

kernel/vdso/mem.c

@@ -0,0 +1,33 @@
+#include <zinnia/mem.h>
+#include <kernel/vdso.h>
+
+zn_status_t zn_vmo_create(size_t length, zn_handle_t* out) {
+    return zn_syscall2(length, out, ZN_SYSCALL_VMO_CREATE);
+}
+
+VDSO_SYMBOL(zn_vmo_create);
+
+zn_status_t zn_vmo_create_phys(uintptr_t phys_addr, size_t length, zn_handle_t* out) {
+    return zn_syscall3(phys_addr, length, out, ZN_SYSCALL_VMO_CREATE_PHYS);
+}
+
+VDSO_SYMBOL(zn_vmo_create_phys);
+
+zn_status_t zn_vmo_map(
+    zn_handle_t vmo,
+    zn_handle_t vas,
+    uintptr_t vmo_offset,
+    uintptr_t* addr,
+    size_t bytes,
+    enum zn_vm_flags flags
+) {
+    return zn_syscall6(vmo, vas, vmo_offset, addr, bytes, flags, ZN_SYSCALL_VMO_MAP);
+}
+
+VDSO_SYMBOL(zn_vmo_map);
+
+zn_status_t zn_vas_create(zn_handle_t* out) {
+    return zn_syscall1(out, ZN_SYSCALL_VAS_CREATE);
+}
+
+VDSO_SYMBOL(zn_vas_create);

kernel/vdso/meson.build

@@ -0,0 +1,48 @@
+vdso_c_args = [
+    '-ffreestanding',
+    '-fno-stack-protector',
+    '-fno-omit-frame-pointer',
+    '-fPIE',
+    '-fPIC',
+    '-nostdinc',
+    '-DIN_VDSO',
+]
+
+vdso_lds = meson.current_source_dir() / 'vdso.ld'
+
+vdso_link_args = [
+    '-ffreestanding',
+    '-nostdlib',
+    '-static',
+    '-T' + vdso_lds,
+]
+
+# Build a shared library, which we are going to embed next.
+# TODO: We need to ensure there are no relocations inside the vDSO.
+vdso = shared_library(
+    'zinnia-vdso',
+    name_prefix: '',
+    c_args: vdso_c_args,
+    include_directories: [
+        common_includes,
+        kernel_includes,
+    ],
+    link_args: vdso_link_args,
+    link_depends: vdso_lds,
+    sources: [
+        'archctl.c',
+        'channel.c',
+        'data.c',
+        'futex.c',
+        'handle.c',
+        'mem.c',
+        'namespace.c',
+        'random.c',
+        'status.c',
+        'system.c',
+        'thread.c',
+    ],
+)
+
+# Tell the kernel where the built binary lives so we can #embed it.
+kernel_c_args += ['-DVDSO_PATH="' + vdso.full_path() + '"']

kernel/vdso/namespace.c

@@ -0,0 +1,14 @@
+#include <zinnia/namespace.h>
+#include <kernel/vdso.h>
+
+zn_status_t zn_ns_create(zn_handle_t* out) {
+    return ZN_ERR_UNSUPPORTED;
+}
+
+VDSO_SYMBOL(zn_ns_create);
+
+zn_status_t zn_ns_move(zn_handle_t handle, zn_handle_t target_ns) {
+    return ZN_ERR_UNSUPPORTED;
+}
+
+VDSO_SYMBOL(zn_ns_move);

kernel/vdso/random.c

@@ -0,0 +1,14 @@
+#include <zinnia/random.h>
+#include <kernel/vdso.h>
+
+zn_status_t zn_random_get(void* addr, size_t len) {
+    return zn_syscall2(addr, len, ZN_SYSCALL_RANDOM_GET);
+}
+
+VDSO_SYMBOL(zn_random_get);
+
+zn_status_t zn_random_entropy(const void* addr, size_t len) {
+    return zn_syscall2(addr, len, ZN_SYSCALL_RANDOM_ENTROPY);
+}
+
+VDSO_SYMBOL(zn_random_entropy);

kernel/vdso/status.c

@@ -0,0 +1,35 @@
+#include <zinnia/status.h>
+#include <kernel/vdso.h>
+
+const char* zn_status_to_string(zn_status_t err) {
+    switch (err) {
+    case ZN_OK:
+        return "No error (OK)";
+    case ZN_ERR_INTERNAL:
+        return "An internal error occured (INTERNAL)";
+    case ZN_ERR_BAD_SYSCALL:
+        return "Syscall number is not a recognized syscall (BAD_SYSCALL)";
+    case ZN_ERR_UNSUPPORTED:
+        return "This operation is not supported or implemented yet (UNSUPPORTED)";
+    case ZN_ERR_NO_MEMORY:
+        return "System does not have enough free memory for this operation (NO_MEMORY)";
+    case ZN_ERR_NO_HANDLES:
+        return "Process can not own any more handles (NO_HANDLES)";
+    case ZN_ERR_INVALID:
+        return "One or more of the provided arguments is not valid (INVALID)";
+    case ZN_ERR_BAD_RANGE:
+        return "Argument is outside of the range for valid values (BAD_RANGE)";
+    case ZN_ERR_BAD_HANDLE:
+        return "Object handle does not name a valid object (BAD_HANDLE)";
+    case ZN_ERR_BAD_PERMS:
+        return "Object has insufficient permissions for this operation (BAD_PERMS)";
+    case ZN_ERR_BAD_BUFFER:
+        return "Buffer is not large enough or doesn't point to a valid memory region (BAD_BUFFER)";
+    case ZN_ERR_ALREADY_EXISTS:
+        return "The resource already exists (ALREADY_EXISTS)";
+    }
+
+    return "Unknown error code";
+}
+
+VDSO_SYMBOL(zn_status_to_string);

kernel/vdso/system.c

@@ -0,0 +1,28 @@
+#include <zinnia/system.h>
+#include <kernel/vdso.h>
+
+void zn_log(const char* message, size_t len) {
+    zn_syscall2(message, len, ZN_SYSCALL_LOG);
+}
+
+VDSO_SYMBOL(zn_log);
+
+size_t zn_page_size() {
+    size_t size = 0;
+    zn_syscall1(&size, ZN_SYSCALL_PAGE_SIZE);
+    return size;
+}
+
+VDSO_SYMBOL(zn_page_size);
+
+zn_status_t zn_powerctl() {
+    return ZN_ERR_UNSUPPORTED;
+}
+
+VDSO_SYMBOL(zn_powerctl);
+
+uint64_t zn_time() {
+    return vdso_data.time.nsec;
+}
+
+VDSO_SYMBOL(zn_time);

kernel/vdso/thread.c

@@ -0,0 +1,26 @@
+#include <zinnia/thread.h>
+#include <kernel/vdso.h>
+
+zn_status_t zn_thread_create(
+    zn_handle_t ns,
+    const char* name,
+    size_t name_len,
+    enum zn_thread_flags flags,
+    zn_handle_t* out
+) {
+    return zn_syscall5(ns, name, name_len, flags, out, ZN_SYSCALL_THREAD_CREATE);
+}
+
+VDSO_SYMBOL(zn_thread_create);
+
+zn_status_t zn_thread_start(zn_handle_t thread, uintptr_t ip, uintptr_t sp, uintptr_t arg) {
+    return zn_syscall4(thread, ip, sp, arg, ZN_SYSCALL_THREAD_START);
+}
+
+VDSO_SYMBOL(zn_thread_start);
+
+void zn_thread_exit(void) {
+    zn_syscall0(ZN_SYSCALL_THREAD_EXIT);
+}
+
+VDSO_SYMBOL(zn_thread_exit);

kernel/vdso/vdso.ld

@@ -0,0 +1,58 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+
+VERSION {
+    ZINNIA_0 {
+        global:
+            __vdso*;
+        local: *;
+    };
+}
+
+PHDRS {
+    text    PT_LOAD    FILEHDR PHDRS FLAGS(5);
+    dynamic PT_DYNAMIC FLAGS(4);
+    note    PT_NOTE    FLAGS(4);
+}
+
+SECTIONS
+{
+    . = SIZEOF_HEADERS;
+
+    .text : {
+        *(.text .text.*)
+        *(.plt .plt.*)
+    } :text
+
+    .rodata : {
+        *(.rodata .rodata.*)
+        *(.got .got.*)
+    } :text
+
+    .data ALIGN(CONSTANT(MAXPAGESIZE)) : {
+        *(.vdso_data)
+    } :text
+
+    .dynsym : {
+        *(.dynsym)
+    } :text
+
+    .dynstr : {
+        *(.dynstr)
+    } :text
+
+    .dynamic : {
+        *(.dynamic)
+    } :text :dynamic
+
+    /DISCARD/ :
+    {
+        *(.data*)
+        *(.bss*)
+        *(.comment*)
+        *(.eh_frame*)
+        *(.rel.eh_frame*)
+        *(.gcc_except_table*)
+        *(.note.gnu.property)
+        *(.interp)
+    }
+}