| // Copyright 2021 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #![allow(dead_code)] |
| #![allow(non_camel_case_types)] |
| #![allow(non_upper_case_globals)] |
| |
| use fuchsia_zircon as zx; |
| use paste::paste; |
| use std::fmt; |
| use zerocopy::{AsBytes, FromBytes}; |
| |
| use crate::fs::FdNumber; |
| pub use crate::user_address::*; |
| |
| #[cfg(target_arch = "x86_64")] |
| use linux_uapi::x86_64 as uapi; |
| pub use uapi::*; |
| |
| pub type dev_t = uapi::__kernel_old_dev_t; |
| pub type gid_t = uapi::__kernel_gid_t; |
| pub type ino_t = uapi::__kernel_ino_t; |
| pub type mode_t = uapi::__kernel_mode_t; |
| pub type off_t = uapi::__kernel_off_t; |
| pub type pid_t = uapi::__kernel_pid_t; |
| pub type uid_t = uapi::__kernel_uid_t; |
| |
| #[derive(Debug, Eq, PartialEq)] |
| pub struct Errno { |
| value: u32, |
| name: &'static str, |
| } |
| |
| impl Errno { |
| pub fn value(&self) -> i32 { |
| self.value as i32 |
| } |
| } |
| |
| impl fmt::Display for Errno { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| write!(f, "error {}: {}", self.value, self.name) |
| } |
| } |
| |
| pub const EPERM: Errno = Errno { value: uapi::EPERM, name: "EPERM" }; |
| pub const ENOENT: Errno = Errno { value: uapi::ENOENT, name: "ENOENT" }; |
| pub const ESRCH: Errno = Errno { value: uapi::ESRCH, name: "ESRCH" }; |
| pub const EINTR: Errno = Errno { value: uapi::EINTR, name: "EINTR" }; |
| pub const EIO: Errno = Errno { value: uapi::EIO, name: "EIO" }; |
| pub const ENXIO: Errno = Errno { value: uapi::ENXIO, name: "ENXIO" }; |
| pub const E2BIG: Errno = Errno { value: uapi::E2BIG, name: "E2BIG" }; |
| pub const ENOEXEC: Errno = Errno { value: uapi::ENOEXEC, name: "ENOEXEC" }; |
| pub const EBADF: Errno = Errno { value: uapi::EBADF, name: "EBADF" }; |
| pub const ECHILD: Errno = Errno { value: uapi::ECHILD, name: "ECHILD" }; |
| pub const EAGAIN: Errno = Errno { value: uapi::EAGAIN, name: "EAGAIN" }; |
| pub const ENOMEM: Errno = Errno { value: uapi::ENOMEM, name: "ENOMEM" }; |
| pub const EACCES: Errno = Errno { value: uapi::EACCES, name: "EACCES" }; |
| pub const EFAULT: Errno = Errno { value: uapi::EFAULT, name: "EFAULT" }; |
| pub const ENOTBLK: Errno = Errno { value: uapi::ENOTBLK, name: "ENOTBLK" }; |
| pub const EBUSY: Errno = Errno { value: uapi::EBUSY, name: "EBUSY" }; |
| pub const EEXIST: Errno = Errno { value: uapi::EEXIST, name: "EEXIST" }; |
| pub const EXDEV: Errno = Errno { value: uapi::EXDEV, name: "EXDEV" }; |
| pub const ENODEV: Errno = Errno { value: uapi::ENODEV, name: "ENODEV" }; |
| pub const ENOTDIR: Errno = Errno { value: uapi::ENOTDIR, name: "ENOTDIR" }; |
| pub const EISDIR: Errno = Errno { value: uapi::EISDIR, name: "EISDIR" }; |
| pub const EINVAL: Errno = Errno { value: uapi::EINVAL, name: "EINVAL" }; |
| pub const ENFILE: Errno = Errno { value: uapi::ENFILE, name: "ENFILE" }; |
| pub const EMFILE: Errno = Errno { value: uapi::EMFILE, name: "EMFILE" }; |
| pub const ENOTTY: Errno = Errno { value: uapi::ENOTTY, name: "ENOTTY" }; |
| pub const ETXTBSY: Errno = Errno { value: uapi::ETXTBSY, name: "ETXTBSY" }; |
| pub const EFBIG: Errno = Errno { value: uapi::EFBIG, name: "EFBIG" }; |
| pub const ENOSPC: Errno = Errno { value: uapi::ENOSPC, name: "ENOSPC" }; |
| pub const ESPIPE: Errno = Errno { value: uapi::ESPIPE, name: "ESPIPE" }; |
| pub const EROFS: Errno = Errno { value: uapi::EROFS, name: "EROFS" }; |
| pub const EMLINK: Errno = Errno { value: uapi::EMLINK, name: "EMLINK" }; |
| pub const EPIPE: Errno = Errno { value: uapi::EPIPE, name: "EPIPE" }; |
| pub const EDOM: Errno = Errno { value: uapi::EDOM, name: "EDOM" }; |
| pub const ERANGE: Errno = Errno { value: uapi::ERANGE, name: "ERANGE" }; |
| pub const EDEADLK: Errno = Errno { value: uapi::EDEADLK, name: "EDEADLK" }; |
| pub const ENAMETOOLONG: Errno = Errno { value: uapi::ENAMETOOLONG, name: "ENAMETOOLONG" }; |
| pub const ENOLCK: Errno = Errno { value: uapi::ENOLCK, name: "ENOLCK" }; |
| pub const ENOSYS: Errno = Errno { value: uapi::ENOSYS, name: "ENOSYS" }; |
| pub const ENOTEMPTY: Errno = Errno { value: uapi::ENOTEMPTY, name: "ENOTEMPTY" }; |
| pub const ELOOP: Errno = Errno { value: uapi::ELOOP, name: "ELOOP" }; |
| pub const EWOULDBLOCK: Errno = Errno { value: uapi::EWOULDBLOCK, name: "EWOULDBLOCK" }; |
| pub const ENOMSG: Errno = Errno { value: uapi::ENOMSG, name: "ENOMSG" }; |
| pub const EIDRM: Errno = Errno { value: uapi::EIDRM, name: "EIDRM" }; |
| pub const ECHRNG: Errno = Errno { value: uapi::ECHRNG, name: "ECHRNG" }; |
| pub const EL2NSYNC: Errno = Errno { value: uapi::EL2NSYNC, name: "EL2NSYNC" }; |
| pub const EL3HLT: Errno = Errno { value: uapi::EL3HLT, name: "EL3HLT" }; |
| pub const EL3RST: Errno = Errno { value: uapi::EL3RST, name: "EL3RST" }; |
| pub const ELNRNG: Errno = Errno { value: uapi::ELNRNG, name: "ELNRNG" }; |
| pub const EUNATCH: Errno = Errno { value: uapi::EUNATCH, name: "EUNATCH" }; |
| pub const ENOCSI: Errno = Errno { value: uapi::ENOCSI, name: "ENOCSI" }; |
| pub const EL2HLT: Errno = Errno { value: uapi::EL2HLT, name: "EL2HLT" }; |
| pub const EBADE: Errno = Errno { value: uapi::EBADE, name: "EBADE" }; |
| pub const EBADR: Errno = Errno { value: uapi::EBADR, name: "EBADR" }; |
| pub const EXFULL: Errno = Errno { value: uapi::EXFULL, name: "EXFULL" }; |
| pub const ENOANO: Errno = Errno { value: uapi::ENOANO, name: "ENOANO" }; |
| pub const EBADRQC: Errno = Errno { value: uapi::EBADRQC, name: "EBADRQC" }; |
| pub const EBADSLT: Errno = Errno { value: uapi::EBADSLT, name: "EBADSLT" }; |
| pub const EDEADLOCK: Errno = Errno { value: uapi::EDEADLOCK, name: "EDEADLOCK" }; |
| pub const EBFONT: Errno = Errno { value: uapi::EBFONT, name: "EBFONT" }; |
| pub const ENOSTR: Errno = Errno { value: uapi::ENOSTR, name: "ENOSTR" }; |
| pub const ENODATA: Errno = Errno { value: uapi::ENODATA, name: "ENODATA" }; |
| pub const ETIME: Errno = Errno { value: uapi::ETIME, name: "ETIME" }; |
| pub const ENOSR: Errno = Errno { value: uapi::ENOSR, name: "ENOSR" }; |
| pub const ENONET: Errno = Errno { value: uapi::ENONET, name: "ENONET" }; |
| pub const ENOPKG: Errno = Errno { value: uapi::ENOPKG, name: "ENOPKG" }; |
| pub const EREMOTE: Errno = Errno { value: uapi::EREMOTE, name: "EREMOTE" }; |
| pub const ENOLINK: Errno = Errno { value: uapi::ENOLINK, name: "ENOLINK" }; |
| pub const EADV: Errno = Errno { value: uapi::EADV, name: "EADV" }; |
| pub const ESRMNT: Errno = Errno { value: uapi::ESRMNT, name: "ESRMNT" }; |
| pub const ECOMM: Errno = Errno { value: uapi::ECOMM, name: "ECOMM" }; |
| pub const EPROTO: Errno = Errno { value: uapi::EPROTO, name: "EPROTO" }; |
| pub const EMULTIHOP: Errno = Errno { value: uapi::EMULTIHOP, name: "EMULTIHOP" }; |
| pub const EDOTDOT: Errno = Errno { value: uapi::EDOTDOT, name: "EDOTDOT" }; |
| pub const EBADMSG: Errno = Errno { value: uapi::EBADMSG, name: "EBADMSG" }; |
| pub const EOVERFLOW: Errno = Errno { value: uapi::EOVERFLOW, name: "EOVERFLOW" }; |
| pub const ENOTUNIQ: Errno = Errno { value: uapi::ENOTUNIQ, name: "ENOTUNIQ" }; |
| pub const EBADFD: Errno = Errno { value: uapi::EBADFD, name: "EBADFD" }; |
| pub const EREMCHG: Errno = Errno { value: uapi::EREMCHG, name: "EREMCHG" }; |
| pub const ELIBACC: Errno = Errno { value: uapi::ELIBACC, name: "ELIBACC" }; |
| pub const ELIBBAD: Errno = Errno { value: uapi::ELIBBAD, name: "ELIBBAD" }; |
| pub const ELIBSCN: Errno = Errno { value: uapi::ELIBSCN, name: "ELIBSCN" }; |
| pub const ELIBMAX: Errno = Errno { value: uapi::ELIBMAX, name: "ELIBMAX" }; |
| pub const ELIBEXEC: Errno = Errno { value: uapi::ELIBEXEC, name: "ELIBEXEC" }; |
| pub const EILSEQ: Errno = Errno { value: uapi::EILSEQ, name: "EILSEQ" }; |
| pub const ERESTART: Errno = Errno { value: uapi::ERESTART, name: "ERESTART" }; |
| pub const ESTRPIPE: Errno = Errno { value: uapi::ESTRPIPE, name: "ESTRPIPE" }; |
| pub const EUSERS: Errno = Errno { value: uapi::EUSERS, name: "EUSERS" }; |
| pub const ENOTSOCK: Errno = Errno { value: uapi::ENOTSOCK, name: "ENOTSOCK" }; |
| pub const EDESTADDRREQ: Errno = Errno { value: uapi::EDESTADDRREQ, name: "EDESTADDRREQ" }; |
| pub const EMSGSIZE: Errno = Errno { value: uapi::EMSGSIZE, name: "EMSGSIZE" }; |
| pub const EPROTOTYPE: Errno = Errno { value: uapi::EPROTOTYPE, name: "EPROTOTYPE" }; |
| pub const ENOPROTOOPT: Errno = Errno { value: uapi::ENOPROTOOPT, name: "ENOPROTOOPT" }; |
| pub const EPROTONOSUPPORT: Errno = Errno { value: uapi::EPROTONOSUPPORT, name: "EPROTONOSUPPORT" }; |
| pub const ESOCKTNOSUPPORT: Errno = Errno { value: uapi::ESOCKTNOSUPPORT, name: "ESOCKTNOSUPPORT" }; |
| pub const EOPNOTSUPP: Errno = Errno { value: uapi::EOPNOTSUPP, name: "EOPNOTSUPP" }; |
| pub const EPFNOSUPPORT: Errno = Errno { value: uapi::EPFNOSUPPORT, name: "EPFNOSUPPORT" }; |
| pub const EAFNOSUPPORT: Errno = Errno { value: uapi::EAFNOSUPPORT, name: "EAFNOSUPPORT" }; |
| pub const EADDRINUSE: Errno = Errno { value: uapi::EADDRINUSE, name: "EADDRINUSE" }; |
| pub const EADDRNOTAVAIL: Errno = Errno { value: uapi::EADDRNOTAVAIL, name: "EADDRNOTAVAIL" }; |
| pub const ENETDOWN: Errno = Errno { value: uapi::ENETDOWN, name: "ENETDOWN" }; |
| pub const ENETUNREACH: Errno = Errno { value: uapi::ENETUNREACH, name: "ENETUNREACH" }; |
| pub const ENETRESET: Errno = Errno { value: uapi::ENETRESET, name: "ENETRESET" }; |
| pub const ECONNABORTED: Errno = Errno { value: uapi::ECONNABORTED, name: "ECONNABORTED" }; |
| pub const ECONNRESET: Errno = Errno { value: uapi::ECONNRESET, name: "ECONNRESET" }; |
| pub const ENOBUFS: Errno = Errno { value: uapi::ENOBUFS, name: "ENOBUFS" }; |
| pub const EISCONN: Errno = Errno { value: uapi::EISCONN, name: "EISCONN" }; |
| pub const ENOTCONN: Errno = Errno { value: uapi::ENOTCONN, name: "ENOTCONN" }; |
| pub const ESHUTDOWN: Errno = Errno { value: uapi::ESHUTDOWN, name: "ESHUTDOWN" }; |
| pub const ETOOMANYREFS: Errno = Errno { value: uapi::ETOOMANYREFS, name: "ETOOMANYREFS" }; |
| pub const ETIMEDOUT: Errno = Errno { value: uapi::ETIMEDOUT, name: "ETIMEDOUT" }; |
| pub const ECONNREFUSED: Errno = Errno { value: uapi::ECONNREFUSED, name: "ECONNREFUSED" }; |
| pub const EHOSTDOWN: Errno = Errno { value: uapi::EHOSTDOWN, name: "EHOSTDOWN" }; |
| pub const EHOSTUNREACH: Errno = Errno { value: uapi::EHOSTUNREACH, name: "EHOSTUNREACH" }; |
| pub const EALREADY: Errno = Errno { value: uapi::EALREADY, name: "EALREADY" }; |
| pub const EINPROGRESS: Errno = Errno { value: uapi::EINPROGRESS, name: "EINPROGRESS" }; |
| pub const ESTALE: Errno = Errno { value: uapi::ESTALE, name: "ESTALE" }; |
| pub const EUCLEAN: Errno = Errno { value: uapi::EUCLEAN, name: "EUCLEAN" }; |
| pub const ENOTNAM: Errno = Errno { value: uapi::ENOTNAM, name: "ENOTNAM" }; |
| pub const ENAVAIL: Errno = Errno { value: uapi::ENAVAIL, name: "ENAVAIL" }; |
| pub const EISNAM: Errno = Errno { value: uapi::EISNAM, name: "EISNAM" }; |
| pub const EREMOTEIO: Errno = Errno { value: uapi::EREMOTEIO, name: "EREMOTEIO" }; |
| pub const EDQUOT: Errno = Errno { value: uapi::EDQUOT, name: "EDQUOT" }; |
| pub const ENOMEDIUM: Errno = Errno { value: uapi::ENOMEDIUM, name: "ENOMEDIUM" }; |
| pub const EMEDIUMTYPE: Errno = Errno { value: uapi::EMEDIUMTYPE, name: "EMEDIUMTYPE" }; |
| pub const ECANCELED: Errno = Errno { value: uapi::ECANCELED, name: "ECANCELED" }; |
| pub const ENOKEY: Errno = Errno { value: uapi::ENOKEY, name: "ENOKEY" }; |
| pub const EKEYEXPIRED: Errno = Errno { value: uapi::EKEYEXPIRED, name: "EKEYEXPIRED" }; |
| pub const EKEYREVOKED: Errno = Errno { value: uapi::EKEYREVOKED, name: "EKEYREVOKED" }; |
| pub const EKEYREJECTED: Errno = Errno { value: uapi::EKEYREJECTED, name: "EKEYREJECTED" }; |
| pub const EOWNERDEAD: Errno = Errno { value: uapi::EOWNERDEAD, name: "EOWNERDEAD" }; |
| pub const ENOTRECOVERABLE: Errno = Errno { value: uapi::ENOTRECOVERABLE, name: "ENOTRECOVERABLE" }; |
| pub const ERFKILL: Errno = Errno { value: uapi::ERFKILL, name: "ERFKILL" }; |
| pub const EHWPOISON: Errno = Errno { value: uapi::EHWPOISON, name: "EHWPOISON" }; |
| |
| // There isn't really a mapping from zx::Status to Errno. The correct mapping is context-speific |
| // but this converter is a reasonable first-approximation. The translation matches |
| // fdio_status_to_errno. See fxbug.dev/30921 for more context. |
| // TODO: Replace clients with more context-specific mappings. |
| impl Errno { |
| pub fn from_status_like_fdio(status: zx::Status) -> Self { |
| match status { |
| zx::Status::NOT_FOUND => ENOENT, |
| zx::Status::NO_MEMORY => ENOMEM, |
| zx::Status::INVALID_ARGS => EINVAL, |
| zx::Status::BUFFER_TOO_SMALL => EINVAL, |
| zx::Status::TIMED_OUT => ETIMEDOUT, |
| zx::Status::UNAVAILABLE => EBUSY, |
| zx::Status::ALREADY_EXISTS => EEXIST, |
| zx::Status::PEER_CLOSED => EPIPE, |
| zx::Status::BAD_STATE => EPIPE, |
| zx::Status::BAD_PATH => ENAMETOOLONG, |
| zx::Status::IO => EIO, |
| zx::Status::NOT_FILE => EISDIR, |
| zx::Status::NOT_DIR => ENOTDIR, |
| zx::Status::NOT_SUPPORTED => EOPNOTSUPP, |
| zx::Status::WRONG_TYPE => EOPNOTSUPP, |
| zx::Status::OUT_OF_RANGE => EINVAL, |
| zx::Status::NO_RESOURCES => ENOMEM, |
| zx::Status::BAD_HANDLE => EBADF, |
| zx::Status::ACCESS_DENIED => EACCES, |
| zx::Status::SHOULD_WAIT => EAGAIN, |
| zx::Status::FILE_BIG => EFBIG, |
| zx::Status::NO_SPACE => ENOSPC, |
| zx::Status::NOT_EMPTY => ENOTEMPTY, |
| zx::Status::IO_REFUSED => ECONNREFUSED, |
| zx::Status::IO_INVALID => EIO, |
| zx::Status::CANCELED => EBADF, |
| zx::Status::PROTOCOL_NOT_SUPPORTED => EPROTONOSUPPORT, |
| zx::Status::ADDRESS_UNREACHABLE => ENETUNREACH, |
| zx::Status::ADDRESS_IN_USE => EADDRINUSE, |
| zx::Status::NOT_CONNECTED => ENOTCONN, |
| zx::Status::CONNECTION_REFUSED => ECONNREFUSED, |
| zx::Status::CONNECTION_RESET => ECONNRESET, |
| zx::Status::CONNECTION_ABORTED => ECONNABORTED, |
| _ => EIO, |
| } |
| } |
| } |
| |
| /// Calls the given callback with the given context, delimited with semicolons, |
| /// followed by each syscall, delimited with commas. |
| /// |
| /// Intended to be used with other macros to produce code that needs to handle |
| /// each syscall. |
| macro_rules! for_each_syscall { |
| {$callback:ident $(,$context:ident)*} => { |
| $callback!{ |
| $($context;)* |
| read, |
| write, |
| open, |
| close, |
| stat, |
| fstat, |
| lstat, |
| poll, |
| lseek, |
| mmap, |
| mprotect, |
| munmap, |
| brk, |
| rt_sigaction, |
| rt_sigprocmask, |
| rt_sigreturn, |
| ioctl, |
| pread64, |
| pwrite64, |
| readv, |
| writev, |
| access, |
| pipe, |
| select, |
| sched_yield, |
| mremap, |
| msync, |
| mincore, |
| madvise, |
| shmget, |
| shmat, |
| shmctl, |
| dup, |
| dup2, |
| pause, |
| nanosleep, |
| getitimer, |
| alarm, |
| setitimer, |
| getpid, |
| sendfile, |
| socket, |
| connect, |
| accept, |
| sendto, |
| recvfrom, |
| sendmsg, |
| recvmsg, |
| shutdown, |
| bind, |
| listen, |
| getsockname, |
| getpeername, |
| socketpair, |
| setsockopt, |
| getsockopt, |
| clone, |
| fork, |
| vfork, |
| execve, |
| exit, |
| wait4, |
| kill, |
| uname, |
| semget, |
| semop, |
| semctl, |
| shmdt, |
| msgget, |
| msgsnd, |
| msgrcv, |
| msgctl, |
| fcntl, |
| flock, |
| fsync, |
| fdatasync, |
| truncate, |
| ftruncate, |
| getdents, |
| getcwd, |
| chdir, |
| fchdir, |
| rename, |
| mkdir, |
| rmdir, |
| creat, |
| link, |
| unlink, |
| symlink, |
| readlink, |
| chmod, |
| fchmod, |
| chown, |
| fchown, |
| lchown, |
| umask, |
| gettimeofday, |
| getrlimit, |
| getrusage, |
| sysinfo, |
| times, |
| ptrace, |
| getuid, |
| syslog, |
| getgid, |
| setuid, |
| setgid, |
| geteuid, |
| getegid, |
| setpgid, |
| getppid, |
| getpgrp, |
| setsid, |
| setreuid, |
| setregid, |
| getgroups, |
| setgroups, |
| setresuid, |
| getresuid, |
| setresgid, |
| getresgid, |
| getpgid, |
| setfsuid, |
| setfsgid, |
| getsid, |
| capget, |
| capset, |
| rt_sigpending, |
| rt_sigtimedwait, |
| rt_sigqueueinfo, |
| rt_sigsuspend, |
| sigaltstack, |
| utime, |
| mknod, |
| uselib, |
| personality, |
| ustat, |
| statfs, |
| fstatfs, |
| sysfs, |
| getpriority, |
| setpriority, |
| sched_setparam, |
| sched_getparam, |
| sched_setscheduler, |
| sched_getscheduler, |
| sched_get_priority_max, |
| sched_get_priority_min, |
| sched_rr_get_interval, |
| mlock, |
| munlock, |
| mlockall, |
| munlockall, |
| vhangup, |
| modify_ldt, |
| pivot_root, |
| _sysctl, |
| prctl, |
| arch_prctl, |
| adjtimex, |
| setrlimit, |
| chroot, |
| sync, |
| acct, |
| settimeofday, |
| mount, |
| umount2, |
| swapon, |
| swapoff, |
| reboot, |
| sethostname, |
| setdomainname, |
| iopl, |
| ioperm, |
| create_module, |
| init_module, |
| delete_module, |
| get_kernel_syms, |
| query_module, |
| quotactl, |
| nfsservctl, |
| getpmsg, |
| putpmsg, |
| afs_syscall, |
| tuxcall, |
| security, |
| gettid, |
| readahead, |
| setxattr, |
| lsetxattr, |
| fsetxattr, |
| getxattr, |
| lgetxattr, |
| fgetxattr, |
| listxattr, |
| llistxattr, |
| flistxattr, |
| removexattr, |
| lremovexattr, |
| fremovexattr, |
| tkill, |
| time, |
| futex, |
| sched_setaffinity, |
| sched_getaffinity, |
| set_thread_area, |
| io_setup, |
| io_destroy, |
| io_getevents, |
| io_submit, |
| io_cancel, |
| get_thread_area, |
| lookup_dcookie, |
| epoll_create, |
| epoll_ctl_old, |
| epoll_wait_old, |
| remap_file_pages, |
| getdents64, |
| set_tid_address, |
| restart_syscall, |
| semtimedop, |
| fadvise64, |
| timer_create, |
| timer_settime, |
| timer_gettime, |
| timer_getoverrun, |
| timer_delete, |
| clock_settime, |
| clock_gettime, |
| clock_getres, |
| clock_nanosleep, |
| exit_group, |
| epoll_wait, |
| epoll_ctl, |
| tgkill, |
| utimes, |
| vserver, |
| mbind, |
| set_mempolicy, |
| get_mempolicy, |
| mq_open, |
| mq_unlink, |
| mq_timedsend, |
| mq_timedreceive, |
| mq_notify, |
| mq_getsetattr, |
| kexec_load, |
| waitid, |
| add_key, |
| request_key, |
| keyctl, |
| ioprio_set, |
| ioprio_get, |
| inotify_init, |
| inotify_add_watch, |
| inotify_rm_watch, |
| migrate_pages, |
| openat, |
| mkdirat, |
| mknodat, |
| fchownat, |
| futimesat, |
| newfstatat, |
| unlinkat, |
| renameat, |
| linkat, |
| symlinkat, |
| readlinkat, |
| fchmodat, |
| faccessat, |
| pselect6, |
| ppoll, |
| unshare, |
| set_robust_list, |
| get_robust_list, |
| splice, |
| tee, |
| sync_file_range, |
| vmsplice, |
| move_pages, |
| utimensat, |
| epoll_pwait, |
| signalfd, |
| timerfd_create, |
| eventfd, |
| fallocate, |
| timerfd_settime, |
| timerfd_gettime, |
| accept4, |
| signalfd4, |
| eventfd2, |
| epoll_create1, |
| dup3, |
| pipe2, |
| inotify_init1, |
| preadv, |
| pwritev, |
| rt_tgsigqueueinfo, |
| perf_event_open, |
| recvmmsg, |
| fanotify_init, |
| fanotify_mark, |
| prlimit64, |
| name_to_handle_at, |
| open_by_handle_at, |
| clock_adjtime, |
| syncfs, |
| sendmmsg, |
| setns, |
| getcpu, |
| process_vm_readv, |
| process_vm_writev, |
| kcmp, |
| finit_module, |
| sched_setattr, |
| sched_getattr, |
| renameat2, |
| seccomp, |
| getrandom, |
| memfd_create, |
| kexec_file_load, |
| bpf, |
| execveat, |
| userfaultfd, |
| membarrier, |
| mlock2, |
| copy_file_range, |
| preadv2, |
| pwritev2, |
| pkey_mprotect, |
| pkey_alloc, |
| pkey_free, |
| statx, |
| io_pgetevents, |
| rseq, |
| pidfd_send_signal, |
| io_uring_setup, |
| io_uring_enter, |
| io_uring_register, |
| open_tree, |
| move_mount, |
| fsopen, |
| fsconfig, |
| fsmount, |
| fspick, |
| pidfd_open, |
| clone3, |
| close_range, |
| openat2, |
| pidfd_getfd, |
| faccessat2, |
| process_madvise, |
| } |
| } |
| } |
| |
| /// A system call declaration. |
| /// |
| /// Describes the name of the syscall and its number. |
| /// |
| /// TODO: Add information about the number of arguments (and their types) so |
| /// that we can make strace more useful. |
| pub struct SyscallDecl { |
| pub name: &'static str, |
| pub number: u64, |
| } |
| |
| /// A macro for declaring a const SyscallDecl for a given syscall. |
| /// |
| /// The constant will be called DECL_<SYSCALL>. |
| macro_rules! syscall_decl { |
| {$($name:ident,)*} => { |
| paste! { |
| $(pub const [<DECL_ $name:upper>]: SyscallDecl = SyscallDecl { name: stringify!($name), number: [<__NR_ $name>] as u64};)* |
| } |
| } |
| } |
| |
| // Produce each syscall declaration. |
| for_each_syscall! {syscall_decl} |
| |
| /// A declaration for an unknown syscall. |
| /// |
| /// Useful so that functions that return a SyscallDecl have a sentinel |
| /// to return when they cannot find an appropriate syscall. |
| pub const DECL_UNKNOWN: SyscallDecl = SyscallDecl { name: "<unknown>", number: 0xFFFF }; |
| |
| /// A macro for the body of SyscallDecl::from_number. |
| /// |
| /// Evaluates to the &'static SyscallDecl for the given number or to |
| /// &DECL_UNKNOWN if the number is unknown. |
| macro_rules! syscall_match { |
| {$number:ident; $($name:ident,)*} => { |
| paste! { |
| match $number as u32 { |
| $([<__NR_ $name>] => &[<DECL_ $name:upper>],)* |
| _ => &DECL_UNKNOWN, |
| } |
| } |
| } |
| } |
| |
| impl SyscallDecl { |
| /// The SyscallDecl for the given syscall number. |
| /// |
| /// Returns &DECL_UNKNOWN if the given syscall number is not known. |
| pub fn from_number(number: u64) -> &'static SyscallDecl { |
| for_each_syscall! { syscall_match, number } |
| } |
| } |
| |
| /// The result of executing a syscall. |
| /// |
| /// It would be nice to have this also cover errors, but currently there is no stable way |
| /// to implement `std::ops::Try` (for the `?` operator) for custom enums, making it difficult |
| /// to work with. |
| #[derive(Debug, Eq, PartialEq)] |
| pub enum SyscallResult { |
| /// The process exited as a result of the syscall. The associated `u64` represents the process' |
| /// exit code. |
| Exit(i32), |
| |
| /// The syscall completed successfully. The associated `u64` is the return value from the |
| /// syscall. |
| Success(u64), |
| } |
| |
| pub const SUCCESS: SyscallResult = SyscallResult::Success(0); |
| |
| impl From<UserAddress> for SyscallResult { |
| fn from(value: UserAddress) -> Self { |
| SyscallResult::Success(value.ptr() as u64) |
| } |
| } |
| |
| impl From<FdNumber> for SyscallResult { |
| fn from(value: FdNumber) -> Self { |
| SyscallResult::Success(value.raw() as u64) |
| } |
| } |
| |
| impl From<bool> for SyscallResult { |
| fn from(value: bool) -> Self { |
| SyscallResult::Success(if value { 1 } else { 0 }) |
| } |
| } |
| |
| impl From<i32> for SyscallResult { |
| fn from(value: i32) -> Self { |
| SyscallResult::Success(value as u64) |
| } |
| } |
| |
| impl From<u32> for SyscallResult { |
| fn from(value: u32) -> Self { |
| SyscallResult::Success(value as u64) |
| } |
| } |
| |
| impl From<u64> for SyscallResult { |
| fn from(value: u64) -> Self { |
| SyscallResult::Success(value) |
| } |
| } |
| |
| impl From<usize> for SyscallResult { |
| fn from(value: usize) -> Self { |
| SyscallResult::Success(value as u64) |
| } |
| } |
| |
| #[derive(Debug, Eq, PartialEq, Hash, Copy, Clone, AsBytes, FromBytes)] |
| #[repr(C)] |
| pub struct utsname_t { |
| pub sysname: [u8; 65], |
| pub nodename: [u8; 65], |
| pub release: [u8; 65], |
| pub version: [u8; 65], |
| pub machine: [u8; 65], |
| } |
| |
| #[derive(Debug, Default, Clone, Copy, AsBytes, FromBytes)] |
| #[repr(C)] |
| pub struct stat_t { |
| pub st_dev: dev_t, |
| pub st_ino: ino_t, |
| pub st_nlink: u64, |
| pub st_mode: mode_t, |
| pub st_uid: uid_t, |
| pub st_gid: gid_t, |
| pub _pad0: u32, |
| pub st_rdev: dev_t, |
| pub st_size: off_t, |
| pub st_blksize: i64, |
| pub st_blocks: i64, |
| pub st_atim: timespec, |
| pub st_mtim: timespec, |
| pub st_ctim: timespec, |
| pub _pad3: [i64; 3], |
| } |
| |
| #[derive(Debug, Default, Clone, Copy, AsBytes, FromBytes)] |
| #[repr(C)] |
| pub struct iovec_t { |
| pub iov_base: UserAddress, |
| pub iov_len: usize, |
| } |
| |
| #[derive(Debug, Default, Clone, Copy, AsBytes, FromBytes)] |
| #[repr(C)] |
| pub struct statfs { |
| f_type: i64, |
| f_bsize: i64, |
| f_blocks: i64, |
| f_bfree: i64, |
| f_bavail: i64, |
| f_files: i64, |
| f_ffree: i64, |
| f_fsid: i64, |
| f_namelen: i64, |
| f_frsize: i64, |
| f_flags: i64, |
| f_spare: [i64; 4], |
| } |
| |
| #[derive(Debug, Default, Clone, Copy, PartialEq, Eq, AsBytes, FromBytes)] |
| #[repr(C)] |
| pub struct sigaltstack_t { |
| pub ss_sp: UserAddress, |
| pub ss_flags: u32, |
| pub _pad0: u32, |
| pub ss_size: usize, |
| } |
