1 /* $NetBSD: sysproxy.c,v 1.3 2015/04/18 15:49:18 pooka 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.3 2015/04/18 15:49:18 pooka 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 39 #define _RUMP_SYSPROXY 40 #include <rump/rumpuser.h> 41 42 #include "rump_private.h" 43 44 int 45 rump_init_server(const char *url) 46 { 47 48 return rumpuser_sp_init(url, ostype, osrelease, MACHINE); 49 } 50 51 static pid_t 52 hyp_getpid(void) 53 { 54 55 return curproc->p_pid; 56 } 57 58 static int 59 hyp_syscall(int num, void *arg, long *retval) 60 { 61 register_t regrv[2] = {0, 0}; 62 struct lwp *l; 63 struct sysent *callp; 64 int rv; 65 66 if (__predict_false(num >= SYS_NSYSENT)) 67 return ENOSYS; 68 69 /* XXX: always uses native syscall vector */ 70 callp = rump_sysent + num; 71 l = curlwp; 72 rv = sy_invoke(callp, l, (void *)arg, regrv, num); 73 retval[0] = regrv[0]; 74 retval[1] = regrv[1]; 75 76 return rv; 77 } 78 79 static struct pmap remotepmap; 80 81 static int 82 hyp_rfork(void *priv, int flags, const char *comm) 83 { 84 struct rump_spctl *spctl; 85 struct vmspace *vm; 86 struct proc *p; 87 struct lwp *l; 88 int error; 89 bool initfds; 90 91 /* 92 * If we are forking off of pid 1, initialize file descriptors. 93 */ 94 l = curlwp; 95 if (l->l_proc->p_pid == 1) { 96 KASSERT(flags == RUMP_RFFD_CLEAR); 97 initfds = true; 98 } else { 99 initfds = false; 100 } 101 102 /* 103 * Since it's a proxy proc, we create a vmspace for it. 104 */ 105 spctl = kmem_zalloc(sizeof(*spctl), KM_SLEEP); 106 vm = &spctl->spctl_vm; 107 uvmspace_init(vm, &remotepmap, 0, 0, false); 108 spctl->spctl = priv; 109 110 if ((error = rump_lwproc_rfork_vmspace(vm, flags)) != 0) { 111 kmem_free(vm, sizeof(*vm)); 112 return error; 113 } 114 115 /* 116 * We forked in this routine, so cannot use curlwp (const) 117 */ 118 l = rump_lwproc_curlwp(); 119 p = l->l_proc; 120 121 if (comm) 122 strlcpy(p->p_comm, comm, sizeof(p->p_comm)); 123 if (initfds) 124 rump_consdev_init(); 125 126 return 0; 127 } 128 129 /* 130 * Order all lwps in a process to exit. does *not* wait for them to drain. 131 */ 132 static void 133 hyp_lwpexit(void) 134 { 135 struct proc *p = curproc; 136 uint64_t where; 137 struct lwp *l; 138 139 mutex_enter(p->p_lock); 140 /* 141 * First pass: mark all lwps in the process with LW_RUMP_QEXIT 142 * so that they know they should exit. 143 */ 144 LIST_FOREACH(l, &p->p_lwps, l_sibling) { 145 if (l == curlwp) 146 continue; 147 l->l_flag |= LW_RUMP_QEXIT; 148 } 149 mutex_exit(p->p_lock); 150 151 /* 152 * Next, make sure everyone on all CPUs sees our status 153 * update. This keeps threads inside cv_wait() and makes 154 * sure we don't access a stale cv pointer later when 155 * we wake up the threads. 156 */ 157 158 where = xc_broadcast(0, (xcfunc_t)nullop, NULL, NULL); 159 xc_wait(where); 160 161 /* 162 * Ok, all lwps are either: 163 * 1) not in the cv code 164 * 2) sleeping on l->l_private 165 * 3) sleeping on p->p_waitcv 166 * 167 * Either way, l_private is stable until we set PS_RUMP_LWPEXIT 168 * in p->p_sflag. 169 */ 170 171 mutex_enter(p->p_lock); 172 LIST_FOREACH(l, &p->p_lwps, l_sibling) { 173 if (l->l_private) 174 cv_broadcast(l->l_private); 175 } 176 p->p_sflag |= PS_RUMP_LWPEXIT; 177 cv_broadcast(&p->p_waitcv); 178 mutex_exit(p->p_lock); 179 } 180 181 /* 182 * Notify process that all threads have been drained and exec is complete. 183 */ 184 static void 185 hyp_execnotify(const char *comm) 186 { 187 struct proc *p = curproc; 188 189 fd_closeexec(); 190 mutex_enter(p->p_lock); 191 KASSERT(p->p_nlwps == 1 && p->p_sflag & PS_RUMP_LWPEXIT); 192 p->p_sflag &= ~PS_RUMP_LWPEXIT; 193 mutex_exit(p->p_lock); 194 strlcpy(p->p_comm, comm, sizeof(p->p_comm)); 195 } 196 197 /* 198 * Initialize interface pointers since component is present. 199 */ 200 RUMP_COMPONENT(RUMP_COMPONENT_KERN) 201 { 202 203 rump_sysproxy_ops.rspo_copyin = rumpuser_sp_copyin; 204 rump_sysproxy_ops.rspo_copyinstr = rumpuser_sp_copyinstr; 205 rump_sysproxy_ops.rspo_copyout = rumpuser_sp_copyout; 206 rump_sysproxy_ops.rspo_copyoutstr = rumpuser_sp_copyoutstr; 207 rump_sysproxy_ops.rspo_anonmmap = rumpuser_sp_anonmmap; 208 rump_sysproxy_ops.rspo_raise = rumpuser_sp_raise; 209 rump_sysproxy_ops.rspo_fini = rumpuser_sp_fini; 210 211 rump_sysproxy_ops.rspo_hyp_getpid = hyp_getpid; 212 rump_sysproxy_ops.rspo_hyp_syscall = hyp_syscall; 213 rump_sysproxy_ops.rspo_hyp_rfork = hyp_rfork; 214 rump_sysproxy_ops.rspo_hyp_lwpexit = hyp_lwpexit; 215 rump_sysproxy_ops.rspo_hyp_execnotify = hyp_execnotify; 216 } 217