wash/magenta
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

meta: rename kernel to Magenta

Browse Source
This commit is contained in:
max 🍓
2026-04-30 20:30:36 +01:00
parent 560da0daa0
commit 1db6de6bc2
65 changed files with 122 additions and 122 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libmagenta/CMakeLists.txt
+12
View File
@@ -0,0 +1,12 @@
file(GLOB headers ${CMAKE_CURRENT_SOURCE_DIR}/include/magenta/*.h)
file(GLOB asm_sources
${CMAKE_CURRENT_SOURCE_DIR}/arch/${CMAKE_SYSTEM_PROCESSOR}/*.S)
set(public_include_dirs
${CMAKE_CURRENT_SOURCE_DIR}/include
${CMAKE_CURRENT_SOURCE_DIR}/include-user)
add_library(libmagenta STATIC ${asm_sources})
target_include_directories(libmagenta PUBLIC
${CMAKE_CURRENT_SOURCE_DIR}/include
${CMAKE_CURRENT_SOURCE_DIR}/include-user)
libmagenta/arch/x86_64/syscall.S
+115
View File
@@ -0,0 +1,115 @@
#include "magenta/syscall.h"
# Registers:
# rax = syscall ID + return value
# rdi = 1st parameter
# rsi = 2nd parameter
# rdx = 3rd parameter
# r12 = 4th parameter
# r8 = 5th parameter
# r9 = 6th parameter
# r13 = 7th parameter
# r14 = 8th parameter
.macro SYSCALL_GATE name index args
.global \name
.type \name, @function
\name:
push %rbp
mov %rsp, %rbp
# Syscall ID
mov $\index, %rax
# The syscall instruction uses rcx, so move this parameter to r12
.if \args >= 4
pushq %r12
movq %rcx, %r12
.endif
# r13 and r14 are callee-saved so we save it beforehand
.if \args >= 7
pushq %r13
movq 16(%rbp), %r13
.endif
.if \args >= 8
pushq %r14
movq 24(%rbp), %r14
.endif
syscall
.if \args >= 8
popq %r14
.endif
.if \args >= 7
popq %r13
.endif
.if \args >= 4
popq %r12
.endif
pop %rbp
ret
.endm
SYSCALL_GATE task_exit SYS_TASK_EXIT 1
SYSCALL_GATE task_self SYS_TASK_SELF 1
SYSCALL_GATE task_create SYS_TASK_CREATE 6
SYSCALL_GATE task_duplicate SYS_TASK_DUPLICATE 2
SYSCALL_GATE task_create_thread SYS_TASK_CREATE_THREAD 6
SYSCALL_GATE task_get_address_space SYS_TASK_GET_ADDRESS_SPACE 1
SYSCALL_GATE task_config_get SYS_TASK_CONFIG_GET 4
SYSCALL_GATE task_config_set SYS_TASK_CONFIG_SET 4
SYSCALL_GATE thread_self SYS_THREAD_SELF 1
SYSCALL_GATE thread_start SYS_THREAD_START 1
SYSCALL_GATE thread_exit SYS_THREAD_EXIT 0
SYSCALL_GATE thread_config_get SYS_THREAD_CONFIG_GET 4
SYSCALL_GATE thread_config_set SYS_THREAD_CONFIG_SET 4
SYSCALL_GATE vm_object_create SYS_VM_OBJECT_CREATE 5
SYSCALL_GATE vm_object_read SYS_VM_OBJECT_READ 5
SYSCALL_GATE vm_object_write SYS_VM_OBJECT_WRITE 5
SYSCALL_GATE vm_object_copy SYS_VM_OBJECT_COPY 6
SYSCALL_GATE address_space_read SYS_ADDRESS_SPACE_READ 5
SYSCALL_GATE address_space_write SYS_ADDRESS_SPACE_WRITE 5
SYSCALL_GATE address_space_map SYS_ADDRESS_SPACE_MAP 8
SYSCALL_GATE address_space_unmap SYS_ADDRESS_SPACE_UNMAP 3
SYSCALL_GATE address_space_reserve SYS_ADDRESS_SPACE_RESERVE 4
SYSCALL_GATE address_space_release SYS_ADDRESS_SPACE_RELEASE 3
SYSCALL_GATE kern_log SYS_KERN_LOG 1
SYSCALL_GATE kern_handle_close SYS_KERN_HANDLE_CLOSE 1
SYSCALL_GATE kern_handle_transfer SYS_KERN_HANDLE_TRANSFER 6
SYSCALL_GATE kern_config_get SYS_KERN_CONFIG_GET 3
SYSCALL_GATE kern_config_set SYS_KERN_CONFIG_SET 3
SYSCALL_GATE channel_create SYS_CHANNEL_CREATE 2
SYSCALL_GATE port_create SYS_PORT_CREATE 1
SYSCALL_GATE port_connect SYS_PORT_CONNECT 3
SYSCALL_GATE port_disconnect SYS_PORT_DISCONNECT 1
SYSCALL_GATE msg_send SYS_MSG_SEND 5
SYSCALL_GATE msg_recv SYS_MSG_RECV 4
SYSCALL_GATE msg_reply SYS_MSG_REPLY 4
SYSCALL_GATE msg_read SYS_MSG_READ 6
SYSCALL_GATE msg_write SYS_MSG_WRITE 6
SYSCALL_GATE vm_controller_create SYS_VM_CONTROLLER_CREATE 1
SYSCALL_GATE vm_controller_recv SYS_VM_CONTROLLER_RECV 2
SYSCALL_GATE vm_controller_recv_async SYS_VM_CONTROLLER_RECV_ASYNC 3
SYSCALL_GATE vm_controller_create_object SYS_VM_CONTROLLER_CREATE_OBJECT 7
SYSCALL_GATE vm_controller_prepare_attach SYS_VM_CONTROLLER_PREPARE_ATTACH 3
SYSCALL_GATE vm_controller_finish_attach SYS_VM_CONTROLLER_FINISH_ATTACH 3
SYSCALL_GATE vm_controller_detach_object SYS_VM_CONTROLLER_DETACH_OBJECT 2
SYSCALL_GATE vm_controller_supply_pages SYS_VM_CONTROLLER_SUPPLY_PAGES 6
SYSCALL_GATE kern_object_wait SYS_KERN_OBJECT_WAIT 2
SYSCALL_GATE kern_object_query SYS_KERN_OBJECT_QUERY 2
SYSCALL_GATE futex_wait SYS_FUTEX_WAIT 3
SYSCALL_GATE futex_wake SYS_FUTEX_WAKE 3
libmagenta/include-user/magenta/config.h
+17
View File
@@ -0,0 +1,17 @@
#ifndef MAGENTA_CONFIG_H_
#define MAGENTA_CONFIG_H_
#include <magenta/status.h>
#include <magenta/types.h>
#include <stddef.h>
extern kern_status_t kern_config_get(
kern_config_key_t key,
void *ptr,
size_t len);
extern kern_status_t kern_config_set(
kern_config_key_t key,
const void *ptr,
size_t len);
#endif
libmagenta/include-user/magenta/equeue.h
+9
View File
@@ -0,0 +1,9 @@
#ifndef MAGENTA_EQUEUE_H_
#define MAGENTA_EQUEUE_H_
#include <magenta/types.h>
extern kern_status_t equeue_create(kern_handle_t *out);
extern kern_status_t equeue_dequeue(kern_handle_t eq, equeue_packet_t *out);
#endif
libmagenta/include-user/magenta/futex.h
+16
View File
@@ -0,0 +1,16 @@
#ifndef MAGENTA_FUTEX_H_
#define MAGENTA_FUTEX_H_
#include <magenta/status.h>
#include <magenta/types.h>
extern kern_status_t futex_wait(
kern_futex_t *futex,
kern_futex_t new_val,
unsigned int flags);
extern kern_status_t futex_wake(
kern_futex_t *futex,
unsigned int nr_waiters,
unsigned int flags);
#endif
libmagenta/include-user/magenta/handle.h
+22
View File
@@ -0,0 +1,22 @@
#ifndef MAGENTA_HANDLE_H_
#define MAGENTA_HANDLE_H_
#include <magenta/status.h>
#include <magenta/types.h>
extern kern_status_t kern_handle_close(kern_handle_t handle);
extern kern_status_t kern_handle_transfer(
kern_handle_t src_task,
kern_handle_t src_handle,
kern_handle_t dest_task,
kern_handle_t dest_handle,
unsigned int mode,
kern_handle_t *out_handle);
extern kern_status_t kern_handle_control(
kern_handle_t task,
kern_handle_t handle,
uint32_t set_mask,
uint32_t clear_mask,
uint32_t *out_flags);
#endif
libmagenta/include-user/magenta/log.h
+31
View File
@@ -0,0 +1,31 @@
#ifndef MAGENTA_LOG_H_
#define MAGENTA_LOG_H_
#include <magenta/status.h>
#include <magenta/types.h>
#undef TRACE
extern kern_status_t kern_log(const char *s);
#define kern_logf(...) \
do { \
char __logbuf[128]; \
snprintf(__logbuf, sizeof __logbuf, __VA_ARGS__); \
kern_log(__logbuf); \
} while (0)
#ifdef TRACE
#define kern_trace(...) kern_log(__VA_ARGS__)
#define kern_tracef(...) \
do { \
char __logbuf[128]; \
snprintf(__logbuf, sizeof __logbuf, __VA_ARGS__); \
kern_log(__logbuf); \
} while (0)
#else
#define kern_trace(...)
#define kern_tracef(...)
#endif
#endif
libmagenta/include-user/magenta/msg.h
+43
View File
@@ -0,0 +1,43 @@
#ifndef MAGENTA_MSG_H_
#define MAGENTA_MSG_H_
#include <magenta/status.h>
#include <magenta/types.h>
extern kern_status_t channel_create(unsigned int id, kern_handle_t *out);
extern kern_status_t port_create(kern_handle_t *out);
extern kern_status_t port_connect(
kern_handle_t port,
tid_t task_id,
unsigned int channel_id);
extern kern_status_t port_disconnect(kern_handle_t port);
extern kern_status_t msg_send(
kern_handle_t port,
const kern_msg_t *msg,
kern_msg_t *out_response);
extern kern_status_t msg_recv(kern_handle_t channel, kern_msg_t *out);
extern kern_status_t msg_reply(
kern_handle_t channel,
msgid_t id,
const kern_msg_t *response);
extern kern_status_t msg_read(
kern_handle_t channel,
msgid_t id,
size_t offset,
kern_iovec_t *out,
size_t out_count,
size_t *nr_read);
extern kern_status_t msg_write(
kern_handle_t channel,
msgid_t id,
size_t offset,
const kern_iovec_t *in,
size_t nr_in,
size_t *nr_written);
#endif
libmagenta/include-user/magenta/object.h
+11
View File
@@ -0,0 +1,11 @@
#ifndef MAGENTA_OBJECT_H_
#define MAGENTA_OBJECT_H_
#include <magenta/types.h>
extern kern_status_t kern_object_wait(kern_wait_item_t *items, size_t nr_items);
extern kern_status_t kern_object_query(
kern_handle_t handle,
kern_object_info_t *out);
#endif
libmagenta/include-user/magenta/task.h
+62
View File
@@ -0,0 +1,62 @@
#ifndef MAGENTA_TASK_H_
#define MAGENTA_TASK_H_
#include <magenta/status.h>
#include <magenta/types.h>
extern kern_status_t task_exit(int status);
extern kern_status_t task_self(kern_handle_t *out);
extern kern_status_t task_create(
kern_handle_t parent,
task_flags_t flags,
const char *name,
size_t name_len,
kern_handle_t *out_task,
kern_handle_t *out_address_space);
extern kern_status_t task_create_thread(
kern_handle_t task,
virt_addr_t ip,
virt_addr_t sp,
uintptr_t *args,
size_t nr_args,
kern_handle_t *out_thread);
extern kern_status_t task_get_address_space(
kern_handle_t task,
kern_handle_t *out);
extern kern_status_t task_config_get(
kern_handle_t task,
kern_config_key_t key,
void *ptr,
size_t len);
extern kern_status_t task_config_set(
kern_handle_t task,
kern_config_key_t key,
const void *ptr,
size_t len);
extern kern_status_t task_duplicate(
kern_handle_t *out_task,
kern_handle_t *out_address_space);
extern kern_status_t task_reset(
virt_addr_t ip,
virt_addr_t sp,
uintptr_t *args,
size_t nr_args,
virt_addr_t unmap_base,
size_t unmap_length);
extern kern_status_t thread_self(kern_handle_t *out);
extern kern_status_t thread_start(kern_handle_t thread);
extern kern_status_t thread_exit(void);
extern kern_status_t thread_config_get(
kern_handle_t thread,
kern_config_key_t key,
void *ptr,
size_t len);
extern kern_status_t thread_config_set(
kern_handle_t thread,
kern_config_key_t key,
const void *ptr,
size_t len);
#endif
libmagenta/include-user/magenta/vm.h
+103
View File
@@ -0,0 +1,103 @@
#ifndef MAGENTA_VM_H_
#define MAGENTA_VM_H_
#include <magenta/status.h>
#include <magenta/types.h>
extern kern_status_t vm_object_create(
const char *name,
size_t name_len,
size_t data_len,
vm_prot_t prot,
kern_handle_t *out);
extern kern_status_t vm_object_read(
kern_handle_t object,
void *dst,
off_t offset,
size_t count,
size_t *nr_read);
extern kern_status_t vm_object_write(
kern_handle_t object,
const void *src,
off_t offset,
size_t count,
size_t *nr_written);
extern kern_status_t vm_object_copy(
kern_handle_t dst,
off_t dst_offset,
kern_handle_t src,
off_t src_offset,
size_t count,
size_t *nr_copied);
extern kern_status_t address_space_read(
kern_handle_t region,
void *dst,
virt_addr_t base,
size_t count,
size_t *nr_read);
extern kern_status_t address_space_write(
kern_handle_t region,
const void *src,
virt_addr_t base,
size_t count,
size_t *nr_read);
extern kern_status_t address_space_map(
kern_handle_t region,
virt_addr_t map_address,
kern_handle_t object,
off_t object_offset,
size_t length,
vm_flags_t flags,
vm_prot_t prot,
virt_addr_t *out_base_address);
extern kern_status_t address_space_unmap(
kern_handle_t region,
virt_addr_t base,
size_t length);
extern kern_status_t address_space_reserve(
kern_handle_t region,
virt_addr_t base,
size_t length,
virt_addr_t *out_base_address);
extern kern_status_t address_space_release(
kern_handle_t region,
virt_addr_t base,
size_t length);
extern kern_status_t vm_controller_create(kern_handle_t *out);
extern kern_status_t vm_controller_recv(
kern_handle_t ctrl,
equeue_packet_vm_request_t *out);
extern kern_status_t vm_controller_recv_async(
kern_handle_t ctrl,
kern_handle_t eq,
equeue_key_t key);
extern kern_status_t vm_controller_create_object(
kern_handle_t ctrl,
const char *name,
size_t name_len,
equeue_key_t key,
size_t data_len,
vm_prot_t prot,
kern_handle_t *out);
extern kern_status_t vm_controller_prepare_attach(
kern_handle_t ctrl,
uint64_t req_id,
kern_handle_t *out_vmo);
extern kern_status_t vm_controller_finish_attach(
kern_handle_t ctrl,
uint64_t req_id,
equeue_key_t new_key);
extern kern_status_t vm_controller_detach_object(
kern_handle_t ctrl,
kern_handle_t vmo);
extern kern_status_t vm_controller_supply_pages(
kern_handle_t ctrl,
kern_handle_t dst_vmo,
off_t dst_offset,
kern_handle_t src_vmo,
off_t src_offset,
size_t length);
#endif
libmagenta/include/magenta/signal.h
+12
View File
@@ -0,0 +1,12 @@
#ifndef MAGENTA_SIGNAL_H_
#define MAGENTA_SIGNAL_H_
#define THREAD_SIGNAL_STOPPED 0x01u
#define CHANNEL_SIGNAL_MSG_RECEIVED 0x01u
#define VM_CONTROLLER_SIGNAL_REQUEST_RECEIVED 0x01u
#define EQUEUE_SIGNAL_PACKET_RECEIVED 0x01u
#endif
libmagenta/include/magenta/status.h
+21
View File
@@ -0,0 +1,21 @@
#ifndef MAGENTA_STATUS_H_
#define MAGENTA_STATUS_H_
#define KERN_OK (0)
#define KERN_UNIMPLEMENTED (1)
#define KERN_NAME_EXISTS (2)
#define KERN_INVALID_ARGUMENT (3)
#define KERN_UNSUPPORTED (4)
#define KERN_NO_MEMORY (5)
#define KERN_NO_ENTRY (6)
#define KERN_WOULD_BLOCK (7)
#define KERN_BUSY (8)
#define KERN_NO_DEVICE (9)
#define KERN_DEVICE_STUCK (10)
#define KERN_IO_ERROR (11)
#define KERN_FATAL_ERROR (12)
#define KERN_BAD_STATE (13)
#define KERN_MEMORY_FAULT (14)
#define KERN_ACCESS_DENIED (15)
#endif
libmagenta/include/magenta/syscall.h
+58
View File
@@ -0,0 +1,58 @@
#ifndef MAGENTA_SYSCALL_H_
#define MAGENTA_SYSCALL_H_
#define SYS_KERN_LOG 1
#define SYS_KERN_HANDLE_CLOSE 2
#define SYS_KERN_HANDLE_TRANSFER 3
#define SYS_KERN_HANDLE_CONTROL 4
#define SYS_KERN_CONFIG_GET 5
#define SYS_KERN_CONFIG_SET 6
#define SYS_KERN_OBJECT_WAIT 7
#define SYS_KERN_OBJECT_WAIT_ASYNC 8
#define SYS_TASK_EXIT 9
#define SYS_TASK_SELF 10
#define SYS_TASK_CREATE 11
#define SYS_TASK_CREATE_THREAD 12
#define SYS_TASK_GET_ADDRESS_SPACE 13
#define SYS_TASK_CONFIG_GET 14
#define SYS_TASK_CONFIG_SET 15
#define SYS_TASK_DUPLICATE 16
#define SYS_THREAD_SELF 17
#define SYS_THREAD_START 18
#define SYS_THREAD_EXIT 19
#define SYS_THREAD_CONFIG_GET 20
#define SYS_THREAD_CONFIG_SET 21
#define SYS_VM_OBJECT_CREATE 22
#define SYS_VM_OBJECT_READ 23
#define SYS_VM_OBJECT_WRITE 24
#define SYS_VM_OBJECT_COPY 25
#define SYS_ADDRESS_SPACE_READ 26
#define SYS_ADDRESS_SPACE_WRITE 27
#define SYS_ADDRESS_SPACE_MAP 28
#define SYS_ADDRESS_SPACE_UNMAP 29
#define SYS_ADDRESS_SPACE_RESERVE 30
#define SYS_ADDRESS_SPACE_RELEASE 31
#define SYS_MSG_SEND 32
#define SYS_MSG_RECV 33
#define SYS_MSG_REPLY 34
#define SYS_MSG_READ 35
#define SYS_MSG_WRITE 36
#define SYS_CHANNEL_CREATE 37
#define SYS_PORT_CREATE 38
#define SYS_PORT_CONNECT 39
#define SYS_PORT_DISCONNECT 40
#define SYS_EQUEUE_CREATE 41
#define SYS_EQUEUE_DEQUEUE 42
#define SYS_VM_CONTROLLER_CREATE 43
#define SYS_VM_CONTROLLER_RECV 44
#define SYS_VM_CONTROLLER_RECV_ASYNC 45
#define SYS_VM_CONTROLLER_CREATE_OBJECT 46
#define SYS_VM_CONTROLLER_PREPARE_ATTACH 47
#define SYS_VM_CONTROLLER_FINISH_ATTACH 48
#define SYS_VM_CONTROLLER_DETACH_OBJECT 49
#define SYS_VM_CONTROLLER_SUPPLY_PAGES 50
#define SYS_FUTEX_WAIT 51
#define SYS_FUTEX_WAKE 52
#define SYS_KERN_OBJECT_QUERY 53
#endif
libmagenta/include/magenta/types.h
+239
View File
@@ -0,0 +1,239 @@
#ifndef MAGENTA_TYPES_H_
#define MAGENTA_TYPES_H_
#include <stddef.h>
#include <stdint.h>
#define VM_PROT_READ 0x01u
#define VM_PROT_WRITE 0x02u
#define VM_PROT_EXEC 0x04u
#define VM_PROT_USER 0x08u
#define VM_PROT_SVR 0x10u
#define VM_PROT_NOCACHE 0x10u
#define VM_PROT_MAP_SPECIFIC 0x40u
#define MAP_ADDRESS_ANY ((virt_addr_t) - 1)
#define MAP_ADDRESS_INVALID ((virt_addr_t)0)
#define KERN_HANDLE_INVALID ((kern_handle_t)0xFFFFFFFF)
/* task creation flags */
#define TASK_F_DEFAULT 0x0000u
#define TASK_F_CLONE_ALL_HANDLES 0x0001u
/* config keys for use with kern_config_get/kern_config_set */
#define KERN_CFG_INVALID 0x00000u
#define KERN_CFG_PAGE_SIZE 0x00001u
/* config keys for use with task_config_get/task_config_set */
#define TASK_CFG_INVALID 0x00000u
#define TASK_CFG_ID 0x10001u
/* config keys for use with thread_config_get/thread_config_set */
#define THREAD_CFG_INVALID 0x00000u
#define THREAD_CFG_FSBASE 0x20001u
#define THREAD_CFG_GSBASE 0x20002u
/* user-defined flags that can be set on handles */
#define KERN_HANDLE_FLAG0 0x10000000UL
#define KERN_HANDLE_FLAG1 0x20000000UL
#define KERN_HANDLE_FLAG2 0x40000000UL
#define KERN_HANDLE_FLAG3 0x80000000UL
/* flags to specify when creating address-space mappings */
/* this mapping is private. if a task with this mapping is duplicated,
the duplicate task will receive a copy-on-write mapping. changes to one
mapping will not be visible to the other. */
#define VM_PRIVATE 0x0000u
/* this mapping is shared. if a task with this mapping is duplicated,
* the duplicate will receive a mapping of the same data. changes to one mapping
* will be visibile to the other */
#define VM_SHARED 0x0001u
/* maximum number of handles that can be sent in a single message */
#define KERN_MSG_MAX_HANDLES 64
/* the corresponding handle should be ignored */
#define HANDLE_TRANSFER_IGNORE 0
/* the corresponding handle should be moved to the recipient task. the handle
* will be closed. */
#define HANDLE_TRANSFER_MOVE 1
/* the corresponding handle should be copied to the recipient task. the handle
* will remain valid for the sending task. */
#define HANDLE_TRANSFER_COPY 2
/* maximum number of objects that can be waited on in a single call to
* kern_object_wait */
#define KERN_WAIT_MAX_ITEMS 64
/* message types */
#define KERN_MSG_TYPE_NONE 0
#define KERN_MSG_TYPE_DATA 1
#define KERN_MSG_TYPE_EVENT 2
/* event message types */
#define KERN_MSG_EVENT_NONE 0
#define KERN_MSG_EVENT_CONNECTION 1
#define KERN_MSG_EVENT_DISCONNECTION 2
/* equeue packet types */
#define EQUEUE_PKT_VM_REQUEST 0x01u
#define EQUEUE_PKT_ASYNC_SIGNAL 0x02u
/* vm request types */
#define VM_REQUEST_READ 0x01u
#define VM_REQUEST_DIRTY 0x02u
#define VM_REQUEST_ATTACH 0x03u
#define VM_REQUEST_DETACH 0x04u
/* futex special values */
#define FUTEX_WAKE_ALL ((size_t)-1)
/* futex flags */
#define FUTEX_PRIVATE 0x01u
#define FUTEX_SHARED 0x02u
#define IOVEC(p, len) \
{ \
.io_base = (virt_addr_t)(p), \
.io_len = (len), \
}
#define MSG_HANDLE(mode, value) \
{ \
.hnd_mode = (mode), \
.hnd_value = (value), \
}
#define MSG(data, data_count, handles, handles_len) \
{ \
.msg_data = (data), \
.msg_data_count = (data_count), \
.msg_handles = (handles), \
.msg_handles_count = (handles_len), \
}
typedef uintptr_t phys_addr_t;
typedef uintptr_t virt_addr_t;
typedef uint64_t msgid_t;
typedef uint64_t off_t;
typedef uint64_t koid_t;
typedef uintptr_t equeue_key_t;
typedef unsigned int tid_t;
typedef unsigned int vm_controller_packet_type_t;
typedef unsigned int kern_status_t;
typedef uint32_t kern_handle_t;
typedef uint32_t kern_config_key_t;
typedef uint32_t vm_prot_t;
typedef uint32_t vm_flags_t;
typedef uint32_t task_flags_t;
typedef int64_t ssize_t;
typedef uint32_t kern_futex_t;
typedef uint32_t kern_msg_type_t;
typedef uint32_t kern_msg_event_type_t;
typedef unsigned short equeue_packet_type_t;
typedef unsigned int umode_t;
typedef struct {
koid_t obj_id;
} kern_object_info_t;
typedef struct {
virt_addr_t io_base;
size_t io_len;
} kern_iovec_t;
typedef struct {
kern_handle_t w_handle;
uint32_t w_waitfor;
uint32_t w_observed;
} kern_wait_item_t;
typedef struct {
unsigned int hnd_mode;
kern_handle_t hnd_value;
kern_status_t hnd_result;
} kern_msg_handle_t;
typedef struct {
/* transaction id. identifies a particular request/response exchange.
* used when replying to a particular message. */
msgid_t msg_id;
/* the id of the task that sent a particular message. */
tid_t msg_sender;
/* the id of the port or channel used to send a particular message. */
koid_t msg_endpoint;
/* the message type */
kern_msg_type_t msg_type;
union {
/* msg_type = KERN_MSG_TYPE_DATA */
struct {
/* a list of iovecs that point to the buffers that make
* up the main message data. */
kern_iovec_t *msg_data;
size_t msg_data_count;
/* a list of handle entries that contain the kernel
* handles included in a message. */
kern_msg_handle_t *msg_handles;
size_t msg_handles_count;
};
/* msg_type = KERN_MSG_TYPE_EVENT */
struct {
kern_msg_event_type_t msg_event;
};
};
} kern_msg_t;
typedef struct {
uint32_t s_observed;
} equeue_packet_async_signal_t;
typedef struct {
/* the key of the vm-object for which the page request relates, as
* specified when the vm-object was created */
equeue_key_t req_vmo;
/* page request type. one of VM_REQUEST_* */
unsigned short req_type;
/* the offset into the vm-object for which pages are being requested */
union {
/* used for:
* VM_REQUEST_READ
* VM_REQUEST_DIRTY
*/
struct {
off_t req_offset;
/* the length in bytes of the region being requested */
size_t req_length;
};
/* used for:
* VM_REQUEST_ATTACH
*/
struct {
/* the key of the original/source vmo. */
equeue_key_t req_src_vmo;
/* a request ID. used to retrieve information about
* the newly-attached object, as the server won't know
* about it yet, and won't have a handle to it. */
uint64_t req_id;
};
};
} equeue_packet_vm_request_t;
typedef struct {
/* the type of packet. one of EQUEUE_PKT_* */
equeue_packet_type_t p_type;
/* the key of the object that is responsible for the event, as specified
* when the event was first subscribed to */
equeue_key_t p_key;
union {
/* p_type = EQUEUE_PKT_VM_REQUEST */
equeue_packet_vm_request_t vm_request;
/* p_type = EQUEUE_PKT_ASYNC_SIGNAL */
equeue_packet_async_signal_t async_signal;
};
} equeue_packet_t;
#endif
libmagenta/msg.c
View File