hel.h

Go to the documentation of this file.

 
 
#ifndef HEL_H
#define HEL_H
 
#include <stddef.h>
#include <string.h>
#include <stdint.h>
 
#include "hel-types.h"
 
#ifdef __cplusplus
#define HEL_C_LINKAGE extern "C"
#else
#define HEL_C_LINKAGE
#endif
 
enum {
    // largest system call number plus 1
    kHelNumCalls = 113,
 
    kHelCallLog = 1,
    kHelCallPanic = 10,
 
    kHelCallNop = 2,
    kHelCallSubmitAsyncNop = 3,
 
    kHelCallCreateUniverse = 62,
    kHelCallTransferDescriptor = 66,
    kHelCallDescriptorInfo = 32,
    kHelCallGetCredentials = 84,
    kHelCallCloseDescriptor = 21,
    kHelCallObtainHandle = 4,
 
    kHelCallCreateQueue = 89,
    kHelCallDriveQueue = 105,
    kHelCallAlertQueue = 106,
 
    kHelCallAllocateMemory = 51,
    kHelCallResizeMemory = 83,
    kHelCallCreateManagedMemory = 64,
    kHelCallCopyOnWrite = 39,
    kHelCallAccessPhysical = 30,
    kHelCallCreateSliceView = 88,
    kHelCallForkMemory = 40,
    kHelCallCreateSpace = 27,
    kHelCallCreateDmaSpace = 108,
    kHelCallConfigureIrq = 109,
    kHelCallCreateIndirectMemory = 45,
    kHelCallAlterMemoryIndirection = 52,
    kHelCallMapMemory = 44,
    kHelCallSubmitProtectMemory = 99,
    kHelCallSubmitSynchronizeSpace = 53,
    kHelCallUnmapMemory = 36,
    kHelCallPointerPhysical = 43,
    kHelCallSubmitReadMemory = 77,
    kHelCallSubmitWriteMemory = 78,
    kHelCallMemoryInfo = 26,
    kHelCallSubmitManageMemory = 46,
    kHelCallUpdateMemory = 47,
    kHelCallSubmitLockMemoryView = 48,
    kHelCallLoadahead = 49,
    kHelCallCreateVirtualizedSpace = 50,
    kHelCallCreateSwapSpace = 110,
    kHelCallAllocateSwappableMemory = 111,
 
    kHelCallAccessIommu = 13,
 
    kHelCallCreateThread = 67,
    kHelCallQueryThreadStats = 95,
    kHelCallSetPriority = 85,
    kHelCallYield = 34,
    kHelCallSubmitObserve = 74,
    kHelCallKillThread = 87,
    kHelCallInterruptThread = 86,
    kHelCallResume = 61,
    kHelCallLoadRegisters = 75,
    kHelCallStoreRegisters = 76,
    kHelCallQueryRegisterInfo = 102,
    kHelCallWriteFsBase = 41,
    kHelCallGetClock = 42,
    kHelCallSubmitAwaitClock = 80,
    kHelCallCreateVirtualizedCpu = 37,
    kHelCallRunVirtualizedCpu = 38,
    kHelCallAssertVirtualizedIrq = 107,
    kHelCallGetRandomBytes = 101,
    kHelCallWriteGsBase = 54,
    kHelCallReadFsBase = 55,
    kHelCallReadGsBase = 56,
    kHelCallGetCurrentCpu = 57,
 
    kHelCallCreateStream = 68,
    kHelCallSubmitAsync = 79,
    kHelCallShutdownLane = 91,
 
    kHelCallFutexWait = 73,
    kHelCallFutexWake = 71,
 
    kHelCallCreateOneshotEvent = 96,
    kHelCallCreateBitsetEvent = 97,
    kHelCallCreateSequencedEvent = 15,
    kHelCallRaiseEvent = 98,
    kHelCallAccessIrq = 14,
    kHelCallHandleIrq = 5,
    kHelCallAcknowledgeIrq = 81,
    kHelCallSubmitAwaitEvent = 82,
    kHelCallAutomateIrq = 94,
    kHelCallQueryMsiInfo = 6,
 
    kHelCallAccessIo = 11,
    kHelCallEnableIo = 12,
 
    kHelCallBindKernlet = 93,
 
    kHelCallGetAffinity = 103,
    kHelCallSetAffinity = 100,
 
    kHelCallCreateToken = 104,
 
    kHelCallExtendHierarchy = 7,
 
    kHelCallSuper = 0x80000000
};
 
enum {
    kHelErrNone = 0,
    kHelErrBufferTooSmall = 1,
    kHelErrBadDescriptor = 2,
    kHelErrTimeout = 3,
    kHelErrNoDescriptor = 4,
    kHelErrIllegalSyscall = 5,
    kHelErrIllegalObject = 6,
    kHelErrIllegalArgs = 7,
    kHelErrLaneShutdown = 8,
    kHelErrEndOfLane = 9,
    kHelErrFault = 10,
    kHelErrThreadTerminated = 11,
    kHelErrCancelled = 12,
    kHelErrTransmissionMismatch = 13,
    kHelErrQueueTooSmall = 14,
    kHelErrIllegalState = 15,
    kHelErrNoHardwareSupport = 16,
    kHelErrNoMemory = 17,
    kHelErrUnsupportedOperation = 18,
    kHelErrOutOfBounds = 19,
    kHelErrDismissed = 20,
    kHelErrRemoteFault = 21,
    kHelErrAlreadyExists = 22,
    kHelErrBadPermissions = 23,
    kHelErrOther = 24,
    kHelErrFutexRace = 25,
    kHelErrBadRights = 26,
};
 
typedef uint32_t HelRights;
 
// No right but easier to recognize in code than a zero literal.
// - General: descriptor properties can be queried without any rights.
// - Memory view: memory size can be queried without any rights.
// - Thread: statistics can be queried without any rights.
static const HelRights kHelRightNull = 0;
// Right to map into an object.
// - Universe: required to transfer into the universe.
// - Universe: required to close descriptors in the universe.
// - Universe: required to create a thread in the universe.
// - Address space: required to map into the space.
// - Address space: required to change memory protection.
// - Virtualized space: required to map into the space.
// - DMA space: required to map into the space.
static const HelRights kHelRightGrant = UINT32_C(1) << 0;
// Right to map from an object.
// - Universe: required to transfer out of the universe.
// - Universe: required to create a thread in the universe.
static const HelRights kHelRightTake = UINT32_C(1) << 1;
// Right to read data.
// - IPC queue: required to map readable.
// - Memory view: required to read.
// - Memory view: required to map readable.
// - Memory view: required to create copy-on-write view.
// - Memory view: required to map into indirect memory.
// - Memory slice: required to map readable.
// - Memory slice: required to map into indirect memory.
// - Address space: required to read from it.
// - Address space: required to create thread.
// - Virtualized space: required to read from it.
// - I/O objects: required to enable userspace I/O.
// - Thread: required to read registers.
// - Thread: required to read memory in its address space.
// - Thread: required to get the affinity.
// - Virtualized CPUs: required to read registers.
static const HelRights kHelRightRead = UINT32_C(1) << 2;
// Right to write data.
// - IPC queue: required to map writeable.
// - Memory view: required to write.
// - Memory view: required to map writeable.
// - Memory view: required to map into indirect memory.
// - Memory slice: required to map writeable.
// - Memory slice: required to map into indirect memory.
// - Address space: required to write to it.
// - Address space: required to create thread.
// - Virtualized space: required to write to it.
// - I/O objects: required to enable userspace I/O.
// - Thread: required to write registers.
// - Thread: required to write memory in its address space.
// - Thread: required to set the affinity.
// - Virtualized CPUs: required to write registers.
static const HelRights kHelRightWrite = UINT32_C(1) << 3;
// Right to execute code.
// - Memory view: required to map executable.
// - Memory slice: required to map executable.
static const HelRights kHelRightExecute = UINT32_C(1) << 4;
// Right to execute operations.
// - IPC queue: required to submit.
// - Lane: required to do exchange messages.
// - Virtualized CPUs: required to run.
static const HelRights kHelRightInvoke = UINT32_C(1) << 5;
// Right to build new objects on top of existing ones.
// - IPC queue: required to map.
// - Universe: required to create thread.
// - Address space: required to create thread.
// - Memory view: required to map.
// - Memory view: required to create copy-on-write view.
// - Memory view: required to map into indirect memory.
// - Memory view: required to create slice.
// - Memory view: required to bind to kernlet.
// - IRQ pin: required to install an IRQ handler.
// - Memory slice: required to map.
// - Memory slice: required to map into indirect memory.
// - Swap space: required to allocate memory backed by it.
// - Virtualized space: required to create virtualized CPU.
// - I/O objects: required to enable userspace I/O.
// - Kernlets: required to create a bound kernlet from it.
// - Bound kernlets: required to attach to an IRQ.
static const HelRights kHelRightAssign = UINT32_C(1) << 6;
// Right to derive new objects that affect the original one.
// - Memory view: required to fork.
// - Hierarchy: required to extend it by a child hierarchy node.
static const HelRights kHelRightDerive = UINT32_C(1) << 7;
// Right to add, remove or manipulate components.
// - Memory views: required to perform loadahead.
// - Address space: required to synchronize.
// - Address space: required to resolve physical addresses.
// - DMA space: required to populate.
// - DMA space: required to resolve physical addresses.
// - Hierarchy: required to charge resources to it.
static const HelRights kHelRightProvision = UINT32_C(1) << 8;
// Right to pin memory pages.
// - Memory view: required to pin pages.
static const HelRights kHelRightPin = UINT32_C(1) << 9;
// Right to perform memory fences.
// - Memory view: required for fences.
static const HelRights kHelRightFence = UINT32_C(1) << 10;
// Right to wait on an object.
// - IPC queue: required to drive.
// - Thread: required to observe.
// - Event: required to wait.
// - IRQ: required to wait.
// - IRQ: required to attach a kernlet.
static const HelRights kHelRightWait = UINT32_C(1) << 11;
// Right to signal an object.
// - IPC queue: required to alert.
// - Thread: required to interrupt.
// - Event: required to raise.
// - Event: required to bind to kernlet.
// - IRQ: required to acknowledge.
// - IRQ: required to attach a kernlet.
// - Virtualized CPUs: required to raise an interrupt.
static const HelRights kHelRightSignal = UINT32_C(1) << 12;
// Right to manage an object (includes potentially destructive operations).
// - Lane: required to shut down.
// - Memory view: required to resize.
// - Memory view: required to manage.
// - Memory view: required to invalidate.
// - Swap space: required to attach or detach swap regions.
// - Thread: required to set priority.
// - Thread: required to resume.
// - Thread: required to kill.
// - IRQ pin: required to configure the IRQ.
// - IRQ pin: required to obtain MSI address and data words.
static const HelRights kHelRightManage = UINT32_C(1) << 13;
// All rights (even unspecified ones). Easier to recognize in code than a literal.
static const HelRights kHelRightsMax = ~UINT32_C(0);
 
struct HelX86SegmentRegister {
    uint64_t base;
    uint32_t limit;
    uint16_t selector;
    uint8_t type, present, dpl, db, s, l, g, avl;
};
 
struct HelX86DescriptorTable {
    uint64_t base;
    uint16_t limit;
};
 
struct HelX86VirtualizationRegs {
    uint64_t rax;
    uint64_t rbx;
    uint64_t rcx;
    uint64_t rdx;
    uint64_t rsi;
    uint64_t rdi;
    uint64_t rbp;
    uint64_t r8;
    uint64_t r9;
    uint64_t r10;
    uint64_t r11;
    uint64_t r12;
    uint64_t r13;
    uint64_t r14;
    uint64_t r15;
 
    uint64_t rsp;
    uint64_t rip;
    uint64_t rflags;
 
    struct HelX86SegmentRegister cs, ds, es, fs, gs, ss;
    struct HelX86SegmentRegister tr, ldt;
    struct HelX86DescriptorTable gdt, idt;
 
    uint64_t cr0, cr2, cr3, cr4, cr8;
    uint64_t efer;
    uint64_t apic_base;
};
 
struct HelRiscv64VirtualizationRegs {
    union {
        uint64_t x[32];
 
        struct {
            uint64_t zero;
            uint64_t ra;
            uint64_t sp;
            uint64_t gp;
            uint64_t tp;
            uint64_t t0;
            uint64_t t1;
            uint64_t t2;
            uint64_t s0;
            uint64_t s1;
            uint64_t a0;
            uint64_t a1;
            uint64_t a2;
            uint64_t a3;
            uint64_t a4;
            uint64_t a5;
            uint64_t a6;
            uint64_t a7;
            uint64_t s2;
            uint64_t s3;
            uint64_t s4;
            uint64_t s5;
            uint64_t s6;
            uint64_t s7;
            uint64_t s8;
            uint64_t s9;
            uint64_t s10;
            uint64_t s11;
            uint64_t t3;
            uint64_t t4;
            uint64_t t5;
            uint64_t t6;
        };
    };
 
    uint64_t pc;
    uint8_t kernelMode;
 
    // CSRs
    uint64_t sstatus;
    uint64_t sie;
    uint64_t stvec;
    uint64_t sscratch;
    uint64_t sepc;
    uint64_t scause;
    uint64_t stval;
    uint64_t sip;
    uint64_t satp;
    uint64_t stimecmp;
};
 
#if defined(__riscv) && __riscv_xlen == 64
typedef struct HelRiscv64VirtualizationRegs HelVirtualizationRegs;
#else
typedef struct HelX86VirtualizationRegs HelVirtualizationRegs;
#endif
 
enum {
    kHelNullHandle = 0,
    kHelThisUniverse = -1,
    kHelThisThread = -2
};
 
enum {
    kHelWaitInfinite = -1
};
 
enum {
    kHelActionNone = 0,
    kHelActionDismiss = 11,
    kHelActionOffer = 5,
    kHelActionAccept = 6,
    kHelActionImbueCredentials = 8,
    kHelActionExtractCredentials = 9,
    kHelActionSendFromBuffer = 1,
    kHelActionSendFromBufferSg = 10,
    kHelActionRecvInline = 7,
    kHelActionRecvToBuffer = 3,
    kHelActionPushDescriptor = 2,
    kHelActionPullDescriptor = 4
};
 
enum {
    kHelItemChain = 1,
    kHelItemAncillary = 2,
    kHelItemWantLane = (1 << 16),
};
 
static const uint32_t kHelTransferDescriptorOut = UINT32_C(1) << 0;
static const uint32_t kHelTransferDescriptorIn = UINT32_C(1) << 1;
 
enum {
    kHelObtainZeroMemory = 1,
    kHelObtainClockPage = 2
};
 
enum {
    kHelClockNone = 0,
    kHelClockTsc = 1,
    kHelClockCntpct = 2,
    kHelClockCntvct = 3,
    kHelClockTime = 4
};
 
struct HelClockPage {
    uint64_t seqlock;
    uint32_t clockType;
    int32_t tickShift;
    uint64_t tickFactor;
};
 
struct HelSgItem {
    void *buffer;
    size_t length;
};
 
struct HelAction {
    int type;
    uint32_t flags;
    // TODO: It may be worth to restructure this to a union of structs
    //       (e.g., a HelActionDataBufferSize, HelActionDataDescriptorRights, ...),
    //       but that requires simultaneous mlibc and Managarm changes.
    union {
        uintptr_t word0;
        void *buffer;
    };
    union {
        uintptr_t word1;
        size_t length;
        // For kHelPushDescriptor, kHelPullDescriptor.
        uint32_t rights;
    };
    union {
        uintptr_t word2;
        // For kHelActionImbueCredentials, kHelPushDescriptor, kHelPullDescriptor.
        HelHandle handle;
    };
};
 
struct HelDescriptorInfo {
    int type;
};
 
enum HelAllocFlags {
    kHelAllocContinuous = 4,
    kHelAllocOnDemand = 1,
};
 
struct HelAllocRestrictions {
    int addressBits;
};
 
enum HelManagedFlags {
    kHelManagedReadahead = 1
};
 
enum HelManageRequests {
    kHelManageInitialize = 1,
    kHelManageWriteback = 2
};
 
enum HelUpdateMemoryTypes {
    kHelUpdateMarkDirty = 3
};
 
enum HelMapFlags {
    // Additional flags that may be set.
    kHelMapProtRead = UINT32_C(1) << 8,
    kHelMapProtWrite = UINT32_C(1) << 9,
    kHelMapProtExecute = UINT32_C(1) << 10,
    kHelMapDontRequireBacking = UINT32_C(1) << 7,
    kHelMapFixed = UINT32_C(1) << 11,
    kHelMapFixedNoReplace = UINT32_C(1) << 12,
    kHelMapPreferBottom = UINT32_C(1) << 13,
    kHelMapNoDirtyTracking = UINT32_C(1) << 14
};
 
enum HelSliceFlags {
    kHelSliceCacheWriteCombine = 1,
};
 
enum HelCachingMode {
    kHelCachingDefault = 0,
    kHelCachingUncached = 1,
    kHelCachingWriteCombine = 2,
    kHelCachingWriteThrough = 3,
    kHelCachingWriteBack = 4,
    kHelCachingMmio = 5,
    kHelCachingMmioNonPosted = 6
};
 
enum HelThreadFlags {
    kHelThreadStopped = 1
};
 
enum HelObservation {
    kHelObserveNull = 0,
    kHelObserveInterrupt = 4,
    kHelObservePanic = 3,
    kHelObserveBreakpoint = 1,
    kHelObservePageFault = 2,
    kHelObserveGeneralFault = 5,
    kHelObserveIllegalInstruction = 6,
    kHelObserveDivByZero = 7,
    kHelObserveSuperCall = 0x80000000
};
 
enum HelRegisterSets {
    kHelRegsProgram = 1,
    kHelRegsGeneral = 2,
    kHelRegsThread = 3,
    kHelRegsDebug = 4,
    kHelRegsVirtualization = 5,
    kHelRegsSimd = 6,
    kHelRegsSignal = 7,
    kHelRegsPageFault = 8
};
 
enum HelPageFaultFlags {
    kHelPageFaultMapError = 1,
    kHelPageFaultAccessError = 2,
    kHelPageFaultOutOfMemory = 3
};
 
struct HelRegisterInfo {
    int setSize;
};
 
#if defined(__x86_64__)
enum HelRegisterIndex {
    kHelRegRax = 0,
    kHelRegRbx = 1,
    kHelRegRcx = 2,
    kHelRegRdx = 3,
    kHelRegRdi = 4,
    kHelRegRsi = 5,
    kHelRegR8 = 6,
    kHelRegR9 = 7,
    kHelRegR10 = 8,
    kHelRegR11 = 9,
    kHelRegR12 = 10,
    kHelRegR13 = 11,
    kHelRegR14 = 12,
    kHelRegR15 = 13,
    kHelRegRbp = 14,
 
    kHelNumGprs = 15,
 
    kHelRegIp = 0,
    kHelRegSp = 1
};
 
enum HelSyscallArgs {
    kHelRegNumber = kHelRegRdi,
    kHelRegError = kHelRegRdi,
 
    kHelRegArg0 = kHelRegRsi,
    kHelRegArg1 = kHelRegRdx,
    kHelRegArg2 = kHelRegRax,
    kHelRegArg3 = kHelRegR8,
    kHelRegArg4 = kHelRegR9,
    kHelRegArg5 = kHelRegR10,
    kHelRegArg6 = kHelRegR12,
    kHelRegArg7 = kHelRegR13,
    kHelRegArg8 = kHelRegR14,
 
    kHelRegOut0 = kHelRegRsi,
    kHelRegOut1 = kHelRegRdx,
    kHelRegOut2 = kHelRegRax
};
 
#elif defined(__aarch64__)
enum HelRegisterIndex {
    kHelRegX0 = 0,
    kHelRegX1,
    kHelRegX2,
    kHelRegX3,
    kHelRegX4,
    kHelRegX5,
    kHelRegX6,
    kHelRegX7,
    kHelRegX8,
    kHelRegX9,
    kHelRegX10,
    kHelRegX11,
    kHelRegX12,
    kHelRegX13,
    kHelRegX14,
    kHelRegX15,
    kHelRegX16,
    kHelRegX17,
    kHelRegX18,
    kHelRegX19,
    kHelRegX20,
    kHelRegX21,
    kHelRegX22,
    kHelRegX23,
    kHelRegX24,
    kHelRegX25,
    kHelRegX26,
    kHelRegX27,
    kHelRegX28,
    kHelRegX29,
    kHelRegX30,
 
    kHelNumGprs = 31,
 
    kHelRegIp = 0,
    kHelRegSp = 1
};
 
enum HelSyscallArgs {
    kHelRegNumber = kHelRegX0,
    kHelRegError = kHelRegX0,
 
    kHelRegArg0 = kHelRegX1,
    kHelRegArg1 = kHelRegX2,
    kHelRegArg2 = kHelRegX3,
    kHelRegArg3 = kHelRegX4,
    kHelRegArg4 = kHelRegX5,
    kHelRegArg5 = kHelRegX6,
    kHelRegArg6 = kHelRegX7,
    kHelRegArg7 = kHelRegX8,
    kHelRegArg8 = kHelRegX9,
 
    kHelRegOut0 = kHelRegX1,
    kHelRegOut1 = kHelRegX2,
    kHelRegOut2 = kHelRegX3
};
 
#elif defined(__riscv) && __riscv_xlen == 64
enum HelRegisterIndex {
    kHelRegRa = 0,
    kHelRegGp,
    kHelRegTp,
    kHelRegT0,
    kHelRegT1,
    kHelRegT2,
    kHelRegS0,
    kHelRegS1,
    kHelRegA0,
    kHelRegA1,
    kHelRegA2,
    kHelRegA3,
    kHelRegA4,
    kHelRegA5,
    kHelRegA6,
    kHelRegA7,
    kHelRegS2,
    kHelRegS3,
    kHelRegS4,
    kHelRegS5,
    kHelRegS6,
    kHelRegS7,
    kHelRegS8,
    kHelRegS9,
    kHelRegS10,
    kHelRegS11,
    kHelRegT3,
    kHelRegT4,
    kHelRegT5,
    kHelRegT6,
    kHelNumGprs,
    kHelRegIp = 0,
    kHelRegSp = 1
};
enum HelSyscallArgs {
    kHelRegNumber = kHelRegA0,
    kHelRegError = kHelRegA0,
    kHelRegArg0 = kHelRegA1,
    kHelRegArg1 = kHelRegA2,
    kHelRegArg2 = kHelRegA3,
    kHelRegArg3 = kHelRegA4,
    kHelRegArg4 = kHelRegA5,
    kHelRegArg5 = kHelRegA6,
    kHelRegArg6 = kHelRegA7,
    kHelRegArg7 = kHelRegS2,
    kHelRegArg8 = kHelRegS3,
 
    kHelRegOut0 = kHelRegA1,
    kHelRegOut1 = kHelRegA2,
    kHelRegOut2 = kHelRegA3
};
 
#endif
 
struct HelQueueParameters {
    uint32_t flags;
    unsigned int numChunks;
    size_t chunkSize;
    unsigned int numSqChunks;
};
 
static const uint32_t kHelHierarchyMemoryController = UINT32_C(1) << 0;
 
struct HelHierarchyParameters {
    // Optional tag to identify the hierarchy in kernel messages.
    // Null-terminated unless it fills the entire array.
    char tag[128];
    // Bitmask of controllers that we want to enable.
    uint32_t controllers;
    // Only used with kHelHierarchyMemoryController; must be zero otherwise.
    // Allocations of the hierarchy and its descendants wait (or fail) unless memoryFloor bytes
    // of memory stay free on top of the kernel's own reserve.
    // This keeps memory available to hierarchies with lower floors.
    // The effective floor is the maximum over this floor and any parent floor.
    size_t memoryFloor;
};
 
static const int kHelUserNotifyCqProgress = (1 << 0);
static const int kHelUserNotifySupplySqChunks = (1 << 1);
static const int kHelUserNotifyError = (1 << 14);
static const int kHelUserNotifyAlert = (1 << 15);
 
static const int kHelKernelNotifySqProgress = (1 << 0);
static const int kHelKernelNotifySupplyCqChunks = (1 << 1);
 
static const uint32_t kHelDriveWait = (1 << 0);
 
enum {
    kHelAccessIommuIntelVtd = 1,
    kHelAccessIommuAmdVi = 2,
};
 
enum {
    kHelDmaRegionRead = 1,
    kHelDmaRegionWrite = 2,
};
 
struct HelDmaReservedRegion {
    uint64_t base;
    uint64_t size;
    uint32_t flags;
};
 
struct HelDmaDeviceId {
    uint32_t segment;
    uint8_t bus;
    uint8_t slot;
    uint8_t function;
};
 
static const uint32_t kHelSubmitCancel = 256;
static const uint32_t kHelSubmitAsyncNop = 1;
static const uint32_t kHelSubmitExchangeMsgs = 2;
static const uint32_t kHelSubmitAwaitClock = 3;
static const uint32_t kHelSubmitAwaitEvent = 4;
static const uint32_t kHelSubmitProtectMemory = 5;
static const uint32_t kHelSubmitSynchronizeSpace = 6;
static const uint32_t kHelSubmitReadMemory = 7;
static const uint32_t kHelSubmitWriteMemory = 8;
static const uint32_t kHelSubmitManageMemory = 9;
static const uint32_t kHelSubmitLockMemoryView = 10;
static const uint32_t kHelSubmitObserve = 11;
static const uint32_t kHelSubmitResizeMemory = 12;
static const uint32_t kHelSubmitForkMemory = 13;
static const uint32_t kHelSubmitWritebackFence = 14;
static const uint32_t kHelSubmitInvalidateMemory = 15;
static const uint32_t kHelSubmitPopulateSpace = 16;
static const uint32_t kHelSubmitMapMemory = 17;
static const uint32_t kHelSubmitUnmapMemory = 18;
static const uint32_t kHelSubmitBindDmaDevice = 19;
static const uint32_t kHelSubmitUnbindDmaDevice = 20;
static const uint32_t kHelSubmitActivateIommu = 21;
static const uint32_t kHelSubmitSetSwapRegion = 23;
 
struct HelQueue {
    int userNotify;
 
    int kernelNotify;
 
    int cqFirst;
 
    int sqFirst;
};
 
static const int kHelNextPresent = (1 << 24);
 
static const int kHelProgressMask = 0xFFFFFF;
static const int kHelProgressDone = (1 << 25);
static const int kHelProgressFull = (1 << 26);
 
struct HelChunk {
    int next;
 
    int progressFutex;
 
    char buffer[];
};
 
struct HelElement {
    unsigned int length;
    unsigned int opcode;
    void *context;
};
 
struct HelSqCancel {
    uint64_t cancellationTag;
};
 
struct HelSqExchangeMsgs {
    HelHandle lane;
    size_t count;
    uint32_t flags;
};
 
struct HelSqAwaitClock {
    uint64_t counter;
    uint64_t cancellationTag;
};
 
struct HelSqAwaitEvent {
    HelHandle handle;
    uint64_t sequence;
    uint64_t cancellationTag;
};
 
struct HelSqProtectMemory {
    HelHandle spaceHandle;
    void *pointer;
    size_t size;
    uint32_t flags;
};
 
struct HelSqSynchronizeSpace {
    HelHandle spaceHandle;
    void *pointer;
    size_t size;
};
 
struct HelSqReadMemory {
    HelHandle handle;
    uintptr_t address;
    size_t length;
    void *buffer;
};
 
struct HelSqWriteMemory {
    HelHandle handle;
    uintptr_t address;
    size_t length;
    const void *buffer;
};
 
struct HelSqManageMemory {
    HelHandle handle;
};
 
struct HelSqLockMemoryView {
    HelHandle handle;
    uintptr_t offset;
    size_t size;
};
 
struct HelSqObserve {
    HelHandle handle;
};
 
struct HelSqResizeMemory {
    HelHandle handle;
    size_t newSize;
};
 
struct HelSqForkMemory {
    HelHandle hierarchyHandle;
    HelHandle handle;
};
 
struct HelSqWritebackFence {
    HelHandle handle;
    uintptr_t offset;
    size_t size;
};
 
static const uint32_t kHelInvalidateNoWriteback = 1;
 
struct HelSqInvalidateMemory {
    HelHandle handle;
    uintptr_t offset;
    size_t size;
    uint32_t flags;
};
 
struct HelSqPopulateSpace {
    HelHandle handle;
    uintptr_t address;
    size_t length;
};
 
struct HelSqMapMemory {
    HelHandle memoryHandle;
    HelHandle spaceHandle;
    void *pointer;
    uintptr_t offset;
    size_t size;
    uint32_t flags;
};
 
struct HelSqUnmapMemory {
    HelHandle spaceHandle;
    void *pointer;
    size_t size;
};
 
struct HelSqBindDmaDevice {
    HelHandle iommuHandle;
    HelHandle dmaSpaceHandle;
    struct HelDmaDeviceId id;
};
 
struct HelSqUnbindDmaDevice {
    HelHandle iommuHandle;
    struct HelDmaDeviceId id;
};
 
struct HelSqActivateIommu {
    HelHandle iommuHandle;
};
 
static const int kHelSwapRegionShift = 44;
static const uint32_t kHelNumSwapRegions = 1 << 18;
 
struct HelSqSetSwapRegion {
    HelHandle swapHandle;
    size_t numPages;
    uint32_t region;
};
 
struct HelSimpleResult {
    HelError error;
    int reserved;
};
 
struct HelCredentialsResult {
    HelError error;
    int reserved;
    char credentials[16];
};
 
struct HelManageResult {
    HelError error;
    int type;
    uintptr_t offset;
    size_t length;
};
 
struct HelObserveResult {
    HelError error;
    unsigned int observation;
};
 
struct HelInlineResult {
    HelError error;
    int reserved;
    size_t length;
    char data[];
};
 
struct HelInlineResultNoFlex {
    HelError error;
    int reserved;
    size_t length;
};
 
struct HelLengthResult {
    HelError error;
    int reserved;
    size_t length;
};
 
struct HelHandleResult {
    HelError error;
    int reserved;
    HelHandle handle;
};
 
struct HelPointerResult {
    HelError error;
    int reserved;
    void *pointer;
};
 
struct HelEventResult {
    HelError error;
    uint32_t bitset;
    uint64_t sequence;
};
 
enum HelAckFlags {
    kHelAckAcknowledge = 2,
    kHelAckNack = 3,
    kHelAckKick = 1,
    kHelAckClear = 0x100,
};
 
union HelKernletData {
    HelHandle handle;
};
 
struct HelThreadStats {
    uint64_t userTime;
};
 
enum {
  kHelVmexitHlt = 0,
  kHelVmexitTranslationFault = 1,
  kHelVmexitHyperCall = 2,
  kHelVmexitInstructionTrap = 3,
  kHelVmexitError = -1,
  kHelVmexitUnknownPlatformSpecificExitCode = -2,
};
 
enum {
  kHelVmFaultRead = 1 << 0,
  kHelVmFaultWrite = 1 << 1,
  kHelVmFaultExecute = 1 << 2,
};
 
#if defined(__riscv) && __riscv_xlen == 64
 
struct HelVmexitReason {
    uint32_t exitReason;
    // If bit 63 is set then stores a compressed unexpanded instruction,
    // otherwise stores a normal 32-bit instruction (possibly originally compressed in which case bits 1:0 aren't 0b11).
    uint64_t instruction;
    size_t address;
    size_t flags;
};
 
#else
 
struct HelVmexitReason {
    uint32_t exitReason;
    uint32_t code;
    size_t address;
    size_t flags;
};
 
#endif
 
// see RFC 5424
enum HelLogSeverity {
    kHelLogSeverityEmergency,
    kHelLogSeverityAlert,
    kHelLogSeverityCritical,
    kHelLogSeverityError,
    kHelLogSeverityWarning,
    kHelLogSeverityNotice,
    kHelLogSeverityInfo,
    kHelLogSeverityDebug,
};
 
enum {
    kHelAccessIrqByGsi = 1,
    kHelAccessIrqByPhandle = 2,
    kHelAccessIrqAllocateMsi = 3,
};
 
enum {
    kHelIrqNameSize = 32,
};
 
enum {
    kHelIrqTriggerNull = 0,
    kHelIrqTriggerEdge = 1,
    kHelIrqTriggerLevel = 2
};
 
enum {
    kHelIrqPolarityNull = 0,
    kHelIrqPolarityHigh = 1,
    kHelIrqPolarityLow = 2
};
 
struct HelMsiInfo {
    uint64_t address;
    uint32_t data;
};
 
 
HEL_C_LINKAGE HelError helLog(const enum HelLogSeverity severity, const char *string, size_t length);
 
HEL_C_LINKAGE void helPanic(const char *string, size_t length)
        __attribute__ (( noreturn ));
 
 
HEL_C_LINKAGE HelError helNop();
 
HEL_C_LINKAGE HelError helSubmitAsyncNop(HelHandle queueHandle, uintptr_t context);
 
HEL_C_LINKAGE HelError helExtendHierarchy(HelHandle hierarchyHandle,
        const struct HelHierarchyParameters *params, HelHandle *handle);
 
 
HEL_C_LINKAGE HelError helCreateUniverse(HelHandle *handle);
 
HEL_C_LINKAGE HelError
helTransferDescriptor(HelHandle handle, HelHandle universeHandle,
        uint32_t flags, uint32_t exposedRights, uint32_t requiredRights, HelHandle *outHandle);
 
HEL_C_LINKAGE HelError helDescriptorInfo(HelHandle handle, struct HelDescriptorInfo *info);
 
HEL_C_LINKAGE HelError helGetCredentials(HelHandle handle, uint32_t flags,
        char *credentials);
 
HEL_C_LINKAGE HelError helCloseDescriptor(HelHandle universeHandle, HelHandle handle);
 
HEL_C_LINKAGE HelError helObtainHandle(int kind, HelHandle *handle);
 
 
HEL_C_LINKAGE HelError helCreateQueue(const struct HelQueueParameters *params,
        HelHandle *handle);
 
HEL_C_LINKAGE HelError helDriveQueue(HelHandle queueHandle, uint32_t flags, uint32_t notifyMask);
 
HEL_C_LINKAGE HelError helAlertQueue(HelHandle queueHandle);
 
 
HEL_C_LINKAGE HelError helAllocateMemory(HelHandle hierarchy, size_t size, uint32_t flags,
        const struct HelAllocRestrictions *restrictions, HelHandle *handle);
 
HEL_C_LINKAGE HelError helResizeMemory(HelHandle handle, size_t newSize);
 
HEL_C_LINKAGE HelError helCreateManagedMemory(HelHandle hierarchy, size_t size, uint32_t flags,
        HelHandle *backingHandle, HelHandle *frontalHandle);
 
HEL_C_LINKAGE HelError helCreateSwapSpace(HelHandle hierarchy, uint32_t flags,
        HelHandle *backingHandle, HelHandle *swapHandle);
 
HEL_C_LINKAGE HelError helAllocateSwappableMemory(HelHandle hierarchy, HelHandle swapSpace,
        size_t size, uint32_t flags, HelHandle *handle);
 
HEL_C_LINKAGE HelError helCopyOnWrite(HelHandle hierarchy, HelHandle swapSpace, HelHandle memory,
        uintptr_t offset, size_t size, HelHandle *handle);
 
HEL_C_LINKAGE HelError helAccessPhysical(
    HelHandle accessToken, uintptr_t physical, size_t size, uint32_t cachingMode, HelHandle *handle
);
 
HEL_C_LINKAGE HelError helCreateIndirectMemory(size_t numSlots, HelHandle *handle);
 
HEL_C_LINKAGE HelError helAlterMemoryIndirection(HelHandle indirectHandle, size_t slotIndex,
        HelHandle memoryHandle, uintptr_t offset, size_t size);
 
HEL_C_LINKAGE HelError helCreateSliceView(HelHandle bundle, uintptr_t offset, size_t size,
        uint32_t flags, HelHandle *handle);
 
HEL_C_LINKAGE HelError helForkMemory(HelHandle handle, HelHandle *forkedHandle);
 
HEL_C_LINKAGE HelError helCreateSpace(HelHandle *handle);
 
HEL_C_LINKAGE HelError helAccessIommu(HelHandle accessHandle, uint32_t mode, uint64_t base,
        HelHandle *handle);
 
HEL_C_LINKAGE HelError helCreateDmaSpace(HelHandle iommuHandle,
        const struct HelDmaReservedRegion *regions, size_t numRegions,
        uint32_t flags, HelHandle *handle);
 
HEL_C_LINKAGE HelError helMapMemory(HelHandle memoryHandle, HelHandle spaceHandle,
        void *pointer, uintptr_t offset, size_t size, uint32_t flags, void **actualPointer);
 
 
HEL_C_LINKAGE HelError helUnmapMemory(HelHandle spaceHandle, void *pointer, size_t size);
 
HEL_C_LINKAGE HelError helPointerPhysical(HelHandle spaceHandle, const void *pointer, uintptr_t *physical);
 
HEL_C_LINKAGE HelError helMemoryInfo(HelHandle handle,
        size_t *size);
 
HEL_C_LINKAGE HelError helUpdateMemory(HelHandle handle, int type, uintptr_t offset, size_t length);
 
HEL_C_LINKAGE HelError helLoadahead(HelHandle handle, uintptr_t offset, size_t length);
 
HEL_C_LINKAGE HelError helCreateVirtualizedSpace(HelHandle *handle);
 
 
HEL_C_LINKAGE HelError helCreateThread(HelHandle hierarchy, HelHandle universe,
        HelHandle spaceHandle, void *ip, void *sp, uint32_t flags, HelHandle *handle);
 
HEL_C_LINKAGE HelError helQueryThreadStats(HelHandle handle, struct HelThreadStats *stats);
 
HEL_C_LINKAGE HelError helSetPriority(HelHandle handle, int priority);
 
HEL_C_LINKAGE HelError helYield();
 
HEL_C_LINKAGE HelError helKillThread(HelHandle handle);
 
HEL_C_LINKAGE HelError helInterruptThread(HelHandle handle);
 
HEL_C_LINKAGE HelError helResume(HelHandle handle);
 
HEL_C_LINKAGE HelError helLoadRegisters(HelHandle handle, int set, void *image);
 
HEL_C_LINKAGE HelError helStoreRegisters(HelHandle handle, int set, const void *image);
 
//      Register set to query information for.
HEL_C_LINKAGE HelError helQueryRegisterInfo(int set, struct HelRegisterInfo *info);
 
HEL_C_LINKAGE HelError helWriteFsBase(void *pointer);
 
HEL_C_LINKAGE HelError helReadFsBase(void **pointer);
 
HEL_C_LINKAGE HelError helWriteGsBase(void *pointer);
 
HEL_C_LINKAGE HelError helReadGsBase(void **pointer);
 
HEL_C_LINKAGE HelError helGetCurrentCpu(int *cpu);
 
HEL_C_LINKAGE HelError helGetClock(uint64_t *counter);
 
HEL_C_LINKAGE HelError helCreateVirtualizedCpu(HelHandle handle, HelHandle *out_handle);
 
HEL_C_LINKAGE HelError helRunVirtualizedCpu(HelHandle handle, struct HelVmexitReason *reason);
 
HEL_C_LINKAGE HelError helAssertVirtualizedIrq(HelHandle handle, uint64_t irq, uint8_t level);
 
HEL_C_LINKAGE HelError helGetRandomBytes(void *buffer, size_t wantedSize, size_t *actualSize);
 
HEL_C_LINKAGE HelError helGetAffinity(HelHandle handle, uint8_t *mask, size_t size, size_t *actualSize);
 
HEL_C_LINKAGE HelError helSetAffinity(HelHandle handle, uint8_t *mask, size_t size);
 
 
HEL_C_LINKAGE HelError helCreateStream(HelHandle *lane1, HelHandle *lane2, uint32_t attach_credentials);
 
HEL_C_LINKAGE HelError helShutdownLane(HelHandle handle);
 
HEL_C_LINKAGE HelError helCreateToken(HelHandle *handle);
 
 
HEL_C_LINKAGE HelError helFutexWait(int *pointer, int expected, int64_t deadline);
 
HEL_C_LINKAGE HelError helFutexWake(int *pointer, unsigned int count);
 
 
HEL_C_LINKAGE HelError helCreateOneshotEvent(HelHandle *handle);
 
HEL_C_LINKAGE HelError helCreateBitsetEvent(HelHandle *handle);
 
HEL_C_LINKAGE HelError helCreateSequencedEvent(HelHandle *waitHandle, HelHandle *raiseHandle);
 
HEL_C_LINKAGE HelError helRaiseEvent(HelHandle handle);
 
HEL_C_LINKAGE HelError helAccessIrq(
    HelHandle accessHandle, uint32_t mode, uint64_t controller, uint64_t index,
    const char *name, HelHandle *handle
);
 
HEL_C_LINKAGE HelError helHandleIrq(HelHandle pinHandle, HelHandle *handle);
 
HEL_C_LINKAGE HelError helConfigureIrq(HelHandle pinHandle, uint32_t trigger, uint32_t polarity);
 
HEL_C_LINKAGE HelError helQueryMsiInfo(HelHandle pinHandle, struct HelMsiInfo *info);
 
HEL_C_LINKAGE HelError helAcknowledgeIrq(HelHandle handle, uint32_t flags, uint64_t sequence);
 
HEL_C_LINKAGE HelError helAutomateIrq(HelHandle handle, uint32_t flags, HelHandle kernlet);
 
 
HEL_C_LINKAGE HelError helAccessIo(
    HelHandle accessToken, const uintptr_t *portArray, size_t numPorts, HelHandle *handle
);
 
HEL_C_LINKAGE HelError helEnableIo(HelHandle handle);
 
 
HEL_C_LINKAGE HelError helBindKernlet(HelHandle handle,
        const union HelKernletData *data, size_t numData, HelHandle *boundHandle);
 
 
extern inline __attribute__ (( always_inline )) const char *_helErrorString(HelError code) {
    switch(code) {
    case kHelErrNone:
        return "Success";
    case kHelErrIllegalSyscall:
        return "Illegal syscall";
    case kHelErrIllegalArgs:
        return "Illegal arguments";
    case kHelErrIllegalState:
        return "Illegal state";
    case kHelErrUnsupportedOperation:
        return "Unsupported operation";
    case kHelErrNoDescriptor:
        return "No such descriptor";
    case kHelErrBadDescriptor:
        return "Illegal descriptor for this operation";
    case kHelErrThreadTerminated:
        return "Thread terminated already";
    case kHelErrLaneShutdown:
        return "Lane shutdown";
    case kHelErrEndOfLane:
        return "End of lane";
    case kHelErrDismissed:
        return "IPC item dismissed by remote";
    case kHelErrBufferTooSmall:
        return "Buffer too small";
    case kHelErrQueueTooSmall:
        return "Buffer too small";
    case kHelErrFault:
        return "Segfault";
    case kHelErrNoHardwareSupport:
        return "Missing hardware support for this feature";
    case kHelErrNoMemory:
        return "Out of memory";
    case kHelErrTransmissionMismatch:
        return "Transmission mismatch";
    case kHelErrCancelled:
        return "Cancelled";
    case kHelErrOutOfBounds:
        return "Out of bounds";
    case kHelErrAlreadyExists:
        return "Already exists";
    case kHelErrBadRights:
        return "Missing rights for this operation";
    default:
        return 0;
    }
}
 
extern inline __attribute__ (( always_inline )) void _helCheckFailed(HelError err_code,
        const char *string, int fatal) {
    helLog(kHelLogSeverityError, string, strlen(string));
 
    const char *err_string = _helErrorString(err_code);
    if(err_string == 0)
        err_string = "(Unexpected error code)";
    helLog(kHelLogSeverityError, err_string, strlen(err_string));
    helLog(kHelLogSeverityError, "\n", 1);
 
    if(fatal)
        helPanic(0, 0);
}
 
#define HEL_STRINGIFY_AUX(x) #x
#define HEL_STRINGIFY(x) HEL_STRINGIFY_AUX(x)
 
#define HEL_CHECK(expr) do { HelError __error = expr; if(__error != kHelErrNone) \
        _helCheckFailed(__error, "HEL_CHECK failed: " #expr "\n" \
        "    In file " __FILE__ " on line " HEL_STRINGIFY(__LINE__) "\n", 1); } while(0)
#define HEL_SOFT_CHECK(expr) do { HelError __error = expr; if(__error != kHelErrNone) \
        _helCheckFailed(__error, "HEL_SOFT_CHECK failed: " #expr "\n" \
        "    In file " __FILE__ " on line " HEL_STRINGIFY(__LINE__) "\n", 0); } while(0)
 
#endif // HEL_H