1 /* $NetBSD: sysproxy.c,v 1.8 2019/10/06 15:11:17 uwe 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.8 2019/10/06 15:11:17 uwe 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