15 KiB

Raw Blame History

SysABI

Syscalls are a way for programms to communicate with the kernel.

To perform a syscall, you need to populate the following registers:

Register	Value
rax	The syscalls ID
rdi	Argument 1
rsi	Argument 2
rdx	Argument 3
rcx	Argument 4

The following calls should be implemented to some degree in noxos 1.0.

Categories

Files

ID	Name	Description	Arg1	Arg2	Arg3	Arg4	Result	Status
0x0001	`nx_fs_open`	Opens the file at the len bytes long path path and writes a file descriptor to the referenced file into fd (which needs to be a pointer).	path	len	*fd		status	Implemented
0x0002	`nx_fs_close`	Closes the file which is indicated by descriptor fd. This should always be called, otherwise the OS will have to unload files without knowledge of usage.	fd				status	Implemented
0x0003	`nx_fs_read`	Reads at most n bytes from a file given as descriptor fd and at a specific position offset into a given memory region mem.	fd	offset	mem	n	status	Implemented
0x0004	`nx_fs_write`	Writes n bytes from a given memory region mem into the file referenced by fd at the given position offset, not inserting but either overwriting existing content or appending to the file.	fd	offset	mem	n	status	Implemented
0x0005	`nx_fs_delete`	Completely delete the file or folder at a given path path, which is len bytes long.	path	len			status	Implemented
0x0006	`nx_fs_list`	List all files and/or directories at the len bytes long path path and write their NULL-separated names into mem. When mem is NULL, needed_mem (which needs to be a pointer to an 32-bit integer) is filled with the appropriate value.	path	len	mem	*needed_mem	status	Implemented
0x0007	`nx_fs_info`	Writes the information about the files attribute attr into mem. Types of attributes are described below.	fd	attr	mem		status	N/A

Note: The len argument of paths isn't used at the moment, rather than using len, path needs to be Null-Terminated.

Memory

ID	Name	Description	Arg1	Arg2	Arg3	Result	Status
0x0101	`nx_mem_alloc`	Maps n 4KB pages to address addr. You can provide a bitmap of flags with the flags argument. Which flags can be used, is described below.	addr	n	flags	status	Implemented
0x0102	`nx_mem_free`	Unmaps n 4KB pages at address addr.	addr	n		status	Implemented
0x0103	`nx_mem_label`	Gives a memory region a file descriptor, called a label, which can then be used for example for executing executable data in that memory region in a new process	addr	len	*fd	status	N/A
0x0104	`nx_mem_unlabel`	Takes the file descriptor away from a memory region.	fd			status	N/A

Processes

ID	Name	Description	Arg1	Arg2	Result	Status
0x0201	`nx_proc_create`	Creates a new process with the configuration conf (which format is described below) and writes its process id to pid.	*conf	*pid	status	N/A
0x0202	`nx_proc_signal_send`	Send the signal signal to pid. See below for a list of signals.	pid	signal	status	N/A
0x0203	`nx_proc_signal_set_handler`	Sets a handler for the signal signal in the current process. Not all signals can have a handler. Look at the list for more information.	signal	*handler	status	N/A
0x0204	`nx_proc_thread_create`	Spawns a new thread for the current process. The starting point is defined by addr. The threads' ID is written into tid.	addr	*tid	status	N/A
0x0205	`nx_proc_thread_start`	Starts the current processes' thread with thread id tid.	tid		status	N/A
0x0206	`nx_proc_thread_pause`	Pauses the current processes' thread with thread id tid.	tid		status	N/A
0x0207	`nx_proc_thread_kill`	Kills the current processes' thread with thread id tid.	tid		status	N/A

Drivers

ID	Name	Description	Arg1	Arg2	Arg3	Result	Status
0x0301	`nx_drv_register`	Registers the executable at the n bytes long path as driver with the configuration conf. The format of the conf struct can be found below.	path	len	*conf	status	N/A
0x0302	`nx_drv_create_command_buffer`	This has to be called from a driver. Registers addr as command queue buffer with the length len, which has to be greater or equal 16384. If addr is NULL or not aligned to 32 bytes or len is less than 16384, the kernel will map a command queue buffer into the drivers address space, which is of length len but at least 16384. The address to the registered buffer will be returned.	addr	len		addr	N/A
0x0303	`nx_drv_flush_command_buffer`	This has to be called from a driver. Flushes the command queue buffer at addr.	addr			status	N/A

Kernel

The kernel syscalls can only be called from the kernels main process [link to processing article needed]. If another process calls them, they will just return without doing anything.

ID	Name	Description	Arg1	Arg2	Arg3	Arg4	Result	Status

Appendixes

Types of file attributes

ID	Name	Description	Data Type	Status
0	`permissions`	Who has what permission to access the file	uint16_t	N/A
1	`size`	The files size in bytes	uint64_t	N/A

Memory mapping flags

Bit	Name	Description
0	`write`	Enables write access to the mapped pages.
1	`no_exec`	Prevents execution of the mapped pages.

Process configuration

header:

Length(bytes)	Name	Description
0x01	privilege_level	Specifies the privilege level the process runs on. (described below)
0x80	name	The processes' name (ascii).
0x08	executable	A file descriptor to the executable the process will be loaded from.
0x04	num_inherit_fds	The amount of file descriptors that will be inherited to the process.
0x0F * `num_inherit_fds`	inherit_fds	The file descriptors that will be inherited to the process. (described below)

header.privilege_level:

Value	Name	Description
0	as_parent	The new process will spawn with the same privilege level as its parent.
1	default	The new process will spawn with default user permissions.

header.inherit_fds:

Length(bytes)	Name	Description
0x08	at_parent	The file descriptor, the parent process wants to inherit.
0x08	at_child	The file descriptor in the new child process. Same as `at_parent` if set to 0.

Process signals

SIGSTART: starts the process
SIGPAUSE: pauses the process
SIGKILL: kills the process and destroys the processes data structures
SIGEXIT: send by the kernel before stopping the process - handler implementation possible
SIGPFAULT: sends when the process access memory it is not permitted to. Followed by SIGEXIT - handler implementation possible
SIGMATHAULT: sends when the process does stuff like dividing by zero. Followed by SIGEXIT - handler implementation possible

Driver configuration