1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #include <sys/errno.h> 27 #include <sys/systm.h> 28 #include <sys/archsystm.h> 29 #include <sys/privregs.h> 30 #include <sys/exec.h> 31 #include <sys/lwp.h> 32 #include <sys/sem.h> 33 #include <sys/brand.h> 34 #include <sys/lx_brand.h> 35 #include <sys/lx_pid.h> 36 #include <sys/lx_futex.h> 37 38 /* Linux specific functions and definitions */ 39 void lx_setrval(klwp_t *, int, int); 40 void lx_exec(); 41 int lx_initlwp(klwp_t *); 42 void lx_forklwp(klwp_t *, klwp_t *); 43 void lx_exitlwp(klwp_t *); 44 void lx_freelwp(klwp_t *); 45 static void lx_save(klwp_t *); 46 static void lx_restore(klwp_t *); 47 extern void lx_ptrace_free(proc_t *); 48 49 /* 50 * Set the return code for the forked child, always zero 51 */ 52 /*ARGSUSED*/ 53 void 54 lx_setrval(klwp_t *lwp, int v1, int v2) 55 { 56 lwptoregs(lwp)->r_r0 = 0; 57 } 58 59 /* 60 * Reset process state on exec(2) 61 */ 62 void 63 lx_exec() 64 { 65 klwp_t *lwp = ttolwp(curthread); 66 struct lx_lwp_data *lwpd = lwptolxlwp(lwp); 67 int err; 68 69 /* 70 * There are two mutually exclusive special cases we need to 71 * address. First, if this was a native process prior to this 72 * exec(), then this lwp won't have its brand-specific data 73 * initialized and it won't be assigned a Linux PID yet. Second, 74 * if this was a multi-threaded Linux process and this lwp wasn't 75 * the main lwp, then we need to make its Solaris and Linux PIDS 76 * match. 77 */ 78 if (lwpd == NULL) { 79 err = lx_initlwp(lwp); 80 /* 81 * Only possible failure from this routine should be an 82 * inability to allocate a new PID. Since single-threaded 83 * processes don't need a new PID, we should never hit this 84 * error. 85 */ 86 ASSERT(err == 0); 87 lwpd = lwptolxlwp(lwp); 88 } else if (curthread->t_tid != 1) { 89 lx_pid_reassign(curthread); 90 } 91 92 installctx(lwptot(lwp), lwp, lx_save, lx_restore, NULL, NULL, lx_save, 93 NULL); 94 95 /* 96 * clear out the tls array 97 */ 98 bzero(lwpd->br_tls, sizeof (lwpd->br_tls)); 99 100 /* 101 * reset the tls entries in the gdt 102 */ 103 kpreempt_disable(); 104 lx_restore(lwp); 105 kpreempt_enable(); 106 } 107 108 void 109 lx_exitlwp(klwp_t *lwp) 110 { 111 struct lx_lwp_data *lwpd = lwptolxlwp(lwp); 112 proc_t *p; 113 kthread_t *t; 114 sigqueue_t *sqp = NULL; 115 pid_t ppid; 116 id_t ptid; 117 118 if (lwpd == NULL) 119 return; /* second time thru' */ 120 121 if (lwpd->br_clear_ctidp != NULL) { 122 (void) suword32(lwpd->br_clear_ctidp, 0); 123 (void) lx_futex((uintptr_t)lwpd->br_clear_ctidp, FUTEX_WAKE, 1, 124 NULL, NULL, 0); 125 } 126 127 if (lwpd->br_signal != 0) { 128 /* 129 * The first thread in a process doesn't cause a signal to 130 * be sent when it exits. It was created by a fork(), not 131 * a clone(), so the parent should get signalled when the 132 * process exits. 133 */ 134 if (lwpd->br_ptid == -1) 135 goto free; 136 137 sqp = kmem_zalloc(sizeof (sigqueue_t), KM_SLEEP); 138 /* 139 * If br_ppid is 0, it means this is a CLONE_PARENT thread, 140 * so the signal goes to the parent process - not to a 141 * specific thread in this process. 142 */ 143 p = lwptoproc(lwp); 144 if (lwpd->br_ppid == 0) { 145 mutex_enter(&p->p_lock); 146 ppid = p->p_ppid; 147 t = NULL; 148 } else { 149 /* 150 * If we have been reparented to init or if our 151 * parent thread is gone, then nobody gets 152 * signaled. 153 */ 154 if ((lx_lwp_ppid(lwp, &ppid, &ptid) == 1) || 155 (ptid == -1)) 156 goto free; 157 158 mutex_enter(&pidlock); 159 if ((p = prfind(ppid)) == NULL || p->p_stat == SIDL) { 160 mutex_exit(&pidlock); 161 goto free; 162 } 163 mutex_enter(&p->p_lock); 164 mutex_exit(&pidlock); 165 166 if ((t = idtot(p, ptid)) == NULL) { 167 mutex_exit(&p->p_lock); 168 goto free; 169 } 170 } 171 172 sqp->sq_info.si_signo = lwpd->br_signal; 173 sqp->sq_info.si_code = lwpd->br_exitwhy; 174 sqp->sq_info.si_status = lwpd->br_exitwhat; 175 sqp->sq_info.si_pid = lwpd->br_pid; 176 sqp->sq_info.si_uid = crgetruid(CRED()); 177 sigaddqa(p, t, sqp); 178 mutex_exit(&p->p_lock); 179 sqp = NULL; 180 } 181 182 free: 183 if (sqp) 184 kmem_free(sqp, sizeof (sigqueue_t)); 185 186 lx_freelwp(lwp); 187 } 188 189 void 190 lx_freelwp(klwp_t *lwp) 191 { 192 struct lx_lwp_data *lwpd = lwptolxlwp(lwp); 193 194 if (lwpd != NULL) { 195 (void) removectx(lwptot(lwp), lwp, lx_save, lx_restore, 196 NULL, NULL, lx_save, NULL); 197 if (lwpd->br_pid != 0) 198 lx_pid_rele(lwptoproc(lwp)->p_pid, 199 lwptot(lwp)->t_tid); 200 201 lwp->lwp_brand = NULL; 202 kmem_free(lwpd, sizeof (struct lx_lwp_data)); 203 } 204 } 205 206 int 207 lx_initlwp(klwp_t *lwp) 208 { 209 struct lx_lwp_data *lwpd; 210 struct lx_lwp_data *plwpd; 211 kthread_t *tp = lwptot(lwp); 212 213 lwpd = kmem_zalloc(sizeof (struct lx_lwp_data), KM_SLEEP); 214 lwpd->br_exitwhy = CLD_EXITED; 215 lwpd->br_lwp = lwp; 216 lwpd->br_clear_ctidp = NULL; 217 lwpd->br_set_ctidp = NULL; 218 lwpd->br_signal = 0; 219 /* 220 * lwpd->br_affinitymask was zeroed by kmem_zalloc(). 221 */ 222 223 /* 224 * The first thread in a process has ppid set to the parent 225 * process's pid, and ptid set to -1. Subsequent threads in the 226 * process have their ppid set to the pid of the thread that 227 * created them, and their ptid to that thread's tid. 228 */ 229 if (tp->t_next == tp) { 230 lwpd->br_ppid = tp->t_procp->p_ppid; 231 lwpd->br_ptid = -1; 232 } else if (ttolxlwp(curthread) != NULL) { 233 plwpd = ttolxlwp(curthread); 234 bcopy(plwpd->br_tls, lwpd->br_tls, sizeof (lwpd->br_tls)); 235 lwpd->br_ppid = plwpd->br_pid; 236 lwpd->br_ptid = curthread->t_tid; 237 } else { 238 /* 239 * Oddball case: the parent thread isn't a Linux process. 240 */ 241 lwpd->br_ppid = 0; 242 lwpd->br_ptid = -1; 243 } 244 lwp->lwp_brand = lwpd; 245 246 if (lx_pid_assign(tp)) { 247 kmem_free(lwpd, sizeof (struct lx_lwp_data)); 248 lwp->lwp_brand = NULL; 249 return (-1); 250 } 251 lwpd->br_tgid = lwpd->br_pid; 252 253 installctx(lwptot(lwp), lwp, lx_save, lx_restore, NULL, NULL, 254 lx_save, NULL); 255 256 return (0); 257 } 258 259 /* 260 * There is no need to have any locking for either the source or 261 * destination struct lx_lwp_data structs. This is always run in the 262 * thread context of the source thread, and the destination thread is 263 * always newly created and not referred to from anywhere else. 264 */ 265 void 266 lx_forklwp(klwp_t *srclwp, klwp_t *dstlwp) 267 { 268 struct lx_lwp_data *src = srclwp->lwp_brand; 269 struct lx_lwp_data *dst = dstlwp->lwp_brand; 270 271 dst->br_ppid = src->br_pid; 272 dst->br_ptid = lwptot(srclwp)->t_tid; 273 bcopy(src->br_tls, dst->br_tls, sizeof (dst->br_tls)); 274 275 /* 276 * copy only these flags 277 */ 278 dst->br_lwp_flags = src->br_lwp_flags & BR_CPU_BOUND; 279 dst->br_clone_args = NULL; 280 } 281 282 /* 283 * When switching a Linux process off the CPU, clear its GDT entries. 284 */ 285 /* ARGSUSED */ 286 static void 287 lx_save(klwp_t *t) 288 { 289 int i; 290 291 #if defined(__amd64) 292 reset_sregs(); 293 #endif 294 for (i = 0; i < LX_TLSNUM; i++) 295 gdt_update_usegd(GDT_TLSMIN + i, &null_udesc); 296 } 297 298 /* 299 * When switching a Linux process on the CPU, set its GDT entries. 300 */ 301 static void 302 lx_restore(klwp_t *t) 303 { 304 struct lx_lwp_data *lwpd = lwptolxlwp(t); 305 user_desc_t *tls; 306 int i; 307 308 ASSERT(lwpd); 309 310 tls = lwpd->br_tls; 311 for (i = 0; i < LX_TLSNUM; i++) 312 gdt_update_usegd(GDT_TLSMIN + i, &tls[i]); 313 } 314 315 void 316 lx_set_gdt(int entry, user_desc_t *descrp) 317 { 318 319 gdt_update_usegd(entry, descrp); 320 } 321 322 void 323 lx_clear_gdt(int entry) 324 { 325 gdt_update_usegd(entry, &null_udesc); 326 } 327 328 longlong_t 329 lx_nosys() 330 { 331 return (set_errno(ENOSYS)); 332 } 333 334 longlong_t 335 lx_opnotsupp() 336 { 337 return (set_errno(EOPNOTSUPP)); 338 } 339 340 /* 341 * Brand-specific routine to check if given non-Solaris standard segment 342 * register values should be modified to other values. 343 */ 344 /*ARGSUSED*/ 345 greg_t 346 lx_fixsegreg(greg_t sr, model_t datamodel) 347 { 348 ASSERT(sr == (sr & 0xffff)); 349 350 /* 351 * Force the SR into the LDT in ring 3 for 32-bit processes. 352 * 353 * 64-bit processes get the null GDT selector since they are not 354 * allowed to have a private LDT. 355 */ 356 #if defined(__amd64) 357 return (datamodel == DATAMODEL_ILP32 ? (sr | SEL_TI_LDT | SEL_UPL) : 0); 358 #elif defined(__i386) 359 datamodel = datamodel; /* datamodel currently unused for 32-bit */ 360 return (sr | SEL_TI_LDT | SEL_UPL); 361 #endif /* __amd64 */ 362 }