From owner-svn-src-head@freebsd.org Wed Aug 24 10:51:34 2016 Return-Path: Delivered-To: svn-src-head@mailman.ysv.freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:1900:2254:206a::19:1]) by mailman.ysv.freebsd.org (Postfix) with ESMTP id BE281BC3EBD; Wed, 24 Aug 2016 10:51:34 +0000 (UTC) (envelope-from ed@FreeBSD.org) Received: from repo.freebsd.org (repo.freebsd.org [IPv6:2610:1c1:1:6068::e6a:0]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (Client did not present a certificate) by mx1.freebsd.org (Postfix) with ESMTPS id 8B95A126E; Wed, 24 Aug 2016 10:51:34 +0000 (UTC) (envelope-from ed@FreeBSD.org) Received: from repo.freebsd.org ([127.0.1.37]) by repo.freebsd.org (8.15.2/8.15.2) with ESMTP id u7OApX9V081654; Wed, 24 Aug 2016 10:51:33 GMT (envelope-from ed@FreeBSD.org) Received: (from ed@localhost) by repo.freebsd.org (8.15.2/8.15.2/Submit) id u7OApXGE081650; Wed, 24 Aug 2016 10:51:33 GMT (envelope-from ed@FreeBSD.org) Message-Id: <201608241051.u7OApXGE081650@repo.freebsd.org> X-Authentication-Warning: repo.freebsd.org: ed set sender to ed@FreeBSD.org using -f From: Ed Schouten Date: Wed, 24 Aug 2016 10:51:33 +0000 (UTC) To: src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-head@freebsd.org Subject: svn commit: r304744 - in head/sys: amd64/cloudabi32 amd64/conf conf contrib/cloudabi X-SVN-Group: head MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-BeenThere: svn-src-head@freebsd.org X-Mailman-Version: 2.1.22 Precedence: list List-Id: SVN commit messages for the src tree for head/-current List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 24 Aug 2016 10:51:34 -0000 Author: ed Date: Wed Aug 24 10:51:33 2016 New Revision: 304744 URL: https://svnweb.freebsd.org/changeset/base/304744 Log: Make execution of 32-bit CloudABI executables work on amd64. A nice thing about requiring a vDSO is that it makes it incredibly easy to provide full support for running 32-bit processes on 64-bit systems. Instead of letting the kernel be responsible for composing/decomposing 64-bit arguments across multiple registers/stack slots, all of this can now be done in the vDSO. This means that there is no need to provide duplicate copies of certain system calls, like the sys_lseek() and freebsd32_lseek() we have for COMPAT_FREEBSD32. This change imports a new vDSO from the CloudABI repository that has automatically generated code in it that copies system call arguments into a buffer, padding them to eight bytes and zero-extending any pointers/size_t arguments. After returning from the kernel, it does the inverse: extracting return values, in the process truncating pointers/size_t values to 32 bits. Obtained from: https://github.com/NuxiNL/cloudabi Added: head/sys/amd64/cloudabi32/ head/sys/amd64/cloudabi32/cloudabi32_sysvec.c - copied, changed from r304742, head/sys/i386/cloudabi32/cloudabi32_sysvec.c head/sys/contrib/cloudabi/cloudabi_vdso_i686_on_64bit.S (contents, props changed) Modified: head/sys/amd64/conf/NOTES head/sys/conf/files.amd64 Copied and modified: head/sys/amd64/cloudabi32/cloudabi32_sysvec.c (from r304742, head/sys/i386/cloudabi32/cloudabi32_sysvec.c) ============================================================================== --- head/sys/i386/cloudabi32/cloudabi32_sysvec.c Wed Aug 24 10:13:18 2016 (r304742, copy source) +++ head/sys/amd64/cloudabi32/cloudabi32_sysvec.c Wed Aug 24 10:51:33 2016 (r304744) @@ -44,9 +44,14 @@ __FBSDID("$FreeBSD$"); #include #include +#include +#include + extern const char *cloudabi32_syscallnames[]; extern struct sysent cloudabi32_sysent[]; +extern unsigned long ia32_maxssiz; + static int cloudabi32_fixup_tcb(register_t **stack_base, struct image_params *imgp) { @@ -80,7 +85,7 @@ cloudabi32_proc_setregs(struct thread *t unsigned long stack) { - exec_setregs(td, imgp, stack); + ia32_setregs(td, imgp, stack); (void)cpu_set_user_tls(td, (void *)stack); } @@ -91,21 +96,30 @@ cloudabi32_fetch_syscall_args(struct thr int error; /* Obtain system call number. */ - sa->code = frame->tf_eax; + sa->code = frame->tf_rax; if (sa->code >= CLOUDABI32_SYS_MAXSYSCALL) return (ENOSYS); sa->callp = &cloudabi32_sysent[sa->code]; sa->narg = sa->callp->sy_narg; - /* Fetch system call arguments from the stack. */ - error = copyin((void *)(frame->tf_esp + 4), sa->args, + /* + * Fetch system call arguments. + * + * The vDSO has already made sure that the arguments are + * eight-byte aligned. Pointers and size_t parameters are + * zero-extended. This makes it possible to copy in the + * arguments directly. As long as the call doesn't use 32-bit + * data structures, we can just invoke the same system call + * implementation used by 64-bit processes. + */ + error = copyin((void *)frame->tf_rcx, sa->args, sa->narg * sizeof(sa->args[0])); if (error != 0) return (error); /* Default system call return values. */ td->td_retval[0] = 0; - td->td_retval[1] = frame->tf_edx; + td->td_retval[1] = 0; return (0); } @@ -116,21 +130,28 @@ cloudabi32_set_syscall_retval(struct thr switch (error) { case 0: - /* System call succeeded. */ - frame->tf_eax = td->td_retval[0]; - frame->tf_edx = td->td_retval[1]; - frame->tf_eflags &= ~PSL_C; + /* + * System call succeeded. + * + * Simply copy out the 64-bit return values into the + * same buffer provided for system call arguments. The + * vDSO will copy them to the right spot, truncating + * pointers and size_t values to 32 bits. + */ + frame->tf_rax = copyout(td->td_retval, (void *)frame->tf_rcx, + sizeof(td->td_retval)) == 0 ? 0 : CLOUDABI_EFAULT; break; case ERESTART: /* Restart system call. */ - frame->tf_eip -= frame->tf_err; + frame->tf_rip -= frame->tf_err; + frame->tf_r10 = frame->tf_rcx; + set_pcb_flags(td->td_pcb, PCB_FULL_IRET); break; case EJUSTRETURN: break; default: /* System call returned an error. */ - frame->tf_eax = cloudabi_convert_errno(error); - frame->tf_eflags |= PSL_C; + frame->tf_rax = cloudabi_convert_errno(error); break; } } @@ -139,10 +160,14 @@ static void cloudabi32_schedtail(struct thread *td) { struct trapframe *frame = td->td_frame; + register_t retval[2]; - /* Initial register values for processes returning from fork. */ - frame->tf_eax = CLOUDABI_PROCESS_CHILD; - frame->tf_edx = td->td_tid; + /* Return values for processes returning from fork. */ + if ((td->td_pflags & TDP_FORKING) != 0) { + retval[0] = CLOUDABI_PROCESS_CHILD; + retval[1] = td->td_tid; + copyout(retval, (void *)frame->tf_rcx, sizeof(retval)); + } } int @@ -167,7 +192,7 @@ cloudabi32_thread_setregs(struct thread args[0] = tcb; args[1] = td->td_tid; args[2] = attr->argument; - frameptr = (void *)td->td_frame->tf_esp; + frameptr = (void *)td->td_frame->tf_rsp; error = copyout(args, frameptr, sizeof(args)); if (error != 0) return (error); @@ -181,12 +206,14 @@ static struct sysentvec cloudabi32_elf_s .sv_fixup = cloudabi32_fixup_tcb, .sv_name = "CloudABI ELF32", .sv_coredump = elf32_coredump, - .sv_pagesize = PAGE_SIZE, - .sv_minuser = VM_MIN_ADDRESS, - .sv_maxuser = VM_MAXUSER_ADDRESS, + .sv_pagesize = IA32_PAGE_SIZE, + .sv_minuser = FREEBSD32_MINUSER, + .sv_maxuser = FREEBSD32_MAXUSER, .sv_stackprot = VM_PROT_READ | VM_PROT_WRITE, .sv_copyout_strings = cloudabi32_copyout_strings, .sv_setregs = cloudabi32_proc_setregs, + .sv_fixlimit = ia32_fixlimit, + .sv_maxssiz = &ia32_maxssiz, .sv_flags = SV_ABI_CLOUDABI | SV_CAPSICUM | SV_IA32 | SV_ILP32, .sv_set_syscall_retval = cloudabi32_set_syscall_retval, .sv_fetch_syscall_args = cloudabi32_fetch_syscall_args, Modified: head/sys/amd64/conf/NOTES ============================================================================== --- head/sys/amd64/conf/NOTES Wed Aug 24 10:36:52 2016 (r304743) +++ head/sys/amd64/conf/NOTES Wed Aug 24 10:51:33 2016 (r304744) @@ -614,6 +614,9 @@ options COMPAT_FREEBSD32 # Emulate spx device for client side of SVR3 local X interface #XXX#options SPX_HACK +# Enable 32-bit runtime support for CloudABI binaries. +options COMPAT_CLOUDABI32 + # Enable 64-bit runtime support for CloudABI binaries. options COMPAT_CLOUDABI64 Modified: head/sys/conf/files.amd64 ============================================================================== --- head/sys/conf/files.amd64 Wed Aug 24 10:36:52 2016 (r304743) +++ head/sys/conf/files.amd64 Wed Aug 24 10:51:33 2016 (r304744) @@ -8,6 +8,18 @@ # dependency lines other than the first are silently ignored. # # +cloudabi32_vdso.o optional compat_cloudabi32 \ + dependency "$S/contrib/cloudabi/cloudabi_vdso_i686_on_64bit.S" \ + compile-with "${CC} -x assembler-with-cpp -m32 -shared -nostdinc -nostdlib -Wl,-T$S/compat/cloudabi/cloudabi_vdso.lds $S/contrib/cloudabi/cloudabi_vdso_i686_on_64bit.S -o ${.TARGET}" \ + no-obj no-implicit-rule \ + clean "cloudabi32_vdso.o" +# +cloudabi32_vdso_blob.o optional compat_cloudabi32 \ + dependency "cloudabi32_vdso.o" \ + compile-with "${OBJCOPY} --input-target binary --output-target elf64-x86-64-freebsd --binary-architecture i386 cloudabi32_vdso.o ${.TARGET}" \ + no-implicit-rule \ + clean "cloudabi32_vdso_blob.o" +# cloudabi64_vdso.o optional compat_cloudabi64 \ dependency "$S/contrib/cloudabi/cloudabi_vdso_x86_64.S" \ compile-with "${CC} -x assembler-with-cpp -shared -nostdinc -nostdlib -Wl,-T$S/compat/cloudabi/cloudabi_vdso.lds $S/contrib/cloudabi/cloudabi_vdso_x86_64.S -o ${.TARGET}" \ @@ -146,6 +158,7 @@ amd64/amd64/trap.c standard amd64/amd64/uio_machdep.c standard amd64/amd64/uma_machdep.c standard amd64/amd64/vm_machdep.c standard +amd64/cloudabi32/cloudabi32_sysvec.c optional compat_cloudabi32 amd64/cloudabi64/cloudabi64_sysvec.c optional compat_cloudabi64 amd64/pci/pci_cfgreg.c optional pci cddl/contrib/opensolaris/common/atomic/amd64/opensolaris_atomic.S optional zfs | dtrace compile-with "${ZFS_S}" Added: head/sys/contrib/cloudabi/cloudabi_vdso_i686_on_64bit.S ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ head/sys/contrib/cloudabi/cloudabi_vdso_i686_on_64bit.S Wed Aug 24 10:51:33 2016 (r304744) @@ -0,0 +1,1223 @@ +// Copyright (c) 2016 Nuxi (https://nuxi.nl/) and contributors. +// +// 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. +// +// This file is automatically generated. Do not edit. +// +// Source: https://github.com/NuxiNL/cloudabi + +#define ENTRY(name) \ + .text; \ + .p2align 2, 0x90; \ + .global name; \ + .type name, @function; \ +name: + +#define END(name) .size name, . - name + +ENTRY(cloudabi_sys_clock_res_get) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -16(%ebp) + mov $0, %eax + mov %ebp, %ecx + sub $16, %ecx + int $0x80 + test %eax, %eax + jnz 1f + mov 12(%ebp), %ecx + mov -16(%ebp), %edx + mov %edx, 0(%ecx) + mov -12(%ebp), %edx + mov %edx, 4(%ecx) +1: + pop %ebp + ret +END(cloudabi_sys_clock_res_get) + +ENTRY(cloudabi_sys_clock_time_get) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -16(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -8(%ebp) + mov 16(%ebp), %ecx + mov %ecx, -4(%ebp) + mov $1, %eax + mov %ebp, %ecx + sub $16, %ecx + int $0x80 + test %eax, %eax + jnz 1f + mov 20(%ebp), %ecx + mov -16(%ebp), %edx + mov %edx, 0(%ecx) + mov -12(%ebp), %edx + mov %edx, 4(%ecx) +1: + pop %ebp + ret +END(cloudabi_sys_clock_time_get) + +ENTRY(cloudabi_sys_condvar_signal) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -24(%ebp) + movl $0, -20(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -16(%ebp) + mov 16(%ebp), %ecx + mov %ecx, -8(%ebp) + mov $2, %eax + mov %ebp, %ecx + sub $24, %ecx + int $0x80 + pop %ebp + ret +END(cloudabi_sys_condvar_signal) + +ENTRY(cloudabi_sys_fd_close) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -16(%ebp) + mov $3, %eax + mov %ebp, %ecx + sub $16, %ecx + int $0x80 + pop %ebp + ret +END(cloudabi_sys_fd_close) + +ENTRY(cloudabi_sys_fd_create1) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -16(%ebp) + mov $4, %eax + mov %ebp, %ecx + sub $16, %ecx + int $0x80 + test %eax, %eax + jnz 1f + mov 12(%ebp), %ecx + mov -16(%ebp), %edx + mov %edx, 0(%ecx) +1: + pop %ebp + ret +END(cloudabi_sys_fd_create1) + +ENTRY(cloudabi_sys_fd_create2) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -16(%ebp) + mov $5, %eax + mov %ebp, %ecx + sub $16, %ecx + int $0x80 + test %eax, %eax + jnz 1f + mov 12(%ebp), %ecx + mov -16(%ebp), %edx + mov %edx, 0(%ecx) + mov 16(%ebp), %ecx + mov -8(%ebp), %edx + mov %edx, 0(%ecx) +1: + pop %ebp + ret +END(cloudabi_sys_fd_create2) + +ENTRY(cloudabi_sys_fd_datasync) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -16(%ebp) + mov $6, %eax + mov %ebp, %ecx + sub $16, %ecx + int $0x80 + pop %ebp + ret +END(cloudabi_sys_fd_datasync) + +ENTRY(cloudabi_sys_fd_dup) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -16(%ebp) + mov $7, %eax + mov %ebp, %ecx + sub $16, %ecx + int $0x80 + test %eax, %eax + jnz 1f + mov 12(%ebp), %ecx + mov -16(%ebp), %edx + mov %edx, 0(%ecx) +1: + pop %ebp + ret +END(cloudabi_sys_fd_dup) + +ENTRY(cloudabi_sys_fd_pread) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -32(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -24(%ebp) + movl $0, -20(%ebp) + mov 16(%ebp), %ecx + mov %ecx, -16(%ebp) + movl $0, -12(%ebp) + mov 20(%ebp), %ecx + mov %ecx, -8(%ebp) + mov 24(%ebp), %ecx + mov %ecx, -4(%ebp) + mov $8, %eax + mov %ebp, %ecx + sub $32, %ecx + int $0x80 + test %eax, %eax + jnz 1f + mov 28(%ebp), %ecx + mov -32(%ebp), %edx + mov %edx, 0(%ecx) +1: + pop %ebp + ret +END(cloudabi_sys_fd_pread) + +ENTRY(cloudabi_sys_fd_pwrite) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -32(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -24(%ebp) + movl $0, -20(%ebp) + mov 16(%ebp), %ecx + mov %ecx, -16(%ebp) + movl $0, -12(%ebp) + mov 20(%ebp), %ecx + mov %ecx, -8(%ebp) + mov 24(%ebp), %ecx + mov %ecx, -4(%ebp) + mov $9, %eax + mov %ebp, %ecx + sub $32, %ecx + int $0x80 + test %eax, %eax + jnz 1f + mov 28(%ebp), %ecx + mov -32(%ebp), %edx + mov %edx, 0(%ecx) +1: + pop %ebp + ret +END(cloudabi_sys_fd_pwrite) + +ENTRY(cloudabi_sys_fd_read) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -24(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -16(%ebp) + movl $0, -12(%ebp) + mov 16(%ebp), %ecx + mov %ecx, -8(%ebp) + movl $0, -4(%ebp) + mov $10, %eax + mov %ebp, %ecx + sub $24, %ecx + int $0x80 + test %eax, %eax + jnz 1f + mov 20(%ebp), %ecx + mov -24(%ebp), %edx + mov %edx, 0(%ecx) +1: + pop %ebp + ret +END(cloudabi_sys_fd_read) + +ENTRY(cloudabi_sys_fd_replace) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -16(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -8(%ebp) + mov $11, %eax + mov %ebp, %ecx + sub $16, %ecx + int $0x80 + pop %ebp + ret +END(cloudabi_sys_fd_replace) + +ENTRY(cloudabi_sys_fd_seek) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -24(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -16(%ebp) + mov 16(%ebp), %ecx + mov %ecx, -12(%ebp) + mov 20(%ebp), %ecx + mov %ecx, -8(%ebp) + mov $12, %eax + mov %ebp, %ecx + sub $24, %ecx + int $0x80 + test %eax, %eax + jnz 1f + mov 24(%ebp), %ecx + mov -24(%ebp), %edx + mov %edx, 0(%ecx) + mov -20(%ebp), %edx + mov %edx, 4(%ecx) +1: + pop %ebp + ret +END(cloudabi_sys_fd_seek) + +ENTRY(cloudabi_sys_fd_stat_get) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -16(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -8(%ebp) + movl $0, -4(%ebp) + mov $13, %eax + mov %ebp, %ecx + sub $16, %ecx + int $0x80 + pop %ebp + ret +END(cloudabi_sys_fd_stat_get) + +ENTRY(cloudabi_sys_fd_stat_put) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -24(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -16(%ebp) + movl $0, -12(%ebp) + mov 16(%ebp), %ecx + mov %ecx, -8(%ebp) + mov $14, %eax + mov %ebp, %ecx + sub $24, %ecx + int $0x80 + pop %ebp + ret +END(cloudabi_sys_fd_stat_put) + +ENTRY(cloudabi_sys_fd_sync) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -16(%ebp) + mov $15, %eax + mov %ebp, %ecx + sub $16, %ecx + int $0x80 + pop %ebp + ret +END(cloudabi_sys_fd_sync) + +ENTRY(cloudabi_sys_fd_write) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -24(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -16(%ebp) + movl $0, -12(%ebp) + mov 16(%ebp), %ecx + mov %ecx, -8(%ebp) + movl $0, -4(%ebp) + mov $16, %eax + mov %ebp, %ecx + sub $24, %ecx + int $0x80 + test %eax, %eax + jnz 1f + mov 20(%ebp), %ecx + mov -24(%ebp), %edx + mov %edx, 0(%ecx) +1: + pop %ebp + ret +END(cloudabi_sys_fd_write) + +ENTRY(cloudabi_sys_file_advise) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -32(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -24(%ebp) + mov 16(%ebp), %ecx + mov %ecx, -20(%ebp) + mov 20(%ebp), %ecx + mov %ecx, -16(%ebp) + mov 24(%ebp), %ecx + mov %ecx, -12(%ebp) + mov 28(%ebp), %ecx + mov %ecx, -8(%ebp) + mov $17, %eax + mov %ebp, %ecx + sub $32, %ecx + int $0x80 + pop %ebp + ret +END(cloudabi_sys_file_advise) + +ENTRY(cloudabi_sys_file_allocate) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -24(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -16(%ebp) + mov 16(%ebp), %ecx + mov %ecx, -12(%ebp) + mov 20(%ebp), %ecx + mov %ecx, -8(%ebp) + mov 24(%ebp), %ecx + mov %ecx, -4(%ebp) + mov $18, %eax + mov %ebp, %ecx + sub $24, %ecx + int $0x80 + pop %ebp + ret +END(cloudabi_sys_file_allocate) + +ENTRY(cloudabi_sys_file_create) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -32(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -24(%ebp) + movl $0, -20(%ebp) + mov 16(%ebp), %ecx + mov %ecx, -16(%ebp) + movl $0, -12(%ebp) + mov 20(%ebp), %ecx + mov %ecx, -8(%ebp) + mov $19, %eax + mov %ebp, %ecx + sub $32, %ecx + int $0x80 + pop %ebp + ret +END(cloudabi_sys_file_create) + +ENTRY(cloudabi_sys_file_link) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -48(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -44(%ebp) + mov 16(%ebp), %ecx + mov %ecx, -40(%ebp) + movl $0, -36(%ebp) + mov 20(%ebp), %ecx + mov %ecx, -32(%ebp) + movl $0, -28(%ebp) + mov 24(%ebp), %ecx + mov %ecx, -24(%ebp) + mov 28(%ebp), %ecx + mov %ecx, -16(%ebp) + movl $0, -12(%ebp) + mov 32(%ebp), %ecx + mov %ecx, -8(%ebp) + movl $0, -4(%ebp) + mov $20, %eax + mov %ebp, %ecx + sub $48, %ecx + int $0x80 + pop %ebp + ret +END(cloudabi_sys_file_link) + +ENTRY(cloudabi_sys_file_open) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -40(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -36(%ebp) + mov 16(%ebp), %ecx + mov %ecx, -32(%ebp) + movl $0, -28(%ebp) + mov 20(%ebp), %ecx + mov %ecx, -24(%ebp) + movl $0, -20(%ebp) + mov 24(%ebp), %ecx + mov %ecx, -16(%ebp) + mov 28(%ebp), %ecx + mov %ecx, -8(%ebp) + movl $0, -4(%ebp) + mov $21, %eax + mov %ebp, %ecx + sub $40, %ecx + int $0x80 + test %eax, %eax + jnz 1f + mov 32(%ebp), %ecx + mov -40(%ebp), %edx + mov %edx, 0(%ecx) +1: + pop %ebp + ret +END(cloudabi_sys_file_open) + +ENTRY(cloudabi_sys_file_readdir) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -32(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -24(%ebp) + movl $0, -20(%ebp) + mov 16(%ebp), %ecx + mov %ecx, -16(%ebp) + movl $0, -12(%ebp) + mov 20(%ebp), %ecx + mov %ecx, -8(%ebp) + mov 24(%ebp), %ecx + mov %ecx, -4(%ebp) + mov $22, %eax + mov %ebp, %ecx + sub $32, %ecx + int $0x80 + test %eax, %eax + jnz 1f + mov 28(%ebp), %ecx + mov -32(%ebp), %edx + mov %edx, 0(%ecx) +1: + pop %ebp + ret +END(cloudabi_sys_file_readdir) + +ENTRY(cloudabi_sys_file_readlink) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -40(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -32(%ebp) + movl $0, -28(%ebp) + mov 16(%ebp), %ecx + mov %ecx, -24(%ebp) + movl $0, -20(%ebp) + mov 20(%ebp), %ecx + mov %ecx, -16(%ebp) + movl $0, -12(%ebp) + mov 24(%ebp), %ecx + mov %ecx, -8(%ebp) + movl $0, -4(%ebp) + mov $23, %eax + mov %ebp, %ecx + sub $40, %ecx + int $0x80 + test %eax, %eax + jnz 1f + mov 28(%ebp), %ecx + mov -40(%ebp), %edx + mov %edx, 0(%ecx) +1: + pop %ebp + ret +END(cloudabi_sys_file_readlink) + +ENTRY(cloudabi_sys_file_rename) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -48(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -40(%ebp) + movl $0, -36(%ebp) + mov 16(%ebp), %ecx + mov %ecx, -32(%ebp) + movl $0, -28(%ebp) + mov 20(%ebp), %ecx + mov %ecx, -24(%ebp) + mov 24(%ebp), %ecx + mov %ecx, -16(%ebp) + movl $0, -12(%ebp) + mov 28(%ebp), %ecx + mov %ecx, -8(%ebp) + movl $0, -4(%ebp) + mov $24, %eax + mov %ebp, %ecx + sub $48, %ecx + int $0x80 + pop %ebp + ret +END(cloudabi_sys_file_rename) + +ENTRY(cloudabi_sys_file_stat_fget) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -16(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -8(%ebp) + movl $0, -4(%ebp) + mov $25, %eax + mov %ebp, %ecx + sub $16, %ecx + int $0x80 + pop %ebp + ret +END(cloudabi_sys_file_stat_fget) + +ENTRY(cloudabi_sys_file_stat_fput) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -24(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -16(%ebp) + movl $0, -12(%ebp) + mov 16(%ebp), %ecx + mov %ecx, -8(%ebp) + mov $26, %eax + mov %ebp, %ecx + sub $24, %ecx + int $0x80 + pop %ebp + ret +END(cloudabi_sys_file_stat_fput) + +ENTRY(cloudabi_sys_file_stat_get) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -32(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -28(%ebp) + mov 16(%ebp), %ecx + mov %ecx, -24(%ebp) + movl $0, -20(%ebp) + mov 20(%ebp), %ecx + mov %ecx, -16(%ebp) + movl $0, -12(%ebp) + mov 24(%ebp), %ecx + mov %ecx, -8(%ebp) + movl $0, -4(%ebp) + mov $27, %eax + mov %ebp, %ecx + sub $32, %ecx + int $0x80 + pop %ebp + ret +END(cloudabi_sys_file_stat_get) + +ENTRY(cloudabi_sys_file_stat_put) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -40(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -36(%ebp) + mov 16(%ebp), %ecx + mov %ecx, -32(%ebp) + movl $0, -28(%ebp) + mov 20(%ebp), %ecx + mov %ecx, -24(%ebp) + movl $0, -20(%ebp) + mov 24(%ebp), %ecx + mov %ecx, -16(%ebp) + movl $0, -12(%ebp) + mov 28(%ebp), %ecx + mov %ecx, -8(%ebp) + mov $28, %eax + mov %ebp, %ecx + sub $40, %ecx + int $0x80 + pop %ebp + ret +END(cloudabi_sys_file_stat_put) + +ENTRY(cloudabi_sys_file_symlink) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -40(%ebp) + movl $0, -36(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -32(%ebp) + movl $0, -28(%ebp) + mov 16(%ebp), %ecx + mov %ecx, -24(%ebp) + mov 20(%ebp), %ecx + mov %ecx, -16(%ebp) + movl $0, -12(%ebp) + mov 24(%ebp), %ecx + mov %ecx, -8(%ebp) + movl $0, -4(%ebp) + mov $29, %eax + mov %ebp, %ecx + sub $40, %ecx + int $0x80 + pop %ebp + ret +END(cloudabi_sys_file_symlink) + +ENTRY(cloudabi_sys_file_unlink) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -32(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -24(%ebp) + movl $0, -20(%ebp) + mov 16(%ebp), %ecx + mov %ecx, -16(%ebp) + movl $0, -12(%ebp) + mov 20(%ebp), %ecx + mov %ecx, -8(%ebp) + mov $30, %eax + mov %ebp, %ecx + sub $32, %ecx + int $0x80 + pop %ebp + ret +END(cloudabi_sys_file_unlink) + +ENTRY(cloudabi_sys_lock_unlock) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -16(%ebp) + movl $0, -12(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -8(%ebp) + mov $31, %eax + mov %ebp, %ecx + sub $16, %ecx + int $0x80 + pop %ebp + ret +END(cloudabi_sys_lock_unlock) + +ENTRY(cloudabi_sys_mem_advise) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -24(%ebp) + movl $0, -20(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -16(%ebp) + movl $0, -12(%ebp) + mov 16(%ebp), %ecx + mov %ecx, -8(%ebp) + mov $32, %eax + mov %ebp, %ecx + sub $24, %ecx + int $0x80 + pop %ebp + ret +END(cloudabi_sys_mem_advise) + +ENTRY(cloudabi_sys_mem_lock) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -16(%ebp) + movl $0, -12(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -8(%ebp) + movl $0, -4(%ebp) + mov $33, %eax + mov %ebp, %ecx + sub $16, %ecx + int $0x80 + pop %ebp + ret +END(cloudabi_sys_mem_lock) + +ENTRY(cloudabi_sys_mem_map) + push %ebp + mov %esp, %ebp + mov 8(%ebp), %ecx + mov %ecx, -48(%ebp) + movl $0, -44(%ebp) + mov 12(%ebp), %ecx + mov %ecx, -40(%ebp) + movl $0, -36(%ebp) + mov 16(%ebp), %ecx + mov %ecx, -32(%ebp) + mov 20(%ebp), %ecx + mov %ecx, -24(%ebp) + mov 24(%ebp), %ecx + mov %ecx, -16(%ebp) + mov 28(%ebp), %ecx + mov %ecx, -8(%ebp) + mov 32(%ebp), %ecx + mov %ecx, -4(%ebp) + mov $34, %eax + mov %ebp, %ecx + sub $48, %ecx + int $0x80 + test %eax, %eax + jnz 1f + mov 36(%ebp), %ecx + mov -48(%ebp), %edx + mov %edx, 0(%ecx) +1: + pop %ebp + ret +END(cloudabi_sys_mem_map) + +ENTRY(cloudabi_sys_mem_protect) + push %ebp + mov %esp, %ebp *** DIFF OUTPUT TRUNCATED AT 1000 LINES ***