drew
/
acadia
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

[zion] Declare z_cap_t and start replacing existing types

This commit is contained in:
Drew Galbraith 2023-06-17 01:53:19 -07:00
parent 5e99dbf7d1
commit 7bd6aa42b0
4 changed files with 83 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
zion/include/zcall.h
View File

@ -6,59 +6,59 @@
void ZProcessExit(uint64_t code); void ZProcessExit(uint64_t code);
[[nodiscard]] z_err_t ZProcessSpawn(uint64_t proc_cap, uint64_t bootstrap_cap, [[nodiscard]] z_err_t ZProcessSpawn(z_cap_t proc_cap, z_cap_t bootstrap_cap,
uint64_t* new_proc_cap, z_cap_t* new_proc_cap,
uint64_t* new_vmas_cap, z_cap_t* new_vmas_cap,
uint64_t* new_bootstrap_cap); z_cap_t* new_bootstrap_cap);
// UNUSED for now, I think we can get away with just starting a thread. // UNUSED for now, I think we can get away with just starting a thread.
[[nodiscard]] z_err_t ZProcessStart(uint64_t proc_cap, uint64_t thread_cap, [[nodiscard]] z_err_t ZProcessStart(z_cap_t proc_cap, z_cap_t thread_cap,
uint64_t entry, uint64_t arg1, uint64_t entry, uint64_t arg1,
uint64_t arg2); uint64_t arg2);
[[nodiscard]] z_err_t ZThreadCreate(uint64_t proc_cap, uint64_t* thread_cap); [[nodiscard]] z_err_t ZThreadCreate(z_cap_t proc_cap, z_cap_t* thread_cap);
[[nodiscard]] z_err_t ZThreadStart(uint64_t thread_cap, uint64_t entry, [[nodiscard]] z_err_t ZThreadStart(z_cap_t thread_cap, uint64_t entry,
uint64_t arg1, uint64_t arg2); uint64_t arg1, uint64_t arg2);
void ZThreadExit(); void ZThreadExit();
[[nodiscard]] z_err_t ZAddressSpaceMap(uint64_t vmas_cap, uint64_t vmas_offset, [[nodiscard]] z_err_t ZAddressSpaceMap(z_cap_t vmas_cap, uint64_t vmas_offset,
uint64_t vmmo_cap, uint64_t* vaddr); z_cap_t vmmo_cap, uint64_t* vaddr);
[[nodiscard]] z_err_t ZMemoryObjectCreate(uint64_t size, uint64_t* vmmo_cap); [[nodiscard]] z_err_t ZMemoryObjectCreate(uint64_t size, z_cap_t* vmmo_cap);
[[nodiscard]] z_err_t ZMemoryObjectCreatePhysical(uint64_t paddr, uint64_t size, [[nodiscard]] z_err_t ZMemoryObjectCreatePhysical(uint64_t paddr, uint64_t size,
uint64_t* vmmo_cap); z_cap_t* vmmo_cap);
[[nodiscard]] z_err_t ZMemoryObjectCreateContiguous(uint64_t size, [[nodiscard]] z_err_t ZMemoryObjectCreateContiguous(uint64_t size,
uint64_t* vmmo_cap, z_cap_t* vmmo_cap,
uint64_t* paddr); uint64_t* paddr);
[[nodiscard]] z_err_t ZTempPcieConfigObjectCreate(uint64_t* vmmo_cap, [[nodiscard]] z_err_t ZTempPcieConfigObjectCreate(z_cap_t* vmmo_cap,
uint64_t* vmmo_size); uint64_t* vmmo_size);
[[nodiscard]] z_err_t ZChannelCreate(uint64_t* channel1, uint64_t* channel2); [[nodiscard]] z_err_t ZChannelCreate(z_cap_t* channel1, z_cap_t* channel2);
[[nodiscard]] z_err_t ZChannelSend(uint64_t chan_cap, uint64_t type, [[nodiscard]] z_err_t ZChannelSend(z_cap_t chan_cap, uint64_t type,
uint64_t num_bytes, const uint8_t* bytes, uint64_t num_bytes, const uint8_t* bytes,
uint64_t num_caps, const uint64_t* caps); uint64_t num_caps, const z_cap_t* caps);
[[nodiscard]] z_err_t ZChannelRecv(uint64_t chan_cap, uint64_t num_bytes, [[nodiscard]] z_err_t ZChannelRecv(z_cap_t chan_cap, uint64_t num_bytes,
uint8_t* bytes, uint64_t num_caps, uint8_t* bytes, uint64_t num_caps,
uint64_t* caps, uint64_t* type, z_cap_t* caps, uint64_t* type,
uint64_t* actual_bytes, uint64_t* actual_bytes,
uint64_t* actual_caps); uint64_t* actual_caps);
[[nodiscard]] z_err_t ZPortCreate(uint64_t* port_cap); [[nodiscard]] z_err_t ZPortCreate(z_cap_t* port_cap);
[[nodiscard]] z_err_t ZPortSend(uint64_t port_cap, uint64_t num_bytes, [[nodiscard]] z_err_t ZPortSend(z_cap_t port_cap, uint64_t num_bytes,
const uint8_t* bytes, uint64_t num_caps, const uint8_t* bytes, uint64_t num_caps,
uint64_t* caps); z_cap_t* caps);
[[nodiscard]] z_err_t ZPortRecv(uint64_t port_cap, uint64_t num_bytes, [[nodiscard]] z_err_t ZPortRecv(z_cap_t port_cap, uint64_t num_bytes,
uint8_t* bytes, uint64_t num_caps, uint8_t* bytes, uint64_t num_caps,
uint64_t* caps, uint64_t* type, z_cap_t* caps, uint64_t* type,
uint64_t* actual_bytes, uint64_t* actual_caps); uint64_t* actual_bytes, uint64_t* actual_caps);
[[nodiscard]] z_err_t ZPortPoll(uint64_t port_cap, uint64_t num_bytes, [[nodiscard]] z_err_t ZPortPoll(z_cap_t port_cap, uint64_t num_bytes,
uint8_t* bytes, uint64_t num_caps, uint8_t* bytes, uint64_t num_caps,
uint64_t* caps, uint64_t* type, z_cap_t* caps, uint64_t* type,
uint64_t* actual_bytes, uint64_t* actual_caps); uint64_t* actual_bytes, uint64_t* actual_caps);
[[nodiscard]] z_err_t ZIrqRegister(uint64_t irq_num, uint64_t* port_cap); [[nodiscard]] z_err_t ZIrqRegister(uint64_t irq_num, z_cap_t* port_cap);
[[nodiscard]] z_err_t ZCapDuplicate(uint64_t cap_in, uint64_t* cap_out); [[nodiscard]] z_err_t ZCapDuplicate(z_cap_t cap_in, z_cap_t* cap_out);
[[nodiscard]] z_err_t ZDebug(const char* message); [[nodiscard]] z_err_t ZDebug(const char* message);

3
zion/include/ztypes.h
View File

@ -72,6 +72,9 @@ typedef uint64_t z_err_t;
/* ------------------------------ /* ------------------------------
* Capability Types * Capability Types
* ------------------------------*/ * ------------------------------*/
typedef uint64_t z_cap_t;
#define Z_INVALID 0x0 #define Z_INVALID 0x0
// General Capability Permissions // General Capability Permissions

52
zion/usr/zcall.cpp
View File

@ -23,9 +23,9 @@ void ZProcessExit(uint64_t code) {
SysCall1(Z_PROCESS_EXIT, reinterpret_cast<void*>(code)); SysCall1(Z_PROCESS_EXIT, reinterpret_cast<void*>(code));
} }
z_err_t ZProcessSpawn(uint64_t proc_cap, uint64_t bootstrap_cap, z_err_t ZProcessSpawn(z_cap_t proc_cap, z_cap_t bootstrap_cap,
uint64_t* new_proc_cap, uint64_t* new_vmas_cap, z_cap_t* new_proc_cap, z_cap_t* new_vmas_cap,
uint64_t* new_bootstrap_cap) { z_cap_t* new_bootstrap_cap) {
ZProcessSpawnReq req{ ZProcessSpawnReq req{
.proc_cap = proc_cap, .proc_cap = proc_cap,
.bootstrap_cap = bootstrap_cap, .bootstrap_cap = bootstrap_cap,
@ -38,7 +38,7 @@ z_err_t ZProcessSpawn(uint64_t proc_cap, uint64_t bootstrap_cap,
return ret; return ret;
} }
z_err_t ZThreadCreate(uint64_t proc_cap, uint64_t* thread_cap) { z_err_t ZThreadCreate(z_cap_t proc_cap, z_cap_t* thread_cap) {
ZThreadCreateReq req{ ZThreadCreateReq req{
.proc_cap = proc_cap, .proc_cap = proc_cap,
}; };
@ -48,7 +48,7 @@ z_err_t ZThreadCreate(uint64_t proc_cap, uint64_t* thread_cap) {
return ret; return ret;
} }
z_err_t ZThreadStart(uint64_t thread_cap, uint64_t entry, uint64_t arg1, z_err_t ZThreadStart(z_cap_t thread_cap, uint64_t entry, uint64_t arg1,
uint64_t arg2) { uint64_t arg2) {
ZThreadStartReq req{ ZThreadStartReq req{
.thread_cap = thread_cap, .thread_cap = thread_cap,
@ -61,8 +61,8 @@ z_err_t ZThreadStart(uint64_t thread_cap, uint64_t entry, uint64_t arg1,
void ZThreadExit() { SysCall0(Z_THREAD_EXIT); } void ZThreadExit() { SysCall0(Z_THREAD_EXIT); }
z_err_t ZAddressSpaceMap(uint64_t vmas_cap, uint64_t vmas_offset, z_err_t ZAddressSpaceMap(z_cap_t vmas_cap, uint64_t vmas_offset,
uint64_t vmmo_cap, uint64_t* vaddr) { z_cap_t vmmo_cap, uint64_t* vaddr) {
ZAddressSpaceMapReq req{ ZAddressSpaceMapReq req{
.vmas_cap = vmas_cap, .vmas_cap = vmas_cap,
.vmas_offset = vmas_offset, .vmas_offset = vmas_offset,
@ -74,7 +74,7 @@ z_err_t ZAddressSpaceMap(uint64_t vmas_cap, uint64_t vmas_offset,
return ret; return ret;
} }
z_err_t ZMemoryObjectCreate(uint64_t size, uint64_t* vmmo_cap) { z_err_t ZMemoryObjectCreate(uint64_t size, z_cap_t* vmmo_cap) {
ZMemoryObjectCreateReq req{ ZMemoryObjectCreateReq req{
.size = size, .size = size,
}; };
@ -85,7 +85,7 @@ z_err_t ZMemoryObjectCreate(uint64_t size, uint64_t* vmmo_cap) {
} }
z_err_t ZMemoryObjectCreatePhysical(uint64_t paddr, uint64_t size, z_err_t ZMemoryObjectCreatePhysical(uint64_t paddr, uint64_t size,
uint64_t* vmmo_cap) { z_cap_t* vmmo_cap) {
ZMemoryObjectCreatePhysicalReq req{ ZMemoryObjectCreatePhysicalReq req{
.paddr = paddr, .paddr = paddr,
.size = size, .size = size,
@ -96,7 +96,7 @@ z_err_t ZMemoryObjectCreatePhysical(uint64_t paddr, uint64_t size,
return ret; return ret;
} }
z_err_t ZMemoryObjectCreateContiguous(uint64_t size, uint64_t* vmmo_cap, z_err_t ZMemoryObjectCreateContiguous(uint64_t size, z_cap_t* vmmo_cap,
uint64_t* paddr) { uint64_t* paddr) {
ZMemoryObjectCreatePhysicalReq req{ ZMemoryObjectCreatePhysicalReq req{
.paddr = 0, .paddr = 0,
@ -109,7 +109,7 @@ z_err_t ZMemoryObjectCreateContiguous(uint64_t size, uint64_t* vmmo_cap,
return ret; return ret;
} }
z_err_t ZTempPcieConfigObjectCreate(uint64_t* vmmo_cap, uint64_t* vmmo_size) { z_err_t ZTempPcieConfigObjectCreate(z_cap_t* vmmo_cap, uint64_t* vmmo_size) {
ZTempPcieConfigObjectCreateResp resp; ZTempPcieConfigObjectCreateResp resp;
z_err_t ret = SysCall2(Z_TEMP_PCIE_CONFIG_OBJECT_CREATE, 0, &resp); z_err_t ret = SysCall2(Z_TEMP_PCIE_CONFIG_OBJECT_CREATE, 0, &resp);
*vmmo_cap = resp.vmmo_cap; *vmmo_cap = resp.vmmo_cap;
@ -117,7 +117,7 @@ z_err_t ZTempPcieConfigObjectCreate(uint64_t* vmmo_cap, uint64_t* vmmo_size) {
return ret; return ret;
} }
z_err_t ZChannelCreate(uint64_t* channel1, uint64_t* channel2) { z_err_t ZChannelCreate(z_cap_t* channel1, z_cap_t* channel2) {
ZChannelCreateResp resp; ZChannelCreateResp resp;
z_err_t ret = SysCall2(Z_CHANNEL_CREATE, 0, &resp); z_err_t ret = SysCall2(Z_CHANNEL_CREATE, 0, &resp);
*channel1 = resp.chan_cap1; *channel1 = resp.chan_cap1;
@ -125,9 +125,9 @@ z_err_t ZChannelCreate(uint64_t* channel1, uint64_t* channel2) {
return ret; return ret;
} }
z_err_t ZChannelSend(uint64_t chan_cap, uint64_t type, uint64_t num_bytes, z_err_t ZChannelSend(z_cap_t chan_cap, uint64_t type, uint64_t num_bytes,
const uint8_t* bytes, uint64_t num_caps, const uint8_t* bytes, uint64_t num_caps,
const uint64_t* caps) { const z_cap_t* caps) {
ZChannelSendReq req{ ZChannelSendReq req{
.chan_cap = chan_cap, .chan_cap = chan_cap,
.message = .message =
@ -136,14 +136,14 @@ z_err_t ZChannelSend(uint64_t chan_cap, uint64_t type, uint64_t num_bytes,
.num_bytes = num_bytes, .num_bytes = num_bytes,
.bytes = const_cast<uint8_t*>(bytes), .bytes = const_cast<uint8_t*>(bytes),
.num_caps = num_caps, .num_caps = num_caps,
.caps = const_cast<uint64_t*>(caps), .caps = const_cast<z_cap_t*>(caps),
}, },
}; };
return SysCall1(Z_CHANNEL_SEND, &req); return SysCall1(Z_CHANNEL_SEND, &req);
} }
z_err_t ZChannelRecv(uint64_t chan_cap, uint64_t num_bytes, uint8_t* bytes, z_err_t ZChannelRecv(z_cap_t chan_cap, uint64_t num_bytes, uint8_t* bytes,
uint64_t num_caps, uint64_t* caps, uint64_t* type, uint64_t num_caps, z_cap_t* caps, uint64_t* type,
uint64_t* actual_bytes, uint64_t* actual_caps) { uint64_t* actual_bytes, uint64_t* actual_caps) {
ZChannelRecvReq req{ ZChannelRecvReq req{
.chan_cap = chan_cap, .chan_cap = chan_cap,
@ -163,15 +163,15 @@ z_err_t ZChannelRecv(uint64_t chan_cap, uint64_t num_bytes, uint8_t* bytes,
return ret; return ret;
} }
z_err_t ZPortCreate(uint64_t* port_cap) { z_err_t ZPortCreate(z_cap_t* port_cap) {
ZPortCreateResp resp; ZPortCreateResp resp;
z_err_t ret = SysCall2(Z_PORT_CREATE, 0, &resp); z_err_t ret = SysCall2(Z_PORT_CREATE, 0, &resp);
*port_cap = resp.port_cap; *port_cap = resp.port_cap;
return ret; return ret;
} }
z_err_t ZPortSend(uint64_t port_cap, uint64_t num_bytes, const uint8_t* bytes, z_err_t ZPortSend(z_cap_t port_cap, uint64_t num_bytes, const uint8_t* bytes,
uint64_t num_caps, uint64_t* caps) { uint64_t num_caps, z_cap_t* caps) {
ZPortSendReq req{.port_cap = port_cap, ZPortSendReq req{.port_cap = port_cap,
.message = { .message = {
.type = 0, .type = 0,
@ -183,8 +183,8 @@ z_err_t ZPortSend(uint64_t port_cap, uint64_t num_bytes, const uint8_t* bytes,
return SysCall1(Z_PORT_SEND, &req); return SysCall1(Z_PORT_SEND, &req);
} }
z_err_t ZPortRecv(uint64_t port_cap, uint64_t num_bytes, uint8_t* bytes, z_err_t ZPortRecv(z_cap_t port_cap, uint64_t num_bytes, uint8_t* bytes,
uint64_t num_caps, uint64_t* caps, uint64_t* type, uint64_t num_caps, z_cap_t* caps, uint64_t* type,
uint64_t* actual_bytes, uint64_t* actual_caps) { uint64_t* actual_bytes, uint64_t* actual_caps) {
ZPortRecvReq req{ ZPortRecvReq req{
.port_cap = port_cap, .port_cap = port_cap,
@ -204,8 +204,8 @@ z_err_t ZPortRecv(uint64_t port_cap, uint64_t num_bytes, uint8_t* bytes,
return ret; return ret;
} }
z_err_t ZPortPoll(uint64_t port_cap, uint64_t num_bytes, uint8_t* bytes, z_err_t ZPortPoll(z_cap_t port_cap, uint64_t num_bytes, uint8_t* bytes,
uint64_t num_caps, uint64_t* caps, uint64_t* type, uint64_t num_caps, z_cap_t* caps, uint64_t* type,
uint64_t* actual_bytes, uint64_t* actual_caps) { uint64_t* actual_bytes, uint64_t* actual_caps) {
ZPortRecvReq req{ ZPortRecvReq req{
.port_cap = port_cap, .port_cap = port_cap,
@ -225,7 +225,7 @@ z_err_t ZPortPoll(uint64_t port_cap, uint64_t num_bytes, uint8_t* bytes,
return ret; return ret;
} }
z_err_t ZIrqRegister(uint64_t irq_num, uint64_t* port_cap) { z_err_t ZIrqRegister(uint64_t irq_num, z_cap_t* port_cap) {
ZIrqRegisterReq req{ ZIrqRegisterReq req{
.irq_num = irq_num, .irq_num = irq_num,
}; };
@ -235,7 +235,7 @@ z_err_t ZIrqRegister(uint64_t irq_num, uint64_t* port_cap) {
return ret; return ret;
} }
z_err_t ZCapDuplicate(uint64_t cap_in, uint64_t* cap_out) { z_err_t ZCapDuplicate(z_cap_t cap_in, z_cap_t* cap_out) {
ZCapDuplicateReq req{ ZCapDuplicateReq req{
.cap = cap_in, .cap = cap_in,
}; };

52
zion/usr/zcall_internal.h
View File

@ -2,36 +2,38 @@
#include <stdint.h> #include <stdint.h>
#include "include/ztypes.h"
struct ZProcessSpawnReq { struct ZProcessSpawnReq {
uint64_t proc_cap; z_cap_t proc_cap;
uint64_t bootstrap_cap; z_cap_t bootstrap_cap;
}; };
struct ZProcessSpawnResp { struct ZProcessSpawnResp {
uint64_t proc_cap; z_cap_t proc_cap;
uint64_t vmas_cap; z_cap_t vmas_cap;
uint64_t bootstrap_cap; z_cap_t bootstrap_cap;
}; };
struct ZThreadCreateReq { struct ZThreadCreateReq {
uint64_t proc_cap; z_cap_t proc_cap;
}; };
struct ZThreadCreateResp { struct ZThreadCreateResp {
uint64_t thread_cap; z_cap_t thread_cap;
}; };
struct ZThreadStartReq { struct ZThreadStartReq {
uint64_t thread_cap; z_cap_t thread_cap;
uint64_t entry; uint64_t entry;
uint64_t arg1; uint64_t arg1;
uint64_t arg2; uint64_t arg2;
}; };
struct ZAddressSpaceMapReq { struct ZAddressSpaceMapReq {
uint64_t vmas_cap; z_cap_t vmas_cap;
uint64_t vmas_offset; z_cap_t vmas_offset;
uint64_t vmmo_cap; z_cap_t vmmo_cap;
}; };
struct ZAddressSpaceMapResp { struct ZAddressSpaceMapResp {
@ -43,7 +45,7 @@ struct ZMemoryObjectCreateReq {
}; };
struct ZMemoryObjectCreateResp { struct ZMemoryObjectCreateResp {
uint64_t vmmo_cap; z_cap_t vmmo_cap;
}; };
struct ZMemoryObjectCreatePhysicalReq { struct ZMemoryObjectCreatePhysicalReq {
@ -52,18 +54,18 @@ struct ZMemoryObjectCreatePhysicalReq {
}; };
struct ZMemoryObjectCreatePhysicalResp { struct ZMemoryObjectCreatePhysicalResp {
uint64_t vmmo_cap; z_cap_t vmmo_cap;
uint64_t paddr; uint64_t paddr;
}; };
struct ZTempPcieConfigObjectCreateResp { struct ZTempPcieConfigObjectCreateResp {
uint64_t vmmo_cap; z_cap_t vmmo_cap;
uint64_t vmmo_size; uint64_t vmmo_size;
}; };
struct ZChannelCreateResp { struct ZChannelCreateResp {
uint64_t chan_cap1; z_cap_t chan_cap1;
uint64_t chan_cap2; z_cap_t chan_cap2;
}; };
struct ZMessage { struct ZMessage {
@ -73,30 +75,30 @@ struct ZMessage {
uint8_t* bytes; uint8_t* bytes;
uint64_t num_caps; uint64_t num_caps;
uint64_t* caps; z_cap_t* caps;
}; };
struct ZChannelSendReq { struct ZChannelSendReq {
uint64_t chan_cap; z_cap_t chan_cap;
ZMessage message; ZMessage message;
}; };
struct ZChannelRecvReq { struct ZChannelRecvReq {
uint64_t chan_cap; z_cap_t chan_cap;
ZMessage message; ZMessage message;
}; };
struct ZPortCreateResp { struct ZPortCreateResp {
uint64_t port_cap; z_cap_t port_cap;
}; };
struct ZPortSendReq { struct ZPortSendReq {
uint64_t port_cap; z_cap_t port_cap;
ZMessage message; ZMessage message;
}; };
struct ZPortRecvReq { struct ZPortRecvReq {
uint64_t port_cap; z_cap_t port_cap;
ZMessage message; ZMessage message;
}; };
@ -105,13 +107,13 @@ struct ZIrqRegisterReq {
}; };
struct ZIrqRegisterResp { struct ZIrqRegisterResp {
uint64_t port_cap; z_cap_t port_cap;
}; };
struct ZCapDuplicateReq { struct ZCapDuplicateReq {
uint64_t cap; z_cap_t cap;
}; };
struct ZCapDuplicateResp { struct ZCapDuplicateResp {
uint64_t cap; z_cap_t cap;
}; };