Index: sys/amd64/cloudabi64/cloudabi64_thread.c =================================================================== --- /dev/null +++ sys/amd64/cloudabi64/cloudabi64_thread.c @@ -0,0 +1,98 @@ +/*- + * 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 +#include + +#include +#include + +#include +#include +#include +#include + +#include +#include + +struct thread_create_args { + cloudabi64_threadattr_t attr; + lwpid_t tid; +}; + +static int +initialize_thread(struct thread *td, void *thunk) +{ + struct thread_create_args *args = thunk; + cloudabi64_threadattr_t *attr = &args->attr; + struct trapframe *tf; + + /* Save the thread ID, so it can be returned. */ + args->tid = td->td_tid; + + /* + * Set up trap frame of new thread. The stack needs to be + * 16-byte aligned. + */ + cpu_thread_clean(td); + tf = td->td_frame; + tf->tf_rbp = 0; + tf->tf_rsp = rounddown2((uintptr_t)attr->stack + attr->stack_size, 16); + tf->tf_rsp -= 8; + tf->tf_rip = attr->entry_point; + tf->tf_ds = _udatasel; + tf->tf_es = _udatasel; + tf->tf_fs = _ufssel; + tf->tf_gs = _ugssel; + tf->tf_flags = TF_HASSEGS; + + /* + * Pass in the thread ID of the new thread and the argument + * pointer provided by the parent thread as arguments to the + * entry point. + */ + tf->tf_rdi = td->td_tid; + tf->tf_rsi = attr->argument; + return (0); +} + +int +cloudabi64_sys_thread_create(struct thread *td, + struct cloudabi64_sys_thread_create_args *uap) +{ + struct thread_create_args args; + int error; + + error = copyin(uap->attr, &args.attr, sizeof(args.attr)); + if (error != 0) + return (error); + error = thread_create(td, NULL, initialize_thread, &args); + td->td_retval[0] = args.tid; + return (error); +} Index: sys/compat/cloudabi64/cloudabi64_thread.c =================================================================== --- sys/compat/cloudabi64/cloudabi64_thread.c +++ /dev/null @@ -1,39 +0,0 @@ -/*- - * 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); -} Index: sys/conf/files =================================================================== --- sys/conf/files +++ sys/conf/files @@ -267,7 +267,6 @@ 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/files.amd64 =================================================================== --- sys/conf/files.amd64 +++ sys/conf/files.amd64 @@ -137,6 +137,7 @@ amd64/amd64/uio_machdep.c standard amd64/amd64/uma_machdep.c standard amd64/amd64/vm_machdep.c standard +amd64/cloudabi64/cloudabi64_thread.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}" cddl/dev/dtrace/amd64/dtrace_asm.S optional dtrace compile-with "${DTRACE_S}" Index: sys/kern/kern_thr.c =================================================================== --- sys/kern/kern_thr.c +++ sys/kern/kern_thr.c @@ -89,29 +89,39 @@ #define suword_lwpid suword #endif -static int create_thread(struct thread *td, mcontext_t *ctx, - void (*start_func)(void *), void *arg, - char *stack_base, size_t stack_size, - char *tls_base, - long *child_tid, long *parent_tid, - int flags, struct rtprio *rtp); - /* * System call interface. */ + +struct thr_create_initthr_args { + ucontext_t ctx; + long *tid; +}; + +static int +thr_create_initthr(struct thread *td, void *thunk) +{ + struct thr_create_initthr_args *args; + + /* Copy out the child tid. */ + args = thunk; + if (args->tid != NULL && suword_lwpid(args->tid, td->td_tid)) + return (EFAULT); + + return (set_mcontext(td, &args->ctx.uc_mcontext)); +} + int sys_thr_create(struct thread *td, struct thr_create_args *uap) /* ucontext_t *ctx, long *id, int flags */ { - ucontext_t ctx; + struct thr_create_initthr_args args; int error; - if ((error = copyin(uap->ctx, &ctx, sizeof(ctx)))) + if ((error = copyin(uap->ctx, &args.ctx, sizeof(args.ctx)))) return (error); - - error = create_thread(td, &ctx.uc_mcontext, NULL, NULL, - NULL, 0, NULL, uap->id, NULL, uap->flags, NULL); - return (error); + args.tid = uap->id; + return (thread_create(td, NULL, thr_create_initthr, &args)); } int @@ -129,6 +139,35 @@ return (kern_thr_new(td, ¶m)); } +static int +thr_new_initthr(struct thread *td, void *thunk) +{ + stack_t stack; + struct thr_param *param; + + /* + * Here we copy out tid to two places, one for child and one + * for parent, because pthread can create a detached thread, + * if parent wants to safely access child tid, it has to provide + * its storage, because child thread may exit quickly and + * memory is freed before parent thread can access it. + */ + param = thunk; + if ((param->child_tid != NULL && + suword_lwpid(param->child_tid, td->td_tid)) || + (param->parent_tid != NULL && + suword_lwpid(param->parent_tid, td->td_tid))) + return (EFAULT); + + /* Set up our machine context. */ + stack.ss_sp = param->stack_base; + stack.ss_size = param->stack_size; + /* Set upcall address to user thread entry function. */ + cpu_set_upcall_kse(td, param->start_func, param->arg, &stack); + /* Setup user TLS address and TLS pointer register. */ + return (cpu_set_user_tls(td, param->tls_base)); +} + int kern_thr_new(struct thread *td, struct thr_param *param) { @@ -142,22 +181,13 @@ return (error); rtpp = &rtp; } - error = create_thread(td, NULL, param->start_func, param->arg, - param->stack_base, param->stack_size, param->tls_base, - param->child_tid, param->parent_tid, param->flags, - rtpp); - return (error); + return (thread_create(td, rtpp, thr_new_initthr, param)); } -static int -create_thread(struct thread *td, mcontext_t *ctx, - void (*start_func)(void *), void *arg, - char *stack_base, size_t stack_size, - char *tls_base, - long *child_tid, long *parent_tid, - int flags, struct rtprio *rtp) +int +thread_create(struct thread *td, struct rtprio *rtp, + int (*initialize_thread)(struct thread *, void *), void *thunk) { - stack_t stack; struct thread *newtd; struct proc *p; int error; @@ -199,24 +229,6 @@ cpu_set_upcall(newtd, td); - /* - * Try the copyout as soon as we allocate the td so we don't - * have to tear things down in a failure case below. - * Here we copy out tid to two places, one for child and one - * for parent, because pthread can create a detached thread, - * if parent wants to safely access child tid, it has to provide - * its storage, because child thread may exit quickly and - * memory is freed before parent thread can access it. - */ - if ((child_tid != NULL && - suword_lwpid(child_tid, newtd->td_tid)) || - (parent_tid != NULL && - suword_lwpid(parent_tid, newtd->td_tid))) { - thread_free(newtd); - error = EFAULT; - goto fail; - } - bzero(&newtd->td_startzero, __rangeof(struct thread, td_startzero, td_endzero)); bcopy(&td->td_startcopy, &newtd->td_startcopy, @@ -224,26 +236,11 @@ newtd->td_proc = td->td_proc; thread_cow_get(newtd, td); - if (ctx != NULL) { /* old way to set user context */ - error = set_mcontext(newtd, ctx); - if (error != 0) { - thread_cow_free(newtd); - thread_free(newtd); - goto fail; - } - } else { - /* Set up our machine context. */ - stack.ss_sp = stack_base; - stack.ss_size = stack_size; - /* Set upcall address to user thread entry function. */ - cpu_set_upcall_kse(newtd, start_func, arg, &stack); - /* Setup user TLS address and TLS pointer register. */ - error = cpu_set_user_tls(newtd, tls_base); - if (error != 0) { - thread_cow_free(newtd); - thread_free(newtd); - goto fail; - } + error = initialize_thread(newtd, thunk); + if (error != 0) { + thread_cow_free(newtd); + thread_free(newtd); + goto fail; } PROC_LOCK(p); Index: sys/sys/proc.h =================================================================== --- sys/sys/proc.h +++ sys/sys/proc.h @@ -992,6 +992,8 @@ void thread_cow_get(struct thread *newtd, struct thread *td); void thread_cow_free(struct thread *td); void thread_cow_update(struct thread *td); +int thread_create(struct thread *td, struct rtprio *rtp, + int (*initialize_thread)(struct thread *, void *), void *thunk); void thread_exit(void) __dead2; void thread_free(struct thread *td); void thread_link(struct thread *td, struct proc *p);