Home | History | Annotate | Line # | Download | only in libsysproxy
sysproxy.c revision 1.4.20.2
      1 /*	$NetBSD: sysproxy.c,v 1.4.20.2 2020/04/13 08:05:18 martin Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 2010, 2011 Antti Kantee.  All Rights Reserved.
      5  *
      6  * Redistribution and use in source and binary forms, with or without
      7  * modification, are permitted provided that the following conditions
      8  * are met:
      9  * 1. Redistributions of source code must retain the above copyright
     10  *    notice, this list of conditions and the following disclaimer.
     11  * 2. Redistributions in binary form must reproduce the above copyright
     12  *    notice, this list of conditions and the following disclaimer in the
     13  *    documentation and/or other materials provided with the distribution.
     14  *
     15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
     16  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     17  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
     18  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
     21  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     25  * SUCH DAMAGE.
     26  */
     27 
     28 #include <sys/cdefs.h>
     29 __KERNEL_RCSID(0, "$NetBSD: sysproxy.c,v 1.4.20.2 2020/04/13 08:05:18 martin Exp $");
     30 
     31 #include <sys/param.h>
     32 #include <sys/filedesc.h>
     33 #include <sys/kmem.h>
     34 #include <sys/syscall.h>
     35 #include <sys/syscallvar.h>
     36 #include <sys/systm.h>
     37 #include <sys/xcall.h>
     38 #include <sys/lockdebug.h>
     39 #include <sys/psref.h>
     40 
     41 #define _RUMP_SYSPROXY
     42 #include <rump/rumpuser.h>
     43 
     44 #include <rump-sys/kern.h>
     45 
     46 int
     47 rump_init_server(const char *url)
     48 {
     49 
     50 	return rumpuser_sp_init(url, ostype, osrelease, MACHINE);
     51 }
     52 
     53 static pid_t
     54 hyp_getpid(void)
     55 {
     56 
     57 	return curproc->p_pid;
     58 }
     59 
     60 static int
     61 hyp_syscall(int num, void *arg, long *retval)
     62 {
     63 	register_t regrv[2] = {0, 0};
     64 	struct lwp *l;
     65 	struct sysent *callp;
     66 	int rv;
     67 
     68 	if (__predict_false(num >= SYS_NSYSENT))
     69 		return ENOSYS;
     70 
     71 	/* XXX: always uses native syscall vector */
     72 	callp = rump_sysent + num;
     73 	l = curlwp;
     74 	rv = sy_invoke(callp, l, (void *)arg, regrv, num);
     75 	retval[0] = regrv[0];
     76 	retval[1] = regrv[1];
     77 
     78 	/* Sanity checks (from mi_userret) */
     79 	LOCKDEBUG_BARRIER(NULL, 0);
     80 	KASSERT(l->l_nopreempt == 0);
     81 	PSREF_DEBUG_BARRIER();
     82 	KASSERT(l->l_psrefs == 0);
     83 
     84 	return rv;
     85 }
     86 
     87 static struct pmap remotepmap;
     88 
     89 static int
     90 hyp_rfork(void *priv, int flags, const char *comm)
     91 {
     92 	struct rump_spctl *spctl;
     93 	struct vmspace *vm;
     94 	struct proc *p;
     95 	struct lwp *l;
     96 	int error;
     97 	bool initfds;
     98 
     99 	/*
    100 	 * If we are forking off of pid 1, initialize file descriptors.
    101 	 */
    102 	l = curlwp;
    103 	if (l->l_proc->p_pid == 1) {
    104 		KASSERT(flags == RUMP_RFFD_CLEAR);
    105 		initfds = true;
    106 	} else {
    107 		initfds = false;
    108 	}
    109 
    110 	/*
    111 	 * Since it's a proxy proc, we create a vmspace for it.
    112 	 */
    113 	spctl = kmem_zalloc(sizeof(*spctl), KM_SLEEP);
    114 	vm = &spctl->spctl_vm;
    115 	uvmspace_init(vm, &remotepmap, 0, 0, false);
    116 	spctl->spctl = priv;
    117 
    118 	if ((error = rump_lwproc_rfork_vmspace(vm, flags)) != 0) {
    119 		kmem_free(vm, sizeof(*vm));
    120 		return error;
    121 	}
    122 
    123 	/*
    124 	 * We forked in this routine, so cannot use curlwp (const)
    125 	 */
    126 	l = rump_lwproc_curlwp();
    127 	p = l->l_proc;
    128 
    129 	if (comm)
    130 		strlcpy(p->p_comm, comm, sizeof(p->p_comm));
    131 	if (initfds)
    132 		rump_consdev_init();
    133 
    134 	return 0;
    135 }
    136 
    137 /*
    138  * Order all lwps in a process to exit.  does *not* wait for them to drain.
    139  */
    140 static void
    141 hyp_lwpexit(void)
    142 {
    143 	struct proc *p = curproc;
    144 	struct lwp *l;
    145 
    146 	mutex_enter(p->p_lock);
    147 	/*
    148 	 * First pass: mark all lwps in the process with LW_RUMP_QEXIT
    149 	 * so that they know they should exit.
    150 	 */
    151 	LIST_FOREACH(l, &p->p_lwps, l_sibling) {
    152 		if (l == curlwp)
    153 			continue;
    154 		l->l_flag |= LW_RUMP_QEXIT;
    155 	}
    156 	mutex_exit(p->p_lock);
    157 
    158 	/*
    159 	 * Next, make sure everyone on all CPUs sees our status
    160 	 * update.  This keeps threads inside cv_wait() and makes
    161 	 * sure we don't access a stale cv pointer later when
    162 	 * we wake up the threads.
    163 	 */
    164 
    165 	xc_barrier(0);
    166 
    167 	/*
    168 	 * Ok, all lwps are either:
    169 	 *  1) not in the cv code
    170 	 *  2) sleeping on l->l_private
    171 	 *  3) sleeping on p->p_waitcv
    172 	 *
    173 	 * Either way, l_private is stable until we set PS_RUMP_LWPEXIT
    174 	 * in p->p_sflag.
    175 	 */
    176 
    177 	mutex_enter(p->p_lock);
    178 	LIST_FOREACH(l, &p->p_lwps, l_sibling) {
    179 		if (l->l_private)
    180 			cv_broadcast(l->l_private);
    181 	}
    182 	p->p_sflag |= PS_RUMP_LWPEXIT;
    183 	cv_broadcast(&p->p_waitcv);
    184 	mutex_exit(p->p_lock);
    185 }
    186 
    187 /*
    188  * Notify process that all threads have been drained and exec is complete.
    189  */
    190 static void
    191 hyp_execnotify(const char *comm)
    192 {
    193 	struct proc *p = curproc;
    194 
    195 	fd_closeexec();
    196 	mutex_enter(p->p_lock);
    197 	KASSERT(p->p_nlwps == 1 && p->p_sflag & PS_RUMP_LWPEXIT);
    198 	p->p_sflag &= ~PS_RUMP_LWPEXIT;
    199 	mutex_exit(p->p_lock);
    200 	strlcpy(p->p_comm, comm, sizeof(p->p_comm));
    201 }
    202 
    203 /*
    204  * Initialize interface pointers since component is present.
    205  */
    206 RUMP_COMPONENT(RUMP_COMPONENT_KERN)
    207 {
    208 
    209 	rump_sysproxy_ops.rspo_copyin		= rumpuser_sp_copyin;
    210 	rump_sysproxy_ops.rspo_copyinstr	= rumpuser_sp_copyinstr;
    211 	rump_sysproxy_ops.rspo_copyout		= rumpuser_sp_copyout;
    212 	rump_sysproxy_ops.rspo_copyoutstr	= rumpuser_sp_copyoutstr;
    213 	rump_sysproxy_ops.rspo_anonmmap		= rumpuser_sp_anonmmap;
    214 	rump_sysproxy_ops.rspo_raise		= rumpuser_sp_raise;
    215 	rump_sysproxy_ops.rspo_fini		= rumpuser_sp_fini;
    216 
    217 	rump_sysproxy_ops.rspo_hyp_getpid	= hyp_getpid;
    218 	rump_sysproxy_ops.rspo_hyp_syscall	= hyp_syscall;
    219 	rump_sysproxy_ops.rspo_hyp_rfork	= hyp_rfork;
    220 	rump_sysproxy_ops.rspo_hyp_lwpexit	= hyp_lwpexit;
    221 	rump_sysproxy_ops.rspo_hyp_execnotify	= hyp_execnotify;
    222 }
    223