syscalls.h File Reference

Go to the source code of this file.

Data Structures
struct	FramebufferScreenInfo

Macros
#define	scarg   __UINTPTR_TYPE__
#define	__SYS_NULL   ((void *)0)
	NULL pointer.
#define	FBIOGET_SCREEN_INFO   0xf0
	Get framebuffer screen info.
#define	call_api_version(version)   syscall1(SYS_API_VERSION, (scarg)version)
	Set syscall version.
#define	call_read(fd, buf, count)   syscall3(SYS_READ, (scarg)fd, (scarg)buf, (scarg)count)
	Read from a file descriptor.
#define	call_pread(fd, buf, count, offset)   syscall4(SYS_PREAD, (scarg)fd, (scarg)buf, (scarg)count, (scarg)offset)
	Read from a file descriptor.
#define	call_write(fd, buf, count)   syscall3(SYS_WRITE, (scarg)fd, (scarg)buf, (scarg)count)
	Write to a file descriptor.
#define	call_pwrite(fd, buf, count, offset)   syscall4(SYS_PWRITE, (scarg)fd, (scarg)buf, (scarg)count, (scarg)offset)
	Write to a file descriptor.
#define	call_open(pathname, flags, mode)   syscall3(SYS_OPEN, (scarg)pathname, (scarg)flags, (scarg)mode)
	Open a file.
#define	call_close(fd)   syscall1(SYS_CLOSE, fd)
	Close a file descriptor.
#define	call_ioctl(fd, request, argp)   syscall3(SYS_IOCTL, (scarg)fd, (scarg)request, (scarg)argp)
	Control a device.
#define	call_stat(pathname, statbuf)   syscall2(SYS_STAT, (scarg)pathname, (scarg)statbuf)
	Retrieve file status.
#define	call_fstat(fd, statbuf)   syscall2(SYS_FSTAT, (scarg)fd, (scarg)statbuf)
	Retrieve file status for an open file descriptor.
#define	call_lstat(pathname, statbuf)   syscall2(SYS_LSTAT, (scarg)pathname, (scarg)statbuf)
	Retrieve file status with symbolic link resolution.
#define	call_access(pathname, mode)   syscall2(SYS_ACCESS, (scarg)pathname, (scarg)mode)
	Check a file's accessibility.
#define	call_truncate(pathname, length)   syscall2(SYS_TRUNCATE, (scarg)pathname, (scarg)length)
	Change the size of a file.
#define	call_ftruncate(fd, length)   syscall2(SYS_FTRUNCATE, (scarg)fd, (scarg)length)
	Change the size of a file referred by a file descriptor.
#define	call_tell(fd)   syscall1(SYS_TELL, (scarg)fd)
	Get the current file offset.
#define	call_seek(fd, offset, whence)   syscall3(SYS_SEEK, (scarg)fd, (scarg)offset, (scarg)whence)
	Set the file offset.
#define	call_exit(status)   syscall1(SYS_EXIT, (scarg)status)
	Terminate the calling process.
#define	call_fork()   syscall0(SYS_FORK)
	Create a child process.
#define	call_execve(pathname, argv, envp)   syscall3(SYS_EXECVE, (scarg)pathname, (scarg)argv, (scarg)envp)
	Execute a program.
#define	call_getpid()   syscall0(SYS_GETPID)
	Get the process ID of the calling process.
#define	call_getppid()   syscall0(SYS_GETPPID)
	Get the parent process ID.
#define	call_waitpid(pid, wstatus, options)   syscall3(SYS_WAITPID, (scarg)pid, (scarg)wstatus, (scarg)options)
	Wait for a child process to change state.
#define	call_kill(pid, sig)   syscall2(SYS_KILL, (scarg)pid, (scarg)sig)
	Send a signal to a process.
#define	call_prctl(option, arg1, arg2, arg3, arg4)   syscall5(SYS_PRCTL, (scarg)option, (scarg)arg1, (scarg)arg2, (scarg)arg3, (scarg)arg4)
	Process/Thread Control.
#define	call_brk(end_data)   syscall1(SYS_BRK, (scarg)end_data)
	Set the program break.
#define	call_mmap(addr, length, prot, flags, fd, offset)   syscall6(SYS_MMAP, (scarg)addr, (scarg)length, (scarg)prot, (scarg)flags, (scarg)fd, (scarg)offset)
	Map files or devices into memory.
#define	call_munmap(addr, length)   syscall2(SYS_MUNMAP, (scarg)addr, (scarg)length)
	Unmap a mapped memory region.
#define	call_mprotect(addr, length, prot)   syscall3(SYS_MPROTECT, (scarg)addr, (scarg)length, (scarg)prot)
	Change memory protection.
#define	call_madvise(addr, length, advice)   syscall3(SYS_MADVISE, (scarg)addr, (scarg)length, (scarg)advice)
	Provide advice about memory usage.
#define	call_pipe(pipefd)   syscall1(SYS_PIPE, (scarg)pipefd)
	Create a pipe.
#define	call_dup(oldfd)   syscall1(SYS_DUP, (scarg)oldfd)
	Duplicate a file descriptor.
#define	call_dup2(oldfd, newfd)   syscall2(SYS_DUP2, (scarg)oldfd, (scarg)newfd)
	Duplicate a file descriptor to a specific value.
#define	call_socket(domain, type, protocol)   syscall3(SYS_SOCKET, (scarg)domain, (scarg)type, (scarg)protocol)
	Create an endpoint for communication.
#define	call_bind(sockfd, addr, addrlen)   syscall3(SYS_BIND, (scarg)sockfd, (scarg)addr, (scarg)addrlen)
	Bind a socket to a local address.
#define	call_connect(sockfd, addr, addrlen)   syscall3(SYS_CONNECT, (scarg)sockfd, (scarg)addr, (scarg)addrlen)
	Connect to a remote address.
#define	call_listen(sockfd, backlog)   syscall2(SYS_LISTEN, (scarg)sockfd, (scarg)backlog)
	Listen for incoming connections on a socket.
#define	call_accept(sockfd, addr, addrlen)   syscall3(SYS_ACCEPT, (scarg)sockfd, (scarg)addr, (scarg)addrlen)
	Accept an incoming connection on a socket.
#define	call_send(sockfd, buf, len, flags)   syscall4(SYS_SEND, (scarg)sockfd, (scarg)buf, (scarg)len, (scarg)flags)
	Send data on a socket.
#define	call_recv(sockfd, buf, len, flags)   syscall4(SYS_RECV, (scarg)sockfd, (scarg)buf, (scarg)len, (scarg)flags)
	Receive data on a socket.
#define	call_shutdown(sockfd, how)   syscall2(SYS_SHUTDOWN, (scarg)sockfd, (scarg)how)
	Shut down part of a full-duplex connection.
#define	call_time(t)   syscall1(SYS_TIME, t)
	Get the current time.
#define	call_clock_gettime(clockid, tp)   syscall2(SYS_CLOCK_GETTIME, (scarg)clockid, (scarg)tp)
	Get the current time of a specific clock.
#define	call_clock_settime(clockid, tp)   syscall2(SYS_CLOCK_SETTIME, (scarg)clockid, (scarg)tp)
	Set the current time of a specific clock.
#define	call_nanosleep(req, rem)   syscall2(SYS_NANOSLEEP, (scarg)req, (scarg)rem)
	Sleep for a specified time.
#define	call_getcwd(buf, size)   syscall2(SYS_GETCWD, (scarg)buf, (scarg)size)
	Get the current working directory.
#define	call_chdir(path)   syscall1(SYS_CHDIR, (scarg)path)
	Change the current working directory.
#define	call_mkdir(path, mode)   syscall2(SYS_MKDIR, (scarg)path, (scarg)mode)
	Create a new directory.
#define	call_rmdir(path)   syscall1(SYS_RMDIR, (scarg)path)
	Remove an empty directory.
#define	call_unlink(pathname)   syscall1(SYS_UNLINK, (scarg)pathname)
	Remove a file.
#define	call_rename(oldpath, newpath)   syscall2(SYS_RENAME, (scarg)oldpath, (scarg)newpath)
	Rename a file or directory.

Typedefs
typedef int	__SYS_clockid_t
typedef unsigned int	__SYS_socklen_t
typedef struct FramebufferScreenInfo	FramebufferScreenInfo

Enumerations
enum	syscall_mmap_flags_t {   __SYS_PROT_READ = 0x1 , __SYS_PROT_WRITE = 0x2 , __SYS_PROT_EXEC = 0x4 , __SYS_PROT_NONE = 0x0 ,   __SYS_MAP_SHARED = 0x1 , __SYS_MAP_PRIVATE = 0x2 , __SYS_MAP_FIXED = 0x4 , __SYS_MAP_ANONYMOUS = 0x8 ,   __SYS_MAP_ANON = __SYS_MAP_ANONYMOUS }
enum	syscall_open_flags_t {   __SYS_O_RDONLY = 0x1 , __SYS_O_WRONLY = 0x2 , __SYS_O_RDWR = 0x3 , __SYS_O_APPEND = 0x4 ,   __SYS_O_CREAT = 0x8 , __SYS_O_DSYNC = 0x10 , __SYS_O_EXCL = 0x20 , __SYS_O_NOCTTY = 0x40 ,   __SYS_O_NONBLOCK = 0x80 , __SYS_O_RSYNC = 0x100 , __SYS_O_SYNC = 0x200 , __SYS_O_TRUNC = 0x400 }
enum	syscall_access_flags_t { __SYS_F_OK = 0 , __SYS_R_OK = 1 , __SYS_W_OK = 2 , __SYS_X_OK = 3 }
enum	syscall_prctl_options_t { __SYS_GET_GS = 0 , __SYS_SET_GS = 1 , __SYS_GET_FS = 2 , __SYS_SET_FS = 3 }
enum	syscall_seek_whence_t { __SYS_SEEK_SET = 0 , __SYS_SEEK_CUR = 1 , __SYS_SEEK_END = 2 }
enum	syscall_signal_t {   __SYS_SIGNULL = 0 , __SYS_SIGABRT = 1 , __SYS_SIGALRM = 2 , __SYS_SIGBUS = 3 ,   __SYS_SIGCHLD = 4 , __SYS_SIGCONT = 5 , __SYS_SIGFPE = 6 , __SYS_SIGHUP = 7 ,   __SYS_SIGILL = 8 , __SYS_SIGINT = 9 , __SYS_SIGKILL = 10 , __SYS_SIGPIPE = 11 ,   __SYS_SIGQUIT = 12 , __SYS_SIGSEGV = 13 , __SYS_SIGSTOP = 14 , __SYS_SIGTERM = 15 ,   __SYS_SIGTSTP = 16 , __SYS_SIGTTIN = 17 , __SYS_SIGTTOU = 18 , __SYS_SIGUSR1 = 19 ,   __SYS_SIGUSR2 = 20 , __SYS_SIGPOLL = 21 , __SYS_SIGPROF = 22 , __SYS_SIGSYS = 23 ,   __SYS_SIGTRAP = 24 , __SYS_SIGURG = 25 , __SYS_SIGVTALRM = 26 , __SYS_SIGXCPU = 27 ,   __SYS_SIGXFSZ = 28 , __SYS_SIGCOMP1 = 29 , __SYS_SIGCOMP2 = 30 , __SYS_SIGCOMP3 = 31 ,   __SYS_SIGRTMIN = 32 , __SYS_SIGRT_1 = 33 , __SYS_SIGRT_2 = 34 , __SYS_SIGRT_3 = 35 ,   __SYS_SIGRT_4 = 36 , __SYS_SIGRT_5 = 37 , __SYS_SIGRT_6 = 38 , __SYS_SIGRT_7 = 39 ,   __SYS_SIGRT_8 = 40 , __SYS_SIGRT_9 = 41 , __SYS_SIGRT_10 = 42 , __SYS_SIGRT_11 = 43 ,   __SYS_SIGRT_12 = 44 , __SYS_SIGRT_13 = 45 , __SYS_SIGRT_14 = 46 , __SYS_SIGRT_15 = 47 ,   __SYS_SIGRT_16 = 48 , __SYS_SIGRT_17 = 49 , __SYS_SIGRT_18 = 50 , __SYS_SIGRT_19 = 51 ,   __SYS_SIGRT_20 = 52 , __SYS_SIGRT_21 = 53 , __SYS_SIGRT_22 = 54 , __SYS_SIGRT_23 = 55 ,   __SYS_SIGRT_24 = 56 , __SYS_SIGRT_25 = 57 , __SYS_SIGRT_26 = 58 , __SYS_SIGRT_27 = 59 ,   __SYS_SIGRT_28 = 60 , __SYS_SIGRT_29 = 61 , __SYS_SIGRT_30 = 62 , __SYS_SIGRT_31 = 63 ,   __SYS_SIGRTMAX = 64 , __SYS_SIGNAL_MAX = __SYS_SIGRTMAX }
enum	syscall_signal_disposition_t {   __SYS_SIG_TERM = 0 , __SYS_SIG_IGN = 1 , __SYS_SIG_CONT = 2 , __SYS_SIG_STOP = 3 ,   __SYS_SIG_CORE = 4 }
enum	syscall_signal_actions_t { __SYS_SIG_BLOCK = 0 , __SYS_SIG_UNBLOCK = 1 , __SYS_SIG_SETMASK = 2 }
enum	syscall_signal_action_flags_t {   __SYS_SA_NOCLDSTOP = 1 , __SYS_SA_ONSTACK = 0x08000000 , __SYS_SA_RESETHAND = 0x80000000 , __SYS_SA_RESTART = 0x10000000 ,   __SYS_SA_SIGINFO = 4 , __SYS_SA_NOCLDWAIT = 2 , __SYS_SA_NODEFER = 0x40000000 }
enum	syscall_signal_action_disposition_t { __SYS_SIG_ERR = -1 , __SYS_SIG_DFL = 0 , ___SYS_SIG_IGN = 1 }
enum	syscall_clockid_t { __SYS_CLOCK_MONOTONIC = 1 , __SYS_CLOCK_PROCESS_CPUTIME_ID = 2 , __SYS_CLOCK_REALTIME = 3 , __SYS_CLOCK_THREAD_CPUTIME_ID = 4 }
enum	syscalls_t {   SYS_API_VERSION = 0 , SYS_READ = 100 , SYS_PREAD , SYS_WRITE ,   SYS_PWRITE , SYS_OPEN , SYS_CLOSE , SYS_IOCTL ,   SYS_STAT = 200 , SYS_FSTAT , SYS_LSTAT , SYS_ACCESS ,   SYS_TRUNCATE , SYS_FTRUNCATE , SYS_TELL , SYS_SEEK ,   SYS_EXIT = 300 , SYS_FORK , SYS_EXECVE , SYS_GETPID ,   SYS_GETPPID , SYS_WAITPID , SYS_KILL , SYS_PRCTL ,   SYS_BRK = 400 , SYS_MMAP , SYS_MUNMAP , SYS_MPROTECT ,   SYS_MADVISE , SYS_PIPE = 500 , SYS_DUP , SYS_DUP2 ,   SYS_SOCKET , SYS_BIND , SYS_CONNECT , SYS_LISTEN ,   SYS_ACCEPT , SYS_SEND , SYS_RECV , SYS_SHUTDOWN ,   SYS_TIME = 600 , SYS_CLOCK_GETTIME , SYS_CLOCK_SETTIME , SYS_NANOSLEEP ,   SYS_GETCWD = 700 , SYS_CHDIR , SYS_MKDIR , SYS_RMDIR ,   SYS_UNLINK , SYS_RENAME , SYS_MAX }
	List of syscalls. More...

Functions
static scarg	syscall0 (scarg syscall)
	Syscall wrapper with 0 arguments.
static scarg	syscall1 (scarg syscall, scarg arg1)
	Syscall wrapper with 1 argument.
static scarg	syscall2 (scarg syscall, scarg arg1, scarg arg2)
	Syscall wrapper with 2 arguments.
static scarg	syscall3 (scarg syscall, scarg arg1, scarg arg2, scarg arg3)
	Syscall wrapper with 3 arguments.
static scarg	syscall4 (scarg syscall, scarg arg1, scarg arg2, scarg arg3, scarg arg4)
	Syscall wrapper with 4 arguments.
static scarg	syscall5 (scarg syscall, scarg arg1, scarg arg2, scarg arg3, scarg arg4, scarg arg5)
	Syscall wrapper with 5 arguments.
static scarg	syscall6 (scarg syscall, scarg arg1, scarg arg2, scarg arg3, scarg arg4, scarg arg5, scarg arg6)
	Syscall wrapper with 6 arguments.

---

Data Structure Documentation

FramebufferScreenInfo

struct FramebufferScreenInfo

Definition at line 605 of file syscalls.h.

Data Fields
__UINT32_TYPE__	Bpp
__UINT32_TYPE__	Height
__UINT32_TYPE__	Pitch
__UINT32_TYPE__	Size
__UINT32_TYPE__	Width

Macro Definition Documentation

__SYS_NULL

#define __SYS_NULL   ((void *)0)

NULL pointer.

This is a pointer to address 0, which is reserved and cannot be dereferenced.

Note

This macro is defined only for this documentation.

Definition at line 378 of file syscalls.h.

call_accept

#define call_accept	(		sockfd,
			addr,
			addrlen
	)		syscall3(SYS_ACCEPT, (scarg)sockfd, (scarg)addr, (scarg)addrlen)

Accept an incoming connection on a socket.

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

Accepts an incoming connection on a listening socket, creating a new socket for communication.

Parameters

sockfd	Socket file descriptor
addr	Client address
addrlen	Length of the address

Returns

• New socket file descriptor on success
• EINVAL if parameters are invalid

Definition at line 1740 of file syscalls.h.

call_access

#define call_access	(		pathname,
			mode
	)		syscall2(SYS_ACCESS, (scarg)pathname, (scarg)mode)

Check a file's accessibility.

int access(const char *pathname, int mode);

Checks if the calling process can access the file specified by pathname according to the specified mode.

Parameters

pathname	Path to the file
mode	Accessibility check mode Supported values: __SYS_F_OK: Check if the file exists __SYS_R_OK: Check if the file is readable __SYS_W_OK: Check if the file is writable __SYS_X_OK: Check if the file is executable

Returns

• EOK on success
• EACCES if access is denied
• ENOENT if the file does not exist

See also

syscall_access_flags_t

Definition at line 1659 of file syscalls.h.

call_api_version

#define call_api_version

(

version

)

syscall1(SYS_API_VERSION, (scarg)version)

Set syscall version.

int api_version(int version);

This syscall is used to set the version of the list. To prevent applications from breaking on major changes, this should be called at the very beginning of the program.

Parameters

version

The version of the syscall list of which the program was compiled with

Returns

• EOK on success
• EINVAL if the requested version is invalid

Note

If this syscall is not used, the latest version will be used.

Definition at line 1622 of file syscalls.h.

call_bind

#define call_bind	(		sockfd,
			addr,
			addrlen
	)		syscall3(SYS_BIND, (scarg)sockfd, (scarg)addr, (scarg)addrlen)

Bind a socket to a local address.

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

Binds a socket to a local address so it can listen for incoming connections.

Parameters

sockfd	Socket file descriptor
addr	Address to bind to
addrlen	Length of the address

Returns

• EOK on success
• EINVAL if the socket is invalid

Definition at line 1731 of file syscalls.h.

call_brk

#define call_brk

(

end_data

)

syscall1(SYS_BRK, (scarg)end_data)

Set the program break.

int brk(void *end_data);

Increases or decreases the program’s data space, ending at end_data.

Parameters

end_data

New program break location

Returns

• EOK on success
• ENOMEM if memory allocation fails

Definition at line 1702 of file syscalls.h.

call_chdir

#define call_chdir

(

path

)

syscall1(SYS_CHDIR, (scarg)path)

Change the current working directory.

int chdir(const char *path);

Changes the current working directory to the specified path.

Parameters

path	New directory path

Returns

• EOK on success
• ENOENT if the directory does not exist
• EACCES if permission is denied

Definition at line 1771 of file syscalls.h.

call_clock_gettime

#define call_clock_gettime	(		clockid,
			tp
	)		syscall2(SYS_CLOCK_GETTIME, (scarg)clockid, (scarg)tp)

Get the current time of a specific clock.

int clock_gettime(clockid_t clockid, struct timespec *tp);

Retrieves the current time for the specified clock (CLOCK_REALTIME, CLOCK_MONOTONIC, etc.).

Parameters

clockid	Clock ID to query
tp	Pointer to store the time

Returns

• EOK on success
• EINVAL if parameters are invalid

Definition at line 1757 of file syscalls.h.

call_clock_settime

#define call_clock_settime	(		clockid,
			tp
	)		syscall2(SYS_CLOCK_SETTIME, (scarg)clockid, (scarg)tp)

Set the current time of a specific clock.

int clock_settime(clockid_t clockid, const struct timespec *tp);

Sets the time for the specified clock (CLOCK_REALTIME, CLOCK_MONOTONIC, etc.).

Parameters

clockid	Clock ID to set
tp	Pointer to the time value

Returns

• EOK on success
• EINVAL if parameters are invalid

Definition at line 1760 of file syscalls.h.

call_close

#define call_close

(

fd

)

syscall1(SYS_CLOSE, fd)

Close a file descriptor.

int close(int fd);

Closes the file descriptor fd, releasing its resources.

Parameters

fd	File descriptor to close

Returns

• EOK on success
• EBADF if fd is not a valid file descriptor

Definition at line 1642 of file syscalls.h.

call_connect

#define call_connect	(		sockfd,
			addr,
			addrlen
	)		syscall3(SYS_CONNECT, (scarg)sockfd, (scarg)addr, (scarg)addrlen)

Connect to a remote address.

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

Connects a socket to a remote address.

Parameters

sockfd	Socket file descriptor
addr	Remote address to connect to
addrlen	Length of the address

Returns

• EOK on success
• EINVAL if parameters are invalid

Definition at line 1734 of file syscalls.h.

call_dup

#define call_dup

(

oldfd

)

syscall1(SYS_DUP, (scarg)oldfd)

Duplicate a file descriptor.

int dup(int oldfd);

Duplicates the file descriptor oldfd, returning the new file descriptor.

Parameters

oldfd

File descriptor to duplicate

Returns

• New file descriptor on success
• EBADF if oldfd is invalid

Definition at line 1722 of file syscalls.h.

call_dup2

#define call_dup2	(		oldfd,
			newfd
	)		syscall2(SYS_DUP2, (scarg)oldfd, (scarg)newfd)

Duplicate a file descriptor to a specific value.

int dup2(int oldfd, int newfd);

Duplicates oldfd to newfd. If newfd is already open, it will be closed first.

Parameters

oldfd	File descriptor to duplicate
newfd	File descriptor to duplicate oldfd to

Returns

• newfd on success
• EBADF if oldfd is invalid
• EINVAL if newfd is invalid

Definition at line 1725 of file syscalls.h.

call_execve

#define call_execve	(		pathname,
			argv,
			envp
	)		syscall3(SYS_EXECVE, (scarg)pathname, (scarg)argv, (scarg)envp)

Execute a program.

int execve(const char *pathname, char *const argv[], char *const envp[]);

Replaces the current process image with a new process image specified by pathname.

Parameters

pathname	Path to the executable file
argv	Argument vector
envp	Environment variables

Returns

• Does not return on success
• ENOENT if the file does not exist
• EACCES if permissions are insufficient

Definition at line 1682 of file syscalls.h.

call_exit

#define call_exit

(

status

)

syscall1(SYS_EXIT, (scarg)status)

Terminate the calling process.

void exit(int status);

Terminates the calling process with the specified status. The status code is made available to the parent process.

Parameters

status

Exit status code

Returns

This function does not return.

Definition at line 1676 of file syscalls.h.

call_fork

#define call_fork

(

)

syscall0(SYS_FORK)

Create a child process.

pid_t fork(void);

Creates a new process by duplicating the calling process. The child process has its own copy of the parent's address space.

Returns

• 0 to the child process
• PID of the child to the parent process
• ENOMEM if memory is insufficient

Definition at line 1679 of file syscalls.h.

call_fstat

#define call_fstat	(		fd,
			statbuf
	)		syscall2(SYS_FSTAT, (scarg)fd, (scarg)statbuf)

Retrieve file status for an open file descriptor.

int fstat(int fd, struct stat *statbuf);

Gets the status of the file referred to by fd.

Parameters

fd	File descriptor
statbuf	Buffer to store file status

Returns

• EOK on success
• EBADF if fd is not a valid file descriptor
• EFAULT if statbuf is outside accessible address space

Definition at line 1653 of file syscalls.h.

call_ftruncate

#define call_ftruncate	(		fd,
			length
	)		syscall2(SYS_FTRUNCATE, (scarg)fd, (scarg)length)

Change the size of a file referred by a file descriptor.

int ftruncate(int fd, off_t length);

Sets the size of the file referred to by fd to length.

Parameters

fd	File descriptor
length	Desired file length

Returns

• EOK on success
• EBADF if fd is not valid
• EINVAL if length is invalid

Definition at line 1665 of file syscalls.h.

call_getcwd

#define call_getcwd	(		buf,
			size
	)		syscall2(SYS_GETCWD, (scarg)buf, (scarg)size)

Get the current working directory.

char *getcwd(char *buf, size_t size);

Retrieves the current working directory.

Parameters

buf	Buffer to store the directory path
size	Size of the buffer

Returns

• Pointer to buf on success
• __SYS_NULL on error

Definition at line 1768 of file syscalls.h.

call_getpid

#define call_getpid

(

)

syscall0(SYS_GETPID)

Get the process ID of the calling process.

pid_t getpid(void);

Returns the process ID of the calling process.

Returns

• Process ID on success

Definition at line 1685 of file syscalls.h.

call_getppid

#define call_getppid

(

)

syscall0(SYS_GETPPID)

Get the parent process ID.

pid_t getppid(void);

Returns the parent process ID of the calling process.

Returns

• Parent process ID on success

Definition at line 1688 of file syscalls.h.

call_ioctl

#define call_ioctl	(		fd,
			request,
			argp
	)		syscall3(SYS_IOCTL, (scarg)fd, (scarg)request, (scarg)argp)

Control a device.

int ioctl(int fd, unsigned long request, void *argp);

Manipulates the underlying parameters of a device.

Parameters

fd	File descriptor referring to the device
request	Device-specific request code
argp	Argument for the request

Returns

• EOK on success
• EBADF if fd is not valid
• EINVAL if the request is invalid

Definition at line 1645 of file syscalls.h.

call_kill

#define call_kill	(		pid,
			sig
	)		syscall2(SYS_KILL, (scarg)pid, (scarg)sig)

Send a signal to a process.

int kill(pid_t pid, int sig);

Sends the signal sig to the process specified by pid.

Parameters

pid	Process ID
sig	Signal to send

Returns

• EOK on success
• ESRCH if the process does not exist
• EINVAL if sig is invalid

Definition at line 1694 of file syscalls.h.

call_listen

#define call_listen	(		sockfd,
			backlog
	)		syscall2(SYS_LISTEN, (scarg)sockfd, (scarg)backlog)

Listen for incoming connections on a socket.

int listen(int sockfd, int backlog);

Sets a socket to listen for incoming connections, specifying the backlog queue size.

Parameters

sockfd	Socket file descriptor
backlog	Number of pending connections to allow

Returns

• EOK on success
• EINVAL if parameters are invalid

Definition at line 1737 of file syscalls.h.

call_lstat

#define call_lstat	(		pathname,
			statbuf
	)		syscall2(SYS_LSTAT, (scarg)pathname, (scarg)statbuf)

Retrieve file status with symbolic link resolution.

int lstat(const char *pathname, struct stat *statbuf);

Gets the status of the file specified by pathname, but does not follow symbolic links.

Parameters

pathname	Path to the file
statbuf	Buffer to store file status

Returns

• EOK on success
• ENOENT if the file does not exist
• EACCES if permissions are insufficient

Definition at line 1656 of file syscalls.h.

call_madvise

#define call_madvise	(		addr,
			length,
			advice
	)		syscall3(SYS_MADVISE, (scarg)addr, (scarg)length, (scarg)advice)

Provide advice about memory usage.

int madvise(void *addr, size_t length, int advice);

Provides advice to the kernel about the expected behavior of the memory region starting at addr for length, such as whether it will be accessed randomly or sequentially.

Parameters

addr	Start address of the memory region
length	Length of the memory region
advice	Desired advice (e.g., MADV_DONTNEED, MADV_SEQUENTIAL)

Returns

• EOK on success
• EINVAL if the parameters are invalid

Definition at line 1714 of file syscalls.h.

call_mkdir

#define call_mkdir	(		path,
			mode
	)		syscall2(SYS_MKDIR, (scarg)path, (scarg)mode)

Create a new directory.

int mkdir(const char *path, mode_t mode);

Creates a new directory at path with the specified permissions.

Parameters

path	Path to the new directory
mode	Directory permissions

Returns

• EOK on success
• EEXIST if the directory already exists
• EACCES if permission is denied

Definition at line 1774 of file syscalls.h.

call_mmap

#define call_mmap	(		addr,
			length,
			prot,
			flags,
			fd,
			offset
	)		syscall6(SYS_MMAP, (scarg)addr, (scarg)length, (scarg)prot, (scarg)flags, (scarg)fd, (scarg)offset)

Map files or devices into memory.

void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);

Maps a file or device into memory. This can be used for memory-mapped I/O or for sharing memory between processes.

Parameters

addr	Desired starting address of the mapping (NULL for automatic allocation)
length	Length of the mapping
prot	Desired memory protection Supported values: __SYS_PROT_READ: Readable __SYS_PROT_WRITE: Writable __SYS_PROT_EXEC: Executable __SYS_PROT_NONE: No access
flags	Mapping options Supported values: __SYS_MAP_SHARED: Share memory with other processes __SYS_MAP_PRIVATE: Create a private copy of the file __SYS_MAP_FIXED: Use addr as the starting address of the mapping __SYS_MAP_ANONYMOUS: Create an anonymous mapping
fd	File descriptor for the file to map
offset	Offset in the file to start the mapping

Returns

There are several possible return values:

• Pointer to mapped area on success
• EACCES
• EAGAIN
• EBADF
• EINVAL
• EMFILE
• ENODEV
• ENOMEM
• ENOTSUP
• ENXIO
• EOVERFLOW

See also

syscall_mmap_flags_t

Definition at line 1705 of file syscalls.h.

call_mprotect

#define call_mprotect	(		addr,
			length,
			prot
	)		syscall3(SYS_MPROTECT, (scarg)addr, (scarg)length, (scarg)prot)

Change memory protection.

int mprotect(void *addr, size_t length, int prot);

Sets the protection on the memory region starting at addr for length.

Parameters

addr	Start address of the memory region
length	Length of the memory region
prot	Desired memory protection (e.g., PROT_READ, PROT_WRITE)

Returns

• EOK on success
• EACCES if protection cannot be set

Definition at line 1711 of file syscalls.h.

call_munmap

#define call_munmap	(		addr,
			length
	)		syscall2(SYS_MUNMAP, (scarg)addr, (scarg)length)

Unmap a mapped memory region.

int munmap(void *addr, size_t length);

Unmaps a previously mapped memory region, making the memory available for reuse.

Parameters

addr	Start address of the memory region
length	Length of the memory region to unmap

Returns

• EOK on success
• EINVAL if the address or length is invalid
• EFAULT if the memory region is not currently mapped

Definition at line 1708 of file syscalls.h.

call_nanosleep

#define call_nanosleep	(		req,
			rem
	)		syscall2(SYS_NANOSLEEP, (scarg)req, (scarg)rem)

Sleep for a specified time.

int nanosleep(const struct timespec *req, struct timespec *rem);

Suspends the execution of the calling thread for the specified time duration.

Parameters

req	Pointer to timespec specifying the time to sleep
rem	Pointer to store remaining time if interrupted

Returns

• EOK on success
• EINTR if interrupted by a signal

Definition at line 1763 of file syscalls.h.

call_open

#define call_open	(		pathname,
			flags,
			mode
	)		syscall3(SYS_OPEN, (scarg)pathname, (scarg)flags, (scarg)mode)

Open a file.

int open(const char *pathname, int flags, mode_t mode);

Opens the file specified by pathname.

Parameters

pathname	Path to the file
flags	Flags for file access mode Supported values: __SYS_O_RDONLY: Open file for reading only. __SYS_O_WRONLY: Open file for writing only. __SYS_O_RDWR: Open file for reading and writing. __SYS_O_APPEND: Append data to the end of file. __SYS_O_CREAT: Create file if it does not exist. __SYS_O_DSYNC: __SYS_O_EXCL: __SYS_O_NOCTTY: __SYS_O_NONBLOCK: __SYS_O_RSYNC: __SYS_O_SYNC: __SYS_O_TRUNC: Truncate file to zero length.
mode	Permissions for newly created file (if applicable)

Returns

• File descriptor on success
• ENOENT if the file does not exist
• EACCES if permissions are insufficient

See also

syscall_open_flags_t

Definition at line 1639 of file syscalls.h.

call_pipe

#define call_pipe

(

pipefd

)

syscall1(SYS_PIPE, (scarg)pipefd)

Create a pipe.

int pipe(int pipefd[2]);

Creates a pipe, returning two file descriptors in pipefd. One is for reading, and the other is for writing.

Parameters

pipefd

Array to store the two file descriptors

Returns

• EOK on success
• EMFILE if the process has too many open file descriptors

Definition at line 1719 of file syscalls.h.

call_prctl

#define call_prctl	(		option,
			arg1,
			arg2,
			arg3,
			arg4
	)		syscall5(SYS_PRCTL, (scarg)option, (scarg)arg1, (scarg)arg2, (scarg)arg3, (scarg)arg4)

Process/Thread Control.

int prctl(syscall_prctl_options_t option, unsigned long arg1, unsigned long arg2, unsigned long arg3, unsigned long arg4);

Perform various operations on a process or thread.

Parameters

option	Operation to perform
arg1	Argument 1
arg2	Argument 2
arg3	Argument 3
arg4	Argument 4

Returns

• EOK on success
• EINVAL if the operation is invalid
• EFAULT if one of the arguments is invalid

Definition at line 1697 of file syscalls.h.

call_pread

#define call_pread	(		fd,
			buf,
			count,
			offset
	)		syscall4(SYS_PREAD, (scarg)fd, (scarg)buf, (scarg)count, (scarg)offset)

Read from a file descriptor.

ssize_t sys_pread(int fildes, void *buf, size_t nbyte, off_t offset);

Reads up to count bytes from the file descriptor fd into the buffer starting at buf.

Parameters

fd	File descriptor to read from
buf	Buffer where data will be stored
count	Maximum number of bytes to read
offset	Offset in the file

Returns

• Number of bytes read on success
• 0 if the end of file is reached
• EFAULT if the buffer is outside accessible address space
• EBADF if fd is not a valid file descriptor

Definition at line 1630 of file syscalls.h.

call_pwrite

#define call_pwrite	(		fd,
			buf,
			count,
			offset
	)		syscall4(SYS_PWRITE, (scarg)fd, (scarg)buf, (scarg)count, (scarg)offset)

Write to a file descriptor.

ssize_t sys_pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);

Writes up to count bytes from the buffer starting at buf to the file descriptor fd.

Parameters

fd	File descriptor to write to
buf	Buffer containing data to write
count	Number of bytes to write
offset	Offset in the file

Returns

• Number of bytes written on success
• EFAULT if the buffer is outside accessible address space
• EBADF if fd is not a valid file descriptor

Definition at line 1636 of file syscalls.h.

call_read

#define call_read	(		fd,
			buf,
			count
	)		syscall3(SYS_READ, (scarg)fd, (scarg)buf, (scarg)count)

Read from a file descriptor.

ssize_t sys_read(int fildes, void *buf, size_t nbyte);

Reads up to count bytes from the file descriptor fd into the buffer starting at buf.

Parameters

fd	File descriptor to read from
buf	Buffer where data will be stored
count	Maximum number of bytes to read

Returns

• Number of bytes read on success
• 0 if the end of file is reached
• EFAULT if the buffer is outside accessible address space
• EBADF if fd is not a valid file descriptor

Definition at line 1627 of file syscalls.h.

call_recv

#define call_recv	(		sockfd,
			buf,
			len,
			flags
	)		syscall4(SYS_RECV, (scarg)sockfd, (scarg)buf, (scarg)len, (scarg)flags)

Receive data on a socket.

ssize_t recv(int sockfd, void *buf, size_t len, int flags);

Receives data from a socket.

Parameters

sockfd	Socket file descriptor
buf	Buffer to store received data
len	Maximum number of bytes to receive
flags	Flags for the receive operation

Returns

• Number of bytes received on success
• EINVAL if parameters are invalid

Definition at line 1746 of file syscalls.h.

call_rename

#define call_rename	(		oldpath,
			newpath
	)		syscall2(SYS_RENAME, (scarg)oldpath, (scarg)newpath)

Rename a file or directory.

int rename(const char *oldpath, const char *newpath);

Renames a file or directory from oldpath to newpath.

Parameters

oldpath	Current name of the file or directory
newpath	New name of the file or directory

Returns

• EOK on success
• EEXIST if the target exists
• EACCES if permission is denied

Definition at line 1783 of file syscalls.h.

call_rmdir

#define call_rmdir

(

path

)

syscall1(SYS_RMDIR, (scarg)path)

Remove an empty directory.

int rmdir(const char *path);

Removes the empty directory specified by path.

Parameters

path	Path to the directory

Returns

• EOK on success
• ENOTEMPTY if the directory is not empty

Definition at line 1777 of file syscalls.h.

call_seek

#define call_seek	(		fd,
			offset,
			whence
	)		syscall3(SYS_SEEK, (scarg)fd, (scarg)offset, (scarg)whence)

Set the file offset.

off_t seek(int fd, off_t offset, int whence);

Sets the file offset for the file referred to by fd to the specified offset according to the directive whence.

Parameters

fd	File descriptor
offset	Offset to set
whence	Directive for setting the offset Supported values: __SYS_SEEK_SET: Set the offset to offset bytes __SYS_SEEK_CUR: Set the offset to the current offset plus offset __SYS_SEEK_END: Set the offset to the size of the file plus offset

Returns

• New file offset on success
• EBADF if fd is not a valid file descriptor
• EINVAL if whence is invalid

Definition at line 1671 of file syscalls.h.

call_send

#define call_send	(		sockfd,
			buf,
			len,
			flags
	)		syscall4(SYS_SEND, (scarg)sockfd, (scarg)buf, (scarg)len, (scarg)flags)

Send data on a socket.

ssize_t send(int sockfd, const void *buf, size_t len, int flags);

Sends data through a socket.

Parameters

sockfd	Socket file descriptor
buf	Data to send
len	Length of the data
flags	Flags for the send operation

Returns

• Number of bytes sent on success
• EINVAL if parameters are invalid

Definition at line 1743 of file syscalls.h.

call_shutdown

#define call_shutdown	(		sockfd,
			how
	)		syscall2(SYS_SHUTDOWN, (scarg)sockfd, (scarg)how)

Shut down part of a full-duplex connection.

int shutdown(int sockfd, int how);

Shuts down part of a full-duplex connection on a socket.

Parameters

sockfd	Socket file descriptor
how	Determines which operations to shut down (e.g., SHUT_RD, SHUT_WR)

Returns

• EOK on success
• EINVAL if parameters are invalid

Definition at line 1749 of file syscalls.h.

call_socket

#define call_socket	(		domain,
			type,
			protocol
	)		syscall3(SYS_SOCKET, (scarg)domain, (scarg)type, (scarg)protocol)

Create an endpoint for communication.

int socket(int domain, int type, int protocol);

Creates an endpoint for communication, returning a socket file descriptor.

Parameters

domain	Communication domain (e.g., AF_INET for IPv4)
type	Type of socket (e.g., SOCK_STREAM for TCP)
protocol	Protocol to use (e.g., IPPROTO_TCP)

Returns

• Socket file descriptor on success
• EINVAL if parameters are invalid

Definition at line 1728 of file syscalls.h.

call_stat

#define call_stat	(		pathname,
			statbuf
	)		syscall2(SYS_STAT, (scarg)pathname, (scarg)statbuf)

Retrieve file status.

int stat(const char *pathname, struct stat *statbuf);

Gets the status of the file specified by pathname.

Parameters

pathname	Path to the file
statbuf	Buffer to store file status

Returns

• EOK on success
• ENOENT if the file does not exist
• EACCES if permissions are insufficient

Definition at line 1650 of file syscalls.h.

call_tell

#define call_tell

(

fd

)

syscall1(SYS_TELL, (scarg)fd)

Get the current file offset.

off_t tell(int fd);

Returns the current file offset for the file referred to by fd.

Parameters

fd	File descriptor

Returns

• Current file offset on success
• EBADF if fd is not a valid file descriptor

Definition at line 1668 of file syscalls.h.

call_time

#define call_time

(

t

)

syscall1(SYS_TIME, t)

Get the current time.

time_t time(time_t *t);

Retrieves the current calendar time as the number of seconds since the epoch.

Parameters

t	Pointer to store the time (optional)

Returns

• Current time in seconds on success
• __SYS_NULL if t is NULL

Definition at line 1754 of file syscalls.h.

call_truncate

#define call_truncate	(		pathname,
			length
	)		syscall2(SYS_TRUNCATE, (scarg)pathname, (scarg)length)

Change the size of a file.

int truncate(const char *pathname, off_t length);

Sets the size of the file specified by pathname to length. If the file is shorter, it is extended and the extended part is zero-filled.

Parameters

pathname	Path to the file
length	Desired file length

Returns

• EOK on success
• EINVAL if length is invalid
• EACCES if permissions are insufficient

Definition at line 1662 of file syscalls.h.

call_unlink

#define call_unlink

(

pathname

)

syscall1(SYS_UNLINK, (scarg)pathname)

Remove a file.

int unlink(const char *pathname);

Removes the file specified by pathname.

Parameters

pathname

Path to the file

Returns

• EOK on success
• ENOENT if the file does not exist
• EACCES if permission is denied

Definition at line 1780 of file syscalls.h.

call_waitpid

#define call_waitpid	(		pid,
			wstatus,
			options
	)		syscall3(SYS_WAITPID, (scarg)pid, (scarg)wstatus, (scarg)options)

Wait for a child process to change state.

pid_t waitpid(pid_t pid, int *wstatus, int options);

Waits for the child process specified by pid to change state.

Parameters

pid	Process ID to wait for
wstatus	Pointer to store the status information
options	Options for waiting behavior

Returns

• Process ID of the child on success
• ECHILD if no child processes exist

Definition at line 1691 of file syscalls.h.

call_write

#define call_write	(		fd,
			buf,
			count
	)		syscall3(SYS_WRITE, (scarg)fd, (scarg)buf, (scarg)count)

Write to a file descriptor.

ssize_t sys_write(int fildes, const void *buf, size_t nbyte);

Writes up to count bytes from the buffer starting at buf to the file descriptor fd.

Parameters

fd	File descriptor to write to
buf	Buffer containing data to write
count	Number of bytes to write

Returns

• Number of bytes written on success
• EFAULT if the buffer is outside accessible address space
• EBADF if fd is not a valid file descriptor
• EPIPE if writing to a pipe with no reader

Definition at line 1633 of file syscalls.h.

FBIOGET_SCREEN_INFO

#define FBIOGET_SCREEN_INFO   0xf0

Get framebuffer screen info.

struct FramebufferScreenInfo info;
int ioctl(fd, FBIOGET_SCREEN_INFO, &info);

Parameters

fd	File descriptor of the framebuffer device
info	Pointer to the framebuffer screen info structure

Definition at line 625 of file syscalls.h.

scarg

#define scarg   __UINTPTR_TYPE__

Definition at line 23 of file syscalls.h.

Typedef Documentation

__SYS_clockid_t

typedef int __SYS_clockid_t

Definition at line 602 of file syscalls.h.

__SYS_socklen_t

typedef unsigned int __SYS_socklen_t

Definition at line 603 of file syscalls.h.

FramebufferScreenInfo

typedef struct FramebufferScreenInfo FramebufferScreenInfo

Enumeration Type Documentation

syscall_access_flags_t

enum syscall_access_flags_t

Enumerator
__SYS_F_OK
__SYS_R_OK
__SYS_W_OK
__SYS_X_OK

Definition at line 410 of file syscalls.h.

{
    __SYS_F_OK = 0,
    __SYS_R_OK = 1,
    __SYS_W_OK = 2,
    __SYS_X_OK = 3
} syscall_access_flags_t;

syscall_clockid_t

enum syscall_clockid_t

Enumerator
__SYS_CLOCK_MONOTONIC
__SYS_CLOCK_PROCESS_CPUTIME_ID
__SYS_CLOCK_REALTIME
__SYS_CLOCK_THREAD_CPUTIME_ID

Definition at line 588 of file syscalls.h.

{
    __SYS_CLOCK_MONOTONIC = 1,
    __SYS_CLOCK_PROCESS_CPUTIME_ID = 2,
    __SYS_CLOCK_REALTIME = 3,
    __SYS_CLOCK_THREAD_CPUTIME_ID = 4,
} syscall_clockid_t;

syscall_mmap_flags_t

enum syscall_mmap_flags_t

Enumerator
__SYS_PROT_READ
__SYS_PROT_WRITE
__SYS_PROT_EXEC
__SYS_PROT_NONE
__SYS_MAP_SHARED
__SYS_MAP_PRIVATE
__SYS_MAP_FIXED
__SYS_MAP_ANONYMOUS
__SYS_MAP_ANON

Definition at line 380 of file syscalls.h.

{
    __SYS_PROT_READ = 0x1,
    __SYS_PROT_WRITE = 0x2,
    __SYS_PROT_EXEC = 0x4,
    __SYS_PROT_NONE = 0x0,
 
    __SYS_MAP_SHARED = 0x1,
    __SYS_MAP_PRIVATE = 0x2,
    __SYS_MAP_FIXED = 0x4,
    __SYS_MAP_ANONYMOUS = 0x8,
    __SYS_MAP_ANON = __SYS_MAP_ANONYMOUS
} syscall_mmap_flags_t;

syscall_open_flags_t

enum syscall_open_flags_t

Enumerator
__SYS_O_RDONLY
__SYS_O_WRONLY
__SYS_O_RDWR
__SYS_O_APPEND
__SYS_O_CREAT
__SYS_O_DSYNC
__SYS_O_EXCL
__SYS_O_NOCTTY
__SYS_O_NONBLOCK
__SYS_O_RSYNC
__SYS_O_SYNC
__SYS_O_TRUNC

Definition at line 394 of file syscalls.h.

{
    __SYS_O_RDONLY = 0x1,
    __SYS_O_WRONLY = 0x2,
    __SYS_O_RDWR = 0x3,
    __SYS_O_APPEND = 0x4,
    __SYS_O_CREAT = 0x8,
    __SYS_O_DSYNC = 0x10,
    __SYS_O_EXCL = 0x20,
    __SYS_O_NOCTTY = 0x40,
    __SYS_O_NONBLOCK = 0x80,
    __SYS_O_RSYNC = 0x100,
    __SYS_O_SYNC = 0x200,
    __SYS_O_TRUNC = 0x400
} syscall_open_flags_t;

syscall_prctl_options_t

enum syscall_prctl_options_t

Enumerator
__SYS_GET_GS
__SYS_SET_GS
__SYS_GET_FS
__SYS_SET_FS

Definition at line 418 of file syscalls.h.

{
    __SYS_GET_GS = 0,
    __SYS_SET_GS = 1,
    __SYS_GET_FS = 2,
    __SYS_SET_FS = 3,
} syscall_prctl_options_t;

syscall_seek_whence_t

enum syscall_seek_whence_t

Enumerator
__SYS_SEEK_SET
__SYS_SEEK_CUR
__SYS_SEEK_END

Definition at line 429 of file syscalls.h.

{
    __SYS_SEEK_SET = 0,
    __SYS_SEEK_CUR = 1,
    __SYS_SEEK_END = 2
} syscall_seek_whence_t;

syscall_signal_action_disposition_t

enum syscall_signal_action_disposition_t

Enumerator
__SYS_SIG_ERR
__SYS_SIG_DFL
___SYS_SIG_IGN

Definition at line 581 of file syscalls.h.

{
    __SYS_SIG_ERR = -1,
    __SYS_SIG_DFL = 0,
    ___SYS_SIG_IGN = 1
} syscall_signal_action_disposition_t;

syscall_signal_action_flags_t

enum syscall_signal_action_flags_t

Enumerator
__SYS_SA_NOCLDSTOP
__SYS_SA_ONSTACK
__SYS_SA_RESETHAND
__SYS_SA_RESTART
__SYS_SA_SIGINFO
__SYS_SA_NOCLDWAIT
__SYS_SA_NODEFER

Definition at line 570 of file syscalls.h.

{
    __SYS_SA_NOCLDSTOP = 1,
    __SYS_SA_ONSTACK = 0x08000000,
    __SYS_SA_RESETHAND = 0x80000000,
    __SYS_SA_RESTART = 0x10000000,
    __SYS_SA_SIGINFO = 4,
    __SYS_SA_NOCLDWAIT = 2,
    __SYS_SA_NODEFER = 0x40000000,
} syscall_signal_action_flags_t;

syscall_signal_actions_t

enum syscall_signal_actions_t

Enumerator
__SYS_SIG_BLOCK
__SYS_SIG_UNBLOCK
__SYS_SIG_SETMASK

Definition at line 563 of file syscalls.h.

{
    __SYS_SIG_BLOCK = 0,
    __SYS_SIG_UNBLOCK = 1,
    __SYS_SIG_SETMASK = 2
} syscall_signal_actions_t;

syscall_signal_disposition_t

enum syscall_signal_disposition_t

Enumerator
__SYS_SIG_TERM	Terminate the process.
__SYS_SIG_IGN	Ignore the signal.
__SYS_SIG_CONT	Continue the process.
__SYS_SIG_STOP	Stop the process.
__SYS_SIG_CORE	Dump core.

Definition at line 546 of file syscalls.h.

{
    __SYS_SIG_TERM = 0,
    __SYS_SIG_IGN = 1,
    __SYS_SIG_CONT = 2,
    __SYS_SIG_STOP = 3,
    __SYS_SIG_CORE = 4
} syscall_signal_disposition_t;

syscall_signal_t

enum syscall_signal_t

Enumerator
__SYS_SIGNULL
__SYS_SIGABRT
__SYS_SIGALRM
__SYS_SIGBUS
__SYS_SIGCHLD
__SYS_SIGCONT
__SYS_SIGFPE
__SYS_SIGHUP
__SYS_SIGILL
__SYS_SIGINT
__SYS_SIGKILL
__SYS_SIGPIPE
__SYS_SIGQUIT
__SYS_SIGSEGV
__SYS_SIGSTOP
__SYS_SIGTERM
__SYS_SIGTSTP
__SYS_SIGTTIN
__SYS_SIGTTOU
__SYS_SIGUSR1
__SYS_SIGUSR2
__SYS_SIGPOLL
__SYS_SIGPROF
__SYS_SIGSYS
__SYS_SIGTRAP
__SYS_SIGURG
__SYS_SIGVTALRM
__SYS_SIGXCPU
__SYS_SIGXFSZ
__SYS_SIGCOMP1	Reserved These are just to match Linux's signal numbers.
__SYS_SIGCOMP2
__SYS_SIGCOMP3
__SYS_SIGRTMIN
__SYS_SIGRT_1
__SYS_SIGRT_2
__SYS_SIGRT_3
__SYS_SIGRT_4
__SYS_SIGRT_5
__SYS_SIGRT_6
__SYS_SIGRT_7
__SYS_SIGRT_8
__SYS_SIGRT_9
__SYS_SIGRT_10
__SYS_SIGRT_11
__SYS_SIGRT_12
__SYS_SIGRT_13
__SYS_SIGRT_14
__SYS_SIGRT_15
__SYS_SIGRT_16
__SYS_SIGRT_17
__SYS_SIGRT_18
__SYS_SIGRT_19
__SYS_SIGRT_20
__SYS_SIGRT_21
__SYS_SIGRT_22
__SYS_SIGRT_23
__SYS_SIGRT_24
__SYS_SIGRT_25
__SYS_SIGRT_26
__SYS_SIGRT_27
__SYS_SIGRT_28
__SYS_SIGRT_29
__SYS_SIGRT_30
__SYS_SIGRT_31
__SYS_SIGRTMAX
__SYS_SIGNAL_MAX

Definition at line 436 of file syscalls.h.

{
    __SYS_SIGNULL = 0,
    /* Process abort signal. */
    __SYS_SIGABRT = 1,
    /* Alarm clock. */
    __SYS_SIGALRM = 2,
    /* Access to an undefined portion of a memory object. */
    __SYS_SIGBUS = 3,
    /* Child process terminated, stopped, or continued. */
    __SYS_SIGCHLD = 4,
    /* Continue executing, if stopped. */
    __SYS_SIGCONT = 5,
    /* Erroneous arithmetic operation. */
    __SYS_SIGFPE = 6,
    /* Hangup. */
    __SYS_SIGHUP = 7,
    /* Illegal instruction. */
    __SYS_SIGILL = 8,
    /* Terminal interrupt signal. */
    __SYS_SIGINT = 9,
    /* Kill (cannot be caught or ignored). */
    __SYS_SIGKILL = 10,
    /* Write on a pipe with no one to read it. */
    __SYS_SIGPIPE = 11,
    /* Terminal quit signal. */
    __SYS_SIGQUIT = 12,
    /* Invalid memory reference. */
    __SYS_SIGSEGV = 13,
    /* Stop executing (cannot be caught or ignored). */
    __SYS_SIGSTOP = 14,
    /* Termination signal. */
    __SYS_SIGTERM = 15,
    /* Terminal stop signal. */
    __SYS_SIGTSTP = 16,
    /* Background process attempting read. */
    __SYS_SIGTTIN = 17,
    /* Background process attempting write. */
    __SYS_SIGTTOU = 18,
    /* User-defined signal 1. */
    __SYS_SIGUSR1 = 19,
    /* User-defined signal 2. */
    __SYS_SIGUSR2 = 20,
    /* Pollable event. */
    __SYS_SIGPOLL = 21,
    /* Profiling timer expired. */
    __SYS_SIGPROF = 22,
    /* Bad system call. */
    __SYS_SIGSYS = 23,
    /* Trace/breakpoint trap. */
    __SYS_SIGTRAP = 24,
    /* High bandwidth data is available at a socket. */
    __SYS_SIGURG = 25,
    /* Virtual timer expired. */
    __SYS_SIGVTALRM = 26,
    /* CPU time limit exceeded. */
    __SYS_SIGXCPU = 27,
    /* File size limit exceeded. */
    __SYS_SIGXFSZ = 28,
 
    __SYS_SIGCOMP1 = 29,
    __SYS_SIGCOMP2 = 30,
    __SYS_SIGCOMP3 = 31,
 
    /* Real-time signals. */
    __SYS_SIGRTMIN = 32,
    __SYS_SIGRT_1 = 33,
    __SYS_SIGRT_2 = 34,
    __SYS_SIGRT_3 = 35,
    __SYS_SIGRT_4 = 36,
    __SYS_SIGRT_5 = 37,
    __SYS_SIGRT_6 = 38,
    __SYS_SIGRT_7 = 39,
    __SYS_SIGRT_8 = 40,
    __SYS_SIGRT_9 = 41,
    __SYS_SIGRT_10 = 42,
    __SYS_SIGRT_11 = 43,
    __SYS_SIGRT_12 = 44,
    __SYS_SIGRT_13 = 45,
    __SYS_SIGRT_14 = 46,
    __SYS_SIGRT_15 = 47,
    __SYS_SIGRT_16 = 48,
    __SYS_SIGRT_17 = 49,
    __SYS_SIGRT_18 = 50,
    __SYS_SIGRT_19 = 51,
    __SYS_SIGRT_20 = 52,
    __SYS_SIGRT_21 = 53,
    __SYS_SIGRT_22 = 54,
    __SYS_SIGRT_23 = 55,
    __SYS_SIGRT_24 = 56,
    __SYS_SIGRT_25 = 57,
    __SYS_SIGRT_26 = 58,
    __SYS_SIGRT_27 = 59,
    __SYS_SIGRT_28 = 60,
    __SYS_SIGRT_29 = 61,
    __SYS_SIGRT_30 = 62,
    __SYS_SIGRT_31 = 63,
    __SYS_SIGRTMAX = 64,
 
    /* Maximum signal number. */
    __SYS_SIGNAL_MAX = __SYS_SIGRTMAX
} syscall_signal_t;

syscalls_t

enum syscalls_t

List of syscalls.

This list contains all the syscalls of the Fennix Kernel API.

Enumerator
SYS_API_VERSION	Set syscall version. int api_version(int version); This syscall is used to set the version of the list. To prevent applications from breaking on major changes, this should be called at the very beginning of the program. Parameters version The version of the syscall list of which the program was compiled with Returns EOK on success EINVAL if the requested version is invalid Note If this syscall is not used, the latest version will be used.
SYS_READ	Read from a file descriptor. ssize_t sys_read(int fildes, void *buf, size_t nbyte); Reads up to count bytes from the file descriptor fd into the buffer starting at buf. Parameters fd File descriptor to read from buf Buffer where data will be stored count Maximum number of bytes to read Returns Number of bytes read on success 0 if the end of file is reached EFAULT if the buffer is outside accessible address space EBADF if fd is not a valid file descriptor
SYS_PREAD	Read from a file descriptor. ssize_t sys_pread(int fildes, void *buf, size_t nbyte, off_t offset); Reads up to count bytes from the file descriptor fd into the buffer starting at buf. Parameters fd File descriptor to read from buf Buffer where data will be stored count Maximum number of bytes to read offset Offset in the file Returns Number of bytes read on success 0 if the end of file is reached EFAULT if the buffer is outside accessible address space EBADF if fd is not a valid file descriptor
SYS_WRITE	Write to a file descriptor. ssize_t sys_write(int fildes, const void *buf, size_t nbyte); Writes up to count bytes from the buffer starting at buf to the file descriptor fd. Parameters fd File descriptor to write to buf Buffer containing data to write count Number of bytes to write Returns Number of bytes written on success EFAULT if the buffer is outside accessible address space EBADF if fd is not a valid file descriptor EPIPE if writing to a pipe with no reader
SYS_PWRITE	Write to a file descriptor. ssize_t sys_pwrite(int fildes, const void *buf, size_t nbyte, off_t offset); Writes up to count bytes from the buffer starting at buf to the file descriptor fd. Parameters fd File descriptor to write to buf Buffer containing data to write count Number of bytes to write offset Offset in the file Returns Number of bytes written on success EFAULT if the buffer is outside accessible address space EBADF if fd is not a valid file descriptor
SYS_OPEN	Open a file. int open(const char *pathname, int flags, mode_t mode); Opens the file specified by pathname. Parameters pathname Path to the file flags Flags for file access mode Supported values: __SYS_O_RDONLY: Open file for reading only. __SYS_O_WRONLY: Open file for writing only. __SYS_O_RDWR: Open file for reading and writing. __SYS_O_APPEND: Append data to the end of file. __SYS_O_CREAT: Create file if it does not exist. __SYS_O_DSYNC: __SYS_O_EXCL: __SYS_O_NOCTTY: __SYS_O_NONBLOCK: __SYS_O_RSYNC: __SYS_O_SYNC: __SYS_O_TRUNC: Truncate file to zero length. mode Permissions for newly created file (if applicable) Returns File descriptor on success ENOENT if the file does not exist EACCES if permissions are insufficient See also syscall_open_flags_t
SYS_CLOSE	Close a file descriptor. int close(int fd); Closes the file descriptor fd, releasing its resources. Parameters fd File descriptor to close Returns EOK on success EBADF if fd is not a valid file descriptor
SYS_IOCTL	Control a device. int ioctl(int fd, unsigned long request, void *argp); Manipulates the underlying parameters of a device. Parameters fd File descriptor referring to the device request Device-specific request code argp Argument for the request Returns EOK on success EBADF if fd is not valid EINVAL if the request is invalid
SYS_STAT	Retrieve file status. int stat(const char *pathname, struct stat *statbuf); Gets the status of the file specified by pathname. Parameters pathname Path to the file statbuf Buffer to store file status Returns EOK on success ENOENT if the file does not exist EACCES if permissions are insufficient
SYS_FSTAT	Retrieve file status for an open file descriptor. int fstat(int fd, struct stat *statbuf); Gets the status of the file referred to by fd. Parameters fd File descriptor statbuf Buffer to store file status Returns EOK on success EBADF if fd is not a valid file descriptor EFAULT if statbuf is outside accessible address space
SYS_LSTAT	Retrieve file status with symbolic link resolution. int lstat(const char *pathname, struct stat *statbuf); Gets the status of the file specified by pathname, but does not follow symbolic links. Parameters pathname Path to the file statbuf Buffer to store file status Returns EOK on success ENOENT if the file does not exist EACCES if permissions are insufficient
SYS_ACCESS	Check a file's accessibility. int access(const char *pathname, int mode); Checks if the calling process can access the file specified by pathname according to the specified mode. Parameters pathname Path to the file mode Accessibility check mode Supported values: __SYS_F_OK: Check if the file exists __SYS_R_OK: Check if the file is readable __SYS_W_OK: Check if the file is writable __SYS_X_OK: Check if the file is executable Returns EOK on success EACCES if access is denied ENOENT if the file does not exist See also syscall_access_flags_t
SYS_TRUNCATE	Change the size of a file. int truncate(const char *pathname, off_t length); Sets the size of the file specified by pathname to length. If the file is shorter, it is extended and the extended part is zero-filled. Parameters pathname Path to the file length Desired file length Returns EOK on success EINVAL if length is invalid EACCES if permissions are insufficient
SYS_FTRUNCATE	Change the size of a file referred by a file descriptor. int ftruncate(int fd, off_t length); Sets the size of the file referred to by fd to length. Parameters fd File descriptor length Desired file length Returns EOK on success EBADF if fd is not valid EINVAL if length is invalid
SYS_TELL	Get the current file offset. off_t tell(int fd); Returns the current file offset for the file referred to by fd. Parameters fd File descriptor Returns Current file offset on success EBADF if fd is not a valid file descriptor
SYS_SEEK	Set the file offset. off_t seek(int fd, off_t offset, int whence); Sets the file offset for the file referred to by fd to the specified offset according to the directive whence. Parameters fd File descriptor offset Offset to set whence Directive for setting the offset Supported values: __SYS_SEEK_SET: Set the offset to offset bytes __SYS_SEEK_CUR: Set the offset to the current offset plus offset __SYS_SEEK_END: Set the offset to the size of the file plus offset Returns New file offset on success EBADF if fd is not a valid file descriptor EINVAL if whence is invalid
SYS_EXIT	Terminate the calling process. void exit(int status); Terminates the calling process with the specified status. The status code is made available to the parent process. Parameters status Exit status code Returns This function does not return.
SYS_FORK	Create a child process. pid_t fork(void); Creates a new process by duplicating the calling process. The child process has its own copy of the parent's address space. Returns 0 to the child process PID of the child to the parent process ENOMEM if memory is insufficient
SYS_EXECVE	Execute a program. int execve(const char *pathname, char *const argv[], char *const envp[]); Replaces the current process image with a new process image specified by pathname. Parameters pathname Path to the executable file argv Argument vector envp Environment variables Returns Does not return on success ENOENT if the file does not exist EACCES if permissions are insufficient
SYS_GETPID	Get the process ID of the calling process. pid_t getpid(void); Returns the process ID of the calling process. Returns Process ID on success
SYS_GETPPID	Get the parent process ID. pid_t getppid(void); Returns the parent process ID of the calling process. Returns Parent process ID on success
SYS_WAITPID	Wait for a child process to change state. pid_t waitpid(pid_t pid, int *wstatus, int options); Waits for the child process specified by pid to change state. Parameters pid Process ID to wait for wstatus Pointer to store the status information options Options for waiting behavior Returns Process ID of the child on success ECHILD if no child processes exist
SYS_KILL	Send a signal to a process. int kill(pid_t pid, int sig); Sends the signal sig to the process specified by pid. Parameters pid Process ID sig Signal to send Returns EOK on success ESRCH if the process does not exist EINVAL if sig is invalid
SYS_PRCTL	Process/Thread Control. int prctl(syscall_prctl_options_t option, unsigned long arg1, unsigned long arg2, unsigned long arg3, unsigned long arg4); Perform various operations on a process or thread. Parameters option Operation to perform arg1 Argument 1 arg2 Argument 2 arg3 Argument 3 arg4 Argument 4 Returns EOK on success EINVAL if the operation is invalid EFAULT if one of the arguments is invalid
SYS_BRK	Set the program break. int brk(void *end_data); Increases or decreases the program’s data space, ending at end_data. Parameters end_data New program break location Returns EOK on success ENOMEM if memory allocation fails
SYS_MMAP	Map files or devices into memory. void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset); Maps a file or device into memory. This can be used for memory-mapped I/O or for sharing memory between processes. Parameters addr Desired starting address of the mapping (NULL for automatic allocation) length Length of the mapping prot Desired memory protection Supported values: __SYS_PROT_READ: Readable __SYS_PROT_WRITE: Writable __SYS_PROT_EXEC: Executable __SYS_PROT_NONE: No access flags Mapping options Supported values: __SYS_MAP_SHARED: Share memory with other processes __SYS_MAP_PRIVATE: Create a private copy of the file __SYS_MAP_FIXED: Use addr as the starting address of the mapping __SYS_MAP_ANONYMOUS: Create an anonymous mapping fd File descriptor for the file to map offset Offset in the file to start the mapping Returns There are several possible return values: Pointer to mapped area on success EACCES EAGAIN EBADF EINVAL EMFILE ENODEV ENOMEM ENOTSUP ENXIO EOVERFLOW See also syscall_mmap_flags_t
SYS_MUNMAP	Unmap a mapped memory region. int munmap(void *addr, size_t length); Unmaps a previously mapped memory region, making the memory available for reuse. Parameters addr Start address of the memory region length Length of the memory region to unmap Returns EOK on success EINVAL if the address or length is invalid EFAULT if the memory region is not currently mapped
SYS_MPROTECT	Change memory protection. int mprotect(void *addr, size_t length, int prot); Sets the protection on the memory region starting at addr for length. Parameters addr Start address of the memory region length Length of the memory region prot Desired memory protection (e.g., PROT_READ, PROT_WRITE) Returns EOK on success EACCES if protection cannot be set
SYS_MADVISE	Provide advice about memory usage. int madvise(void *addr, size_t length, int advice); Provides advice to the kernel about the expected behavior of the memory region starting at addr for length, such as whether it will be accessed randomly or sequentially. Parameters addr Start address of the memory region length Length of the memory region advice Desired advice (e.g., MADV_DONTNEED, MADV_SEQUENTIAL) Returns EOK on success EINVAL if the parameters are invalid
SYS_PIPE	Create a pipe. int pipe(int pipefd[2]); Creates a pipe, returning two file descriptors in pipefd. One is for reading, and the other is for writing. Parameters pipefd Array to store the two file descriptors Returns EOK on success EMFILE if the process has too many open file descriptors
SYS_DUP	Duplicate a file descriptor. int dup(int oldfd); Duplicates the file descriptor oldfd, returning the new file descriptor. Parameters oldfd File descriptor to duplicate Returns New file descriptor on success EBADF if oldfd is invalid
SYS_DUP2	Duplicate a file descriptor to a specific value. int dup2(int oldfd, int newfd); Duplicates oldfd to newfd. If newfd is already open, it will be closed first. Parameters oldfd File descriptor to duplicate newfd File descriptor to duplicate oldfd to Returns newfd on success EBADF if oldfd is invalid EINVAL if newfd is invalid
SYS_SOCKET	Create an endpoint for communication. int socket(int domain, int type, int protocol); Creates an endpoint for communication, returning a socket file descriptor. Parameters domain Communication domain (e.g., AF_INET for IPv4) type Type of socket (e.g., SOCK_STREAM for TCP) protocol Protocol to use (e.g., IPPROTO_TCP) Returns Socket file descriptor on success EINVAL if parameters are invalid
SYS_BIND	Bind a socket to a local address. int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen); Binds a socket to a local address so it can listen for incoming connections. Parameters sockfd Socket file descriptor addr Address to bind to addrlen Length of the address Returns EOK on success EINVAL if the socket is invalid
SYS_CONNECT	Connect to a remote address. int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen); Connects a socket to a remote address. Parameters sockfd Socket file descriptor addr Remote address to connect to addrlen Length of the address Returns EOK on success EINVAL if parameters are invalid
SYS_LISTEN	Listen for incoming connections on a socket. int listen(int sockfd, int backlog); Sets a socket to listen for incoming connections, specifying the backlog queue size. Parameters sockfd Socket file descriptor backlog Number of pending connections to allow Returns EOK on success EINVAL if parameters are invalid
SYS_ACCEPT	Accept an incoming connection on a socket. int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen); Accepts an incoming connection on a listening socket, creating a new socket for communication. Parameters sockfd Socket file descriptor addr Client address addrlen Length of the address Returns New socket file descriptor on success EINVAL if parameters are invalid
SYS_SEND	Send data on a socket. ssize_t send(int sockfd, const void *buf, size_t len, int flags); Sends data through a socket. Parameters sockfd Socket file descriptor buf Data to send len Length of the data flags Flags for the send operation Returns Number of bytes sent on success EINVAL if parameters are invalid
SYS_RECV	Receive data on a socket. ssize_t recv(int sockfd, void *buf, size_t len, int flags); Receives data from a socket. Parameters sockfd Socket file descriptor buf Buffer to store received data len Maximum number of bytes to receive flags Flags for the receive operation Returns Number of bytes received on success EINVAL if parameters are invalid
SYS_SHUTDOWN	Shut down part of a full-duplex connection. int shutdown(int sockfd, int how); Shuts down part of a full-duplex connection on a socket. Parameters sockfd Socket file descriptor how Determines which operations to shut down (e.g., SHUT_RD, SHUT_WR) Returns EOK on success EINVAL if parameters are invalid
SYS_TIME	Get the current time. time_t time(time_t *t); Retrieves the current calendar time as the number of seconds since the epoch. Parameters t Pointer to store the time (optional) Returns Current time in seconds on success __SYS_NULL if t is NULL
SYS_CLOCK_GETTIME	Get the current time of a specific clock. int clock_gettime(clockid_t clockid, struct timespec *tp); Retrieves the current time for the specified clock (CLOCK_REALTIME, CLOCK_MONOTONIC, etc.). Parameters clockid Clock ID to query tp Pointer to store the time Returns EOK on success EINVAL if parameters are invalid
SYS_CLOCK_SETTIME	Set the current time of a specific clock. int clock_settime(clockid_t clockid, const struct timespec *tp); Sets the time for the specified clock (CLOCK_REALTIME, CLOCK_MONOTONIC, etc.). Parameters clockid Clock ID to set tp Pointer to the time value Returns EOK on success EINVAL if parameters are invalid
SYS_NANOSLEEP	Sleep for a specified time. int nanosleep(const struct timespec *req, struct timespec *rem); Suspends the execution of the calling thread for the specified time duration. Parameters req Pointer to timespec specifying the time to sleep rem Pointer to store remaining time if interrupted Returns EOK on success EINTR if interrupted by a signal
SYS_GETCWD	Get the current working directory. char *getcwd(char *buf, size_t size); Retrieves the current working directory. Parameters buf Buffer to store the directory path size Size of the buffer Returns Pointer to buf on success __SYS_NULL on error
SYS_CHDIR	Change the current working directory. int chdir(const char *path); Changes the current working directory to the specified path. Parameters path New directory path Returns EOK on success ENOENT if the directory does not exist EACCES if permission is denied
SYS_MKDIR	Create a new directory. int mkdir(const char *path, mode_t mode); Creates a new directory at path with the specified permissions. Parameters path Path to the new directory mode Directory permissions Returns EOK on success EEXIST if the directory already exists EACCES if permission is denied
SYS_RMDIR	Remove an empty directory. int rmdir(const char *path); Removes the empty directory specified by path. Parameters path Path to the directory Returns EOK on success ENOTEMPTY if the directory is not empty
SYS_UNLINK	Remove a file. int unlink(const char *pathname); Removes the file specified by pathname. Parameters pathname Path to the file Returns EOK on success ENOENT if the file does not exist EACCES if permission is denied
SYS_RENAME	Rename a file or directory. int rename(const char *oldpath, const char *newpath); Renames a file or directory from oldpath to newpath. Parameters oldpath Current name of the file or directory newpath New name of the file or directory Returns EOK on success EEXIST if the target exists EACCES if permission is denied
SYS_MAX	Max number of syscalls. This is used to determine the size of the syscalls_t array. syscalls_t syscalls[SYS_MAX]; Note This must be the last element in the list

Definition at line 633 of file syscalls.h.

{
    /* Initialization */
 
    SYS_API_VERSION = 0,
 
    /* I/O */
 
    SYS_READ = 100,
    SYS_PREAD,
    SYS_WRITE,
    SYS_PWRITE,
    SYS_OPEN,
    SYS_CLOSE,
    SYS_IOCTL,
 
    /* File Status */
 
    SYS_STAT = 200,
    SYS_FSTAT,
    SYS_LSTAT,
    SYS_ACCESS,
    SYS_TRUNCATE,
    SYS_FTRUNCATE,
    SYS_TELL,
    SYS_SEEK,
 
    /* Process Control */
 
    SYS_EXIT = 300,
    SYS_FORK,
    SYS_EXECVE,
    SYS_GETPID,
    SYS_GETPPID,
    SYS_WAITPID,
    SYS_KILL,
    SYS_PRCTL,
 
    /* Memory */
 
    SYS_BRK = 400,
    SYS_MMAP,
    SYS_MUNMAP,
    SYS_MPROTECT,
    SYS_MADVISE,
 
    /* Communication */
 
    SYS_PIPE = 500,
    SYS_DUP,
    SYS_DUP2,
    SYS_SOCKET,
    SYS_BIND,
    SYS_CONNECT,
    SYS_LISTEN,
    SYS_ACCEPT,
    SYS_SEND,
    SYS_RECV,
    SYS_SHUTDOWN,
 
    /* Time */
 
    SYS_TIME = 600,
    SYS_CLOCK_GETTIME,
    SYS_CLOCK_SETTIME,
    SYS_NANOSLEEP,
 
    /* Miscellaneous */
 
    SYS_GETCWD = 700,
    SYS_CHDIR,
    SYS_MKDIR,
    SYS_RMDIR,
    SYS_UNLINK,
    SYS_RENAME,
 
    SYS_MAX
} syscalls_t;

Function Documentation

syscall0()

static scarg syscall0 ( scarg  syscall )

inlinestatic

Syscall wrapper with 0 arguments.

This wrapper is used to call syscalls with 0 arguments

Parameters

syscall

syscalls_t

Returns

The return value of the syscall

Definition at line 54 of file syscalls.h.

{
    scarg ret;
#if defined(__amd64__)
    __asm__ __volatile__("syscall"
                         : "=a"(ret)
                         : "a"(syscall)
                         : "rcx", "r11", "memory");
#elif defined(__i386__)
    __asm__ __volatile__("int $0x30"
                         : "=a"(ret)
                         : "a"(syscall)
                         : "memory");
#elif defined(__arm__)
    register scarg r7 __thumb_r7 = syscall;
    register scarg r0 __asm__("r0");
    __arm_call(__r7_operand);
#elif defined(__aarch64__)
    register scarg x8 __asm__("x8") = syscall;
    register scarg x0 __asm__("x0");
    __asm__ __volatile__("svc 0"
                         : "=r"(x0)
                         : "r"(x8)
                         : "memory", "cc");
#else
#error "Unsupported architecture"
#endif
    return ret;
}

References scarg.

syscall1()

static scarg syscall1 ( scarg  syscall, scarg  arg1  )

inlinestatic

Syscall wrapper with 1 argument.

This wrapper is used to call syscalls with 1 argument

Parameters

syscall	syscalls_t
arg1	Argument 1

Returns

The return value of the syscall

Definition at line 93 of file syscalls.h.

{
    scarg ret;
#if defined(__amd64__)
    __asm__ __volatile__("syscall"
                         : "=a"(ret)
                         : "a"(syscall), "D"(arg1)
                         : "rcx", "r11", "memory");
#elif defined(__i386__)
    __asm__ __volatile__("int $0x30"
                         : "=a"(ret)
                         : "a"(syscall), "b"(arg1)
                         : "memory");
#elif defined(__arm__)
    register scarg r7 __thumb_r7 = syscall;
    register scarg r0 __asm__("r0") = arg1;
    __arm_call(__r7_operand, "0"(r0));
#elif defined(__aarch64__)
    register scarg x8 __asm__("x8") = syscall;
    register scarg x0 __asm__("x0") = arg1;
    __asm__ __volatile__("svc 0"
                         : "=r"(ret)
                         : "r"(x8), "0"(x0)
                         : "memory", "cc");
#else
#error "Unsupported architecture"
#endif
    return ret;
}

References scarg.

syscall2()

static scarg syscall2 ( scarg  syscall, scarg  arg1, scarg  arg2  )

inlinestatic

Syscall wrapper with 2 arguments.

This wrapper is used to call syscalls with 2 arguments

Parameters

syscall	syscalls_t
arg1	Argument 1
arg2	Argument 2

Returns

The return value of the syscall

Definition at line 133 of file syscalls.h.

{
    scarg ret;
#if defined(__amd64__)
    __asm__ __volatile__("syscall"
                         : "=a"(ret)
                         : "a"(syscall), "D"(arg1), "S"(arg2)
                         : "rcx", "r11", "memory");
#elif defined(__i386__)
    __asm__ __volatile__("int $0x30"
                         : "=a"(ret)
                         : "a"(syscall), "b"(arg1), "c"(arg2)
                         : "memory");
#elif defined(__arm__)
    register scarg r7 __thumb_r7 = syscall;
    register scarg r0 __asm__("r0") = arg1;
    register scarg r1 __asm__("r1") = arg2;
    __arm_call(__r7_operand, "0"(r0), "r"(r1));
#elif defined(__aarch64__)
    register scarg x8 __asm__("x8") = syscall;
    register scarg x0 __asm__("x0") = arg1;
    register scarg x1 __asm__("x1") = arg2;
    __asm__ __volatile__("svc 0"
                         : "=r"(ret)
                         : "r"(x8), "0"(x0), "r"(x1)
                         : "memory", "cc");
#else
#error "Unsupported architecture"
#endif
    return ret;
}

References scarg.

syscall3()

static scarg syscall3 ( scarg  syscall, scarg  arg1, scarg  arg2, scarg  arg3  )

inlinestatic

Syscall wrapper with 3 arguments.

This wrapper is used to call syscalls with 3 arguments

Parameters

syscall	syscalls_t
arg1	Argument 1
arg2	Argument 2
arg3	Argument 3

Returns

The return value of the syscall

Definition at line 176 of file syscalls.h.

{
    scarg ret;
#if defined(__amd64__)
    __asm__ __volatile__("syscall"
                         : "=a"(ret)
                         : "a"(syscall), "D"(arg1), "S"(arg2), "d"(arg3)
                         : "rcx", "r11", "memory");
#elif defined(__i386__)
    __asm__ __volatile__("int $0x30"
                         : "=a"(ret)
                         : "a"(syscall), "b"(arg1), "c"(arg2), "d"(arg3)
                         : "memory");
#elif defined(__arm__)
    register scarg r7 __thumb_r7 = syscall;
    register scarg r0 __asm__("r0") = arg1;
    register scarg r1 __asm__("r1") = arg2;
    register scarg r2 __asm__("r2") = arg3;
    __arm_call(__r7_operand, "0"(r0), "r"(r1), "r"(r2));
#elif defined(__aarch64__)
    register scarg x8 __asm__("x8") = syscall;
    register scarg x0 __asm__("x0") = arg1;
    register scarg x1 __asm__("x1") = arg2;
    register scarg x2 __asm__("x2") = arg3;
    __asm__ __volatile__("svc 0"
                         : "=r"(ret)
                         : "r"(x8), "0"(x0), "r"(x1), "r"(x2)
                         : "memory", "cc");
#else
#error "Unsupported architecture"
#endif
    return ret;
}

References scarg.

syscall4()

static scarg syscall4 ( scarg  syscall, scarg  arg1, scarg  arg2, scarg  arg3, scarg  arg4  )

inlinestatic

Syscall wrapper with 4 arguments.

This wrapper is used to call syscalls with 4 arguments

Parameters

syscall	syscalls_t
arg1	Argument 1
arg2	Argument 2
arg3	Argument 3
arg4	Argument 4

Returns

The return value of the syscall

Definition at line 222 of file syscalls.h.

{
    scarg ret;
#if defined(__amd64__)
    register scarg r10 __asm__("r10") = arg4;
    __asm__ __volatile__("syscall"
                         : "=a"(ret)
                         : "a"(syscall), "D"(arg1), "S"(arg2), "d"(arg3), "r"(r10)
                         : "rcx", "r11", "memory");
#elif defined(__i386__)
    __asm__ __volatile__("int $0x30"
                         : "=a"(ret)
                         : "a"(syscall), "b"(arg1), "c"(arg2), "d"(arg3), "S"(arg4)
                         : "memory");
#elif defined(__arm__)
    register scarg r7 __thumb_r7 = syscall;
    register scarg r0 __asm__("r0") = arg1;
    register scarg r1 __asm__("r1") = arg2;
    register scarg r2 __asm__("r2") = arg3;
    register scarg r3 __asm__("r3") = arg4;
    __arm_call(__r7_operand, "0"(r0), "r"(r1), "r"(r2), "r"(r3));
#elif defined(__aarch64__)
    register scarg x8 __asm__("x8") = syscall;
    register scarg x0 __asm__("x0") = arg1;
    register scarg x1 __asm__("x1") = arg2;
    register scarg x2 __asm__("x2") = arg3;
    register scarg x3 __asm__("x3") = arg4;
    __asm__ __volatile__("svc 0"
                         : "=r"(ret)
                         : "r"(x8), "0"(x0), "r"(x1), "r"(x2), "r"(x3)
                         : "memory", "cc");
#else
#error "Unsupported architecture"
#endif
    return ret;
}

References scarg.

syscall5()

static scarg syscall5 ( scarg  syscall, scarg  arg1, scarg  arg2, scarg  arg3, scarg  arg4, scarg  arg5  )

inlinestatic

Syscall wrapper with 5 arguments.

This wrapper is used to call syscalls with 5 arguments

Parameters

syscall	syscalls_t
arg1	Argument 1
arg2	Argument 2
arg3	Argument 3
arg4	Argument 4
arg5	Argument 5

Returns

The return value of the syscall

Definition at line 272 of file syscalls.h.

{
    scarg ret;
#if defined(__amd64__)
    register scarg r10 __asm__("r10") = arg4;
    register scarg r8 __asm__("r8") = arg5;
    __asm__ __volatile__("syscall"
                         : "=a"(ret)
                         : "a"(syscall), "D"(arg1), "S"(arg2), "d"(arg3), "r"(r10), "r"(r8)
                         : "rcx", "r11", "memory");
#elif defined(__i386__)
    __asm__ __volatile__("int $0x30"
                         : "=a"(ret)
                         : "a"(syscall), "b"(arg1), "c"(arg2), "d"(arg3), "S"(arg4), "D"(arg5)
                         : "memory");
#elif defined(__arm__)
    register scarg r7 __thumb_r7 = syscall;
    register scarg r0 __asm__("r0") = arg1;
    register scarg r1 __asm__("r1") = arg2;
    register scarg r2 __asm__("r2") = arg3;
    register scarg r3 __asm__("r3") = arg4;
    register scarg r4 __asm__("r4") = arg5;
    __arm_call(__r7_operand, "0"(r0), "r"(r1), "r"(r2), "r"(r3), "r"(r4));
#elif defined(__aarch64__)
    register scarg x8 __asm__("x8") = syscall;
    register scarg x0 __asm__("x0") = arg1;
    register scarg x1 __asm__("x1") = arg2;
    register scarg x2 __asm__("x2") = arg3;
    register scarg x3 __asm__("x3") = arg4;
    register scarg x4 __asm__("x4") = arg5;
    __asm__ __volatile__("svc 0"
                         : "=r"(ret)
                         : "r"(x8), "0"(x0), "r"(x1), "r"(x2), "r"(x3), "r"(x4)
                         : "memory", "cc");
#else
#error "Unsupported architecture"
#endif
    return ret;
}

References scarg.

syscall6()

static scarg syscall6 ( scarg  syscall, scarg  arg1, scarg  arg2, scarg  arg3, scarg  arg4, scarg  arg5, scarg  arg6  )

inlinestatic

Syscall wrapper with 6 arguments.

This wrapper is used to call syscalls with 6 arguments

Parameters

syscall	syscalls_t
arg1	Argument 1
arg2	Argument 2
arg3	Argument 3
arg4	Argument 4
arg5	Argument 5
arg6	Argument 6

Returns

The return value of the syscall

Definition at line 326 of file syscalls.h.

{
    scarg ret;
#if defined(__amd64__)
    register scarg r10 __asm__("r10") = arg4;
    register scarg r8 __asm__("r8") = arg5;
    register scarg r9 __asm__("r9") = arg6;
    __asm__ __volatile__("syscall"
                         : "=a"(ret)
                         : "a"(syscall), "D"(arg1), "S"(arg2), "d"(arg3), "r"(r10), "r"(r8), "r"(r9)
                         : "rcx", "r11", "memory");
#elif defined(__i386__)
    __asm__ __volatile__("int $0x30"
                         : "=a"(ret)
                         : "a"(syscall), "b"(arg1), "c"(arg2), "d"(arg3), "S"(arg4), "D"(arg5), "g"(arg6)
                         : "memory");
#elif defined(__arm__)
    register scarg r7 __thumb_r7 = syscall;
    register scarg r0 __asm__("r0") = arg1;
    register scarg r1 __asm__("r1") = arg2;
    register scarg r2 __asm__("r2") = arg3;
    register scarg r3 __asm__("r3") = arg4;
    register scarg r4 __asm__("r4") = arg5;
    register scarg r5 __asm__("r5") = arg6;
    __arm_call(__r7_operand, "0"(r0), "r"(r1), "r"(r2), "r"(r3), "r"(r4), "r"(r5));
#elif defined(__aarch64__)
    register scarg x8 __asm__("x8") = syscall;
    register scarg x0 __asm__("x0") = arg1;
    register scarg x1 __asm__("x1") = arg2;
    register scarg x2 __asm__("x2") = arg3;
    register scarg x3 __asm__("x3") = arg4;
    register scarg x4 __asm__("x4") = arg5;
    register scarg x5 __asm__("x5") = arg6;
    __asm__ __volatile__("svc 0"
                         : "=r"(ret)
                         : "r"(x8), "0"(x0), "r"(x1), "r"(x2), "r"(x3), "r"(x4), "r"(x5)
                         : "memory", "cc");
#else
#error "Unsupported architecture"
#endif
    return ret;
}

References scarg.