Index: sys/compat/cloudabi/cloudabi_clock.c =================================================================== --- sys/compat/cloudabi/cloudabi_clock.c +++ sys/compat/cloudabi/cloudabi_clock.c @@ -0,0 +1,47 @@ +/*- + * Copyright (c) 2015 Nuxi, https://nuxi.nl/ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +__FBSDID("$FreeBSD$"); + +#include + +int +cloudabi_sys_clock_res_get(struct thread *td, + struct cloudabi_sys_clock_res_get_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_clock_time_get(struct thread *td, + struct cloudabi_sys_clock_time_get_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} Index: sys/compat/cloudabi/cloudabi_fd.c =================================================================== --- sys/compat/cloudabi/cloudabi_fd.c +++ sys/compat/cloudabi/cloudabi_fd.c @@ -0,0 +1,115 @@ +/*- + * Copyright (c) 2015 Nuxi, https://nuxi.nl/ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +__FBSDID("$FreeBSD$"); + +#include + +int +cloudabi_sys_fd_close(struct thread *td, struct cloudabi_sys_fd_close_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_fd_create1(struct thread *td, + struct cloudabi_sys_fd_create1_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_fd_create2(struct thread *td, + struct cloudabi_sys_fd_create2_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_fd_datasync(struct thread *td, + struct cloudabi_sys_fd_datasync_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_fd_dup(struct thread *td, struct cloudabi_sys_fd_dup_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_fd_replace(struct thread *td, + struct cloudabi_sys_fd_replace_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_fd_seek(struct thread *td, struct cloudabi_sys_fd_seek_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_fd_stat_get(struct thread *td, + struct cloudabi_sys_fd_stat_get_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_fd_stat_put(struct thread *td, + struct cloudabi_sys_fd_stat_put_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_fd_sync(struct thread *td, struct cloudabi_sys_fd_sync_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} Index: sys/compat/cloudabi/cloudabi_file.c =================================================================== --- sys/compat/cloudabi/cloudabi_file.c +++ sys/compat/cloudabi/cloudabi_file.c @@ -0,0 +1,155 @@ +/*- + * Copyright (c) 2015 Nuxi, https://nuxi.nl/ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +__FBSDID("$FreeBSD$"); + +#include + +int +cloudabi_sys_file_advise(struct thread *td, + struct cloudabi_sys_file_advise_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_file_allocate(struct thread *td, + struct cloudabi_sys_file_allocate_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_file_create(struct thread *td, + struct cloudabi_sys_file_create_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_file_link(struct thread *td, + struct cloudabi_sys_file_link_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_file_open(struct thread *td, + struct cloudabi_sys_file_open_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_file_readdir(struct thread *td, + struct cloudabi_sys_file_readdir_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_file_readlink(struct thread *td, + struct cloudabi_sys_file_readlink_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_file_rename(struct thread *td, + struct cloudabi_sys_file_rename_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_file_stat_fget(struct thread *td, + struct cloudabi_sys_file_stat_fget_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_file_stat_fput(struct thread *td, + struct cloudabi_sys_file_stat_fput_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_file_stat_get(struct thread *td, + struct cloudabi_sys_file_stat_get_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_file_stat_put(struct thread *td, + struct cloudabi_sys_file_stat_put_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_file_symlink(struct thread *td, + struct cloudabi_sys_file_symlink_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_file_unlink(struct thread *td, + struct cloudabi_sys_file_unlink_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} Index: sys/compat/cloudabi/cloudabi_futex.c =================================================================== --- sys/compat/cloudabi/cloudabi_futex.c +++ sys/compat/cloudabi/cloudabi_futex.c @@ -0,0 +1,47 @@ +/*- + * Copyright (c) 2015 Nuxi, https://nuxi.nl/ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +__FBSDID("$FreeBSD$"); + +#include + +int +cloudabi_sys_condvar_signal(struct thread *td, + struct cloudabi_sys_condvar_signal_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_lock_unlock(struct thread *td, + struct cloudabi_sys_lock_unlock_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} Index: sys/compat/cloudabi/cloudabi_mem.c =================================================================== --- sys/compat/cloudabi/cloudabi_mem.c +++ sys/compat/cloudabi/cloudabi_mem.c @@ -0,0 +1,89 @@ +/*- + * Copyright (c) 2015 Nuxi, https://nuxi.nl/ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +__FBSDID("$FreeBSD$"); + +#include + +int +cloudabi_sys_mem_advise(struct thread *td, + struct cloudabi_sys_mem_advise_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_mem_lock(struct thread *td, struct cloudabi_sys_mem_lock_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_mem_map(struct thread *td, struct cloudabi_sys_mem_map_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_mem_protect(struct thread *td, + struct cloudabi_sys_mem_protect_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_mem_sync(struct thread *td, struct cloudabi_sys_mem_sync_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_mem_unlock(struct thread *td, + struct cloudabi_sys_mem_unlock_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_mem_unmap(struct thread *td, + struct cloudabi_sys_mem_unmap_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} Index: sys/compat/cloudabi/cloudabi_proc.c =================================================================== --- sys/compat/cloudabi/cloudabi_proc.c +++ sys/compat/cloudabi/cloudabi_proc.c @@ -0,0 +1,65 @@ +/*- + * Copyright (c) 2015 Nuxi, https://nuxi.nl/ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +__FBSDID("$FreeBSD$"); + +#include + +int +cloudabi_sys_proc_exec(struct thread *td, + struct cloudabi_sys_proc_exec_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_proc_exit(struct thread *td, + struct cloudabi_sys_proc_exit_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_proc_fork(struct thread *td, + struct cloudabi_sys_proc_fork_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_proc_raise(struct thread *td, + struct cloudabi_sys_proc_raise_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} Index: sys/compat/cloudabi/cloudabi_proto.h =================================================================== --- sys/compat/cloudabi/cloudabi_proto.h +++ sys/compat/cloudabi/cloudabi_proto.h @@ -0,0 +1,34 @@ +/*- + * Copyright (c) 2015 Nuxi, https://nuxi.nl/ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +/* + * This should provide all prototypes for the machine-independent system + * calls. Unfortunately, we don't have a separate system call table for + * those, so rely on the system call table from COMPAT_CLOUDABI64. + */ +#include +#include Index: sys/compat/cloudabi/cloudabi_random.c =================================================================== --- sys/compat/cloudabi/cloudabi_random.c +++ sys/compat/cloudabi/cloudabi_random.c @@ -0,0 +1,38 @@ +/*- + * Copyright (c) 2015 Nuxi, https://nuxi.nl/ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +__FBSDID("$FreeBSD$"); + +#include + +int +cloudabi_sys_random_get(struct thread *td, + struct cloudabi_sys_random_get_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} Index: sys/compat/cloudabi/cloudabi_sock.c =================================================================== --- sys/compat/cloudabi/cloudabi_sock.c +++ sys/compat/cloudabi/cloudabi_sock.c @@ -0,0 +1,83 @@ +/*- + * Copyright (c) 2015 Nuxi, https://nuxi.nl/ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +__FBSDID("$FreeBSD$"); + +#include + +int +cloudabi_sys_sock_accept(struct thread *td, + struct cloudabi_sys_sock_accept_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_sock_bind(struct thread *td, + struct cloudabi_sys_sock_bind_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_sock_connect(struct thread *td, + struct cloudabi_sys_sock_connect_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_sock_listen(struct thread *td, + struct cloudabi_sys_sock_listen_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_sock_shutdown(struct thread *td, + struct cloudabi_sys_sock_shutdown_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_sock_stat_get(struct thread *td, + struct cloudabi_sys_sock_stat_get_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} Index: sys/compat/cloudabi/cloudabi_syscalldefs.h =================================================================== --- sys/compat/cloudabi/cloudabi_syscalldefs.h +++ sys/compat/cloudabi/cloudabi_syscalldefs.h @@ -0,0 +1,40 @@ +/*- + * Copyright (c) 2015 Nuxi, https://nuxi.nl/ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +#ifndef _CLOUDABI_SYSCALLDEFS_H_ +#define _CLOUDABI_SYSCALLDEFS_H_ + +#include + +#define alignas _Alignas +#define alignof _Alignof +#define static_assert _Static_assert + +/* Import machine-independent CloudABI definitions. */ +#include + +#endif Index: sys/compat/cloudabi/cloudabi_thread.c =================================================================== --- sys/compat/cloudabi/cloudabi_thread.c +++ sys/compat/cloudabi/cloudabi_thread.c @@ -0,0 +1,47 @@ +/*- + * Copyright (c) 2015 Nuxi, https://nuxi.nl/ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +__FBSDID("$FreeBSD$"); + +#include + +int +cloudabi_sys_thread_exit(struct thread *td, + struct cloudabi_sys_thread_exit_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi_sys_thread_yield(struct thread *td, + struct cloudabi_sys_thread_yield_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} Index: sys/compat/cloudabi64/Makefile =================================================================== --- sys/compat/cloudabi64/Makefile +++ sys/compat/cloudabi64/Makefile @@ -0,0 +1,12 @@ +# $FreeBSD$ + +all: + @echo "make sysent only" + +sysent: cloudabi64_sysent.c cloudabi64_syscall.h cloudabi64_proto.h \ + cloudabi64_syscalls.c cloudabi64_systrace_args.c + +cloudabi64_sysent.c cloudabi64_syscall.h cloudabi64_proto.h \ + cloudabi64_syscalls.c cloudabi64_systrace_args.c: \ + ../../kern/makesyscalls.sh syscalls.master syscalls.conf + sh ../../kern/makesyscalls.sh syscalls.master syscalls.conf Index: sys/compat/cloudabi64/cloudabi64_fd.c =================================================================== --- sys/compat/cloudabi64/cloudabi64_fd.c +++ sys/compat/cloudabi64/cloudabi64_fd.c @@ -0,0 +1,66 @@ +/*- + * Copyright (c) 2015 Nuxi, https://nuxi.nl/ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +__FBSDID("$FreeBSD$"); + +#include +#include + +int +cloudabi64_sys_fd_pread(struct thread *td, + struct cloudabi64_sys_fd_pread_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi64_sys_fd_pwrite(struct thread *td, + struct cloudabi64_sys_fd_pwrite_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi64_sys_fd_read(struct thread *td, + struct cloudabi64_sys_fd_read_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi64_sys_fd_write(struct thread *td, + struct cloudabi64_sys_fd_write_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} Index: sys/compat/cloudabi64/cloudabi64_poll.c =================================================================== --- sys/compat/cloudabi64/cloudabi64_poll.c +++ sys/compat/cloudabi64/cloudabi64_poll.c @@ -0,0 +1,38 @@ +/*- + * Copyright (c) 2015 Nuxi, https://nuxi.nl/ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +__FBSDID("$FreeBSD$"); + +#include +#include + +int +cloudabi64_sys_poll(struct thread *td, struct cloudabi64_sys_poll_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} Index: sys/compat/cloudabi64/cloudabi64_sock.c =================================================================== --- sys/compat/cloudabi64/cloudabi64_sock.c +++ sys/compat/cloudabi64/cloudabi64_sock.c @@ -0,0 +1,48 @@ +/*- + * Copyright (c) 2015 Nuxi, https://nuxi.nl/ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +__FBSDID("$FreeBSD$"); + +#include +#include + +int +cloudabi64_sys_sock_recv(struct thread *td, + struct cloudabi64_sys_sock_recv_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi64_sys_sock_send(struct thread *td, + struct cloudabi64_sys_sock_send_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} Index: sys/compat/cloudabi64/cloudabi64_syscalldefs.h =================================================================== --- sys/compat/cloudabi64/cloudabi64_syscalldefs.h +++ sys/compat/cloudabi64/cloudabi64_syscalldefs.h @@ -0,0 +1,45 @@ +/*- + * Copyright (c) 2015 Nuxi, https://nuxi.nl/ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +#ifndef _CLOUDABI64_SYSCALLDEFS_H_ +#define _CLOUDABI64_SYSCALLDEFS_H_ + +#include + +#include + +typedef uint64_t cloudabi64_size_t; +typedef uint64_t cloudabi64_uintptr_t; + +/* Import machine-dependent CloudABI definitions for 64-bit systems. */ +#define IDENT(ident) cloudabi64_##ident +#define PTR(type) cloudabi64_uintptr_t +#include +#undef IDENT +#undef PTR + +#endif Index: sys/compat/cloudabi64/cloudabi64_thread.c =================================================================== --- sys/compat/cloudabi64/cloudabi64_thread.c +++ sys/compat/cloudabi64/cloudabi64_thread.c @@ -0,0 +1,48 @@ +/*- + * Copyright (c) 2015 Nuxi, https://nuxi.nl/ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +__FBSDID("$FreeBSD$"); + +#include +#include + +int +cloudabi64_sys_thread_create(struct thread *td, + struct cloudabi64_sys_thread_create_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} + +int +cloudabi64_sys_thread_tcb_set(struct thread *td, + struct cloudabi64_sys_thread_tcb_set_args *uap) +{ + + /* Not implemented. */ + return (ENOSYS); +} Index: sys/compat/cloudabi64/syscalls.conf =================================================================== --- sys/compat/cloudabi64/syscalls.conf +++ sys/compat/cloudabi64/syscalls.conf @@ -0,0 +1,14 @@ +# $FreeBSD$ +sysnames="cloudabi64_syscalls.c" +sysproto="cloudabi64_proto.h" +sysproto_h=_CLOUDABI64_SYSPROTO_H_ +syshdr="cloudabi64_syscall.h" +syssw="cloudabi64_sysent.c" +sysmk="/dev/null" +syscallprefix="CLOUDABI64_SYS_" +switchname="cloudabi64_sysent" +namesname="cloudabi64_syscallnames" +systrace="cloudabi64_systrace_args.c" + +# Allow all system calls in capabilities mode. +capenabled=`sed -n -e 's/.*\<\(cloudabi[0-9]*_sys_[a-z0-9_]*\)\>.*/\1/p' syscalls.master | tr '\n' ','` Index: sys/compat/cloudabi64/syscalls.master =================================================================== --- sys/compat/cloudabi64/syscalls.master +++ sys/compat/cloudabi64/syscalls.master @@ -0,0 +1,212 @@ + $FreeBSD$ + +; System call table for CloudABI. +; +; All system calls that do not use any machine-dependent data types are +; prefixed with cloudabi_sys_. The others are called cloudabi64_sys_. + +#include +#include + +#include +#include + +0 AUE_NULL STD { cloudabi_timestamp_t \ + cloudabi_sys_clock_res_get( \ + cloudabi_clockid_t clock_id); } +1 AUE_NULL STD { cloudabi_timestamp_t \ + cloudabi_sys_clock_time_get( \ + cloudabi_clockid_t clock_id, \ + cloudabi_timestamp_t precision); } + +2 AUE_NULL STD { void cloudabi_sys_condvar_signal( \ + cloudabi_condvar_t *condvar, \ + cloudabi_nthreads_t nwaiters); } + +3 AUE_NULL STD { void cloudabi_sys_fd_close( \ + cloudabi_fd_t fd); } +4 AUE_NULL STD { cloudabi_fd_t cloudabi_sys_fd_create1( \ + cloudabi_filetype_t type); } +5 AUE_NULL STD { void cloudabi_sys_fd_create2( \ + cloudabi_filetype_t type); } +6 AUE_NULL STD { void cloudabi_sys_fd_datasync( \ + cloudabi_fd_t fd); } +7 AUE_NULL STD { cloudabi_fd_t cloudabi_sys_fd_dup( \ + cloudabi_fd_t from); } +8 AUE_NULL STD { cloudabi64_size_t cloudabi64_sys_fd_pread( \ + cloudabi_fd_t fd, \ + const cloudabi64_iovec_t *iov, \ + cloudabi64_size_t iovcnt, \ + cloudabi_filesize_t offset); } +9 AUE_NULL STD { cloudabi64_size_t cloudabi64_sys_fd_pwrite( \ + cloudabi_fd_t fd, \ + const cloudabi64_ciovec_t *iov, \ + cloudabi64_size_t iovcnt, \ + cloudabi_filesize_t offset); } +10 AUE_NULL STD { cloudabi64_size_t cloudabi64_sys_fd_read( \ + cloudabi_fd_t fd, \ + const cloudabi64_iovec_t *iov, \ + cloudabi64_size_t iovcnt); } +11 AUE_NULL STD { void cloudabi_sys_fd_replace( \ + cloudabi_fd_t from, \ + cloudabi_fd_t to); } +12 AUE_NULL STD { cloudabi_filesize_t cloudabi_sys_fd_seek( \ + cloudabi_fd_t fd, \ + cloudabi_filedelta_t offset, \ + cloudabi_whence_t whence); } +13 AUE_NULL STD { void cloudabi_sys_fd_stat_get( \ + cloudabi_fd_t fd, \ + cloudabi_fdstat_t *buf); } +14 AUE_NULL STD { void cloudabi_sys_fd_stat_put( \ + cloudabi_fd_t fd, \ + const cloudabi_fdstat_t *buf, \ + cloudabi_fdsflags_t flags); } +15 AUE_NULL STD { void cloudabi_sys_fd_sync( \ + cloudabi_fd_t fd); } +16 AUE_NULL STD { cloudabi64_size_t cloudabi64_sys_fd_write( \ + cloudabi_fd_t fd, \ + const cloudabi64_ciovec_t *iov, \ + cloudabi64_size_t iovcnt); } + +17 AUE_NULL STD { void cloudabi_sys_file_advise( \ + cloudabi_fd_t fd, \ + cloudabi_filesize_t offset, \ + cloudabi_filesize_t len, \ + cloudabi_advice_t advice); } +18 AUE_NULL STD { void cloudabi_sys_file_allocate( \ + cloudabi_fd_t fd, \ + cloudabi_filesize_t offset, \ + cloudabi_filesize_t len); } +19 AUE_NULL STD { void cloudabi_sys_file_create( \ + cloudabi_fd_t fd, \ + const char *path, size_t pathlen, \ + cloudabi_filetype_t type); } +20 AUE_NULL STD { void cloudabi_sys_file_link( \ + cloudabi_lookup_t fd1, \ + const char *path1, size_t path1len, \ + cloudabi_fd_t fd2, \ + const char *path2, size_t path2len); } +21 AUE_NULL STD { cloudabi_fd_t cloudabi_sys_file_open( \ + cloudabi_lookup_t fd, \ + const char *path, size_t pathlen, \ + cloudabi_oflags_t oflags, \ + const cloudabi_fdstat_t *fds); } +22 AUE_NULL STD { size_t cloudabi_sys_file_readdir( \ + cloudabi_fd_t fd, \ + void *buf, size_t nbyte, \ + cloudabi_dircookie_t cookie); } +23 AUE_NULL STD { size_t cloudabi_sys_file_readlink( \ + cloudabi_fd_t fd, \ + const char *path, size_t pathlen, \ + void *buf, size_t bufsize); } +24 AUE_NULL STD { void cloudabi_sys_file_rename( \ + cloudabi_fd_t oldfd, \ + const char *old, size_t oldlen, \ + cloudabi_fd_t newfd, \ + const char *new, size_t newlen); } +25 AUE_NULL STD { void cloudabi_sys_file_stat_fget( \ + cloudabi_fd_t fd, \ + cloudabi_filestat_t *buf); } +26 AUE_NULL STD { void cloudabi_sys_file_stat_fput( \ + cloudabi_fd_t fd, \ + const cloudabi_filestat_t *buf, \ + cloudabi_fsflags_t flags); } +27 AUE_NULL STD { void cloudabi_sys_file_stat_get( \ + cloudabi_lookup_t fd, \ + const char *path, size_t pathlen, \ + cloudabi_filestat_t *buf); } +28 AUE_NULL STD { void cloudabi_sys_file_stat_put( \ + cloudabi_lookup_t fd, \ + const char *path, size_t pathlen, \ + const cloudabi_filestat_t *buf, \ + cloudabi_fsflags_t flags); } +29 AUE_NULL STD { void cloudabi_sys_file_symlink( \ + const char *path1, size_t path1len, \ + cloudabi_fd_t fd, \ + const char *path2, size_t path2len); } +30 AUE_NULL STD { void cloudabi_sys_file_unlink( \ + cloudabi_fd_t fd, \ + const char *path, size_t pathlen, \ + cloudabi_ulflags_t flag); } + +31 AUE_NULL STD { void cloudabi_sys_lock_unlock( \ + cloudabi_lock_t *lock); } + +32 AUE_NULL STD { void cloudabi_sys_mem_advise( \ + void *addr, size_t len, \ + cloudabi_advice_t advice); } +33 AUE_NULL STD { void cloudabi_sys_mem_lock( \ + const void *addr, size_t len); } +34 AUE_NULL STD { void cloudabi_sys_mem_map( \ + void *addr, size_t len, \ + cloudabi_mprot_t prot, \ + cloudabi_mflags_t flags, \ + cloudabi_fd_t fd, \ + cloudabi_filesize_t off); } +35 AUE_NULL STD { void cloudabi_sys_mem_protect( \ + void *addr, size_t len, \ + cloudabi_mprot_t prot); } +36 AUE_NULL STD { void cloudabi_sys_mem_sync( \ + void *addr, size_t len, \ + cloudabi_msflags_t flags); } +37 AUE_NULL STD { void cloudabi_sys_mem_unlock( \ + const void *addr, size_t len); } +38 AUE_NULL STD { void cloudabi_sys_mem_unmap( \ + void * addr, size_t len); } + +39 AUE_NULL STD { cloudabi64_size_t cloudabi64_sys_poll( \ + cloudabi_fd_t fd, \ + const cloudabi64_subscription_t *in, \ + cloudabi64_size_t nin, \ + cloudabi64_event_t *out, \ + cloudabi64_size_t nout); } + +40 AUE_NULL STD { void cloudabi_sys_proc_exec( \ + cloudabi_fd_t fd, const void *data, \ + size_t datalen, \ + const cloudabi_fd_t *fds, \ + size_t dslen); } +41 AUE_NULL STD { void cloudabi_sys_proc_exit( \ + cloudabi_exitcode_t rval); } +42 AUE_NULL STD { cloudabi_fd_t cloudabi_sys_proc_fork(); } +43 AUE_NULL STD { void cloudabi_sys_proc_raise( \ + cloudabi_signal_t sig); } + +44 AUE_NULL STD { void cloudabi_sys_random_get( \ + void *buf, size_t nbyte); } + +45 AUE_NULL STD { cloudabi_fd_t cloudabi_sys_sock_accept( \ + cloudabi_fd_t s, \ + cloudabi_sockstat_t *buf); } +46 AUE_NULL STD { void cloudabi_sys_sock_bind( \ + cloudabi_fd_t s, cloudabi_fd_t fd, \ + const char *path, size_t pathlen); } +47 AUE_NULL STD { void cloudabi_sys_sock_connect( \ + cloudabi_fd_t s, cloudabi_fd_t fd, \ + const char *path, size_t pathlen); } +48 AUE_NULL STD { void cloudabi_sys_sock_listen( \ + cloudabi_fd_t s, \ + cloudabi_backlog_t backlog); } +49 AUE_NULL STD { cloudabi64_size_t cloudabi64_sys_sock_recv( \ + cloudabi_fd_t s, \ + const cloudabi64_recv_in_t *in, \ + cloudabi64_recv_out_t *out); } +50 AUE_NULL STD { cloudabi64_size_t cloudabi64_sys_sock_send( \ + cloudabi_fd_t s, \ + const cloudabi64_send_in_t *in, \ + cloudabi64_send_out_t *out); } +51 AUE_NULL STD { void cloudabi_sys_sock_shutdown( \ + cloudabi_fd_t fd, \ + cloudabi_sdflags_t how); } +52 AUE_NULL STD { void cloudabi_sys_sock_stat_get( \ + cloudabi_fd_t fd, \ + cloudabi_sockstat_t *buf, \ + cloudabi_ssflags_t flags); } + +53 AUE_NULL STD { cloudabi_tid_t cloudabi64_sys_thread_create( \ + cloudabi64_threadattr_t *attr); } +54 AUE_NULL STD { void cloudabi_sys_thread_exit( \ + cloudabi_lock_t *lock); } +55 AUE_NULL STD { void cloudabi64_sys_thread_tcb_set( \ + void *tcb); } +56 AUE_NULL STD { void cloudabi_sys_thread_yield(); } Index: sys/conf/files =================================================================== --- sys/conf/files +++ sys/conf/files @@ -253,6 +253,21 @@ cddl/dev/systrace/systrace.c optional dtrace_systrace | dtraceall compile-with "${CDDL_C}" cddl/dev/prototype.c optional dtrace_prototype | dtraceall compile-with "${CDDL_C}" fs/nfsclient/nfs_clkdtrace.c optional dtnfscl nfscl | dtraceall nfscl compile-with "${CDDL_C}" +compat/cloudabi/cloudabi_clock.c optional compat_cloudabi64 +compat/cloudabi/cloudabi_fd.c optional compat_cloudabi64 +compat/cloudabi/cloudabi_file.c optional compat_cloudabi64 +compat/cloudabi/cloudabi_futex.c optional compat_cloudabi64 +compat/cloudabi/cloudabi_mem.c optional compat_cloudabi64 +compat/cloudabi/cloudabi_proc.c optional compat_cloudabi64 +compat/cloudabi/cloudabi_random.c optional compat_cloudabi64 +compat/cloudabi/cloudabi_sock.c optional compat_cloudabi64 +compat/cloudabi/cloudabi_thread.c optional compat_cloudabi64 +compat/cloudabi64/cloudabi64_fd.c optional compat_cloudabi64 +compat/cloudabi64/cloudabi64_poll.c optional compat_cloudabi64 +compat/cloudabi64/cloudabi64_sock.c optional compat_cloudabi64 +compat/cloudabi64/cloudabi64_syscalls.c optional compat_cloudabi64 +compat/cloudabi64/cloudabi64_sysent.c optional compat_cloudabi64 +compat/cloudabi64/cloudabi64_thread.c optional compat_cloudabi64 compat/freebsd32/freebsd32_capability.c optional compat_freebsd32 compat/freebsd32/freebsd32_ioctl.c optional compat_freebsd32 compat/freebsd32/freebsd32_misc.c optional compat_freebsd32 Index: sys/conf/options =================================================================== --- sys/conf/options +++ sys/conf/options @@ -85,6 +85,7 @@ COMPAT_FREEBSD7 opt_compat.h COMPAT_FREEBSD9 opt_compat.h COMPAT_FREEBSD10 opt_compat.h +COMPAT_CLOUDABI64 opt_dontuse.h COMPAT_LINUXAPI opt_compat.h COMPILING_LINT opt_global.h CY_PCI_FASTINTR Index: sys/contrib/cloudabi/syscalldefs_md.h =================================================================== --- sys/contrib/cloudabi/syscalldefs_md.h +++ sys/contrib/cloudabi/syscalldefs_md.h @@ -0,0 +1,255 @@ +// Copyright (c) 2015 Nuxi, https://nuxi.nl/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +// SUCH DAMAGE. + +// Machine dependent definitions. + +// Macro to force sane alignment rules. +// +// On x86-32 it is the case that 64-bit integers are 4-byte aligned when +// embedded in structs, even though they are 8-byte aligned when not +// embedded. Force 8-byte alignment explicitly. +#define MEMBER(type) alignas(alignof(type)) type +#define ASSERT_OFFSET(type, field, offset32, offset64) \ + static_assert((sizeof(PTR(void)) == 4 && \ + offsetof(IDENT(type), field) == (offset32)) || \ + (sizeof(PTR(void)) == 8 && \ + offsetof(IDENT(type), field) == (offset64)), \ + "Offset incorrect") +#define ASSERT_SIZE(type, size32, size64) \ + static_assert( \ + (sizeof(PTR(void)) == 4 && sizeof(IDENT(type)) == (size32)) || \ + (sizeof(PTR(void)) == 8 && sizeof(IDENT(type)) == (size64)), \ + "Size incorrect") + +typedef void IDENT(threadentry_t)(cloudabi_tid_t, PTR(void)); + +typedef struct { + MEMBER(PTR(const void)) iov_base; + MEMBER(IDENT(size_t)) iov_len; +} IDENT(ciovec_t); +ASSERT_OFFSET(ciovec_t, iov_base, 0, 0); +ASSERT_OFFSET(ciovec_t, iov_len, 4, 8); +ASSERT_SIZE(ciovec_t, 8, 16); + +typedef struct { + MEMBER(cloudabi_userdata_t) userdata; + MEMBER(cloudabi_errno_t) error; + MEMBER(cloudabi_eventtype_t) type; + union { + // CLOUDABI_EVENTTYPE_CLOCK: Wait until the value of a clock + // exceeds a value. + struct { + MEMBER(cloudabi_userdata_t) identifier; + } clock; + + // CLOUDABI_EVENTTYPE_CONDVAR: Release a lock and wait on a + // condition variable. + struct { + MEMBER(PTR(_Atomic(cloudabi_condvar_t))) condvar; + } condvar; + + // CLOUDABI_EVENTTYPE_FD_READ and CLOUDABI_EVENTTYPE_FD_WRITE: + // Wait for a file descriptor to allow read() and write() to be + // called without blocking. + struct { + MEMBER(cloudabi_filesize_t) nbytes; + MEMBER(cloudabi_fd_t) fd; + MEMBER(uint16_t) flags; + } fd_readwrite; + + // CLOUDABI_EVENT_LOCK_RDLOCK and CLOUDABI_EVENT_LOCK_WRLOCK: Wait + // and acquire a read or write lock. + struct { + MEMBER(PTR(_Atomic(cloudabi_lock_t))) lock; + } lock; + + // CLOUDABI_EVENTTYPE_PROC_TERMINATE: Wait for a process to terminate. + struct { + MEMBER(cloudabi_fd_t) fd; + MEMBER(cloudabi_signal_t) signal; // Non-zero if process got killed. + MEMBER(cloudabi_exitcode_t) exitcode; // Exit code. + } proc_terminate; + }; +} IDENT(event_t); +ASSERT_OFFSET(event_t, userdata, 0, 0); +ASSERT_OFFSET(event_t, error, 8, 8); +ASSERT_OFFSET(event_t, type, 10, 10); +ASSERT_OFFSET(event_t, clock.identifier, 16, 16); +ASSERT_OFFSET(event_t, condvar.condvar, 16, 16); +ASSERT_OFFSET(event_t, fd_readwrite.nbytes, 16, 16); +ASSERT_OFFSET(event_t, fd_readwrite.fd, 24, 24); +ASSERT_OFFSET(event_t, fd_readwrite.flags, 28, 28); +ASSERT_OFFSET(event_t, lock.lock, 16, 16); +ASSERT_OFFSET(event_t, proc_terminate.fd, 16, 16); +ASSERT_OFFSET(event_t, proc_terminate.signal, 20, 20); +ASSERT_OFFSET(event_t, proc_terminate.exitcode, 24, 24); +ASSERT_SIZE(event_t, 32, 32); + +typedef struct { + MEMBER(PTR(void)) iov_base; + MEMBER(IDENT(size_t)) iov_len; +} IDENT(iovec_t); +ASSERT_OFFSET(iovec_t, iov_base, 0, 0); +ASSERT_OFFSET(iovec_t, iov_len, 4, 8); +ASSERT_SIZE(iovec_t, 8, 16); + +typedef struct { + MEMBER(PTR(const IDENT(iovec_t))) ri_data; // Data I/O vectors. + MEMBER(IDENT(size_t)) ri_datalen; // Number of data I/O vectors. + MEMBER(PTR(cloudabi_fd_t)) ri_fds; // File descriptors. + MEMBER(IDENT(size_t)) ri_fdslen; // Number of file descriptors. + MEMBER(cloudabi_msgflags_t) ri_flags; // Input flags. +} IDENT(recv_in_t); +ASSERT_OFFSET(recv_in_t, ri_data, 0, 0); +ASSERT_OFFSET(recv_in_t, ri_datalen, 4, 8); +ASSERT_OFFSET(recv_in_t, ri_fds, 8, 16); +ASSERT_OFFSET(recv_in_t, ri_fdslen, 12, 24); +ASSERT_OFFSET(recv_in_t, ri_flags, 16, 32); +ASSERT_SIZE(recv_in_t, 20, 40); + +typedef struct { + MEMBER(IDENT(size_t)) ro_datalen; // Bytes of data received. + MEMBER(IDENT(size_t)) ro_fdslen; // Number of file descriptors received. + MEMBER(cloudabi_sockaddr_t) ro_sockname; // Address of receiver. + MEMBER(cloudabi_sockaddr_t) ro_peername; // Address of sender. + MEMBER(cloudabi_msgflags_t) ro_flags; // Output flags. +} IDENT(recv_out_t); +ASSERT_OFFSET(recv_out_t, ro_datalen, 0, 0); +ASSERT_OFFSET(recv_out_t, ro_fdslen, 4, 8); +ASSERT_OFFSET(recv_out_t, ro_sockname, 8, 16); +ASSERT_OFFSET(recv_out_t, ro_peername, 28, 36); +ASSERT_OFFSET(recv_out_t, ro_flags, 48, 56); +ASSERT_SIZE(recv_out_t, 52, 64); + +typedef struct { + MEMBER(PTR(const IDENT(ciovec_t))) si_data; // Data I/O vectors. + MEMBER(IDENT(size_t)) si_datalen; // Number of data I/O vectors. + MEMBER(PTR(const cloudabi_fd_t)) si_fds; // File descriptors. + MEMBER(IDENT(size_t)) si_fdslen; // Number of file descriptors. + MEMBER(cloudabi_msgflags_t) si_flags; // Input flags. +} IDENT(send_in_t); +ASSERT_OFFSET(send_in_t, si_data, 0, 0); +ASSERT_OFFSET(send_in_t, si_datalen, 4, 8); +ASSERT_OFFSET(send_in_t, si_fds, 8, 16); +ASSERT_OFFSET(send_in_t, si_fdslen, 12, 24); +ASSERT_OFFSET(send_in_t, si_flags, 16, 32); +ASSERT_SIZE(send_in_t, 20, 40); + +typedef struct { + MEMBER(IDENT(size_t)) so_datalen; // Bytes of data sent. +} IDENT(send_out_t); +ASSERT_OFFSET(send_out_t, so_datalen, 0, 0); +ASSERT_SIZE(send_out_t, 4, 8); + +typedef struct { + MEMBER(PTR(const void)) sd_arg; // Program argument data. + MEMBER(IDENT(size_t)) sd_arglen; // Program argument data size. + + MEMBER(PTR(void)) sd_elf_phdr; // ELF program header. + MEMBER(IDENT(size_t)) sd_elf_phdrlen; // ELF program header length. + + MEMBER(cloudabi_tid_t) sd_thread_id; // Thread ID. + MEMBER(uint64_t) sd_random_seed; // Random seed, used for SSP. + + MEMBER(uint32_t) sd_ncpus; // Number of CPUs. + MEMBER(uint32_t) sd_pagesize; // Page size. +} IDENT(startup_data_t); +ASSERT_OFFSET(startup_data_t, sd_arg, 0, 0); +ASSERT_OFFSET(startup_data_t, sd_arglen, 4, 8); +ASSERT_OFFSET(startup_data_t, sd_elf_phdr, 8, 16); +ASSERT_OFFSET(startup_data_t, sd_elf_phdrlen, 12, 24); +ASSERT_OFFSET(startup_data_t, sd_thread_id, 16, 32); +ASSERT_OFFSET(startup_data_t, sd_random_seed, 24, 40); +ASSERT_OFFSET(startup_data_t, sd_ncpus, 32, 48); +ASSERT_OFFSET(startup_data_t, sd_pagesize, 36, 52); +ASSERT_SIZE(startup_data_t, 40, 56); + +typedef struct { + MEMBER(cloudabi_userdata_t) userdata; + MEMBER(uint16_t) flags; + MEMBER(cloudabi_eventtype_t) type; + union { + // CLOUDABI_EVENTTYPE_CLOCK: Wait until the value of a clock + // exceeds a value. + struct { + MEMBER(cloudabi_userdata_t) identifier; + MEMBER(cloudabi_clockid_t) clock_id; + MEMBER(cloudabi_timestamp_t) timeout; + MEMBER(cloudabi_timestamp_t) precision; + } clock; + + // CLOUDABI_EVENTTYPE_CONDVAR: Release a lock and wait on a + // condition variable. + struct { + MEMBER(PTR(_Atomic(cloudabi_condvar_t))) condvar; + MEMBER(PTR(_Atomic(cloudabi_lock_t))) lock; + } condvar; + + // CLOUDABI_EVENTTYPE_FD_READ and CLOUDABI_EVENTTYPE_FD_WRITE: + // Wait for a file descriptor to allow read() and write() to be + // called without blocking. + struct { + MEMBER(cloudabi_fd_t) fd; + } fd_readwrite; + + // CLOUDABI_EVENT_LOCK_RDLOCK and CLOUDABI_EVENT_LOCK_WRLOCK: Wait + // and acquire a read or write lock. + struct { + MEMBER(PTR(_Atomic(cloudabi_lock_t))) lock; + } lock; + + // CLOUDABI_EVENTTYPE_PROC_TERMINATE: Wait for a process to terminate. + struct { + MEMBER(cloudabi_fd_t) fd; + } proc_terminate; + }; +} IDENT(subscription_t); +ASSERT_OFFSET(subscription_t, userdata, 0, 0); +ASSERT_OFFSET(subscription_t, flags, 8, 8); +ASSERT_OFFSET(subscription_t, type, 10, 10); +ASSERT_OFFSET(subscription_t, clock.identifier, 16, 16); +ASSERT_OFFSET(subscription_t, clock.clock_id, 24, 24); +ASSERT_OFFSET(subscription_t, clock.timeout, 32, 32); +ASSERT_OFFSET(subscription_t, clock.precision, 40, 40); +ASSERT_OFFSET(subscription_t, condvar.condvar, 16, 16); +ASSERT_OFFSET(subscription_t, condvar.lock, 20, 24); +ASSERT_OFFSET(subscription_t, fd_readwrite.fd, 16, 16); +ASSERT_OFFSET(subscription_t, lock.lock, 16, 16); +ASSERT_OFFSET(subscription_t, proc_terminate.fd, 16, 16); +ASSERT_SIZE(subscription_t, 48, 48); + +typedef struct { + MEMBER(PTR(IDENT(threadentry_t))) entry_point; // Entry point. + MEMBER(PTR(void)) stack; // Pointer to stack buffer. + MEMBER(IDENT(size_t)) stack_size; // Size of stack buffer. + MEMBER(PTR(void)) argument; // Argument to be passed to entry point. +} IDENT(threadattr_t); +ASSERT_OFFSET(threadattr_t, entry_point, 0, 0); +ASSERT_OFFSET(threadattr_t, stack, 4, 8); +ASSERT_OFFSET(threadattr_t, stack_size, 8, 16); +ASSERT_OFFSET(threadattr_t, argument, 12, 24); +ASSERT_SIZE(threadattr_t, 16, 32); + +#undef MEMBER +#undef ASSERT_OFFSET +#undef ASSERT_SIZE Index: sys/contrib/cloudabi/syscalldefs_mi.h =================================================================== --- sys/contrib/cloudabi/syscalldefs_mi.h +++ sys/contrib/cloudabi/syscalldefs_mi.h @@ -0,0 +1,457 @@ +// Copyright (c) 2015 Nuxi, https://nuxi.nl/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +// SUCH DAMAGE. + +#ifndef COMMON_SYSCALLDEFS_MI_H +#define COMMON_SYSCALLDEFS_MI_H + +// Machine independent definitions. + +// Socket address families. +#define CLOUDABI_AF_UNSPEC 0 +#define CLOUDABI_AF_INET 1 +#define CLOUDABI_AF_INET6 2 +#define CLOUDABI_AF_UNIX 3 + +// File and memory I/O advice. +#define CLOUDABI_ADVICE_DONTNEED 1 +#define CLOUDABI_ADVICE_NOREUSE 2 +#define CLOUDABI_ADVICE_NORMAL 3 +#define CLOUDABI_ADVICE_RANDOM 4 +#define CLOUDABI_ADVICE_SEQUENTIAL 5 +#define CLOUDABI_ADVICE_WILLNEED 6 + +// Clocks. +#define CLOUDABI_CLOCK_MONOTONIC 1 +#define CLOUDABI_CLOCK_PROCESS_CPUTIME_ID 2 +#define CLOUDABI_CLOCK_REALTIME 3 +#define CLOUDABI_CLOCK_THREAD_CPUTIME_ID 4 + +// Condition variables. +#define CLOUDABI_CONDVAR_HAS_NO_WAITERS 0 + +// The start of a directory, to be passed to readdir(). +#define CLOUDABI_DIRCOOKIE_START 0 + +// POSIX standard error numbers. +#define CLOUDABI_E2BIG 1 +#define CLOUDABI_EACCES 2 +#define CLOUDABI_EADDRINUSE 3 +#define CLOUDABI_EADDRNOTAVAIL 4 +#define CLOUDABI_EAFNOSUPPORT 5 +#define CLOUDABI_EAGAIN 6 +#define CLOUDABI_EALREADY 7 +#define CLOUDABI_EBADF 8 +#define CLOUDABI_EBADMSG 9 +#define CLOUDABI_EBUSY 10 +#define CLOUDABI_ECANCELED 11 +#define CLOUDABI_ECHILD 12 +#define CLOUDABI_ECONNABORTED 13 +#define CLOUDABI_ECONNREFUSED 14 +#define CLOUDABI_ECONNRESET 15 +#define CLOUDABI_EDEADLK 16 +#define CLOUDABI_EDESTADDRREQ 17 +#define CLOUDABI_EDOM 18 +#define CLOUDABI_EDQUOT 19 +#define CLOUDABI_EEXIST 20 +#define CLOUDABI_EFAULT 21 +#define CLOUDABI_EFBIG 22 +#define CLOUDABI_EHOSTUNREACH 23 +#define CLOUDABI_EIDRM 24 +#define CLOUDABI_EILSEQ 25 +#define CLOUDABI_EINPROGRESS 26 +#define CLOUDABI_EINTR 27 +#define CLOUDABI_EINVAL 28 +#define CLOUDABI_EIO 29 +#define CLOUDABI_EISCONN 30 +#define CLOUDABI_EISDIR 31 +#define CLOUDABI_ELOOP 32 +#define CLOUDABI_EMFILE 33 +#define CLOUDABI_EMLINK 34 +#define CLOUDABI_EMSGSIZE 35 +#define CLOUDABI_EMULTIHOP 36 +#define CLOUDABI_ENAMETOOLONG 37 +#define CLOUDABI_ENETDOWN 38 +#define CLOUDABI_ENETRESET 39 +#define CLOUDABI_ENETUNREACH 40 +#define CLOUDABI_ENFILE 41 +#define CLOUDABI_ENOBUFS 42 +#define CLOUDABI_ENODEV 43 +#define CLOUDABI_ENOENT 44 +#define CLOUDABI_ENOEXEC 45 +#define CLOUDABI_ENOLCK 46 +#define CLOUDABI_ENOLINK 47 +#define CLOUDABI_ENOMEM 48 +#define CLOUDABI_ENOMSG 49 +#define CLOUDABI_ENOPROTOOPT 50 +#define CLOUDABI_ENOSPC 51 +#define CLOUDABI_ENOSYS 52 +#define CLOUDABI_ENOTCONN 53 +#define CLOUDABI_ENOTDIR 54 +#define CLOUDABI_ENOTEMPTY 55 +#define CLOUDABI_ENOTRECOVERABLE 56 +#define CLOUDABI_ENOTSOCK 57 +#define CLOUDABI_ENOTSUP 58 +#define CLOUDABI_ENOTTY 59 +#define CLOUDABI_ENXIO 60 +#define CLOUDABI_EOVERFLOW 61 +#define CLOUDABI_EOWNERDEAD 62 +#define CLOUDABI_EPERM 63 +#define CLOUDABI_EPIPE 64 +#define CLOUDABI_EPROTO 65 +#define CLOUDABI_EPROTONOSUPPORT 66 +#define CLOUDABI_EPROTOTYPE 67 +#define CLOUDABI_ERANGE 68 +#define CLOUDABI_EROFS 69 +#define CLOUDABI_ESPIPE 70 +#define CLOUDABI_ESRCH 71 +#define CLOUDABI_ESTALE 72 +#define CLOUDABI_ETIMEDOUT 73 +#define CLOUDABI_ETXTBSY 74 +#define CLOUDABI_EXDEV 75 + +// Non-standard error numbers. +#define CLOUDABI_ENOTCAPABLE 76 + +#define CLOUDABI_EVENT_FD_READWRITE_HANGUP 0x1 + +// Filter types for cloudabi_eventtype_t. +#define CLOUDABI_EVENTTYPE_CLOCK 1 +#define CLOUDABI_EVENTTYPE_CONDVAR 2 +#define CLOUDABI_EVENTTYPE_FD_READ 3 +#define CLOUDABI_EVENTTYPE_FD_WRITE 4 +#define CLOUDABI_EVENTTYPE_LOCK_RDLOCK 5 +#define CLOUDABI_EVENTTYPE_LOCK_WRLOCK 6 +#define CLOUDABI_EVENTTYPE_PROC_TERMINATE 7 + +// File descriptor behavior flags. +#define CLOUDABI_FDFLAG_APPEND 0x1 +#define CLOUDABI_FDFLAG_DSYNC 0x2 +#define CLOUDABI_FDFLAG_NONBLOCK 0x4 +#define CLOUDABI_FDFLAG_RSYNC 0x8 +#define CLOUDABI_FDFLAG_SYNC 0x10 + +// fdstat_put() flags. +#define CLOUDABI_FDSTAT_FLAGS 0x1 +#define CLOUDABI_FDSTAT_RIGHTS 0x2 + +// filestat_put() flags. +#define CLOUDABI_FILESTAT_ATIM 0x1 +#define CLOUDABI_FILESTAT_ATIM_NOW 0x2 +#define CLOUDABI_FILESTAT_MTIM 0x4 +#define CLOUDABI_FILESTAT_MTIM_NOW 0x8 +#define CLOUDABI_FILESTAT_SIZE 0x10 + +// File types returned through struct stat::st_mode. +#define CLOUDABI_FILETYPE_UNKNOWN 0 +#define CLOUDABI_FILETYPE_BLOCK_DEVICE 0x10 +#define CLOUDABI_FILETYPE_CHARACTER_DEVICE 0x11 +#define CLOUDABI_FILETYPE_DIRECTORY 0x20 +#define CLOUDABI_FILETYPE_FIFO 0x30 +#define CLOUDABI_FILETYPE_POLL 0x40 +#define CLOUDABI_FILETYPE_PROCESS 0x50 +#define CLOUDABI_FILETYPE_REGULAR_FILE 0x60 +#define CLOUDABI_FILETYPE_SHARED_MEMORY 0x70 +#define CLOUDABI_FILETYPE_SOCKET_DGRAM 0x80 +#define CLOUDABI_FILETYPE_SOCKET_SEQPACKET 0x81 +#define CLOUDABI_FILETYPE_SOCKET_STREAM 0x82 +#define CLOUDABI_FILETYPE_SYMBOLIC_LINK 0x90 + +// Read-write lock related constants. +#define CLOUDABI_LOCK_UNLOCKED 0 // Lock is unlocked. +#define CLOUDABI_LOCK_WRLOCKED 0x40000000 // Lock is write locked. +#define CLOUDABI_LOCK_KERNEL_MANAGED 0x80000000 // Lock has waiters. +#define CLOUDABI_LOCK_BOGUS 0x80000000 // Lock is broken. + +// Lookup properties for *at() functions. +#define CLOUDABI_LOOKUP_SYMLINK_FOLLOW (UINT64_C(0x1) << 32) + +// Open flags for openat(), etc. +#define CLOUDABI_O_CREAT 0x1 +#define CLOUDABI_O_DIRECTORY 0x2 +#define CLOUDABI_O_EXCL 0x4 +#define CLOUDABI_O_TRUNC 0x8 + +// File descriptor passed to poll() to poll just once. +#define CLOUDABI_POLL_ONCE 0xffffffff + +// File descriptor returned to pdfork()'s child process. +#define CLOUDABI_PROCESS_CHILD 0xffffffff + +// mmap() map flags. +#define CLOUDABI_MAP_ANON 0x1 +#define CLOUDABI_MAP_FIXED 0x2 +#define CLOUDABI_MAP_PRIVATE 0x4 +#define CLOUDABI_MAP_SHARED 0x8 + +// msync() flags. +#define CLOUDABI_MS_ASYNC 0x1 +#define CLOUDABI_MS_INVALIDATE 0x2 +#define CLOUDABI_MS_SYNC 0x4 + +// send() and recv() flags. +#define CLOUDABI_MSG_CTRUNC 0x1 // Control data truncated. +#define CLOUDABI_MSG_EOR 0x2 // Terminates a record. +#define CLOUDABI_MSG_PEEK 0x4 // Leave received data in queue. +#define CLOUDABI_MSG_TRUNC 0x8 // Normal data truncated. +#define CLOUDABI_MSG_WAITALL 0x10 // Attempt to fill the read buffer. + +// mmap()/mprotect() protection flags. +#define CLOUDABI_PROT_EXEC 0x1 +#define CLOUDABI_PROT_WRITE 0x2 +#define CLOUDABI_PROT_READ 0x4 + +// File descriptor capabilities/rights. +#define CLOUDABI_RIGHT_BIT(bit) (UINT64_C(1) << (bit)) +#define CLOUDABI_RIGHT_FD_DATASYNC CLOUDABI_RIGHT_BIT(0) +#define CLOUDABI_RIGHT_FD_READ CLOUDABI_RIGHT_BIT(1) +#define CLOUDABI_RIGHT_FD_SEEK CLOUDABI_RIGHT_BIT(2) +#define CLOUDABI_RIGHT_FD_STAT_PUT_FLAGS CLOUDABI_RIGHT_BIT(3) +#define CLOUDABI_RIGHT_FD_SYNC CLOUDABI_RIGHT_BIT(4) +#define CLOUDABI_RIGHT_FD_TELL CLOUDABI_RIGHT_BIT(5) +#define CLOUDABI_RIGHT_FD_WRITE CLOUDABI_RIGHT_BIT(6) +#define CLOUDABI_RIGHT_FILE_ADVISE CLOUDABI_RIGHT_BIT(7) +#define CLOUDABI_RIGHT_FILE_ALLOCATE CLOUDABI_RIGHT_BIT(8) +#define CLOUDABI_RIGHT_FILE_CREATE_DIRECTORY CLOUDABI_RIGHT_BIT(9) +#define CLOUDABI_RIGHT_FILE_CREATE_FILE CLOUDABI_RIGHT_BIT(10) +#define CLOUDABI_RIGHT_FILE_CREATE_FIFO CLOUDABI_RIGHT_BIT(11) +#define CLOUDABI_RIGHT_FILE_LINK_SOURCE CLOUDABI_RIGHT_BIT(12) +#define CLOUDABI_RIGHT_FILE_LINK_TARGET CLOUDABI_RIGHT_BIT(13) +#define CLOUDABI_RIGHT_FILE_OPEN CLOUDABI_RIGHT_BIT(14) +#define CLOUDABI_RIGHT_FILE_READDIR CLOUDABI_RIGHT_BIT(15) +#define CLOUDABI_RIGHT_FILE_READLINK CLOUDABI_RIGHT_BIT(16) +#define CLOUDABI_RIGHT_FILE_RENAME_SOURCE CLOUDABI_RIGHT_BIT(17) +#define CLOUDABI_RIGHT_FILE_RENAME_TARGET CLOUDABI_RIGHT_BIT(18) +#define CLOUDABI_RIGHT_FILE_STAT_FGET CLOUDABI_RIGHT_BIT(19) +#define CLOUDABI_RIGHT_FILE_STAT_FPUT_SIZE CLOUDABI_RIGHT_BIT(20) +#define CLOUDABI_RIGHT_FILE_STAT_FPUT_TIMES CLOUDABI_RIGHT_BIT(21) +#define CLOUDABI_RIGHT_FILE_STAT_GET CLOUDABI_RIGHT_BIT(22) +#define CLOUDABI_RIGHT_FILE_STAT_PUT_TIMES CLOUDABI_RIGHT_BIT(23) +#define CLOUDABI_RIGHT_FILE_SYMLINK CLOUDABI_RIGHT_BIT(24) +#define CLOUDABI_RIGHT_FILE_UNLINK CLOUDABI_RIGHT_BIT(25) +#define CLOUDABI_RIGHT_MEM_MAP CLOUDABI_RIGHT_BIT(26) +#define CLOUDABI_RIGHT_MEM_MAP_EXEC CLOUDABI_RIGHT_BIT(27) +#define CLOUDABI_RIGHT_POLL_FD_READWRITE CLOUDABI_RIGHT_BIT(28) +#define CLOUDABI_RIGHT_POLL_MODIFY CLOUDABI_RIGHT_BIT(29) +#define CLOUDABI_RIGHT_POLL_PROC_TERMINATE CLOUDABI_RIGHT_BIT(30) +#define CLOUDABI_RIGHT_POLL_WAIT CLOUDABI_RIGHT_BIT(31) +#define CLOUDABI_RIGHT_PROC_EXEC CLOUDABI_RIGHT_BIT(32) +#define CLOUDABI_RIGHT_SOCK_ACCEPT CLOUDABI_RIGHT_BIT(33) +#define CLOUDABI_RIGHT_SOCK_BIND_DIRECTORY CLOUDABI_RIGHT_BIT(34) +#define CLOUDABI_RIGHT_SOCK_BIND_SOCKET CLOUDABI_RIGHT_BIT(35) +#define CLOUDABI_RIGHT_SOCK_CONNECT_DIRECTORY CLOUDABI_RIGHT_BIT(36) +#define CLOUDABI_RIGHT_SOCK_CONNECT_SOCKET CLOUDABI_RIGHT_BIT(37) +#define CLOUDABI_RIGHT_SOCK_LISTEN CLOUDABI_RIGHT_BIT(38) +#define CLOUDABI_RIGHT_SOCK_SHUTDOWN CLOUDABI_RIGHT_BIT(39) +#define CLOUDABI_RIGHT_SOCK_STAT_GET CLOUDABI_RIGHT_BIT(40) + +// Socket shutdown flags. +#define CLOUDABI_SHUT_RD 0x1 +#define CLOUDABI_SHUT_WR 0x2 + +// Signals. +#define CLOUDABI_SIGABRT 1 +#define CLOUDABI_SIGALRM 2 +#define CLOUDABI_SIGBUS 3 +#define CLOUDABI_SIGCHLD 4 +#define CLOUDABI_SIGCONT 5 +#define CLOUDABI_SIGFPE 6 +#define CLOUDABI_SIGHUP 7 +#define CLOUDABI_SIGILL 8 +#define CLOUDABI_SIGINT 9 +#define CLOUDABI_SIGKILL 10 +#define CLOUDABI_SIGPIPE 11 +#define CLOUDABI_SIGQUIT 12 +#define CLOUDABI_SIGSEGV 13 +#define CLOUDABI_SIGSTOP 14 +#define CLOUDABI_SIGSYS 15 +#define CLOUDABI_SIGTERM 16 +#define CLOUDABI_SIGTRAP 17 +#define CLOUDABI_SIGTSTP 18 +#define CLOUDABI_SIGTTIN 19 +#define CLOUDABI_SIGTTOU 20 +#define CLOUDABI_SIGURG 21 +#define CLOUDABI_SIGUSR1 22 +#define CLOUDABI_SIGUSR2 23 +#define CLOUDABI_SIGVTALRM 24 +#define CLOUDABI_SIGXCPU 25 +#define CLOUDABI_SIGXFSZ 26 + +// sockstat() flags. +#define CLOUDABI_SOCKSTAT_CLEAR_ERROR 0x1 + +// sockstat() state. +#define CLOUDABI_SOCKSTAT_ACCEPTCONN 0x1 + +// cloudabi_subscription_t flags. +#define CLOUDABI_SUBSCRIPTION_ADD 0x1 +#define CLOUDABI_SUBSCRIPTION_CLEAR 0x2 +#define CLOUDABI_SUBSCRIPTION_DELETE 0x4 +#define CLOUDABI_SUBSCRIPTION_DISABLE 0x8 +#define CLOUDABI_SUBSCRIPTION_ENABLE 0x10 +#define CLOUDABI_SUBSCRIPTION_ONESHOT 0x20 + +// unlinkat(). +#define CLOUDABI_UNLINK_REMOVEDIR 0x1 + +// Seeking. +#define CLOUDABI_WHENCE_CUR 1 +#define CLOUDABI_WHENCE_END 2 +#define CLOUDABI_WHENCE_SET 3 + +typedef uint8_t cloudabi_advice_t; // posix_fadvise() and posix_madvise(). +typedef uint32_t cloudabi_backlog_t; // listen(). +typedef uint32_t cloudabi_clockid_t; // clock_*(). +typedef uint32_t cloudabi_condvar_t; // pthread_cond_*(). +typedef uint64_t cloudabi_device_t; // struct stat::st_dev. +typedef uint64_t cloudabi_dircookie_t; // readdir(). +typedef uint16_t cloudabi_errno_t; // errno. +typedef uint8_t cloudabi_eventtype_t; // poll(). +typedef uint32_t cloudabi_exitcode_t; // _exit() and _Exit(). +typedef uint32_t cloudabi_fd_t; // File descriptors. +typedef uint16_t cloudabi_fdflags_t; // cloudabi_fdstat_t. +typedef uint16_t cloudabi_fdsflags_t; // fd_stat_put(). +typedef int64_t cloudabi_filedelta_t; // lseek(). +typedef uint64_t cloudabi_filesize_t; // ftruncate(), struct stat::st_size. +typedef uint8_t cloudabi_filetype_t; // struct stat::st_mode. +typedef uint16_t cloudabi_fsflags_t; // file_stat_put(). +typedef uint64_t cloudabi_inode_t; // struct stat::st_ino. +typedef uint32_t cloudabi_linkcount_t; // struct stat::st_nlink. +typedef uint32_t cloudabi_lock_t; // pthread_{mutex,rwlock}_*(). +typedef uint64_t cloudabi_lookup_t; // openat(), linkat(), etc. +typedef uint8_t cloudabi_mflags_t; // mmap(). +typedef uint8_t cloudabi_mprot_t; // mmap(). +typedef uint8_t cloudabi_msflags_t; // msync(). +typedef uint16_t cloudabi_msgflags_t; // send() and recv(). +typedef uint32_t cloudabi_nthreads_t; // pthread_cond_*(). +typedef uint16_t cloudabi_oflags_t; // openat(), etc. +typedef uint64_t cloudabi_rights_t; // File descriptor rights. +typedef uint8_t cloudabi_sa_family_t; // Socket address family. +typedef uint8_t cloudabi_sdflags_t; // shutdown(). +typedef uint8_t cloudabi_ssflags_t; // sockstat(). +typedef uint8_t cloudabi_signal_t; // raise(). +typedef uint32_t cloudabi_tid_t; // Thread ID. +typedef uint64_t cloudabi_timestamp_t; // clock_*(), struct stat::st_*tim. +typedef uint8_t cloudabi_ulflags_t; // unlinkat(). +typedef uint64_t cloudabi_userdata_t; // User-supplied data for callbacks. +typedef uint8_t cloudabi_whence_t; // lseek(). + +// Macro to force sane alignment rules. +// +// On x86-32 it is the case that 64-bit integers are 4-byte aligned when +// embedded in structs, even though they are 8-byte aligned when not +// embedded. Force 8-byte alignment explicitly. +#define MEMBER(type) alignas(alignof(type)) type +#define ASSERT_OFFSET(type, field, offset) \ + static_assert(offsetof(cloudabi_##type, field) == (offset), \ + "Offset incorrect") +#define ASSERT_SIZE(type, size) \ + static_assert(sizeof(cloudabi_##type) == (size), "Size incorrect") + +// Directory entries. +typedef struct { + MEMBER(cloudabi_dircookie_t) d_next; // Cookie of the next entry. + MEMBER(cloudabi_inode_t) d_ino; // Inode number of the current entry. + MEMBER(uint32_t) d_namlen; // Length of the name of the current entry. + MEMBER(cloudabi_filetype_t) d_type; // File type of the current entry. +} cloudabi_dirent_t; +ASSERT_OFFSET(dirent_t, d_next, 0); +ASSERT_OFFSET(dirent_t, d_ino, 8); +ASSERT_OFFSET(dirent_t, d_namlen, 16); +ASSERT_OFFSET(dirent_t, d_type, 20); +ASSERT_SIZE(dirent_t, 24); + +// File descriptor status. +typedef struct { + MEMBER(cloudabi_filetype_t) fs_filetype; // File descriptor type. + MEMBER(cloudabi_fdflags_t) fs_flags; // Non-blocking mode, etc. + MEMBER(cloudabi_rights_t) fs_rights_base; // Base rights. + MEMBER(cloudabi_rights_t) fs_rights_inheriting; // Inheriting rights. +} cloudabi_fdstat_t; +ASSERT_OFFSET(fdstat_t, fs_filetype, 0); +ASSERT_OFFSET(fdstat_t, fs_flags, 2); +ASSERT_OFFSET(fdstat_t, fs_rights_base, 8); +ASSERT_OFFSET(fdstat_t, fs_rights_inheriting, 16); +ASSERT_SIZE(fdstat_t, 24); + +// File status. +typedef struct { + MEMBER(cloudabi_device_t) st_dev; // Device storing the file. + MEMBER(cloudabi_inode_t) st_ino; // Inode of the file. + MEMBER(cloudabi_filetype_t) st_filetype; // File type. + MEMBER(cloudabi_linkcount_t) st_nlink; // Number of hardlinks. + MEMBER(cloudabi_filesize_t) st_size; // Size of the file. + MEMBER(cloudabi_timestamp_t) st_atim; // Access time. + MEMBER(cloudabi_timestamp_t) st_mtim; // Modification time. + MEMBER(cloudabi_timestamp_t) st_ctim; // Change time. +} cloudabi_filestat_t; +ASSERT_OFFSET(filestat_t, st_dev, 0); +ASSERT_OFFSET(filestat_t, st_ino, 8); +ASSERT_OFFSET(filestat_t, st_filetype, 16); +ASSERT_OFFSET(filestat_t, st_nlink, 20); +ASSERT_OFFSET(filestat_t, st_size, 24); +ASSERT_OFFSET(filestat_t, st_atim, 32); +ASSERT_OFFSET(filestat_t, st_mtim, 40); +ASSERT_OFFSET(filestat_t, st_ctim, 48); +ASSERT_SIZE(filestat_t, 56); + +typedef struct { + MEMBER(cloudabi_sa_family_t) sa_family; + union { + struct { + // IPv4 address and port number. + MEMBER(uint8_t) addr[4]; + MEMBER(uint16_t) port; + } sa_inet; + struct { + // IPv6 address and port number. + // TODO(edje): What about the flow info and scope ID? + MEMBER(uint8_t) addr[16]; + MEMBER(uint16_t) port; + } sa_inet6; + }; +} cloudabi_sockaddr_t; +ASSERT_OFFSET(sockaddr_t, sa_family, 0); +ASSERT_OFFSET(sockaddr_t, sa_inet.addr, 2); +ASSERT_OFFSET(sockaddr_t, sa_inet.port, 6); +ASSERT_OFFSET(sockaddr_t, sa_inet6.addr, 2); +ASSERT_OFFSET(sockaddr_t, sa_inet6.port, 18); +ASSERT_SIZE(sockaddr_t, 20); + +// Socket status. +typedef struct { + MEMBER(cloudabi_sockaddr_t) ss_sockname; // Socket address. + MEMBER(cloudabi_sockaddr_t) ss_peername; // Peer address. + MEMBER(cloudabi_errno_t) ss_error; // Current error state. + MEMBER(uint32_t) ss_state; // State flags. +} cloudabi_sockstat_t; +ASSERT_OFFSET(sockstat_t, ss_sockname, 0); +ASSERT_OFFSET(sockstat_t, ss_peername, 20); +ASSERT_OFFSET(sockstat_t, ss_error, 40); +ASSERT_OFFSET(sockstat_t, ss_state, 44); +ASSERT_SIZE(sockstat_t, 48); + +#undef MEMBER +#undef ASSERT_OFFSET +#undef ASSERT_SIZE + +#endif Index: sys/kern/makesyscalls.sh =================================================================== --- sys/kern/makesyscalls.sh +++ sys/kern/makesyscalls.sh @@ -446,7 +446,8 @@ if (funcname == "nosys" || funcname == "lkmnosys" || funcname == "sysarch" || funcname ~ /^freebsd/ || funcname ~ /^linux/ || funcname ~ /^svr4/ || - funcname ~ /^ibcs2/ || funcname ~ /^xenix/) { + funcname ~ /^ibcs2/ || funcname ~ /^xenix/ || + funcname ~ /^cloudabi/) { printf("%s\t%s(struct thread *, struct %s *)", rettype, funcname, argalias) > sysdcl } else { @@ -466,7 +467,8 @@ if (funcname == "nosys" || funcname == "sysarch" || funcname == "lkmnosys" || funcname ~ /^freebsd/ || funcname ~ /^linux/ || funcname ~ /^svr4/ || - funcname ~ /^ibcs2/ || funcname ~ /^xenix/) { + funcname ~ /^ibcs2/ || funcname ~ /^xenix/ || + funcname ~ /^cloudabi/) { printf("%s, %s, NULL, 0, 0, %s, %s },", funcname, auditev, flags, thr_flag) > sysent column = column + length(funcname) + length(auditev) + length(flags) + 3 } else {