Port cloudabi32.ko to FreeBSD/arm64.

This change adds an implementation of a sysent for running CloudABI
armv6 and armv7 binaries on FreeBSD/arm64. It is a somewhat literal copy
of the armv6 version, except that it's been patched up to use the proper
registers.

Just like for cloudabi32.ko on FreeBSD/amd64, we make use of a vDSO that
automatically pads system call parameters to 64-bit value. These are
stored in a buffer on the stack, meaning we need to use copyin() and
copyout() unconditionally.

share/man/man4/cloudabi.4

@@ -1,4 +1,4 @@
-.\" Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
+.\" Copyright (c) 2015-2017 Nuxi, https://nuxi.nl/
 .\"
 .\" Redistribution and use in source and binary forms, with or without
 .\" modification, are permitted provided that the following conditions
@@ -22,7 +22,7 @@
 .\" SUCH DAMAGE.
 .\"
 .\" $FreeBSD$
-.Dd September 22, 2016
+.Dd November 30, 2017
 .Dt CLOUDABI 4
 .Os
 .Sh NAME
@@ -84,7 +84,7 @@ module can be loaded on any architecture supported by
 .Fx ,
 the
 .Nm cloudabi32
-module is only available on amd64, armv6 and i386.
+module is only available on amd64, arm64, armv6, armv7 and i386.
 The same holds for the
 .Nm cloudabi64
 module,

sys/arm64/cloudabi32/cloudabi32_sysvec.c

@@ -0,0 +1,205 @@
+/*-
+ * Copyright (c) 2015-2017 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 <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/imgact.h>
+#include <sys/kernel.h>
+#include <sys/proc.h>
+#include <sys/sysent.h>
+
+#include <vm/vm.h>
+#include <vm/pmap.h>
+
+#include <machine/frame.h>
+#include <machine/pcb.h>
+#include <machine/vmparam.h>
+
+#include <compat/cloudabi/cloudabi_util.h>
+
+#include <compat/cloudabi32/cloudabi32_syscall.h>
+#include <compat/cloudabi32/cloudabi32_util.h>
+
+extern const char *cloudabi32_syscallnames[];
+extern struct sysent cloudabi32_sysent[];
+
+static void
+cloudabi32_proc_setregs(struct thread *td, struct image_params *imgp,
+    unsigned long stack)
+{
+	struct trapframe *regs;
+
+	regs = td->td_frame;
+	memset(regs, 0, sizeof(*regs));
+	regs->tf_x[0] =
+	    stack + roundup(sizeof(cloudabi32_tcb_t), sizeof(register_t));
+	regs->tf_x[13] = STACKALIGN(stack);
+	regs->tf_elr = imgp->entry_addr;
+	regs->tf_spsr |= PSR_AARCH32;
+	(void)cpu_set_user_tls(td, TO_PTR(stack));
+}
+
+static int
+cloudabi32_fetch_syscall_args(struct thread *td)
+{
+	struct trapframe *frame;
+	struct syscall_args *sa;
+	int error;
+
+	frame = td->td_frame;
+	sa = &td->td_sa;
+
+	/* Obtain system call number. */
+	sa->code = frame->tf_x[0];
+	if (sa->code >= CLOUDABI32_SYS_MAXSYSCALL)
+		return (ENOSYS);
+	sa->callp = &cloudabi32_sysent[sa->code];
+	sa->narg = sa->callp->sy_narg;
+
+	/*
+	 * 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_x[2], 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] = 0;
+	return (0);
+}
+
+static void
+cloudabi32_set_syscall_retval(struct thread *td, int error)
+{
+	struct trapframe *frame = td->td_frame;
+
+	switch (error) {
+	case 0:
+		/*
+		 * 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.
+		 */
+		if (copyout(td->td_retval, (void *)frame->tf_x[2],
+		    sizeof(td->td_retval)) == 0) {
+			frame->tf_x[0] = 0;
+			frame->tf_spsr &= ~PSR_C;
+		} else {
+			frame->tf_x[0] = CLOUDABI_EFAULT;
+			frame->tf_spsr |= PSR_C;
+		}
+		break;
+	case ERESTART:
+		/* Restart system call. */
+		frame->tf_elr -= 4;
+		break;
+	case EJUSTRETURN:
+		break;
+	default:
+		/* System call returned an error. */
+		frame->tf_x[0] = cloudabi_convert_errno(error);
+		frame->tf_spsr |= PSR_C;
+		break;
+	}
+}
+
+static void
+cloudabi32_schedtail(struct thread *td)
+{
+	struct trapframe *frame = td->td_frame;
+	register_t retval[2];
+
+	/* 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_x[2], sizeof(retval));
+	}
+	frame->tf_spsr |= PSR_AARCH32;
+}
+
+int
+cloudabi32_thread_setregs(struct thread *td,
+    const cloudabi32_threadattr_t *attr, uint32_t tcb)
+{
+	struct trapframe *frame;
+
+	/*
+	 * Pass in the thread ID of the new thread and the argument
+	 * pointer provided by the parent thread in as arguments to the
+	 * entry point.
+	 */
+	frame = td->td_frame;
+	memset(frame, 0, sizeof(*frame));
+	frame->tf_x[0] = td->td_tid;
+	frame->tf_x[1] = attr->argument;
+	frame->tf_x[13] = STACKALIGN(attr->stack + attr->stack_len);
+	frame->tf_elr = attr->entry_point;
+
+	/* Set up TLS. */
+	return (cpu_set_user_tls(td, TO_PTR(tcb)));
+}
+
+static struct sysentvec cloudabi32_elf_sysvec = {
+	.sv_size		= CLOUDABI32_SYS_MAXSYSCALL,
+	.sv_table		= cloudabi32_sysent,
+	.sv_fixup		= cloudabi32_fixup,
+	.sv_name		= "CloudABI ELF32",
+	.sv_coredump		= elf32_coredump,
+	.sv_pagesize		= PAGE_SIZE,
+	.sv_minuser		= VM_MIN_ADDRESS,
+	.sv_maxuser		= (uintmax_t)1 << 32,
+	.sv_stackprot		= VM_PROT_READ | VM_PROT_WRITE,
+	.sv_copyout_strings	= cloudabi32_copyout_strings,
+	.sv_setregs		= cloudabi32_proc_setregs,
+	.sv_flags		= SV_ABI_CLOUDABI | SV_CAPSICUM | SV_ILP32,
+	.sv_set_syscall_retval	= cloudabi32_set_syscall_retval,
+	.sv_fetch_syscall_args	= cloudabi32_fetch_syscall_args,
+	.sv_syscallnames	= cloudabi32_syscallnames,
+	.sv_schedtail		= cloudabi32_schedtail,
+};
+
+INIT_SYSENTVEC(elf_sysvec, &cloudabi32_elf_sysvec);
+
+Elf32_Brandinfo cloudabi32_brand = {
+	.brand		= ELFOSABI_CLOUDABI,
+	.machine	= EM_ARM,
+	.sysvec		= &cloudabi32_elf_sysvec,
+	.flags		= BI_BRAND_ONLY_STATIC,
+};

sys/conf/files.arm64

@@ -1,4 +1,16 @@
 # $FreeBSD$
+cloudabi32_vdso.o		optional	compat_cloudabi32	\
+	dependency	"$S/contrib/cloudabi/cloudabi_vdso_armv6_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_armv6_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-littleaarch64 --binary-architecture aarch64 cloudabi32_vdso.o ${.TARGET}" \
+	no-implicit-rule						\
+	clean		"cloudabi32_vdso_blob.o"
+#
 cloudabi64_vdso.o		optional	compat_cloudabi64	\
 	dependency	"$S/contrib/cloudabi/cloudabi_vdso_aarch64.S"	\
 	compile-with	"${CC} -x assembler-with-cpp -shared -nostdinc -nostdlib -Wl,-T$S/compat/cloudabi/cloudabi_vdso.lds $S/contrib/cloudabi/cloudabi_vdso_aarch64.S -o ${.TARGET}" \
@@ -130,6 +142,7 @@ arm64/cavium/thunder_pcie_fdt.c		optional	soc_cavm_thunderx pci fdt
 arm64/cavium/thunder_pcie_pem.c		optional	soc_cavm_thunderx pci
 arm64/cavium/thunder_pcie_pem_fdt.c	optional	soc_cavm_thunderx pci fdt
 arm64/cavium/thunder_pcie_common.c	optional	soc_cavm_thunderx pci
+arm64/cloudabi32/cloudabi32_sysvec.c	optional compat_cloudabi32
 arm64/cloudabi64/cloudabi64_sysvec.c	optional compat_cloudabi64
 contrib/vchiq/interface/compat/vchi_bsd.c	optional vchiq soc_brcm_bcm2837 \
 	compile-with "${NORMAL_C} -DUSE_VCHIQ_ARM -D__VCCOREVER__=0x04000000 -I$S/contrib/vchiq"

sys/modules/Makefile

@@ -796,8 +796,8 @@ _em=		em
 _epic=		epic
 .endif
 
-.if (${MACHINE_CPUARCH} == "amd64" || ${MACHINE_ARCH:Marmv[67]*} != "" || \
-     ${MACHINE_CPUARCH} == "i386")
+.if (${MACHINE_CPUARCH} == "aarch64" || ${MACHINE_CPUARCH} == "amd64" || \
+     ${MACHINE_ARCH:Marmv[67]*} != "" || ${MACHINE_CPUARCH} == "i386")
 _cloudabi32=	cloudabi32
 .endif
 .if ${MACHINE_CPUARCH} == "aarch64" || ${MACHINE_CPUARCH} == "amd64"