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
215struct HelSgItem {
216 void *buffer;
217 size_t length;
218};
219
220struct HelAction {
221 int type;
222 uint32_t flags;
223 // TODO: the following fields could be put into unions
224 void *buffer;
225 size_t length;
226 HelHandle handle;
227};
228
229struct HelDescriptorInfo {
230 int type;
231};
232
233enum HelAllocFlags {
234 kHelAllocContinuous = 4,
235 kHelAllocOnDemand = 1,
236};
237
238struct HelAllocRestrictions {
239 int addressBits;
240};
241
242enum HelManagedFlags {
243 kHelManagedReadahead = 1
244};
245
246enum HelManageRequests {
247 kHelManageInitialize = 1,
248 kHelManageWriteback = 2
249};
250
251enum HelMapFlags {
252 // Additional flags that may be set.
253 kHelMapProtRead = 256,
254 kHelMapProtWrite = 512,
255 kHelMapProtExecute = 1024,
256 kHelMapDontRequireBacking = 128,
257 kHelMapFixed = 2048,
258 kHelMapFixedNoReplace = 4096
259};
260
261enum HelSliceFlags {
262 kHelSliceCacheWriteCombine = 1,
263};
264
265enum HelThreadFlags {
266 kHelThreadStopped = 1
267};
268
269enum HelObservation {
270 kHelObserveNull = 0,
271 kHelObserveInterrupt = 4,
272 kHelObservePanic = 3,
273 kHelObserveBreakpoint = 1,
274 kHelObservePageFault = 2,
275 kHelObserveGeneralFault = 5,
276 kHelObserveIllegalInstruction = 6,
277 kHelObserveDivByZero = 7,
278 kHelObserveSuperCall = 0x80000000
279};
280
281enum HelRegisterSets {
282 kHelRegsProgram = 1,
283 kHelRegsGeneral = 2,
284 kHelRegsThread = 3,
285 kHelRegsDebug = 4,
286 kHelRegsVirtualization = 5,
287 kHelRegsSimd = 6,
288 kHelRegsSignal = 7
289};
290
295};
296
297#if defined(__x86_64__)
298enum HelRegisterIndex {
299 kHelRegRax = 0,
300 kHelRegRbx = 1,
301 kHelRegRcx = 2,
302 kHelRegRdx = 3,
303 kHelRegRdi = 4,
304 kHelRegRsi = 5,
305 kHelRegR8 = 6,
306 kHelRegR9 = 7,
307 kHelRegR10 = 8,
308 kHelRegR11 = 9,
309 kHelRegR12 = 10,
310 kHelRegR13 = 11,
311 kHelRegR14 = 12,
312 kHelRegR15 = 13,
313 kHelRegRbp = 14,
314
315 kHelNumGprs = 15,
316
317 kHelRegIp = 0,
318 kHelRegSp = 1
319};
320
321enum HelSyscallArgs {
322 kHelRegNumber = kHelRegRdi,
323 kHelRegError = kHelRegRdi,
324
325 kHelRegArg0 = kHelRegRsi,
326 kHelRegArg1 = kHelRegRdx,
327 kHelRegArg2 = kHelRegRax,
328 kHelRegArg3 = kHelRegR8,
329 kHelRegArg4 = kHelRegR9,
330 kHelRegArg5 = kHelRegR10,
331 kHelRegArg6 = kHelRegR12,
332 kHelRegArg7 = kHelRegR13,
333 kHelRegArg8 = kHelRegR14,
334
335 kHelRegOut0 = kHelRegRsi,
336 kHelRegOut1 = kHelRegRdx
337};
338
339#elif defined(__aarch64__)
340enum HelRegisterIndex {
341 kHelRegX0 = 0,
342 kHelRegX1,
343 kHelRegX2,
344 kHelRegX3,
345 kHelRegX4,
346 kHelRegX5,
347 kHelRegX6,
348 kHelRegX7,
349 kHelRegX8,
350 kHelRegX9,
351 kHelRegX10,
352 kHelRegX11,
353 kHelRegX12,
354 kHelRegX13,
355 kHelRegX14,
356 kHelRegX15,
357 kHelRegX16,
358 kHelRegX17,
359 kHelRegX18,
360 kHelRegX19,
361 kHelRegX20,
362 kHelRegX21,
363 kHelRegX22,
364 kHelRegX23,
365 kHelRegX24,
366 kHelRegX25,
367 kHelRegX26,
368 kHelRegX27,
369 kHelRegX28,
370 kHelRegX29,
371 kHelRegX30,
372
373 kHelNumGprs = 31,
374
375 kHelRegIp = 0,
376 kHelRegSp = 1
377};
378
379enum HelSyscallArgs {
380 kHelRegNumber = kHelRegX0,
381 kHelRegError = kHelRegX0,
382
383 kHelRegArg0 = kHelRegX1,
384 kHelRegArg1 = kHelRegX2,
385 kHelRegArg2 = kHelRegX3,
386 kHelRegArg3 = kHelRegX4,
387 kHelRegArg4 = kHelRegX5,
388 kHelRegArg5 = kHelRegX6,
389 kHelRegArg6 = kHelRegX7,
390 kHelRegArg7 = kHelRegX8,
391 kHelRegArg8 = kHelRegX9,
392
393 kHelRegOut0 = kHelRegX1,
394 kHelRegOut1 = kHelRegX2
395};
396
397#elif defined(__riscv) && __riscv_xlen == 64
398enum HelRegisterIndex {
399 kHelRegRa = 0,
400 kHelRegGp,
401 kHelRegTp,
402 kHelRegT0,
403 kHelRegT1,
404 kHelRegT2,
405 kHelRegS0,
406 kHelRegS1,
407 kHelRegA0,
408 kHelRegA1,
409 kHelRegA2,
410 kHelRegA3,
411 kHelRegA4,
412 kHelRegA5,
413 kHelRegA6,
414 kHelRegA7,
415 kHelRegS2,
416 kHelRegS3,
417 kHelRegS4,
418 kHelRegS5,
419 kHelRegS6,
420 kHelRegS7,
421 kHelRegS8,
422 kHelRegS9,
423 kHelRegS10,
424 kHelRegS11,
425 kHelRegT3,
426 kHelRegT4,
427 kHelRegT5,
428 kHelRegT6,
429 kHelNumGprs,
430 kHelRegIp = 0,
431 kHelRegSp = 1
432};
433enum HelSyscallArgs {
434 kHelRegNumber = kHelRegA0,
435 kHelRegError = kHelRegA0,
436 kHelRegArg0 = kHelRegA1,
437 kHelRegArg1 = kHelRegA2,
438 kHelRegArg2 = kHelRegA3,
439 kHelRegArg3 = kHelRegA4,
440 kHelRegArg4 = kHelRegA5,
441 kHelRegArg5 = kHelRegA6,
442 kHelRegArg6 = kHelRegA7,
443 kHelRegArg7 = kHelRegS2,
444 kHelRegArg8 = kHelRegS3,
445 kHelRegOut0 = kHelRegA1,
446 kHelRegOut1 = kHelRegA2
447};
448
449#endif
450
451struct HelQueueParameters {
452 uint32_t flags;
453 unsigned int ringShift;
454 unsigned int numChunks;
455 size_t chunkSize;
456};
457
459static const int kHelHeadMask = 0xFFFFFF;
460
462static const int kHelHeadWaiters = (1 << 24);
463
465struct HelQueue {
468
470 char padding[4];
471
474};
475
477static const int kHelProgressMask = 0xFFFFFF;
478
480static const int kHelProgressWaiters = (1 << 24);
481
483static const int kHelProgressDone = (1 << 25);
484
485struct HelChunk {
487 int progressFutex;
488
490 char padding[4];
491
493 char buffer[];
494};
495
499 unsigned int length;
500 unsigned int reserved;
502 void *context;
503};
504
505struct HelSimpleResult {
506 HelError error;
507 int reserved;
508};
509
510struct HelCredentialsResult {
511 HelError error;
512 int reserved;
513 char credentials[16];
514};
515
516struct HelManageResult {
517 HelError error;
518 int type;
519 uintptr_t offset;
520 size_t length;
521};
522
523struct HelObserveResult {
524 HelError error;
525 unsigned int observation;
526 uint64_t sequence;
527};
528
529struct HelInlineResult {
530 HelError error;
531 int reserved;
532 size_t length;
533 char data[];
534};
535
536struct HelInlineResultNoFlex {
537 HelError error;
538 int reserved;
539 size_t length;
540};
541
542struct HelLengthResult {
543 HelError error;
544 int reserved;
545 size_t length;
546};
547
548struct HelHandleResult {
549 HelError error;
550 int reserved;
551 HelHandle handle;
552};
553
554struct HelEventResult {
555 HelError error;
556 uint32_t bitset;
557 uint64_t sequence;
558};
559
560enum HelAckFlags {
561 kHelAckAcknowledge = 2,
562 kHelAckNack = 3,
563 kHelAckKick = 1,
564 kHelAckClear = 0x100,
565};
566
567union HelKernletData {
568 HelHandle handle;
569};
570
571struct HelThreadStats {
572 uint64_t userTime;
573};
574
575enum {
576 kHelVmexitHlt = 0,
577 kHelVmexitTranslationFault = 1,
578 kHelVmexitError = -1,
579 kHelVmexitUnknownPlatformSpecificExitCode = -2,
580};
581
582struct HelVmexitReason {
583 uint32_t exitReason;
584 uint32_t code;
585 size_t address;
586 size_t flags;
587};
588
589// see RFC 5424
590enum HelLogSeverity {
591 kHelLogSeverityEmergency,
592 kHelLogSeverityAlert,
593 kHelLogSeverityCritical,
594 kHelLogSeverityError,
595 kHelLogSeverityWarning,
596 kHelLogSeverityNotice,
597 kHelLogSeverityInfo,
598 kHelLogSeverityDebug,
599};
600
603
611HEL_C_LINKAGE HelError helLog(const enum HelLogSeverity severity, const char *string, size_t length);
612
618HEL_C_LINKAGE void helPanic(const char *string, size_t length)
619 __attribute__ (( noreturn ));
620
624
626HEL_C_LINKAGE HelError helNop();
627
631HEL_C_LINKAGE HelError helSubmitAsyncNop(HelHandle queueHandle, uintptr_t context);
632
636
640HEL_C_LINKAGE HelError helCreateUniverse(HelHandle *handle);
641
649HEL_C_LINKAGE HelError helTransferDescriptor(HelHandle handle, HelHandle universeHandle,
650 HelHandle *outHandle);
651
652HEL_C_LINKAGE HelError helDescriptorInfo(HelHandle handle, struct HelDescriptorInfo *info);
653
659HEL_C_LINKAGE HelError helGetCredentials(HelHandle handle, uint32_t flags,
660 char *credentials);
661
667HEL_C_LINKAGE HelError helCloseDescriptor(HelHandle universeHandle, HelHandle handle);
668
672
678HEL_C_LINKAGE HelError helCreateQueue(const struct HelQueueParameters *params,
679 HelHandle *handle);
680
686HEL_C_LINKAGE HelError helCancelAsync(HelHandle queueHandle, uint64_t asyncId);
687
691
701HEL_C_LINKAGE HelError helAllocateMemory(size_t size, uint32_t flags,
702 const struct HelAllocRestrictions *restrictions, HelHandle *handle);
703
710HEL_C_LINKAGE HelError helResizeMemory(HelHandle handle, size_t newSize);
711
723HEL_C_LINKAGE HelError helCreateManagedMemory(size_t size, uint32_t flags,
724 HelHandle *backingHandle, HelHandle *frontalHandle);
725
736HEL_C_LINKAGE HelError helCopyOnWrite(HelHandle memory,
737 uintptr_t offset, size_t size, HelHandle *handle);
738
739HEL_C_LINKAGE HelError helAccessPhysical(uintptr_t physical,
740 size_t size, HelHandle *handle);
741
747HEL_C_LINKAGE HelError helCreateIndirectMemory(size_t numSlots, HelHandle *handle);
748
765HEL_C_LINKAGE HelError helAlterMemoryIndirection(HelHandle indirectHandle, size_t slotIndex,
766 HelHandle memoryHandle, uintptr_t offset, size_t size);
767
768HEL_C_LINKAGE HelError helCreateSliceView(HelHandle bundle, uintptr_t offset, size_t size,
769 uint32_t flags, HelHandle *handle);
770
778HEL_C_LINKAGE HelError helForkMemory(HelHandle handle, HelHandle *forkedHandle);
779
783HEL_C_LINKAGE HelError helCreateSpace(HelHandle *handle);
784
802HEL_C_LINKAGE HelError helMapMemory(HelHandle memoryHandle, HelHandle spaceHandle,
803 void *pointer, uintptr_t offset, size_t size, uint32_t flags, void **actualPointer);
804
816HEL_C_LINKAGE HelError helSubmitProtectMemory(HelHandle spaceHandle,
817 void *pointer, size_t size, uint32_t flags,
818 HelHandle queueHandle, uintptr_t context);
819
835HEL_C_LINKAGE HelError helSubmitSynchronizeSpace(HelHandle spaceHandle,
836 void *pointer, size_t size,
837 HelHandle queueHandle, uintptr_t context);
838
849HEL_C_LINKAGE HelError helUnmapMemory(HelHandle spaceHandle, void *pointer, size_t size);
850
851HEL_C_LINKAGE HelError helPointerPhysical(const void *pointer, uintptr_t *physical);
852
864HEL_C_LINKAGE HelError helSubmitReadMemory(HelHandle handle, uintptr_t address,
865 size_t length, void *buffer,
866 HelHandle queue, uintptr_t context);
867
879HEL_C_LINKAGE HelError helSubmitWriteMemory(HelHandle handle, uintptr_t address,
880 size_t length, const void *buffer,
881 HelHandle queue, uintptr_t context);
882
883HEL_C_LINKAGE HelError helMemoryInfo(HelHandle handle,
884 size_t *size);
885
886HEL_C_LINKAGE HelError helSubmitManageMemory(HelHandle handle,
887 HelHandle queue, uintptr_t context);
888
889HEL_C_LINKAGE HelError helUpdateMemory(HelHandle handle, int type, uintptr_t offset, size_t length);
890
891HEL_C_LINKAGE HelError helSubmitLockMemoryView(HelHandle handle, uintptr_t offset, size_t size,
892 HelHandle queue, uintptr_t context);
893
904HEL_C_LINKAGE HelError helLoadahead(HelHandle handle, uintptr_t offset, size_t length);
905
906HEL_C_LINKAGE HelError helCreateVirtualizedSpace(HelHandle *handle);
907
911
925HEL_C_LINKAGE HelError helCreateThread(HelHandle universe, HelHandle spaceHandle,
926 HelAbi abi, void *ip, void *sp, uint32_t flags, HelHandle *handle);
927
933HEL_C_LINKAGE HelError helQueryThreadStats(HelHandle handle, struct HelThreadStats *stats);
934
943HEL_C_LINKAGE HelError helSetPriority(HelHandle handle, int priority);
944
946HEL_C_LINKAGE HelError helYield();
947
955HEL_C_LINKAGE HelError helSubmitObserve(HelHandle handle, uint64_t sequence,
956 HelHandle queue, uintptr_t context);
957
961HEL_C_LINKAGE HelError helKillThread(HelHandle handle);
962
969HEL_C_LINKAGE HelError helInterruptThread(HelHandle handle);
970
977HEL_C_LINKAGE HelError helResume(HelHandle handle);
978
986HEL_C_LINKAGE HelError helLoadRegisters(HelHandle handle, int set, void *image);
987
995HEL_C_LINKAGE HelError helStoreRegisters(HelHandle handle, int set, const void *image);
996
999// Register set to query information for.
1002HEL_C_LINKAGE HelError helQueryRegisterInfo(int set, struct HelRegisterInfo *info);
1003
1004HEL_C_LINKAGE HelError helWriteFsBase(void *pointer);
1005
1006HEL_C_LINKAGE HelError helReadFsBase(void **pointer);
1007
1008HEL_C_LINKAGE HelError helWriteGsBase(void *pointer);
1009
1010HEL_C_LINKAGE HelError helReadGsBase(void **pointer);
1011
1013HEL_C_LINKAGE HelError helGetCurrentCpu(int *cpu);
1014
1019HEL_C_LINKAGE HelError helGetClock(uint64_t *counter);
1020
1028HEL_C_LINKAGE HelError helSubmitAwaitClock(uint64_t counter,
1029 HelHandle queue, uintptr_t context, uint64_t *asyncId);
1030
1031HEL_C_LINKAGE HelError helCreateVirtualizedCpu(HelHandle handle, HelHandle *out_handle);
1032
1033HEL_C_LINKAGE HelError helRunVirtualizedCpu(HelHandle handle, struct HelVmexitReason *reason);
1034
1035HEL_C_LINKAGE HelError helGetRandomBytes(void *buffer, size_t wantedSize, size_t *actualSize);
1036
1046HEL_C_LINKAGE HelError helGetAffinity(HelHandle handle, uint8_t *mask, size_t size, size_t *actualSize);
1047
1055HEL_C_LINKAGE HelError helSetAffinity(HelHandle handle, uint8_t *mask, size_t size);
1056
1060
1068HEL_C_LINKAGE HelError helCreateStream(HelHandle *lane1, HelHandle *lane2, uint32_t attach_credentials);
1069
1077HEL_C_LINKAGE HelError helSubmitAsync(HelHandle handle, const struct HelAction *actions,
1078 size_t count, HelHandle queue, uintptr_t context, uint32_t flags);
1079
1080HEL_C_LINKAGE HelError helShutdownLane(HelHandle handle);
1081
1089HEL_C_LINKAGE HelError helCreateToken(HelHandle *handle);
1090
1094
1103HEL_C_LINKAGE HelError helFutexWait(int *pointer, int expected, int64_t deadline);
1104
1108HEL_C_LINKAGE HelError helFutexWake(int *pointer);
1109
1113
1117HEL_C_LINKAGE HelError helCreateOneshotEvent(HelHandle *handle);
1118
1122HEL_C_LINKAGE HelError helCreateBitsetEvent(HelHandle *handle);
1123
1127HEL_C_LINKAGE HelError helRaiseEvent(HelHandle handle);
1128
1129HEL_C_LINKAGE HelError helAccessIrq(int number, HelHandle *handle);
1130
1131HEL_C_LINKAGE HelError helAcknowledgeIrq(HelHandle handle, uint32_t flags, uint64_t sequence);
1132
1140HEL_C_LINKAGE HelError helSubmitAwaitEvent(HelHandle handle, uint64_t sequence,
1141 HelHandle queue, uintptr_t context);
1142
1143HEL_C_LINKAGE HelError helAutomateIrq(HelHandle handle, uint32_t flags, HelHandle kernlet);
1144
1148
1149HEL_C_LINKAGE HelError helAccessIo(uintptr_t *port_array, size_t num_ports,
1150 HelHandle *handle);
1151
1155HEL_C_LINKAGE HelError helEnableIo(HelHandle handle);
1156
1157HEL_C_LINKAGE HelError helEnableFullIo();
1158
1162
1172HEL_C_LINKAGE HelError helBindKernlet(HelHandle handle,
1173 const union HelKernletData *data, size_t numData, HelHandle *boundHandle);
1174
1176
1177extern inline __attribute__ (( always_inline )) const char *_helErrorString(HelError code) {
1178 switch(code) {
1179 case kHelErrNone:
1180 return "Success";
1181 case kHelErrIllegalSyscall:
1182 return "Illegal syscall";
1183 case kHelErrIllegalArgs:
1184 return "Illegal arguments";
1185 case kHelErrIllegalState:
1186 return "Illegal state";
1187 case kHelErrUnsupportedOperation:
1188 return "Unsupported operation";
1189 case kHelErrNoDescriptor:
1190 return "No such descriptor";
1191 case kHelErrBadDescriptor:
1192 return "Illegal descriptor for this operation";
1193 case kHelErrThreadTerminated:
1194 return "Thread terminated already";
1195 case kHelErrLaneShutdown:
1196 return "Lane shutdown";
1197 case kHelErrEndOfLane:
1198 return "End of lane";
1199 case kHelErrDismissed:
1200 return "IPC item dismissed by remote";
1201 case kHelErrBufferTooSmall:
1202 return "Buffer too small";
1203 case kHelErrQueueTooSmall:
1204 return "Buffer too small";
1205 case kHelErrFault:
1206 return "Segfault";
1207 case kHelErrNoHardwareSupport:
1208 return "Missing hardware support for this feature";
1209 case kHelErrNoMemory:
1210 return "Out of memory";
1211 case kHelErrTransmissionMismatch:
1212 return "Transmission mismatch";
1213 case kHelErrCancelled:
1214 return "Cancelled";
1215 case kHelErrOutOfBounds:
1216 return "Out of bounds";
1217 case kHelErrAlreadyExists:
1218 return "Already exists";
1219 default:
1220 return 0;
1221 }
1222}
1223
1224extern inline __attribute__ (( always_inline )) void _helCheckFailed(HelError err_code,
1225 const char *string, int fatal) {
1226 helLog(kHelLogSeverityError, string, strlen(string));
1227
1228 const char *err_string = _helErrorString(err_code);
1229 if(err_string == 0)
1230 err_string = "(Unexpected error code)";
1231 helLog(kHelLogSeverityError, err_string, strlen(err_string));
1232 helLog(kHelLogSeverityError, "\n", 1);
1233
1234 if(fatal)
1235 helPanic(0, 0);
1236}
1237
1238#define HEL_STRINGIFY_AUX(x) #x
1239#define HEL_STRINGIFY(x) HEL_STRINGIFY_AUX(x)
1240
1241#define HEL_CHECK(expr) do { HelError __error = expr; if(__error != kHelErrNone) \
1242 _helCheckFailed(__error, "HEL_CHECK failed: " #expr "\n" \
1243 " In file " __FILE__ " on line " HEL_STRINGIFY(__LINE__) "\n", 1); } while(0)
1244#define HEL_SOFT_CHECK(expr) do { HelError __error = expr; if(__error != kHelErrNone) \
1245 _helCheckFailed(__error, "HEL_SOFT_CHECK failed: " #expr "\n" \
1246 " In file " __FILE__ " on line " HEL_STRINGIFY(__LINE__) "\n", 0); } while(0)
1247
1248#endif // HEL_H
1249
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 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.
HEL_C_LINKAGE HelError helSubmitAwaitEvent(HelHandle handle, uint64_t sequence, HelHandle queue, uintptr_t context)
Wait for an event.
static const int kHelHeadMask
Mask to extract the current queue head.
Definition hel.h:459
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:477
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 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 helTransferDescriptor(HelHandle handle, HelHandle universeHandle, HelHandle *outHandle)
Copies descriptors from the current universe to another universe.
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:462
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:480
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:483
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:497
unsigned int length
Length of the element in bytes.
Definition hel.h:499
void * context
User-defined value.
Definition hel.h:502
In-memory kernel/user-space queue.
Definition hel.h:465
char padding[4]
Ensures that the buffer is 8-byte aligned.
Definition hel.h:470
int headFutex
Futex for kernel/user-space head synchronization.
Definition hel.h:467
int indexQueue[]
The actual queue.
Definition hel.h:473
Register-related information returned by helQueryRegisterInfo.
Definition hel.h:292
int setSize
Size of the selected register set.
Definition hel.h:294