managarm/hel
Loading...
Searching...
No Matches
hel.h
Go to the documentation of this file.
1
3
4#ifndef HEL_H
5#define HEL_H
6
7#include <stddef.h>
8#include <string.h>
9#include <stdint.h>
10
11#include "hel-types.h"
12
13#ifdef __cplusplus
14#define HEL_C_LINKAGE extern "C"
15#else
16#define HEL_C_LINKAGE
17#endif
18
19enum {
20 // largest system call number plus 1
21 kHelNumCalls = 105,
22
23 kHelCallLog = 1,
24 kHelCallPanic = 10,
25
26 kHelCallNop = 2,
27 kHelCallSubmitAsyncNop = 3,
28
29 kHelCallCreateUniverse = 62,
30 kHelCallTransferDescriptor = 66,
31 kHelCallDescriptorInfo = 32,
32 kHelCallGetCredentials = 84,
33 kHelCallCloseDescriptor = 21,
34
35 kHelCallCreateQueue = 89,
36 kHelCallCancelAsync = 92,
37
38 kHelCallAllocateMemory = 51,
39 kHelCallResizeMemory = 83,
40 kHelCallCreateManagedMemory = 64,
41 kHelCallCopyOnWrite = 39,
42 kHelCallAccessPhysical = 30,
43 kHelCallCreateSliceView = 88,
44 kHelCallForkMemory = 40,
45 kHelCallCreateSpace = 27,
46 kHelCallCreateIndirectMemory = 45,
47 kHelCallAlterMemoryIndirection = 52,
48 kHelCallMapMemory = 44,
49 kHelCallSubmitProtectMemory = 99,
50 kHelCallSubmitSynchronizeSpace = 53,
51 kHelCallUnmapMemory = 36,
52 kHelCallPointerPhysical = 43,
53 kHelCallSubmitReadMemory = 77,
54 kHelCallSubmitWriteMemory = 78,
55 kHelCallMemoryInfo = 26,
56 kHelCallSubmitManageMemory = 46,
57 kHelCallUpdateMemory = 47,
58 kHelCallSubmitLockMemoryView = 48,
59 kHelCallLoadahead = 49,
60 kHelCallCreateVirtualizedSpace = 50,
61
62 kHelCallCreateThread = 67,
63 kHelCallQueryThreadStats = 95,
64 kHelCallSetPriority = 85,
65 kHelCallYield = 34,
66 kHelCallSubmitObserve = 74,
67 kHelCallKillThread = 87,
68 kHelCallInterruptThread = 86,
69 kHelCallResume = 61,
70 kHelCallLoadRegisters = 75,
71 kHelCallStoreRegisters = 76,
72 kHelCallQueryRegisterInfo = 102,
73 kHelCallWriteFsBase = 41,
74 kHelCallGetClock = 42,
75 kHelCallSubmitAwaitClock = 80,
76 kHelCallCreateVirtualizedCpu = 37,
77 kHelCallRunVirtualizedCpu = 38,
78 kHelCallGetRandomBytes = 101,
79 kHelCallWriteGsBase = 54,
80 kHelCallReadFsBase = 55,
81 kHelCallReadGsBase = 56,
82 kHelCallGetCurrentCpu = 57,
83
84 kHelCallCreateStream = 68,
85 kHelCallSubmitAsync = 79,
86 kHelCallShutdownLane = 91,
87
88 kHelCallFutexWait = 73,
89 kHelCallFutexWake = 71,
90
91 kHelCallCreateOneshotEvent = 96,
92 kHelCallCreateBitsetEvent = 97,
93 kHelCallRaiseEvent = 98,
94 kHelCallAccessIrq = 14,
95 kHelCallAcknowledgeIrq = 81,
96 kHelCallSubmitAwaitEvent = 82,
97 kHelCallAutomateIrq = 94,
98
99 kHelCallAccessIo = 11,
100 kHelCallEnableIo = 12,
101 kHelCallEnableFullIo = 35,
102
103 kHelCallBindKernlet = 93,
104
105 kHelCallGetAffinity = 103,
106 kHelCallSetAffinity = 100,
107
108 kHelCallCreateToken = 104,
109
110 kHelCallSuper = 0x80000000
111};
112
113enum {
114 kHelErrNone = 0,
115 kHelErrIllegalSyscall = 5,
116 kHelErrIllegalArgs = 7,
117 kHelErrIllegalState = 15,
118 kHelErrUnsupportedOperation = 18,
119 kHelErrOutOfBounds = 19,
120 kHelErrQueueTooSmall = 14,
121 kHelErrCancelled = 12,
122 kHelErrNoDescriptor = 4,
123 kHelErrBadDescriptor = 2,
124 kHelErrThreadTerminated = 11,
125 kHelErrTransmissionMismatch = 13,
126 kHelErrLaneShutdown = 8,
127 kHelErrEndOfLane = 9,
128 kHelErrDismissed = 20,
129 kHelErrBufferTooSmall = 1,
130 kHelErrFault = 10,
131 kHelErrRemoteFault = 21,
132 kHelErrNoHardwareSupport = 16,
133 kHelErrNoMemory = 17,
134 kHelErrAlreadyExists = 22
135};
136
137struct HelX86SegmentRegister {
138 uint64_t base;
139 uint32_t limit;
140 uint16_t selector;
141 uint8_t type, present, dpl, db, s, l, g, avl;
142};
143
144struct HelX86DescriptorTable {
145 uint64_t base;
146 uint16_t limit;
147};
148
149struct HelX86VirtualizationRegs {
150 uint64_t rax;
151 uint64_t rbx;
152 uint64_t rcx;
153 uint64_t rdx;
154 uint64_t rsi;
155 uint64_t rdi;
156 uint64_t rbp;
157 uint64_t r8;
158 uint64_t r9;
159 uint64_t r10;
160 uint64_t r11;
161 uint64_t r12;
162 uint64_t r13;
163 uint64_t r14;
164 uint64_t r15;
165
166 uint64_t rsp;
167 uint64_t rip;
168 uint64_t rflags;
169
170 struct HelX86SegmentRegister cs, ds, es, fs, gs, ss;
171 struct HelX86SegmentRegister tr, ldt;
172 struct HelX86DescriptorTable gdt, idt;
173
174 uint64_t cr0, cr2, cr3, cr4, cr8;
175 uint64_t efer;
176 uint64_t apic_base;
177};
178
179enum {
180 kHelNullHandle = 0,
181 kHelThisUniverse = -1,
182 kHelThisThread = -2,
183 kHelZeroMemory = -3
184};
185
186enum {
187 kHelWaitInfinite = -1
188};
189
190enum {
191 kHelAbiSystemV = 1
192};
193
194enum {
195 kHelActionNone = 0,
196 kHelActionDismiss = 11,
197 kHelActionOffer = 5,
198 kHelActionAccept = 6,
199 kHelActionImbueCredentials = 8,
200 kHelActionExtractCredentials = 9,
201 kHelActionSendFromBuffer = 1,
202 kHelActionSendFromBufferSg = 10,
203 kHelActionRecvInline = 7,
204 kHelActionRecvToBuffer = 3,
205 kHelActionPushDescriptor = 2,
206 kHelActionPullDescriptor = 4
207};
208
209enum {
210 kHelItemChain = 1,
211 kHelItemAncillary = 2,
212 kHelItemWantLane = (1 << 16),
213};
214
215enum HelTransferDescriptorFlags {
216 kHelTransferDescriptorOut,
217 kHelTransferDescriptorIn,
218};
219
220struct HelSgItem {
221 void *buffer;
222 size_t length;
223};
224
225struct HelAction {
226 int type;
227 uint32_t flags;
228 // TODO: the following fields could be put into unions
229 void *buffer;
230 size_t length;
231 HelHandle handle;
232};
233
234struct HelDescriptorInfo {
235 int type;
236};
237
238enum HelAllocFlags {
239 kHelAllocContinuous = 4,
240 kHelAllocOnDemand = 1,
241};
242
243struct HelAllocRestrictions {
244 int addressBits;
245};
246
247enum HelManagedFlags {
248 kHelManagedReadahead = 1
249};
250
251enum HelManageRequests {
252 kHelManageInitialize = 1,
253 kHelManageWriteback = 2
254};
255
256enum HelMapFlags {
257 // Additional flags that may be set.
258 kHelMapProtRead = 256,
259 kHelMapProtWrite = 512,
260 kHelMapProtExecute = 1024,
261 kHelMapDontRequireBacking = 128,
262 kHelMapFixed = 2048,
263 kHelMapFixedNoReplace = 4096
264};
265
266enum HelSliceFlags {
267 kHelSliceCacheWriteCombine = 1,
268};
269
270enum HelThreadFlags {
271 kHelThreadStopped = 1
272};
273
274enum HelObservation {
275 kHelObserveNull = 0,
276 kHelObserveInterrupt = 4,
277 kHelObservePanic = 3,
278 kHelObserveBreakpoint = 1,
279 kHelObservePageFault = 2,
280 kHelObserveGeneralFault = 5,
281 kHelObserveIllegalInstruction = 6,
282 kHelObserveDivByZero = 7,
283 kHelObserveSuperCall = 0x80000000
284};
285
286enum HelRegisterSets {
287 kHelRegsProgram = 1,
288 kHelRegsGeneral = 2,
289 kHelRegsThread = 3,
290 kHelRegsDebug = 4,
291 kHelRegsVirtualization = 5,
292 kHelRegsSimd = 6,
293 kHelRegsSignal = 7
294};
295
300};
301
302#if defined(__x86_64__)
303enum HelRegisterIndex {
304 kHelRegRax = 0,
305 kHelRegRbx = 1,
306 kHelRegRcx = 2,
307 kHelRegRdx = 3,
308 kHelRegRdi = 4,
309 kHelRegRsi = 5,
310 kHelRegR8 = 6,
311 kHelRegR9 = 7,
312 kHelRegR10 = 8,
313 kHelRegR11 = 9,
314 kHelRegR12 = 10,
315 kHelRegR13 = 11,
316 kHelRegR14 = 12,
317 kHelRegR15 = 13,
318 kHelRegRbp = 14,
319
320 kHelNumGprs = 15,
321
322 kHelRegIp = 0,
323 kHelRegSp = 1
324};
325
326enum HelSyscallArgs {
327 kHelRegNumber = kHelRegRdi,
328 kHelRegError = kHelRegRdi,
329
330 kHelRegArg0 = kHelRegRsi,
331 kHelRegArg1 = kHelRegRdx,
332 kHelRegArg2 = kHelRegRax,
333 kHelRegArg3 = kHelRegR8,
334 kHelRegArg4 = kHelRegR9,
335 kHelRegArg5 = kHelRegR10,
336 kHelRegArg6 = kHelRegR12,
337 kHelRegArg7 = kHelRegR13,
338 kHelRegArg8 = kHelRegR14,
339
340 kHelRegOut0 = kHelRegRsi,
341 kHelRegOut1 = kHelRegRdx
342};
343
344#elif defined(__aarch64__)
345enum HelRegisterIndex {
346 kHelRegX0 = 0,
347 kHelRegX1,
348 kHelRegX2,
349 kHelRegX3,
350 kHelRegX4,
351 kHelRegX5,
352 kHelRegX6,
353 kHelRegX7,
354 kHelRegX8,
355 kHelRegX9,
356 kHelRegX10,
357 kHelRegX11,
358 kHelRegX12,
359 kHelRegX13,
360 kHelRegX14,
361 kHelRegX15,
362 kHelRegX16,
363 kHelRegX17,
364 kHelRegX18,
365 kHelRegX19,
366 kHelRegX20,
367 kHelRegX21,
368 kHelRegX22,
369 kHelRegX23,
370 kHelRegX24,
371 kHelRegX25,
372 kHelRegX26,
373 kHelRegX27,
374 kHelRegX28,
375 kHelRegX29,
376 kHelRegX30,
377
378 kHelNumGprs = 31,
379
380 kHelRegIp = 0,
381 kHelRegSp = 1
382};
383
384enum HelSyscallArgs {
385 kHelRegNumber = kHelRegX0,
386 kHelRegError = kHelRegX0,
387
388 kHelRegArg0 = kHelRegX1,
389 kHelRegArg1 = kHelRegX2,
390 kHelRegArg2 = kHelRegX3,
391 kHelRegArg3 = kHelRegX4,
392 kHelRegArg4 = kHelRegX5,
393 kHelRegArg5 = kHelRegX6,
394 kHelRegArg6 = kHelRegX7,
395 kHelRegArg7 = kHelRegX8,
396 kHelRegArg8 = kHelRegX9,
397
398 kHelRegOut0 = kHelRegX1,
399 kHelRegOut1 = kHelRegX2
400};
401
402#elif defined(__riscv) && __riscv_xlen == 64
403enum HelRegisterIndex {
404 kHelRegRa = 0,
405 kHelRegGp,
406 kHelRegTp,
407 kHelRegT0,
408 kHelRegT1,
409 kHelRegT2,
410 kHelRegS0,
411 kHelRegS1,
412 kHelRegA0,
413 kHelRegA1,
414 kHelRegA2,
415 kHelRegA3,
416 kHelRegA4,
417 kHelRegA5,
418 kHelRegA6,
419 kHelRegA7,
420 kHelRegS2,
421 kHelRegS3,
422 kHelRegS4,
423 kHelRegS5,
424 kHelRegS6,
425 kHelRegS7,
426 kHelRegS8,
427 kHelRegS9,
428 kHelRegS10,
429 kHelRegS11,
430 kHelRegT3,
431 kHelRegT4,
432 kHelRegT5,
433 kHelRegT6,
434 kHelNumGprs,
435 kHelRegIp = 0,
436 kHelRegSp = 1
437};
438enum HelSyscallArgs {
439 kHelRegNumber = kHelRegA0,
440 kHelRegError = kHelRegA0,
441 kHelRegArg0 = kHelRegA1,
442 kHelRegArg1 = kHelRegA2,
443 kHelRegArg2 = kHelRegA3,
444 kHelRegArg3 = kHelRegA4,
445 kHelRegArg4 = kHelRegA5,
446 kHelRegArg5 = kHelRegA6,
447 kHelRegArg6 = kHelRegA7,
448 kHelRegArg7 = kHelRegS2,
449 kHelRegArg8 = kHelRegS3,
450 kHelRegOut0 = kHelRegA1,
451 kHelRegOut1 = kHelRegA2
452};
453
454#endif
455
456struct HelQueueParameters {
457 uint32_t flags;
458 unsigned int ringShift;
459 unsigned int numChunks;
460 size_t chunkSize;
461};
462
464static const int kHelHeadMask = 0xFFFFFF;
465
467static const int kHelHeadWaiters = (1 << 24);
468
470struct HelQueue {
473
475 char padding[4];
476
479};
480
482static const int kHelProgressMask = 0xFFFFFF;
483
485static const int kHelProgressWaiters = (1 << 24);
486
488static const int kHelProgressDone = (1 << 25);
489
490struct HelChunk {
492 int progressFutex;
493
495 char padding[4];
496
498 char buffer[];
499};
500
504 unsigned int length;
505 unsigned int reserved;
507 void *context;
508};
509
510struct HelSimpleResult {
511 HelError error;
512 int reserved;
513};
514
515struct HelCredentialsResult {
516 HelError error;
517 int reserved;
518 char credentials[16];
519};
520
521struct HelManageResult {
522 HelError error;
523 int type;
524 uintptr_t offset;
525 size_t length;
526};
527
528struct HelObserveResult {
529 HelError error;
530 unsigned int observation;
531 uint64_t sequence;
532};
533
534struct HelInlineResult {
535 HelError error;
536 int reserved;
537 size_t length;
538 char data[];
539};
540
541struct HelInlineResultNoFlex {
542 HelError error;
543 int reserved;
544 size_t length;
545};
546
547struct HelLengthResult {
548 HelError error;
549 int reserved;
550 size_t length;
551};
552
553struct HelHandleResult {
554 HelError error;
555 int reserved;
556 HelHandle handle;
557};
558
559struct HelEventResult {
560 HelError error;
561 uint32_t bitset;
562 uint64_t sequence;
563};
564
565enum HelAckFlags {
566 kHelAckAcknowledge = 2,
567 kHelAckNack = 3,
568 kHelAckKick = 1,
569 kHelAckClear = 0x100,
570};
571
572union HelKernletData {
573 HelHandle handle;
574};
575
576struct HelThreadStats {
577 uint64_t userTime;
578};
579
580enum {
581 kHelVmexitHlt = 0,
582 kHelVmexitTranslationFault = 1,
583 kHelVmexitError = -1,
584 kHelVmexitUnknownPlatformSpecificExitCode = -2,
585};
586
587struct HelVmexitReason {
588 uint32_t exitReason;
589 uint32_t code;
590 size_t address;
591 size_t flags;
592};
593
594// see RFC 5424
595enum HelLogSeverity {
596 kHelLogSeverityEmergency,
597 kHelLogSeverityAlert,
598 kHelLogSeverityCritical,
599 kHelLogSeverityError,
600 kHelLogSeverityWarning,
601 kHelLogSeverityNotice,
602 kHelLogSeverityInfo,
603 kHelLogSeverityDebug,
604};
605
608
616HEL_C_LINKAGE HelError helLog(const enum HelLogSeverity severity, const char *string, size_t length);
617
623HEL_C_LINKAGE void helPanic(const char *string, size_t length)
624 __attribute__ (( noreturn ));
625
629
631HEL_C_LINKAGE HelError helNop();
632
636HEL_C_LINKAGE HelError helSubmitAsyncNop(HelHandle queueHandle, uintptr_t context);
637
641
645HEL_C_LINKAGE HelError helCreateUniverse(HelHandle *handle);
646
654HEL_C_LINKAGE HelError
655helTransferDescriptor(HelHandle handle, HelHandle universeHandle,
656 enum HelTransferDescriptorFlags direction, HelHandle *outHandle);
657
658HEL_C_LINKAGE HelError helDescriptorInfo(HelHandle handle, struct HelDescriptorInfo *info);
659
665HEL_C_LINKAGE HelError helGetCredentials(HelHandle handle, uint32_t flags,
666 char *credentials);
667
673HEL_C_LINKAGE HelError helCloseDescriptor(HelHandle universeHandle, HelHandle handle);
674
678
684HEL_C_LINKAGE HelError helCreateQueue(const struct HelQueueParameters *params,
685 HelHandle *handle);
686
692HEL_C_LINKAGE HelError helCancelAsync(HelHandle queueHandle, uint64_t asyncId);
693
697
707HEL_C_LINKAGE HelError helAllocateMemory(size_t size, uint32_t flags,
708 const struct HelAllocRestrictions *restrictions, HelHandle *handle);
709
716HEL_C_LINKAGE HelError helResizeMemory(HelHandle handle, size_t newSize);
717
729HEL_C_LINKAGE HelError helCreateManagedMemory(size_t size, uint32_t flags,
730 HelHandle *backingHandle, HelHandle *frontalHandle);
731
742HEL_C_LINKAGE HelError helCopyOnWrite(HelHandle memory,
743 uintptr_t offset, size_t size, HelHandle *handle);
744
745HEL_C_LINKAGE HelError helAccessPhysical(uintptr_t physical,
746 size_t size, HelHandle *handle);
747
753HEL_C_LINKAGE HelError helCreateIndirectMemory(size_t numSlots, HelHandle *handle);
754
771HEL_C_LINKAGE HelError helAlterMemoryIndirection(HelHandle indirectHandle, size_t slotIndex,
772 HelHandle memoryHandle, uintptr_t offset, size_t size);
773
774HEL_C_LINKAGE HelError helCreateSliceView(HelHandle bundle, uintptr_t offset, size_t size,
775 uint32_t flags, HelHandle *handle);
776
784HEL_C_LINKAGE HelError helForkMemory(HelHandle handle, HelHandle *forkedHandle);
785
789HEL_C_LINKAGE HelError helCreateSpace(HelHandle *handle);
790
808HEL_C_LINKAGE HelError helMapMemory(HelHandle memoryHandle, HelHandle spaceHandle,
809 void *pointer, uintptr_t offset, size_t size, uint32_t flags, void **actualPointer);
810
822HEL_C_LINKAGE HelError helSubmitProtectMemory(HelHandle spaceHandle,
823 void *pointer, size_t size, uint32_t flags,
824 HelHandle queueHandle, uintptr_t context);
825
841HEL_C_LINKAGE HelError helSubmitSynchronizeSpace(HelHandle spaceHandle,
842 void *pointer, size_t size,
843 HelHandle queueHandle, uintptr_t context);
844
855HEL_C_LINKAGE HelError helUnmapMemory(HelHandle spaceHandle, void *pointer, size_t size);
856
857HEL_C_LINKAGE HelError helPointerPhysical(const void *pointer, uintptr_t *physical);
858
870HEL_C_LINKAGE HelError helSubmitReadMemory(HelHandle handle, uintptr_t address,
871 size_t length, void *buffer,
872 HelHandle queue, uintptr_t context);
873
885HEL_C_LINKAGE HelError helSubmitWriteMemory(HelHandle handle, uintptr_t address,
886 size_t length, const void *buffer,
887 HelHandle queue, uintptr_t context);
888
889HEL_C_LINKAGE HelError helMemoryInfo(HelHandle handle,
890 size_t *size);
891
892HEL_C_LINKAGE HelError helSubmitManageMemory(HelHandle handle,
893 HelHandle queue, uintptr_t context);
894
895HEL_C_LINKAGE HelError helUpdateMemory(HelHandle handle, int type, uintptr_t offset, size_t length);
896
897HEL_C_LINKAGE HelError helSubmitLockMemoryView(HelHandle handle, uintptr_t offset, size_t size,
898 HelHandle queue, uintptr_t context);
899
910HEL_C_LINKAGE HelError helLoadahead(HelHandle handle, uintptr_t offset, size_t length);
911
912HEL_C_LINKAGE HelError helCreateVirtualizedSpace(HelHandle *handle);
913
917
931HEL_C_LINKAGE HelError helCreateThread(HelHandle universe, HelHandle spaceHandle,
932 HelAbi abi, void *ip, void *sp, uint32_t flags, HelHandle *handle);
933
939HEL_C_LINKAGE HelError helQueryThreadStats(HelHandle handle, struct HelThreadStats *stats);
940
949HEL_C_LINKAGE HelError helSetPriority(HelHandle handle, int priority);
950
952HEL_C_LINKAGE HelError helYield();
953
961HEL_C_LINKAGE HelError helSubmitObserve(HelHandle handle, uint64_t sequence,
962 HelHandle queue, uintptr_t context);
963
967HEL_C_LINKAGE HelError helKillThread(HelHandle handle);
968
975HEL_C_LINKAGE HelError helInterruptThread(HelHandle handle);
976
983HEL_C_LINKAGE HelError helResume(HelHandle handle);
984
992HEL_C_LINKAGE HelError helLoadRegisters(HelHandle handle, int set, void *image);
993
1001HEL_C_LINKAGE HelError helStoreRegisters(HelHandle handle, int set, const void *image);
1002
1005// Register set to query information for.
1008HEL_C_LINKAGE HelError helQueryRegisterInfo(int set, struct HelRegisterInfo *info);
1009
1010HEL_C_LINKAGE HelError helWriteFsBase(void *pointer);
1011
1012HEL_C_LINKAGE HelError helReadFsBase(void **pointer);
1013
1014HEL_C_LINKAGE HelError helWriteGsBase(void *pointer);
1015
1016HEL_C_LINKAGE HelError helReadGsBase(void **pointer);
1017
1019HEL_C_LINKAGE HelError helGetCurrentCpu(int *cpu);
1020
1025HEL_C_LINKAGE HelError helGetClock(uint64_t *counter);
1026
1034HEL_C_LINKAGE HelError helSubmitAwaitClock(uint64_t counter,
1035 HelHandle queue, uintptr_t context, uint64_t *asyncId);
1036
1037HEL_C_LINKAGE HelError helCreateVirtualizedCpu(HelHandle handle, HelHandle *out_handle);
1038
1039HEL_C_LINKAGE HelError helRunVirtualizedCpu(HelHandle handle, struct HelVmexitReason *reason);
1040
1041HEL_C_LINKAGE HelError helGetRandomBytes(void *buffer, size_t wantedSize, size_t *actualSize);
1042
1052HEL_C_LINKAGE HelError helGetAffinity(HelHandle handle, uint8_t *mask, size_t size, size_t *actualSize);
1053
1061HEL_C_LINKAGE HelError helSetAffinity(HelHandle handle, uint8_t *mask, size_t size);
1062
1066
1074HEL_C_LINKAGE HelError helCreateStream(HelHandle *lane1, HelHandle *lane2, uint32_t attach_credentials);
1075
1083HEL_C_LINKAGE HelError helSubmitAsync(HelHandle handle, const struct HelAction *actions,
1084 size_t count, HelHandle queue, uintptr_t context, uint32_t flags);
1085
1086HEL_C_LINKAGE HelError helShutdownLane(HelHandle handle);
1087
1095HEL_C_LINKAGE HelError helCreateToken(HelHandle *handle);
1096
1100
1109HEL_C_LINKAGE HelError helFutexWait(int *pointer, int expected, int64_t deadline);
1110
1114HEL_C_LINKAGE HelError helFutexWake(int *pointer);
1115
1119
1123HEL_C_LINKAGE HelError helCreateOneshotEvent(HelHandle *handle);
1124
1128HEL_C_LINKAGE HelError helCreateBitsetEvent(HelHandle *handle);
1129
1133HEL_C_LINKAGE HelError helRaiseEvent(HelHandle handle);
1134
1135HEL_C_LINKAGE HelError helAccessIrq(int number, HelHandle *handle);
1136
1137HEL_C_LINKAGE HelError helAcknowledgeIrq(HelHandle handle, uint32_t flags, uint64_t sequence);
1138
1146HEL_C_LINKAGE HelError helSubmitAwaitEvent(HelHandle handle, uint64_t sequence,
1147 HelHandle queue, uintptr_t context, uint64_t *asyncId);
1148
1149HEL_C_LINKAGE HelError helAutomateIrq(HelHandle handle, uint32_t flags, HelHandle kernlet);
1150
1154
1155HEL_C_LINKAGE HelError helAccessIo(uintptr_t *port_array, size_t num_ports,
1156 HelHandle *handle);
1157
1161HEL_C_LINKAGE HelError helEnableIo(HelHandle handle);
1162
1163HEL_C_LINKAGE HelError helEnableFullIo();
1164
1168
1178HEL_C_LINKAGE HelError helBindKernlet(HelHandle handle,
1179 const union HelKernletData *data, size_t numData, HelHandle *boundHandle);
1180
1182
1183extern inline __attribute__ (( always_inline )) const char *_helErrorString(HelError code) {
1184 switch(code) {
1185 case kHelErrNone:
1186 return "Success";
1187 case kHelErrIllegalSyscall:
1188 return "Illegal syscall";
1189 case kHelErrIllegalArgs:
1190 return "Illegal arguments";
1191 case kHelErrIllegalState:
1192 return "Illegal state";
1193 case kHelErrUnsupportedOperation:
1194 return "Unsupported operation";
1195 case kHelErrNoDescriptor:
1196 return "No such descriptor";
1197 case kHelErrBadDescriptor:
1198 return "Illegal descriptor for this operation";
1199 case kHelErrThreadTerminated:
1200 return "Thread terminated already";
1201 case kHelErrLaneShutdown:
1202 return "Lane shutdown";
1203 case kHelErrEndOfLane:
1204 return "End of lane";
1205 case kHelErrDismissed:
1206 return "IPC item dismissed by remote";
1207 case kHelErrBufferTooSmall:
1208 return "Buffer too small";
1209 case kHelErrQueueTooSmall:
1210 return "Buffer too small";
1211 case kHelErrFault:
1212 return "Segfault";
1213 case kHelErrNoHardwareSupport:
1214 return "Missing hardware support for this feature";
1215 case kHelErrNoMemory:
1216 return "Out of memory";
1217 case kHelErrTransmissionMismatch:
1218 return "Transmission mismatch";
1219 case kHelErrCancelled:
1220 return "Cancelled";
1221 case kHelErrOutOfBounds:
1222 return "Out of bounds";
1223 case kHelErrAlreadyExists:
1224 return "Already exists";
1225 default:
1226 return 0;
1227 }
1228}
1229
1230extern inline __attribute__ (( always_inline )) void _helCheckFailed(HelError err_code,
1231 const char *string, int fatal) {
1232 helLog(kHelLogSeverityError, string, strlen(string));
1233
1234 const char *err_string = _helErrorString(err_code);
1235 if(err_string == 0)
1236 err_string = "(Unexpected error code)";
1237 helLog(kHelLogSeverityError, err_string, strlen(err_string));
1238 helLog(kHelLogSeverityError, "\n", 1);
1239
1240 if(fatal)
1241 helPanic(0, 0);
1242}
1243
1244#define HEL_STRINGIFY_AUX(x) #x
1245#define HEL_STRINGIFY(x) HEL_STRINGIFY_AUX(x)
1246
1247#define HEL_CHECK(expr) do { HelError __error = expr; if(__error != kHelErrNone) \
1248 _helCheckFailed(__error, "HEL_CHECK failed: " #expr "\n" \
1249 " In file " __FILE__ " on line " HEL_STRINGIFY(__LINE__) "\n", 1); } while(0)
1250#define HEL_SOFT_CHECK(expr) do { HelError __error = expr; if(__error != kHelErrNone) \
1251 _helCheckFailed(__error, "HEL_SOFT_CHECK failed: " #expr "\n" \
1252 " In file " __FILE__ " on line " HEL_STRINGIFY(__LINE__) "\n", 0); } while(0)
1253
1254#endif // HEL_H
1255
HEL_C_LINKAGE HelError helLog(const enum HelLogSeverity severity, const char *string, size_t length)
Writes a text message (e.g., a line of text) to the kernel's log.
HEL_C_LINKAGE HelError helSetPriority(HelHandle handle, int priority)
Set the priority of a thread.
HEL_C_LINKAGE HelError helYield()
Yields the current thread.
HEL_C_LINKAGE HelError helTransferDescriptor(HelHandle handle, HelHandle universeHandle, enum HelTransferDescriptorFlags direction, HelHandle *outHandle)
Copies descriptors from the current universe to another universe.
HEL_C_LINKAGE HelError helSubmitReadMemory(HelHandle handle, uintptr_t address, size_t length, void *buffer, HelHandle queue, uintptr_t context)
Load memory (i.e., bytes) from a descriptor.
HEL_C_LINKAGE HelError helCloseDescriptor(HelHandle universeHandle, HelHandle handle)
Closes a descriptor.
HEL_C_LINKAGE HelError helQueryRegisterInfo(int set, struct HelRegisterInfo *info)
Query register-related information.
HEL_C_LINKAGE HelError helMapMemory(HelHandle memoryHandle, HelHandle spaceHandle, void *pointer, uintptr_t offset, size_t size, uint32_t flags, void **actualPointer)
Maps memory objects into an address space.
HEL_C_LINKAGE HelError helSetAffinity(HelHandle handle, uint8_t *mask, size_t size)
Set a thread's CPU affinity mask.
HEL_C_LINKAGE HelError helSubmitAsync(HelHandle handle, const struct HelAction *actions, size_t count, HelHandle queue, uintptr_t context, uint32_t flags)
Pass messages on a stream.
static const int kHelHeadMask
Mask to extract the current queue head.
Definition hel.h:464
HEL_C_LINKAGE HelError helQueryThreadStats(HelHandle handle, struct HelThreadStats *stats)
Query run-time statistics of a thread.
HEL_C_LINKAGE HelError helAlterMemoryIndirection(HelHandle indirectHandle, size_t slotIndex, HelHandle memoryHandle, uintptr_t offset, size_t size)
Modifies indirect memory objects.
HEL_C_LINKAGE HelError helCreateBitsetEvent(HelHandle *handle)
Create an event consisting of multiple bits that can fire independently.
HEL_C_LINKAGE HelError helSubmitObserve(HelHandle handle, uint64_t sequence, HelHandle queue, uintptr_t context)
Observe whether a thread changes its state.
HEL_C_LINKAGE HelError helGetCredentials(HelHandle handle, uint32_t flags, char *credentials)
Returns the credentials associated with a given descriptor.
HEL_C_LINKAGE HelError helKillThread(HelHandle handle)
Kill (i.e., terminate) a thread.
HEL_C_LINKAGE HelError helSubmitAwaitClock(uint64_t counter, HelHandle queue, uintptr_t context, uint64_t *asyncId)
Wait until time passes.
HEL_C_LINKAGE HelError helGetAffinity(HelHandle handle, uint8_t *mask, size_t size, size_t *actualSize)
Get a thread's CPU affinity mask.
HEL_C_LINKAGE HelError helGetClock(uint64_t *counter)
Read the system-wide monotone clock.
HEL_C_LINKAGE HelError helLoadahead(HelHandle handle, uintptr_t offset, size_t length)
Notifies the kernel that a certain range of memory should be preloaded.
HEL_C_LINKAGE HelError helLoadRegisters(HelHandle handle, int set, void *image)
Load a register image (e.g., from a thread).
HEL_C_LINKAGE HelError helCopyOnWrite(HelHandle memory, uintptr_t offset, size_t size, HelHandle *handle)
Creates memory object that obtains its memory by copy-on-write from another memory object.
HEL_C_LINKAGE void helPanic(const char *string, size_t length) __attribute__((noreturn))
Kills the current thread and writes an error message to the kernel's log.
HEL_C_LINKAGE HelError helUnmapMemory(HelHandle spaceHandle, void *pointer, size_t size)
Unmaps memory from an address space.
HEL_C_LINKAGE HelError helResizeMemory(HelHandle handle, size_t newSize)
Resizes a memory object.
HEL_C_LINKAGE HelError helSubmitSynchronizeSpace(HelHandle spaceHandle, void *pointer, size_t size, HelHandle queueHandle, uintptr_t context)
Notifies the kernel of dirty pages in a memory mapping.
static const int kHelProgressMask
Mask to extract the number of valid bytes in the chunk.
Definition hel.h:482
HEL_C_LINKAGE HelError helCreateManagedMemory(size_t size, uint32_t flags, HelHandle *backingHandle, HelHandle *frontalHandle)
Creates a memory object that is managed by userspace.
HEL_C_LINKAGE HelError helInterruptThread(HelHandle handle)
Interrupt a thread.
HEL_C_LINKAGE HelError helSubmitAwaitEvent(HelHandle handle, uint64_t sequence, HelHandle queue, uintptr_t context, uint64_t *asyncId)
Wait for an event.
HEL_C_LINKAGE HelError helRaiseEvent(HelHandle handle)
Raise an event.
HEL_C_LINKAGE HelError helForkMemory(HelHandle handle, HelHandle *forkedHandle)
Forks memory objects, i.e., copies them using copy-on-write.
HEL_C_LINKAGE HelError helFutexWake(int *pointer)
Wakes up all waiters of a futex.
HEL_C_LINKAGE HelError helCreateQueue(const struct HelQueueParameters *params, HelHandle *handle)
Creates an IPC queue.
HEL_C_LINKAGE HelError helCreateToken(HelHandle *handle)
Create a token object.
HEL_C_LINKAGE HelError helAllocateMemory(size_t size, uint32_t flags, const struct HelAllocRestrictions *restrictions, HelHandle *handle)
Creates a memory object consisting of unmanaged RAM.
HEL_C_LINKAGE HelError helCreateThread(HelHandle universe, HelHandle spaceHandle, HelAbi abi, void *ip, void *sp, uint32_t flags, HelHandle *handle)
Create a new thread.
HEL_C_LINKAGE HelError helResume(HelHandle handle)
Resume a suspended thread.
HEL_C_LINKAGE HelError helSubmitAsyncNop(HelHandle queueHandle, uintptr_t context)
Does nothing, asynchronously (useful only for profiling).
HEL_C_LINKAGE HelError helStoreRegisters(HelHandle handle, int set, const void *image)
Store a register image (e.g., to a thread).
HEL_C_LINKAGE HelError helSubmitProtectMemory(HelHandle spaceHandle, void *pointer, size_t size, uint32_t flags, HelHandle queueHandle, uintptr_t context)
Changes protection attributes of a memory mapping.
HEL_C_LINKAGE HelError helCreateStream(HelHandle *lane1, HelHandle *lane2, uint32_t attach_credentials)
Create a stream (which always consists of two lanes).
HEL_C_LINKAGE HelError helCreateIndirectMemory(size_t numSlots, HelHandle *handle)
Creates a memory object that obtains its memory by delegating to other memory objects.
HEL_C_LINKAGE HelError helSubmitWriteMemory(HelHandle handle, uintptr_t address, size_t length, const void *buffer, HelHandle queue, uintptr_t context)
Store memory (i.e., bytes) to a descriptor.
HEL_C_LINKAGE HelError helGetCurrentCpu(int *cpu)
Gets the index of the cpu which the calling thread is running on.
HEL_C_LINKAGE HelError helNop()
Does nothing (useful only for profiling).
HEL_C_LINKAGE HelError helFutexWait(int *pointer, int expected, int64_t deadline)
Waits on a futex.
static const int kHelHeadWaiters
Can be set by the kernel to request a FutexWake on update.
Definition hel.h:467
HEL_C_LINKAGE HelError helBindKernlet(HelHandle handle, const union HelKernletData *data, size_t numData, HelHandle *boundHandle)
Bind parameters to a kernlet.
HEL_C_LINKAGE HelError helCreateSpace(HelHandle *handle)
Creates a virtual address space that threads can run in.
HEL_C_LINKAGE HelError helCreateOneshotEvent(HelHandle *handle)
Create an event that fires at most once.
static const int kHelProgressWaiters
Can be set by userspace to request a FutexWake on update.
Definition hel.h:485
HEL_C_LINKAGE HelError helCreateUniverse(HelHandle *handle)
Creates a new universe descriptor.
static const int kHelProgressDone
Set by the kernel once it retires the chunk.
Definition hel.h:488
HEL_C_LINKAGE HelError helEnableIo(HelHandle handle)
Enable userspace access to hardware I/O resources.
HEL_C_LINKAGE HelError helCancelAsync(HelHandle queueHandle, uint64_t asyncId)
Cancels an ongoing asynchronous operation.
A single element of a HelQueue.
Definition hel.h:502
unsigned int length
Length of the element in bytes.
Definition hel.h:504
void * context
User-defined value.
Definition hel.h:507
In-memory kernel/user-space queue.
Definition hel.h:470
char padding[4]
Ensures that the buffer is 8-byte aligned.
Definition hel.h:475
int headFutex
Futex for kernel/user-space head synchronization.
Definition hel.h:472
int indexQueue[]
The actual queue.
Definition hel.h:478
Register-related information returned by helQueryRegisterInfo.
Definition hel.h:297
int setSize
Size of the selected register set.
Definition hel.h:299