Print this page
OS-???? [lx] SIGEV_THREAD_ID emulation needed
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/brand/lx/os/lx_brand.c
+++ new/usr/src/uts/common/brand/lx/os/lx_brand.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 23 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
24 24 * Use is subject to license terms.
25 25 */
26 26
27 27 /*
28 28 * Copyright 2015, Joyent, Inc. All rights reserved.
29 29 */
30 30
31 31 /*
32 32 * The LX Brand: emulation of a Linux operating environment within a zone.
33 33 *
34 34 * OVERVIEW
35 35 *
36 36 * The LX brand enables a full Linux userland -- including a C library,
37 37 * init(1) framework, and some set of applications -- to run unmodified
38 38 * within an illumos zone. Unlike illumos, where applications are expected
39 39 * to link against and consume functions exported from libraries, the
40 40 * supported Linux binary compatibility boundary is the system call
41 41 * interface. By accurately emulating the behaviour of Linux system calls,
42 42 * Linux software can be executed in this environment as if it were running
43 43 * on a native Linux system.
44 44 *
45 45 * EMULATING LINUX SYSTEM CALLS
46 46 *
47 47 * Linux system calls are made in 32-bit processes via the "int 0x80"
48 48 * instruction; in 64-bit processes the "syscall" instruction is used, as it
49 49 * is with native illumos processes. In both cases, arguments to system
50 50 * calls are generally passed in registers and the usermode stack is not
51 51 * interpreted or modified by the Linux kernel.
52 52 *
53 53 * When the emulated Linux process makes a system call, it traps into the
54 54 * illumos kernel. The in-kernel brand module contains various emulation
55 55 * routines, and can fully service some emulated system calls; e.g. read(2)
56 56 * and write(2). Other system calls require assistance from the illumos
57 57 * libc, bouncing back out to the brand library ("lx_brand.so.1") for
58 58 * emulation.
59 59 *
60 60 * The brand mechanism allows for the provision of an alternative trap
61 61 * handler for the various system call mechanisms. Traditionally this was
62 62 * used to immediately revector execution to the usermode emulation library,
63 63 * which was responsible for handling all system calls. In the interests of
64 64 * more accurate emulation and increased performance, much of the regular
65 65 * illumos system call path is now invoked. Only the argument processing and
66 66 * handler dispatch are replaced by the brand, via the per-LWP
67 67 * "lwp_brand_syscall" interposition function pointer.
68 68 *
69 69 * THE NATIVE AND BRAND STACKS
70 70 *
71 71 * Some runtime environments (e.g. the Go language) allocate very small
72 72 * thread stacks, preferring to grow or split the stack as necessary. The
73 73 * Linux kernel generally does not use the usermode stack when servicing
74 74 * system calls, so this is not a problem. In order for our emulation to
75 75 * have the same zero stack impact, we must execute usermode emulation
76 76 * routines on an _alternate_ stack. This is similar, in principle, to the
77 77 * use of sigaltstack(3C) to run signal handlers off the main thread stack.
78 78 *
79 79 * To this end, the brand library allocates and installs an alternate stack
80 80 * (called the "native" stack) for each LWP. The in-kernel brand code uses
81 81 * this stack for usermode emulation calls and interposed signal delivery,
82 82 * while the emulated Linux process sees only the data on the main thread
83 83 * stack, known as the "brand" stack. The stack mode is tracked in the
84 84 * per-LWP brand-private data, using the LX_STACK_MODE_* enum.
85 85 *
86 86 * The stack mode doubles as a system call "mode bit". When in the
87 87 * LX_STACK_MODE_BRAND mode, system calls are processed as emulated Linux
88 88 * system calls. In other modes, system calls are assumed to be native
89 89 * illumos system calls as made during brand library initialisation and
90 90 * usermode emulation.
91 91 *
92 92 * USERMODE EMULATION
93 93 *
94 94 * When a Linux system call cannot be emulated within the kernel, we preserve
95 95 * the register state of the Linux process and revector the LWP to the brand
96 96 * library usermode emulation handler: the "lx_emulate()" function in
97 97 * "lx_brand.so.1". This revectoring is modelled on the delivery of signals,
98 98 * and is performed in "lx_emulate_user()".
99 99 *
100 100 * First, the emulated process state is written out to the usermode stack of
101 101 * the process as a "ucontext_t" object. Arguments to the emulation routine
102 102 * are passed on the stack or in registers, depending on the ABI. When the
103 103 * usermode emulation is complete, the result is passed back to the kernel
104 104 * (via the "B_EMULATION_DONE" brandsys subcommand) with the saved context
105 105 * for restoration.
106 106 *
107 107 * SIGNAL DELIVERY, SETCONTEXT AND GETCONTEXT
108 108 *
109 109 * When servicing emulated system calls in the usermode brand library, or
110 110 * during signal delivery, various state is preserved by the kernel so that
111 111 * the running LWP may be revectored to a handling routine. The context
112 112 * allows the kernel to restart the program at the point of interruption,
113 113 * either at the return of the signal handler, via setcontext(3C); or after
114 114 * the usermode emulation request has been serviced, via B_EMULATION_DONE.
115 115 *
116 116 * In illumos native processes, the saved context (a "ucontext_t" object)
117 117 * includes the state of registers and the current signal mask at the point
118 118 * of interruption. The context also includes a link to the most recently
119 119 * saved context, forming a chain to be unwound as requests complete. The LX
120 120 * brand requires additional book-keeping to describe the machine state: in
121 121 * particular, the current stack mode and the occupied extent of the native
122 122 * stack.
123 123 *
124 124 * The brand code is able to interpose on the context save and restore
125 125 * operations in the kernel -- see "lx_savecontext()" and
126 126 * "lx_restorecontext()" -- to enable getcontext(3C) and setcontext(3C) to
127 127 * function correctly in the face of a dual stack LWP. The brand also
128 128 * interposes on the signal delivery mechanism -- see "lx_sendsig()" and
129 129 * "lx_sendsig_stack()" -- to allow all signals to be delivered to the brand
130 130 * library interposer on the native stack, regardless of the interrupted
131 131 * execution mode. Linux sigaltstack(2) emulation is performed entirely by
132 132 * the usermode brand library during signal handler interposition.
133 133 */
134 134
135 135 #include <sys/types.h>
136 136 #include <sys/kmem.h>
137 137 #include <sys/errno.h>
138 138 #include <sys/thread.h>
139 139 #include <sys/systm.h>
140 140 #include <sys/syscall.h>
141 141 #include <sys/proc.h>
142 142 #include <sys/modctl.h>
143 143 #include <sys/cmn_err.h>
144 144 #include <sys/model.h>
145 145 #include <sys/exec.h>
146 146 #include <sys/lx_impl.h>
147 147 #include <sys/machbrand.h>
148 148 #include <sys/lx_syscalls.h>
149 149 #include <sys/lx_misc.h>
150 150 #include <sys/lx_futex.h>
151 151 #include <sys/lx_brand.h>
152 152 #include <sys/param.h>
153 153 #include <sys/termios.h>
154 154 #include <sys/sunddi.h>
155 155 #include <sys/ddi.h>
156 156 #include <sys/vnode.h>
157 157 #include <sys/pathname.h>
158 158 #include <sys/auxv.h>
159 159 #include <sys/priv.h>
160 160 #include <sys/regset.h>
161 161 #include <sys/privregs.h>
162 162 #include <sys/archsystm.h>
163 163 #include <sys/zone.h>
164 164 #include <sys/brand.h>
165 165 #include <sys/sdt.h>
166 166 #include <sys/x86_archext.h>
167 167 #include <sys/controlregs.h>
168 168 #include <sys/core.h>
169 169 #include <sys/stack.h>
170 170 #include <sys/stat.h>
171 171 #include <sys/socket.h>
172 172 #include <lx_signum.h>
173 173 #include <util/sscanf.h>
174 174
175 175 int lx_debug = 0;
176 176
177 177 void lx_init_brand_data(zone_t *);
178 178 void lx_free_brand_data(zone_t *);
179 179 void lx_setbrand(proc_t *);
180 180 int lx_getattr(zone_t *, int, void *, size_t *);
181 181 int lx_setattr(zone_t *, int, void *, size_t);
182 182 int lx_brandsys(int, int64_t *, uintptr_t, uintptr_t, uintptr_t,
183 183 uintptr_t, uintptr_t);
184 184 void lx_set_kern_version(zone_t *, char *);
185 185 void lx_copy_procdata(proc_t *, proc_t *);
186 186
187 187 extern int getsetcontext(int, void *);
188 188 extern int waitsys(idtype_t, id_t, siginfo_t *, int);
189 189 #if defined(_SYSCALL32_IMPL)
190 190 extern int getsetcontext32(int, void *);
191 191 extern int waitsys32(idtype_t, id_t, siginfo_t *, int);
192 192 #endif
193 193
194 194 extern void lx_proc_exit(proc_t *);
195 195 extern int lx_sched_affinity(int, uintptr_t, int, uintptr_t, int64_t *);
196 196
197 197 extern void lx_ioctl_init();
198 198 extern void lx_ioctl_fini();
199 199 extern void lx_socket_init();
200 200 extern void lx_socket_fini();
201 201
202 202 lx_systrace_f *lx_systrace_entry_ptr;
203 203 lx_systrace_f *lx_systrace_return_ptr;
204 204
205 205 static int lx_systrace_enabled;
206 206
207 207 /*
208 208 * While this is effectively mmu.hole_start - PAGESIZE, we don't particularly
209 209 * want an MMU dependency here (and should there be a microprocessor without
210 210 * a hole, we don't want to start allocating from the top of the VA range).
211 211 */
212 212 #define LX_MAXSTACK64 0x7ffffff00000
213 213
214 214 uint64_t lx_maxstack64 = LX_MAXSTACK64;
215 215
216 216 static int lx_elfexec(struct vnode *vp, struct execa *uap, struct uarg *args,
217 217 struct intpdata *idata, int level, long *execsz, int setid,
218 218 caddr_t exec_file, struct cred *cred, int *brand_action);
219 219
220 220 static boolean_t lx_native_exec(uint8_t, const char **);
221 221 static uint32_t lx_map32limit(proc_t *);
222 222
223 223 static void lx_savecontext(ucontext_t *);
224 224 static void lx_restorecontext(ucontext_t *);
225 225 static caddr_t lx_sendsig_stack(int);
226 226 static void lx_sendsig(int);
227 227 #if defined(_SYSCALL32_IMPL)
228 228 static void lx_savecontext32(ucontext32_t *);
229 229 #endif
230 230 static int lx_setid_clear(vattr_t *, cred_t *);
231 231 #if defined(_LP64)
232 232 static int lx_pagefault(proc_t *, klwp_t *, caddr_t, enum fault_type,
233 233 enum seg_rw);
234 234 #endif
235 235
236 236
237 237 /* lx brand */
238 238 struct brand_ops lx_brops = {
239 239 lx_init_brand_data, /* b_init_brand_data */
240 240 lx_free_brand_data, /* b_free_brand_data */
241 241 lx_brandsys, /* b_brandsys */
242 242 lx_setbrand, /* b_setbrand */
243 243 lx_getattr, /* b_getattr */
244 244 lx_setattr, /* b_setattr */
245 245 lx_copy_procdata, /* b_copy_procdata */
246 246 lx_proc_exit, /* b_proc_exit */
247 247 lx_exec, /* b_exec */
248 248 lx_setrval, /* b_lwp_setrval */
249 249 lx_lwpdata_alloc, /* b_lwpdata_alloc */
250 250 lx_lwpdata_free, /* b_lwpdata_free */
251 251 lx_initlwp, /* b_initlwp */
252 252 lx_forklwp, /* b_forklwp */
253 253 lx_freelwp, /* b_freelwp */
254 254 lx_exitlwp, /* b_lwpexit */
255 255 lx_elfexec, /* b_elfexec */
256 256 NULL, /* b_sigset_native_to_brand */
257 257 NULL, /* b_sigset_brand_to_native */
258 258 lx_sigfd_translate, /* b_sigfd_translate */
259 259 NSIG, /* b_nsig */
260 260 lx_exit_with_sig, /* b_exit_with_sig */
261 261 lx_wait_filter, /* b_wait_filter */
262 262 lx_native_exec, /* b_native_exec */
263 263 lx_map32limit, /* b_map32limit */
264 264 lx_stop_notify, /* b_stop_notify */
265 265 lx_waitid_helper, /* b_waitid_helper */
266 266 lx_sigcld_repost, /* b_sigcld_repost */
267 267 lx_ptrace_issig_stop, /* b_issig_stop */
268 268 lx_ptrace_sig_ignorable, /* b_sig_ignorable */
269 269 lx_savecontext, /* b_savecontext */
270 270 #if defined(_SYSCALL32_IMPL)
271 271 lx_savecontext32, /* b_savecontext32 */
272 272 #endif
273 273 lx_restorecontext, /* b_restorecontext */
274 274 lx_sendsig_stack, /* b_sendsig_stack */
275 275 lx_sendsig, /* b_sendsig */
276 276 lx_setid_clear, /* b_setid_clear */
277 277 #if defined(_LP64)
278 278 lx_pagefault /* b_pagefault */
279 279 #else
280 280 NULL
281 281 #endif
282 282 };
283 283
284 284 struct brand_mach_ops lx_mops = {
285 285 NULL,
286 286 NULL,
287 287 NULL,
288 288 NULL,
289 289 NULL,
290 290 lx_fixsegreg,
291 291 lx_fsbase
292 292 };
293 293
294 294 struct brand lx_brand = {
295 295 BRAND_VER_1,
296 296 "lx",
297 297 &lx_brops,
298 298 &lx_mops,
299 299 sizeof (struct lx_proc_data)
300 300 };
301 301
302 302 static struct modlbrand modlbrand = {
303 303 &mod_brandops, "lx brand", &lx_brand
304 304 };
305 305
306 306 static struct modlinkage modlinkage = {
307 307 MODREV_1, (void *)&modlbrand, NULL
308 308 };
309 309
310 310 void
311 311 lx_proc_exit(proc_t *p)
312 312 {
313 313 lx_proc_data_t *lxpd;
314 314 proc_t *cp;
315 315
316 316 mutex_enter(&p->p_lock);
317 317 VERIFY(lxpd = ptolxproc(p));
318 318 if ((lxpd->l_flags & LX_PROC_CHILD_DEATHSIG) == 0) {
319 319 mutex_exit(&p->p_lock);
320 320 return;
321 321 }
322 322 mutex_exit(&p->p_lock);
323 323
324 324 /* Check for children which desire notification of parental death. */
325 325 mutex_enter(&pidlock);
326 326 for (cp = p->p_child; cp != NULL; cp = cp->p_sibling) {
327 327 mutex_enter(&cp->p_lock);
328 328 if ((lxpd = ptolxproc(cp)) == NULL) {
329 329 mutex_exit(&cp->p_lock);
330 330 continue;
331 331 }
332 332 if (lxpd->l_parent_deathsig != 0) {
333 333 sigtoproc(p, NULL, lxpd->l_parent_deathsig);
334 334 }
335 335 mutex_exit(&cp->p_lock);
336 336 }
337 337 mutex_exit(&pidlock);
338 338 }
339 339
340 340 void
341 341 lx_setbrand(proc_t *p)
342 342 {
343 343 /* Send SIGCHLD to parent by default when child exits */
344 344 ptolxproc(p)->l_signal = stol_signo[SIGCHLD];
345 345 }
346 346
347 347 /* ARGSUSED */
348 348 int
349 349 lx_setattr(zone_t *zone, int attr, void *buf, size_t bufsize)
350 350 {
351 351 char vers[LX_VERS_MAX];
352 352
353 353 if (attr == LX_KERN_VERSION_NUM) {
354 354 if (bufsize > (LX_VERS_MAX - 1))
355 355 return (ERANGE);
356 356 bzero(vers, LX_VERS_MAX);
357 357 if (copyin(buf, &vers, bufsize) != 0)
358 358 return (EFAULT);
359 359 lx_set_kern_version(zone, vers);
360 360 return (0);
361 361 }
362 362 return (EINVAL);
363 363 }
364 364
365 365 /* ARGSUSED */
366 366 int
367 367 lx_getattr(zone_t *zone, int attr, void *buf, size_t *bufsize)
368 368 {
369 369 if (attr == LX_KERN_VERSION_NUM) {
370 370 if (*bufsize < LX_VERS_MAX)
371 371 return (ERANGE);
372 372 if (copyout(lx_get_zone_kern_version(curzone), buf,
373 373 LX_VERS_MAX) != 0)
374 374 return (EFAULT);
375 375 *bufsize = LX_VERS_MAX;
376 376 return (0);
377 377 }
378 378 return (-EINVAL);
379 379 }
380 380
381 381 uint32_t
382 382 lx_map32limit(proc_t *p)
383 383 {
384 384 /*
385 385 * To be bug-for-bug compatible with Linux, we have MAP_32BIT only
386 386 * allow mappings in the first 31 bits. This was a nuance in the
387 387 * original Linux implementation circa 2002, and applications have
388 388 * come to depend on its behavior.
389 389 *
390 390 * This is only relevant for 64-bit processes.
391 391 */
392 392 if (p->p_model == DATAMODEL_LP64)
393 393 return (1 << 31);
394 394
395 395 return ((uint32_t)USERLIMIT32);
396 396 }
397 397
398 398 void
399 399 lx_brand_systrace_enable(void)
400 400 {
401 401 VERIFY(!lx_systrace_enabled);
402 402
403 403 lx_systrace_enabled = 1;
404 404 }
405 405
406 406 void
407 407 lx_brand_systrace_disable(void)
408 408 {
409 409 VERIFY(lx_systrace_enabled);
410 410
411 411 lx_systrace_enabled = 0;
412 412 }
413 413
414 414 void
415 415 lx_lwp_set_native_stack_current(lx_lwp_data_t *lwpd, uintptr_t new_sp)
416 416 {
417 417 VERIFY(lwpd->br_ntv_stack != 0);
418 418
419 419 /*
420 420 * The "brand-lx-set-ntv-stack-current" probe has arguments:
421 421 * arg0: stack pointer before change
422 422 * arg1: stack pointer after change
423 423 * arg2: current stack base
424 424 */
425 425 DTRACE_PROBE3(brand__lx__set__ntv__stack__current,
426 426 uintptr_t, lwpd->br_ntv_stack_current,
427 427 uintptr_t, new_sp,
428 428 uintptr_t, lwpd->br_ntv_stack);
429 429
430 430 lwpd->br_ntv_stack_current = new_sp;
431 431 }
432 432
433 433 #if defined(_LP64)
434 434 static int
435 435 lx_pagefault(proc_t *p, klwp_t *lwp, caddr_t addr, enum fault_type type,
436 436 enum seg_rw rw)
437 437 {
438 438 int syscall_num;
439 439
440 440 /*
441 441 * We only want to handle a very specific set of circumstances.
442 442 * Namely: this is a 64-bit LX-branded process attempting to execute an
443 443 * address in a page for which it does not have a valid mapping. If
444 444 * this is not the case, we bail out as fast as possible.
445 445 */
446 446 VERIFY(PROC_IS_BRANDED(p));
447 447 if (type != F_INVAL || rw != S_EXEC || lwp_getdatamodel(lwp) !=
448 448 DATAMODEL_NATIVE) {
449 449 return (-1);
450 450 }
451 451
452 452 if (!lx_vsyscall_iscall(lwp, (uintptr_t)addr, &syscall_num)) {
453 453 return (-1);
454 454 }
455 455
456 456 /*
457 457 * This is a valid vsyscall address. We service the system call and
458 458 * return 0 to signal that the pagefault has been handled completely.
459 459 */
460 460 lx_vsyscall_enter(p, lwp, syscall_num);
461 461 return (0);
462 462 }
463 463 #endif
464 464
465 465 /*
466 466 * This hook runs prior to sendsig() processing and allows us to nominate
467 467 * an alternative stack pointer for delivery of the signal handling frame.
468 468 * Critically, this routine should _not_ modify any LWP state as the
469 469 * savecontext() does not run until after this hook.
470 470 */
471 471 static caddr_t
472 472 lx_sendsig_stack(int sig)
473 473 {
474 474 klwp_t *lwp = ttolwp(curthread);
475 475 lx_lwp_data_t *lwpd = lwptolxlwp(lwp);
476 476
477 477 /*
478 478 * We want to take signal delivery on the native stack, but only if
479 479 * one has been allocated and installed for this LWP.
480 480 */
481 481 if (lwpd->br_stack_mode == LX_STACK_MODE_BRAND) {
482 482 /*
483 483 * The program is not running on the native stack. Return
484 484 * the native stack pointer from our brand-private data so
485 485 * that we may switch to it for signal handling.
486 486 */
487 487 return ((caddr_t)lwpd->br_ntv_stack_current);
488 488 } else {
489 489 struct regs *rp = lwptoregs(lwp);
490 490
491 491 /*
492 492 * Either the program is already running on the native stack,
493 493 * or one has not yet been allocated for this LWP. Use the
494 494 * current stack pointer value.
495 495 */
496 496 return ((caddr_t)rp->r_sp);
497 497 }
498 498 }
499 499
500 500 /*
501 501 * This hook runs after sendsig() processing and allows us to update the
502 502 * per-LWP mode flags for system calls and stacks. The pre-signal
503 503 * context has already been saved and delivered to the user at this point.
504 504 */
505 505 static void
506 506 lx_sendsig(int sig)
507 507 {
508 508 klwp_t *lwp = ttolwp(curthread);
509 509 lx_lwp_data_t *lwpd = lwptolxlwp(lwp);
510 510 struct regs *rp = lwptoregs(lwp);
511 511
512 512 switch (lwpd->br_stack_mode) {
513 513 case LX_STACK_MODE_BRAND:
514 514 case LX_STACK_MODE_NATIVE:
515 515 /*
516 516 * In lx_sendsig_stack(), we nominated a stack pointer from the
517 517 * native stack. Update the stack mode, and the current in-use
518 518 * extent of the native stack, accordingly:
519 519 */
520 520 lwpd->br_stack_mode = LX_STACK_MODE_NATIVE;
521 521 lx_lwp_set_native_stack_current(lwpd, rp->r_sp);
522 522
523 523 /*
524 524 * Fix up segment registers, etc.
525 525 */
526 526 lx_switch_to_native(lwp);
527 527 break;
528 528
529 529 default:
530 530 /*
531 531 * Otherwise, the brand library has not yet installed the
532 532 * alternate stack for this LWP. Signals will be handled on
533 533 * the regular stack thread.
534 534 */
535 535 return;
536 536 }
537 537 }
538 538
539 539 /*
540 540 * This hook runs prior to the context restoration, allowing us to take action
541 541 * or modify the context before it is loaded.
542 542 */
543 543 static void
544 544 lx_restorecontext(ucontext_t *ucp)
545 545 {
546 546 klwp_t *lwp = ttolwp(curthread);
547 547 lx_lwp_data_t *lwpd = lwptolxlwp(lwp);
548 548 uintptr_t flags = (uintptr_t)ucp->uc_brand_data[0];
549 549 caddr_t sp = ucp->uc_brand_data[1];
550 550
551 551 /*
552 552 * We have a saved native stack pointer value that we must restore
553 553 * into the per-LWP data.
554 554 */
555 555 if (flags & LX_UC_RESTORE_NATIVE_SP) {
556 556 lx_lwp_set_native_stack_current(lwpd, (uintptr_t)sp);
557 557 }
558 558
559 559 /*
560 560 * We do not wish to restore the value of uc_link in this context,
561 561 * so replace it with the value currently in the LWP.
562 562 */
563 563 if (flags & LX_UC_IGNORE_LINK) {
564 564 ucp->uc_link = (ucontext_t *)lwp->lwp_oldcontext;
565 565 }
566 566
567 567 /*
568 568 * Restore the stack mode:
569 569 */
570 570 if (flags & LX_UC_STACK_NATIVE) {
571 571 lwpd->br_stack_mode = LX_STACK_MODE_NATIVE;
572 572 } else if (flags & LX_UC_STACK_BRAND) {
573 573 lwpd->br_stack_mode = LX_STACK_MODE_BRAND;
574 574 }
575 575
576 576 #if defined(__amd64)
577 577 /*
578 578 * Override the fs/gsbase in the context with the value provided
579 579 * through the Linux arch_prctl(2) system call.
580 580 */
581 581 if (flags & LX_UC_STACK_BRAND) {
582 582 if (lwpd->br_lx_fsbase != 0) {
583 583 ucp->uc_mcontext.gregs[REG_FSBASE] = lwpd->br_lx_fsbase;
584 584 }
585 585 if (lwpd->br_lx_gsbase != 0) {
586 586 ucp->uc_mcontext.gregs[REG_GSBASE] = lwpd->br_lx_gsbase;
587 587 }
588 588 }
589 589 #endif
590 590 }
591 591
592 592 static void
593 593 lx_savecontext(ucontext_t *ucp)
594 594 {
595 595 klwp_t *lwp = ttolwp(curthread);
596 596 lx_lwp_data_t *lwpd = lwptolxlwp(lwp);
597 597 uintptr_t flags = 0;
598 598
599 599 /*
600 600 * The ucontext_t affords us three private pointer-sized members in
601 601 * "uc_brand_data". We pack a variety of flags into the first element,
602 602 * and an optional stack pointer in the second element. The flags
603 603 * determine which stack pointer (native or brand), if any, is stored
604 604 * in the second element. The third element may contain the system
605 605 * call number; this is analogous to the "orig_[er]ax" member of a
606 606 * Linux "user_regs_struct".
607 607 */
608 608
609 609 if (lwpd->br_stack_mode != LX_STACK_MODE_INIT &&
610 610 lwpd->br_stack_mode != LX_STACK_MODE_PREINIT) {
611 611 /*
612 612 * Record the value of the native stack pointer to restore
613 613 * when returning to this branded context:
614 614 */
615 615 flags |= LX_UC_RESTORE_NATIVE_SP;
616 616 ucp->uc_brand_data[1] = (void *)lwpd->br_ntv_stack_current;
617 617 }
618 618
619 619 /*
620 620 * Save the stack mode:
621 621 */
622 622 if (lwpd->br_stack_mode == LX_STACK_MODE_NATIVE) {
623 623 flags |= LX_UC_STACK_NATIVE;
624 624 } else if (lwpd->br_stack_mode == LX_STACK_MODE_BRAND) {
625 625 flags |= LX_UC_STACK_BRAND;
626 626 }
627 627
628 628 /*
629 629 * If we might need to restart this system call, save that information
630 630 * in the context:
631 631 */
632 632 if (lwpd->br_stack_mode == LX_STACK_MODE_BRAND) {
633 633 ucp->uc_brand_data[2] =
634 634 (void *)(uintptr_t)lwpd->br_syscall_num;
635 635 if (lwpd->br_syscall_restart) {
636 636 flags |= LX_UC_RESTART_SYSCALL;
637 637 }
638 638 } else {
639 639 ucp->uc_brand_data[2] = NULL;
640 640 }
641 641
642 642 ucp->uc_brand_data[0] = (void *)flags;
643 643 }
644 644
645 645 #if defined(_SYSCALL32_IMPL)
646 646 static void
647 647 lx_savecontext32(ucontext32_t *ucp)
648 648 {
649 649 klwp_t *lwp = ttolwp(curthread);
650 650 lx_lwp_data_t *lwpd = lwptolxlwp(lwp);
651 651 unsigned int flags = 0;
652 652
653 653 /*
654 654 * The ucontext_t affords us three private pointer-sized members in
655 655 * "uc_brand_data". We pack a variety of flags into the first element,
656 656 * and an optional stack pointer in the second element. The flags
657 657 * determine which stack pointer (native or brand), if any, is stored
658 658 * in the second element. The third element may contain the system
659 659 * call number; this is analogous to the "orig_[er]ax" member of a
660 660 * Linux "user_regs_struct".
661 661 */
662 662
663 663 if (lwpd->br_stack_mode != LX_STACK_MODE_INIT &&
664 664 lwpd->br_stack_mode != LX_STACK_MODE_PREINIT) {
665 665 /*
666 666 * Record the value of the native stack pointer to restore
667 667 * when returning to this branded context:
668 668 */
669 669 flags |= LX_UC_RESTORE_NATIVE_SP;
670 670 ucp->uc_brand_data[1] = (caddr32_t)lwpd->br_ntv_stack_current;
671 671 }
672 672
673 673 /*
674 674 * Save the stack mode:
675 675 */
676 676 if (lwpd->br_stack_mode == LX_STACK_MODE_NATIVE) {
677 677 flags |= LX_UC_STACK_NATIVE;
678 678 } else if (lwpd->br_stack_mode == LX_STACK_MODE_BRAND) {
679 679 flags |= LX_UC_STACK_BRAND;
680 680 }
681 681
682 682 /*
683 683 * If we might need to restart this system call, save that information
684 684 * in the context:
685 685 */
686 686 if (lwpd->br_stack_mode == LX_STACK_MODE_BRAND) {
687 687 ucp->uc_brand_data[2] = (caddr32_t)lwpd->br_syscall_num;
688 688 if (lwpd->br_syscall_restart) {
689 689 flags |= LX_UC_RESTART_SYSCALL;
690 690 }
691 691 } else {
692 692 ucp->uc_brand_data[2] = NULL;
693 693 }
694 694
695 695 ucp->uc_brand_data[0] = flags;
696 696 }
697 697 #endif
698 698
699 699 void
700 700 lx_init_brand_data(zone_t *zone)
701 701 {
702 702 lx_zone_data_t *data;
703 703 ASSERT(zone->zone_brand == &lx_brand);
704 704 ASSERT(zone->zone_brand_data == NULL);
705 705 data = (lx_zone_data_t *)kmem_zalloc(sizeof (lx_zone_data_t), KM_SLEEP);
706 706 /*
707 707 * Set the default lxzd_kernel_version to 2.4.
708 708 * This can be changed by a call to setattr() during zone boot.
709 709 */
710 710 (void) strlcpy(data->lxzd_kernel_version, "2.4.21", LX_VERS_MAX);
711 711
712 712 /*
713 713 * Linux is not at all picky about address family when it comes to
714 714 * supporting interface-related ioctls. To mimic this behavior, we'll
715 715 * attempt those ioctls against a ksocket configured for that purpose.
716 716 */
717 717 (void) ksocket_socket(&data->lxzd_ioctl_sock, AF_INET, SOCK_DGRAM, 0,
718 718 0, zone->zone_kcred);
719 719
720 720 zone->zone_brand_data = data;
721 721
722 722 /*
723 723 * In Linux, if the init(1) process terminates the system panics.
724 724 * The zone must reboot to simulate this behaviour.
725 725 */
726 726 zone->zone_reboot_on_init_exit = B_TRUE;
727 727 }
728 728
729 729 void
730 730 lx_free_brand_data(zone_t *zone)
731 731 {
732 732 lx_zone_data_t *data = ztolxzd(zone);
733 733 ASSERT(data != NULL);
734 734 if (data->lxzd_ioctl_sock != NULL) {
735 735 /*
736 736 * Since zone_kcred has been cleaned up already, close the
737 737 * socket using the global kcred.
738 738 */
739 739 ksocket_close(data->lxzd_ioctl_sock, kcred);
740 740 data->lxzd_ioctl_sock = NULL;
741 741 }
742 742 zone->zone_brand_data = NULL;
743 743 kmem_free(data, sizeof (*data));
744 744 }
745 745
746 746 void
747 747 lx_unsupported(char *dmsg)
748 748 {
749 749 lx_proc_data_t *pd = ttolxproc(curthread);
750 750
751 751 DTRACE_PROBE1(brand__lx__unsupported, char *, dmsg);
752 752
753 753 if (pd != NULL && (pd->l_flags & LX_PROC_STRICT_MODE) != 0) {
754 754 /*
755 755 * If this process was run with strict mode enabled
756 756 * (via LX_STRICT in the environment), we mark this
757 757 * LWP as having triggered an unsupported behaviour.
758 758 * This flag will be checked at an appropriate point
759 759 * by lx_check_strict_failure().
760 760 */
761 761 lx_lwp_data_t *lwpd = ttolxlwp(curthread);
762 762
763 763 lwpd->br_strict_failure = B_TRUE;
764 764 }
765 765 }
766 766
767 767 void
768 768 lx_check_strict_failure(lx_lwp_data_t *lwpd)
769 769 {
770 770 proc_t *p;
771 771
772 772 if (!lwpd->br_strict_failure) {
773 773 return;
774 774 }
775 775
776 776 lwpd->br_strict_failure = B_FALSE;
777 777
778 778 /*
779 779 * If this process is operating in strict mode (via LX_STRICT in
780 780 * the environment), and has triggered a call to
781 781 * lx_unsupported(), we drop SIGSYS on it as we return.
782 782 */
783 783 p = curproc;
784 784 mutex_enter(&p->p_lock);
785 785 sigtoproc(p, curthread, SIGSYS);
786 786 mutex_exit(&p->p_lock);
787 787 }
788 788
789 789 void
790 790 lx_trace_sysenter(int syscall_num, uintptr_t *args)
791 791 {
792 792 if (lx_systrace_enabled) {
793 793 VERIFY(lx_systrace_entry_ptr != NULL);
794 794
795 795 (*lx_systrace_entry_ptr)(syscall_num, args[0], args[1],
796 796 args[2], args[3], args[4], args[5]);
797 797 }
798 798 }
799 799
800 800 void
801 801 lx_trace_sysreturn(int syscall_num, long ret)
802 802 {
803 803 if (lx_systrace_enabled) {
804 804 VERIFY(lx_systrace_return_ptr != NULL);
805 805
806 806 (*lx_systrace_return_ptr)(syscall_num, ret, ret, 0, 0, 0, 0);
807 807 }
808 808 }
809 809
810 810 /*
811 811 * Get the addresses of the user-space system call handler and attach it to
812 812 * the proc structure. Returning 0 indicates success; the value returned
813 813 * by the system call is the value stored in rval. Returning a non-zero
814 814 * value indicates a failure; the value returned is used to set errno, -1
815 815 * is returned from the syscall and the contents of rval are ignored. To
816 816 * set errno and have the syscall return a value other than -1 we can
817 817 * manually set errno and rval and return 0.
818 818 */
819 819 int
820 820 lx_brandsys(int cmd, int64_t *rval, uintptr_t arg1, uintptr_t arg2,
821 821 uintptr_t arg3, uintptr_t arg4, uintptr_t arg5)
822 822 {
823 823 kthread_t *t = curthread;
824 824 klwp_t *lwp = ttolwp(t);
825 825 proc_t *p = ttoproc(t);
826 826 lx_proc_data_t *pd;
827 827 struct termios *termios;
828 828 uint_t termios_len;
829 829 int error;
830 830 int code;
831 831 int sig;
832 832 lx_brand_registration_t reg;
833 833 lx_lwp_data_t *lwpd = lwptolxlwp(lwp);
834 834
835 835 /*
836 836 * There is one operation that is suppored for non-branded
837 837 * process. B_EXEC_BRAND. This is the equilivant of an
838 838 * exec call, but the new process that is created will be
839 839 * a branded process.
840 840 */
841 841 if (cmd == B_EXEC_BRAND) {
842 842 VERIFY(p->p_zone != NULL);
843 843 VERIFY(p->p_zone->zone_brand == &lx_brand);
844 844 return (exec_common(
845 845 (char *)arg1, (const char **)arg2, (const char **)arg3,
846 846 EBA_BRAND));
847 847 }
848 848
849 849 /* For all other operations this must be a branded process. */
850 850 if (p->p_brand == NULL)
851 851 return (ENOSYS);
852 852
853 853 VERIFY(p->p_brand == &lx_brand);
854 854 VERIFY(p->p_brand_data != NULL);
855 855
856 856 switch (cmd) {
857 857 case B_REGISTER:
858 858 if (lwpd->br_stack_mode != LX_STACK_MODE_PREINIT) {
859 859 lx_print("stack mode was not PREINIT during "
860 860 "REGISTER\n");
861 861 return (EINVAL);
862 862 }
863 863
864 864 if (p->p_model == DATAMODEL_NATIVE) {
865 865 if (copyin((void *)arg1, ®, sizeof (reg)) != 0) {
866 866 lx_print("Failed to copyin brand registration "
867 867 "at 0x%p\n", (void *)arg1);
868 868 return (EFAULT);
869 869 }
870 870 }
871 871 #ifdef _LP64
872 872 else {
873 873 /* 32-bit userland on 64-bit kernel */
874 874 lx_brand_registration32_t reg32;
875 875
876 876 if (copyin((void *)arg1, ®32, sizeof (reg32)) != 0) {
877 877 lx_print("Failed to copyin brand registration "
878 878 "at 0x%p\n", (void *)arg1);
879 879 return (EFAULT);
880 880 }
881 881
882 882 reg.lxbr_version = (uint_t)reg32.lxbr_version;
883 883 reg.lxbr_handler =
884 884 (void *)(uintptr_t)reg32.lxbr_handler;
885 885 reg.lxbr_flags = reg32.lxbr_flags;
886 886 }
887 887 #endif
888 888
889 889 if (reg.lxbr_version != LX_VERSION_1) {
890 890 lx_print("Invalid brand library version (%u)\n",
891 891 reg.lxbr_version);
892 892 return (EINVAL);
893 893 }
894 894
895 895 if ((reg.lxbr_flags & ~LX_PROC_ALL) != 0) {
896 896 lx_print("Invalid brand flags (%u)\n",
897 897 reg.lxbr_flags);
898 898 return (EINVAL);
899 899 }
900 900
901 901 lx_print("Assigning brand 0x%p and handler 0x%p to proc 0x%p\n",
902 902 (void *)&lx_brand, (void *)reg.lxbr_handler, (void *)p);
903 903 pd = p->p_brand_data;
904 904 pd->l_handler = (uintptr_t)reg.lxbr_handler;
905 905 pd->l_flags = reg.lxbr_flags & LX_PROC_ALL;
906 906
907 907 return (0);
908 908
909 909 case B_TTYMODES:
910 910 /* This is necessary for emulating TCGETS ioctls. */
911 911 if (ddi_prop_lookup_byte_array(DDI_DEV_T_ANY, ddi_root_node(),
912 912 DDI_PROP_NOTPROM, "ttymodes", (uchar_t **)&termios,
913 913 &termios_len) != DDI_SUCCESS)
914 914 return (EIO);
915 915
916 916 ASSERT(termios_len == sizeof (*termios));
917 917
918 918 if (copyout(&termios, (void *)arg1, sizeof (termios)) != 0) {
919 919 ddi_prop_free(termios);
920 920 return (EFAULT);
921 921 }
922 922
923 923 ddi_prop_free(termios);
924 924 return (0);
925 925
926 926 case B_ELFDATA:
927 927 pd = curproc->p_brand_data;
928 928 if (get_udatamodel() == DATAMODEL_NATIVE) {
929 929 if (copyout(&pd->l_elf_data, (void *)arg1,
930 930 sizeof (lx_elf_data_t)) != 0) {
931 931 return (EFAULT);
932 932 }
933 933 }
934 934 #if defined(_LP64)
935 935 else {
936 936 /* 32-bit userland on 64-bit kernel */
937 937 lx_elf_data32_t led32;
938 938
939 939 led32.ed_phdr = (int)pd->l_elf_data.ed_phdr;
940 940 led32.ed_phent = (int)pd->l_elf_data.ed_phent;
941 941 led32.ed_phnum = (int)pd->l_elf_data.ed_phnum;
942 942 led32.ed_entry = (int)pd->l_elf_data.ed_entry;
943 943 led32.ed_base = (int)pd->l_elf_data.ed_base;
944 944 led32.ed_ldentry = (int)pd->l_elf_data.ed_ldentry;
945 945
946 946 if (copyout(&led32, (void *)arg1,
947 947 sizeof (led32)) != 0) {
948 948 return (EFAULT);
949 949 }
950 950 }
951 951 #endif
952 952 return (0);
953 953
954 954 case B_EXEC_NATIVE:
955 955 return (exec_common((char *)arg1, (const char **)arg2,
956 956 (const char **)arg3, EBA_NATIVE));
957 957
958 958 /*
959 959 * The B_TRUSS_POINT subcommand is used so that we can make a no-op
960 960 * syscall for debugging purposes (dtracing) from within the user-level
961 961 * emulation.
962 962 */
963 963 case B_TRUSS_POINT:
964 964 return (0);
965 965
966 966 case B_LPID_TO_SPAIR: {
967 967 /*
968 968 * Given a Linux pid as arg1, return the Solaris pid in arg2 and
969 969 * the Solaris LWP in arg3. We also translate pid 1 (which is
970 970 * hardcoded in many applications) to the zone's init process.
971 971 */
972 972 pid_t s_pid;
973 973 id_t s_tid;
974 974
975 975 if ((pid_t)arg1 == 1) {
976 976 s_pid = p->p_zone->zone_proc_initpid;
977 977 /* handle the dead/missing init(1M) case */
978 978 if (s_pid == -1)
979 979 s_pid = 1;
980 980 s_tid = 1;
981 981 } else if (lx_lpid_to_spair((pid_t)arg1, &s_pid, &s_tid) < 0) {
982 982 return (ESRCH);
|
↓ open down ↓ |
982 lines elided |
↑ open up ↑ |
983 983 }
984 984
985 985 if (copyout(&s_pid, (void *)arg2, sizeof (s_pid)) != 0 ||
986 986 copyout(&s_tid, (void *)arg3, sizeof (s_tid)) != 0) {
987 987 return (EFAULT);
988 988 }
989 989
990 990 return (0);
991 991 }
992 992
993 + case B_SIGEV_THREAD_ID: {
994 + /*
995 + * Emulate Linux's timer_create(2) SIGEV_THREAD_ID
996 + * notification method. This mechanism is only meant
997 + * for userland threading libraries such as glibc and
998 + * is documented as such. Therefore, assume this is
999 + * only ever invoked for the purpose of alerting a
1000 + * Linux threading library. Assume that the tid is a
1001 + * member of the caller's process and the signal
1002 + * number is valid. See lx_sigev_thread_id() for the
1003 + * userland side of this emulation.
1004 + *
1005 + * The return code from this function is not checked
1006 + * by the caller since it executes in an asynchronous
1007 + * context and there is nothing much to be done. If
1008 + * this function does fail then it will manifest as
1009 + * Linux threads waiting for a signal they will never
1010 + * receive.
1011 + *
1012 + * arg1 -- Linux tid
1013 + * arg2 -- signal number
1014 + * arg3 -- union sigval
1015 + */
1016 +
1017 + int native_sig = lx_stol_signo((int)arg2, LX_SIGTIMER);
1018 + pid_t native_pid;
1019 + int native_tid;
1020 + sigqueue_t *sqp;
1021 +
1022 + lx_lpid_to_spair((pid_t)arg1, &native_pid, &native_tid);
1023 + sqp = kmem_zalloc(sizeof (sigqueue_t), KM_SLEEP);
1024 + mutex_enter(&curproc->p_lock);
1025 +
1026 + if ((t = idtot(curproc, native_tid)) == NULL) {
1027 + mutex_exit(&curproc->p_lock);
1028 + kmem_free(sqp, sizeof (sigqueue_t));
1029 + return (ESRCH);
1030 + }
1031 +
1032 + sqp->sq_info.si_signo = native_sig;
1033 + sqp->sq_info.si_code = SI_TIMER;
1034 + sqp->sq_info.si_pid = curproc->p_pid;
1035 + sqp->sq_info.si_zoneid = getzoneid();
1036 + sqp->sq_info.si_uid = crgetruid(CRED());
1037 + sqp->sq_info.si_value = (union sigval)((void *)arg3);
1038 + sigaddqa(curproc, t, sqp);
1039 +
1040 + mutex_exit(&curproc->p_lock);
1041 + kmem_free(sqp, sizeof (sigqueue_t));
1042 +
1043 + return (0);
1044 + }
1045 +
993 1046 case B_SET_AFFINITY_MASK:
994 1047 case B_GET_AFFINITY_MASK:
995 1048 /*
996 1049 * Retrieve or store the CPU affinity mask for the
997 1050 * requested linux pid.
998 1051 *
999 1052 * arg1 is a linux PID (0 means curthread).
1000 1053 * arg2 is the size of the given mask.
1001 1054 * arg3 is the address of the affinity mask.
1002 1055 */
1003 1056 return (lx_sched_affinity(cmd, arg1, arg2, arg3, rval));
1004 1057
1005 1058 case B_PTRACE_STOP_FOR_OPT:
1006 1059 return (lx_ptrace_stop_for_option((int)arg1, arg2 == 0 ?
1007 1060 B_FALSE : B_TRUE, (ulong_t)arg3, arg4));
1008 1061
1009 1062 case B_PTRACE_CLONE_BEGIN:
1010 1063 return (lx_ptrace_set_clone_inherit((int)arg1, arg2 == 0 ?
1011 1064 B_FALSE : B_TRUE));
1012 1065
1013 1066 case B_PTRACE_KERNEL:
1014 1067 return (lx_ptrace_kernel((int)arg1, (pid_t)arg2, arg3, arg4));
1015 1068
1016 1069 case B_HELPER_WAITID: {
1017 1070 idtype_t idtype = (idtype_t)arg1;
1018 1071 id_t id = (id_t)arg2;
1019 1072 siginfo_t *infop = (siginfo_t *)arg3;
1020 1073 int options = (int)arg4;
1021 1074
1022 1075 lwpd = ttolxlwp(curthread);
1023 1076
1024 1077 /*
1025 1078 * Our brand-specific waitid helper only understands a subset of
1026 1079 * the possible idtypes. Ensure we keep to that subset here:
1027 1080 */
1028 1081 if (idtype != P_ALL && idtype != P_PID && idtype != P_PGID) {
1029 1082 return (EINVAL);
1030 1083 }
1031 1084
1032 1085 /*
1033 1086 * Enable the return of emulated ptrace(2) stop conditions
1034 1087 * through lx_waitid_helper, and stash the Linux-specific
1035 1088 * extra waitid() flags.
1036 1089 */
1037 1090 lwpd->br_waitid_emulate = B_TRUE;
1038 1091 lwpd->br_waitid_flags = (int)arg5;
1039 1092
1040 1093 #if defined(_SYSCALL32_IMPL)
1041 1094 if (get_udatamodel() != DATAMODEL_NATIVE) {
1042 1095 return (waitsys32(idtype, id, infop, options));
1043 1096 } else
1044 1097 #endif
1045 1098 {
1046 1099 return (waitsys(idtype, id, infop, options));
1047 1100 }
1048 1101
1049 1102 lwpd->br_waitid_emulate = B_FALSE;
1050 1103 lwpd->br_waitid_flags = 0;
1051 1104
1052 1105 return (0);
1053 1106 }
1054 1107
1055 1108 case B_UNSUPPORTED: {
1056 1109 char dmsg[256];
1057 1110
1058 1111 if (copyin((void *)arg1, &dmsg, sizeof (dmsg)) != 0) {
1059 1112 lx_print("Failed to copyin unsupported msg "
1060 1113 "at 0x%p\n", (void *)arg1);
1061 1114 return (EFAULT);
1062 1115 }
1063 1116 dmsg[255] = '\0';
1064 1117 lx_unsupported(dmsg);
1065 1118
1066 1119 lx_check_strict_failure(lwpd);
1067 1120
1068 1121 return (0);
1069 1122 }
1070 1123
1071 1124 case B_STORE_ARGS: {
1072 1125 /*
1073 1126 * B_STORE_ARGS subcommand
1074 1127 * arg1 = address of struct to be copied in
1075 1128 * arg2 = size of the struct being copied in
1076 1129 * arg3-arg6 ignored
1077 1130 * rval = the amount of data copied.
1078 1131 */
1079 1132 void *buf;
1080 1133
1081 1134 /* only have upper limit because arg2 is unsigned */
1082 1135 if (arg2 > LX_BR_ARGS_SIZE_MAX) {
1083 1136 return (EINVAL);
1084 1137 }
1085 1138
1086 1139 buf = kmem_alloc(arg2, KM_SLEEP);
1087 1140 if (copyin((void *)arg1, buf, arg2) != 0) {
1088 1141 lx_print("Failed to copyin scall arg at 0x%p\n",
1089 1142 (void *) arg1);
1090 1143 kmem_free(buf, arg2);
1091 1144 /*
1092 1145 * Purposely not setting br_scall_args to NULL
1093 1146 * to preserve data for debugging.
1094 1147 */
1095 1148 return (EFAULT);
1096 1149 }
1097 1150
1098 1151 if (lwpd->br_scall_args != NULL) {
1099 1152 ASSERT(lwpd->br_args_size > 0);
1100 1153 kmem_free(lwpd->br_scall_args,
1101 1154 lwpd->br_args_size);
1102 1155 }
1103 1156
1104 1157 lwpd->br_scall_args = buf;
1105 1158 lwpd->br_args_size = arg2;
1106 1159 *rval = arg2;
1107 1160 return (0);
1108 1161 }
1109 1162
1110 1163 case B_HELPER_CLONE:
1111 1164 return (lx_helper_clone(rval, arg1, (void *)arg2, (void *)arg3,
1112 1165 (void *)arg4));
1113 1166
1114 1167 case B_HELPER_SETGROUPS:
1115 1168 return (lx_helper_setgroups(arg1, (gid_t *)arg2));
1116 1169
1117 1170 case B_HELPER_SIGQUEUE:
1118 1171 return (lx_helper_rt_sigqueueinfo(arg1, arg2,
1119 1172 (siginfo_t *)arg3));
1120 1173
1121 1174 case B_HELPER_TGSIGQUEUE:
1122 1175 return (lx_helper_rt_tgsigqueueinfo(arg1, arg2, arg3,
1123 1176 (siginfo_t *)arg4));
1124 1177
1125 1178 case B_SET_THUNK_PID:
1126 1179 lwpd->br_lx_thunk_pid = arg1;
1127 1180 return (0);
1128 1181
1129 1182 case B_GETPID:
1130 1183 /*
1131 1184 * The usermode clone(2) code needs to be able to call
1132 1185 * lx_getpid() from native code:
1133 1186 */
1134 1187 *rval = lx_getpid();
1135 1188 return (0);
1136 1189
1137 1190 case B_SET_NATIVE_STACK:
1138 1191 /*
1139 1192 * B_SET_NATIVE_STACK subcommand
1140 1193 * arg1 = the base of the stack to use for emulation
1141 1194 */
1142 1195 if (lwpd->br_stack_mode != LX_STACK_MODE_PREINIT) {
1143 1196 lx_print("B_SET_NATIVE_STACK when stack was already "
1144 1197 "set to %p\n", (void *)arg1);
1145 1198 return (EEXIST);
1146 1199 }
1147 1200
1148 1201 /*
1149 1202 * We move from the PREINIT state, where we have no brand
1150 1203 * emulation stack, to the INIT state. Here, we are still
1151 1204 * running on what will become the BRAND stack, but are running
1152 1205 * emulation (i.e. native) code. Once the initialisation
1153 1206 * process for this thread has finished, we will jump to
1154 1207 * brand-specific code, while moving to the BRAND mode.
1155 1208 *
1156 1209 * When a new LWP is created, lx_initlwp() will clear the
1157 1210 * stack data. If that LWP is actually being duplicated
1158 1211 * into a child process by fork(2), lx_forklwp() will copy
1159 1212 * it so that the cloned thread will keep using the same
1160 1213 * alternate stack.
1161 1214 */
1162 1215 lwpd->br_ntv_stack = arg1;
1163 1216 lwpd->br_stack_mode = LX_STACK_MODE_INIT;
1164 1217 lx_lwp_set_native_stack_current(lwpd, arg1);
1165 1218
1166 1219 return (0);
1167 1220
1168 1221 case B_GET_CURRENT_CONTEXT:
1169 1222 /*
1170 1223 * B_GET_CURRENT_CONTEXT subcommand:
1171 1224 * arg1 = address for pointer to current ucontext_t
1172 1225 */
1173 1226
1174 1227 #if defined(_SYSCALL32_IMPL)
1175 1228 if (get_udatamodel() != DATAMODEL_NATIVE) {
1176 1229 caddr32_t addr = (caddr32_t)lwp->lwp_oldcontext;
1177 1230
1178 1231 error = copyout(&addr, (void *)arg1, sizeof (addr));
1179 1232 } else
1180 1233 #endif
1181 1234 {
1182 1235 error = copyout(&lwp->lwp_oldcontext, (void *)arg1,
1183 1236 sizeof (lwp->lwp_oldcontext));
1184 1237 }
1185 1238
1186 1239 return (error != 0 ? EFAULT : 0);
1187 1240
1188 1241 case B_JUMP_TO_LINUX:
1189 1242 /*
1190 1243 * B_JUMP_TO_LINUX subcommand:
1191 1244 * arg1 = ucontext_t pointer for jump state
1192 1245 */
1193 1246
1194 1247 if (arg1 == NULL)
1195 1248 return (EINVAL);
1196 1249
1197 1250 switch (lwpd->br_stack_mode) {
1198 1251 case LX_STACK_MODE_NATIVE: {
1199 1252 struct regs *rp = lwptoregs(lwp);
1200 1253
1201 1254 /*
1202 1255 * We are on the NATIVE stack, so we must preserve
1203 1256 * the extent of that stack. The pointer will be
1204 1257 * reset by a future setcontext().
1205 1258 */
1206 1259 lx_lwp_set_native_stack_current(lwpd,
1207 1260 (uintptr_t)rp->r_sp);
1208 1261 break;
1209 1262 }
1210 1263
1211 1264 case LX_STACK_MODE_INIT:
1212 1265 /*
1213 1266 * The LWP is transitioning to Linux code for the first
1214 1267 * time.
1215 1268 */
1216 1269 break;
1217 1270
1218 1271 case LX_STACK_MODE_PREINIT:
1219 1272 /*
1220 1273 * This LWP has not installed an alternate stack for
1221 1274 * usermode emulation handling.
1222 1275 */
1223 1276 return (ENOENT);
1224 1277
1225 1278 case LX_STACK_MODE_BRAND:
1226 1279 /*
1227 1280 * The LWP should not be on the BRAND stack.
1228 1281 */
1229 1282 exit(CLD_KILLED, SIGSYS);
1230 1283 return (0);
1231 1284 }
1232 1285
1233 1286 /*
1234 1287 * Transfer control to Linux:
1235 1288 */
1236 1289 return (lx_runexe(lwp, (void *)arg1));
1237 1290
1238 1291 case B_EMULATION_DONE:
1239 1292 /*
1240 1293 * B_EMULATION_DONE subcommand:
1241 1294 * arg1 = ucontext_t * to restore
1242 1295 * arg2 = system call number
1243 1296 * arg3 = return code
1244 1297 * arg4 = if operation failed, the errno value
1245 1298 */
1246 1299
1247 1300 /*
1248 1301 * The first part of this operation is a setcontext() to
1249 1302 * restore the register state to the copy we preserved
1250 1303 * before vectoring to the usermode emulation routine.
1251 1304 * If that fails, we return (hopefully) to the emulation
1252 1305 * routine and it will handle the error.
1253 1306 */
1254 1307 #if (_SYSCALL32_IMPL)
1255 1308 if (get_udatamodel() != DATAMODEL_NATIVE) {
1256 1309 error = getsetcontext32(SETCONTEXT, (void *)arg1);
1257 1310 } else
1258 1311 #endif
1259 1312 {
1260 1313 error = getsetcontext(SETCONTEXT, (void *)arg1);
1261 1314 }
1262 1315
1263 1316 if (error != 0) {
1264 1317 return (error);
1265 1318 }
1266 1319
1267 1320 /*
1268 1321 * The saved Linux context has been restored. We handle the
1269 1322 * return value or errno with code common to the in-kernel
1270 1323 * system call emulation.
1271 1324 */
1272 1325 if ((error = (int)arg4) != 0) {
1273 1326 /*
1274 1327 * lx_syscall_return() looks at the errno in the LWP,
1275 1328 * so set it here:
1276 1329 */
1277 1330 set_errno(error);
1278 1331 }
1279 1332 lx_syscall_return(ttolwp(curthread), (int)arg2, (long)arg3);
1280 1333
1281 1334 return (0);
1282 1335
1283 1336 case B_EXIT_AS_SIG:
1284 1337 code = CLD_KILLED;
1285 1338 sig = (int)arg1;
1286 1339 proc_is_exiting(p);
1287 1340 if (exitlwps(1) != 0) {
1288 1341 mutex_enter(&p->p_lock);
1289 1342 lwp_exit();
1290 1343 }
1291 1344 ttolwp(curthread)->lwp_cursig = sig;
1292 1345 if (sig == SIGSEGV) {
1293 1346 if (core(sig, 0) == 0)
1294 1347 code = CLD_DUMPED;
1295 1348 }
1296 1349 exit(code, sig);
1297 1350 /* NOTREACHED */
1298 1351 break;
1299 1352 }
1300 1353
1301 1354 return (EINVAL);
1302 1355 }
1303 1356
1304 1357 char *
1305 1358 lx_get_zone_kern_version(zone_t *zone)
1306 1359 {
1307 1360 return (((lx_zone_data_t *)zone->zone_brand_data)->lxzd_kernel_version);
1308 1361 }
1309 1362
1310 1363 void
1311 1364 lx_set_kern_version(zone_t *zone, char *vers)
1312 1365 {
1313 1366 lx_zone_data_t *lxzd = (lx_zone_data_t *)zone->zone_brand_data;
1314 1367
1315 1368 (void) strlcpy(lxzd->lxzd_kernel_version, vers, LX_VERS_MAX);
1316 1369 }
1317 1370
1318 1371 /*
1319 1372 * Compare linux kernel version to the one set for the zone.
1320 1373 * Returns greater than 0 if zone version is higher, less than 0 if the zone
1321 1374 * version is lower, and 0 if the version are equal.
1322 1375 */
1323 1376 int
1324 1377 lx_kern_version_cmp(zone_t *zone, const char *vers)
1325 1378 {
1326 1379 int zvers[3] = {0, 0, 0};
1327 1380 int cvers[3] = {0, 0, 0};
1328 1381 int i;
1329 1382
1330 1383 VERIFY(zone->zone_brand == &lx_brand);
1331 1384
1332 1385 (void) sscanf(ztolxzd(zone)->lxzd_kernel_version, "%d.%d.%d", &zvers[0],
1333 1386 &zvers[1], &zvers[2]);
1334 1387 (void) sscanf(vers, "%d.%d.%d", &cvers[0], &cvers[1], &cvers[2]);
1335 1388
1336 1389 for (i = 0; i < 3; i++) {
1337 1390 if (zvers[i] > cvers[i]) {
1338 1391 return (1);
1339 1392 } else if (zvers[i] < cvers[i]) {
1340 1393 return (-1);
1341 1394 }
1342 1395 }
1343 1396 return (0);
1344 1397 }
1345 1398
1346 1399 /*
1347 1400 * Linux unconditionally removes the setuid and setgid bits when changing
1348 1401 * file ownership. This brand hook overrides the illumos native behaviour,
1349 1402 * which is based on the PRIV_FILE_SETID privilege.
1350 1403 */
1351 1404 static int
1352 1405 lx_setid_clear(vattr_t *vap, cred_t *cr)
1353 1406 {
1354 1407 if (S_ISDIR(vap->va_mode)) {
1355 1408 return (0);
1356 1409 }
1357 1410
1358 1411 if (vap->va_mode & S_ISUID) {
1359 1412 vap->va_mask |= AT_MODE;
1360 1413 vap->va_mode &= ~S_ISUID;
1361 1414 }
1362 1415 if ((vap->va_mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP)) {
1363 1416 vap->va_mask |= AT_MODE;
1364 1417 vap->va_mode &= ~S_ISGID;
1365 1418 }
1366 1419
1367 1420 return (0);
1368 1421 }
1369 1422
1370 1423 /*
1371 1424 * Copy the per-process brand data from a parent proc to a child.
1372 1425 */
1373 1426 void
1374 1427 lx_copy_procdata(proc_t *child, proc_t *parent)
1375 1428 {
1376 1429 lx_proc_data_t *cpd = child->p_brand_data;
1377 1430 lx_proc_data_t *ppd = parent->p_brand_data;
1378 1431
1379 1432 VERIFY(parent->p_brand == &lx_brand);
1380 1433 VERIFY(child->p_brand == &lx_brand);
1381 1434 VERIFY(ppd != NULL);
1382 1435 VERIFY(cpd != NULL);
1383 1436
1384 1437 *cpd = *ppd;
1385 1438
1386 1439 cpd->l_fake_limits[LX_RLFAKE_LOCKS].rlim_cur = LX_RLIM64_INFINITY;
1387 1440 cpd->l_fake_limits[LX_RLFAKE_LOCKS].rlim_max = LX_RLIM64_INFINITY;
1388 1441
1389 1442 cpd->l_fake_limits[LX_RLFAKE_NICE].rlim_cur = 20;
1390 1443 cpd->l_fake_limits[LX_RLFAKE_NICE].rlim_max = 20;
1391 1444
1392 1445 cpd->l_fake_limits[LX_RLFAKE_RTPRIO].rlim_cur = LX_RLIM64_INFINITY;
1393 1446 cpd->l_fake_limits[LX_RLFAKE_RTPRIO].rlim_max = LX_RLIM64_INFINITY;
1394 1447
1395 1448 cpd->l_fake_limits[LX_RLFAKE_RTTIME].rlim_cur = LX_RLIM64_INFINITY;
1396 1449 cpd->l_fake_limits[LX_RLFAKE_RTTIME].rlim_max = LX_RLIM64_INFINITY;
1397 1450 }
1398 1451
1399 1452 #if defined(_LP64)
1400 1453 static void
1401 1454 Ehdr32to64(Elf32_Ehdr *src, Ehdr *dst)
1402 1455 {
1403 1456 bcopy(src->e_ident, dst->e_ident, sizeof (src->e_ident));
1404 1457 dst->e_type = src->e_type;
1405 1458 dst->e_machine = src->e_machine;
1406 1459 dst->e_version = src->e_version;
1407 1460 dst->e_entry = src->e_entry;
1408 1461 dst->e_phoff = src->e_phoff;
1409 1462 dst->e_shoff = src->e_shoff;
1410 1463 dst->e_flags = src->e_flags;
1411 1464 dst->e_ehsize = src->e_ehsize;
1412 1465 dst->e_phentsize = src->e_phentsize;
1413 1466 dst->e_phnum = src->e_phnum;
1414 1467 dst->e_shentsize = src->e_shentsize;
1415 1468 dst->e_shnum = src->e_shnum;
1416 1469 dst->e_shstrndx = src->e_shstrndx;
1417 1470 }
1418 1471 #endif /* _LP64 */
1419 1472
1420 1473 static void
1421 1474 restoreexecenv(struct execenv *ep, stack_t *sp)
1422 1475 {
1423 1476 klwp_t *lwp = ttolwp(curthread);
1424 1477
1425 1478 setexecenv(ep);
1426 1479 lwp->lwp_sigaltstack.ss_sp = sp->ss_sp;
1427 1480 lwp->lwp_sigaltstack.ss_size = sp->ss_size;
1428 1481 lwp->lwp_sigaltstack.ss_flags = sp->ss_flags;
1429 1482 }
1430 1483
1431 1484 extern int elfexec(vnode_t *, execa_t *, uarg_t *, intpdata_t *, int,
1432 1485 long *, int, caddr_t, cred_t *, int *);
1433 1486
1434 1487 extern int elf32exec(struct vnode *, execa_t *, uarg_t *, intpdata_t *, int,
1435 1488 long *, int, caddr_t, cred_t *, int *);
1436 1489
1437 1490 /*
1438 1491 * Exec routine called by elfexec() to load either 32-bit or 64-bit Linux
1439 1492 * binaries.
1440 1493 */
1441 1494 static int
1442 1495 lx_elfexec(struct vnode *vp, struct execa *uap, struct uarg *args,
1443 1496 struct intpdata *idata, int level, long *execsz, int setid,
1444 1497 caddr_t exec_file, struct cred *cred, int *brand_action)
1445 1498 {
1446 1499 int error;
1447 1500 vnode_t *nvp;
1448 1501 Ehdr ehdr;
1449 1502 Addr uphdr_vaddr;
1450 1503 intptr_t voffset;
1451 1504 char *interp = NULL;
1452 1505 uintptr_t ldaddr = NULL;
1453 1506 int i;
1454 1507 proc_t *p = ttoproc(curthread);
1455 1508 klwp_t *lwp = ttolwp(curthread);
1456 1509 struct execenv env;
1457 1510 struct execenv origenv;
1458 1511 stack_t orig_sigaltstack;
1459 1512 struct user *up = PTOU(ttoproc(curthread));
1460 1513 lx_elf_data_t *edp;
1461 1514 char *lib_path = NULL;
1462 1515
1463 1516 ASSERT(ttoproc(curthread)->p_brand == &lx_brand);
1464 1517 ASSERT(ttoproc(curthread)->p_brand_data != NULL);
1465 1518
1466 1519 edp = &ttolxproc(curthread)->l_elf_data;
1467 1520
1468 1521 if (args->to_model == DATAMODEL_NATIVE) {
1469 1522 lib_path = LX_LIB_PATH;
1470 1523 }
1471 1524 #if defined(_LP64)
1472 1525 else {
1473 1526 lib_path = LX_LIB_PATH32;
1474 1527 }
1475 1528 #endif
1476 1529
1477 1530 /*
1478 1531 * Set the brandname and library name for the new process so that
1479 1532 * elfexec() puts them onto the stack.
1480 1533 */
1481 1534 args->brandname = LX_BRANDNAME;
1482 1535 args->emulator = lib_path;
1483 1536
1484 1537 #if defined(_LP64)
1485 1538 /*
1486 1539 * To conform with the way Linux lays out the address space, we clamp
1487 1540 * the stack to be the top of the lower region of the x86-64 canonical
1488 1541 * form address space -- which has the side-effect of laying out the
1489 1542 * entire address space in that lower region. Note that this only
1490 1543 * matters on 64-bit processes (this value will always be greater than
1491 1544 * the size of a 32-bit address space) and doesn't actually affect
1492 1545 * USERLIMIT: if a Linux-branded processes wishes to map something
1493 1546 * into the top half of the address space, it can do so -- but with
1494 1547 * the user stack starting at the top of the bottom region, those high
1495 1548 * virtual addresses won't be used unless explicitly directed.
1496 1549 */
1497 1550 args->maxstack = lx_maxstack64;
1498 1551 #endif
1499 1552
1500 1553 /*
1501 1554 * We will first exec the brand library, then map in the linux
1502 1555 * executable and the linux linker.
1503 1556 */
1504 1557 if ((error = lookupname(lib_path, UIO_SYSSPACE, FOLLOW, NULLVPP,
1505 1558 &nvp))) {
1506 1559 uprintf("%s: not found.", lib_path);
1507 1560 return (error);
1508 1561 }
1509 1562
1510 1563 /*
1511 1564 * We will eventually set the p_exec member to be the vnode for the new
1512 1565 * executable when we call setexecenv(). However, if we get an error
1513 1566 * before that call we need to restore the execenv to its original
1514 1567 * values so that when we return to the caller fop_close() works
1515 1568 * properly while cleaning up from the failed exec(). Restoring the
1516 1569 * original value will also properly decrement the 2nd VN_RELE that we
1517 1570 * took on the brand library.
1518 1571 */
1519 1572 origenv.ex_bssbase = p->p_bssbase;
1520 1573 origenv.ex_brkbase = p->p_brkbase;
1521 1574 origenv.ex_brksize = p->p_brksize;
1522 1575 origenv.ex_vp = p->p_exec;
1523 1576 orig_sigaltstack.ss_sp = lwp->lwp_sigaltstack.ss_sp;
1524 1577 orig_sigaltstack.ss_size = lwp->lwp_sigaltstack.ss_size;
1525 1578 orig_sigaltstack.ss_flags = lwp->lwp_sigaltstack.ss_flags;
1526 1579
1527 1580 if (args->to_model == DATAMODEL_NATIVE) {
1528 1581 error = elfexec(nvp, uap, args, idata, level + 1, execsz,
1529 1582 setid, exec_file, cred, brand_action);
1530 1583 }
1531 1584 #if defined(_LP64)
1532 1585 else {
1533 1586 error = elf32exec(nvp, uap, args, idata, level + 1, execsz,
1534 1587 setid, exec_file, cred, brand_action);
1535 1588 }
1536 1589 #endif
1537 1590 VN_RELE(nvp);
1538 1591 if (error != 0) {
1539 1592 restoreexecenv(&origenv, &orig_sigaltstack);
1540 1593 return (error);
1541 1594 }
1542 1595
1543 1596 /*
1544 1597 * exec-ed in the brand library above.
1545 1598 * The u_auxv vectors are now setup by elfexec to point to the
1546 1599 * brand emulation library and its linker.
1547 1600 */
1548 1601
1549 1602 bzero(&env, sizeof (env));
1550 1603
1551 1604 /*
1552 1605 * map in the the Linux executable
1553 1606 */
1554 1607 if (args->to_model == DATAMODEL_NATIVE) {
1555 1608 error = mapexec_brand(vp, args, &ehdr, &uphdr_vaddr,
1556 1609 &voffset, exec_file, &interp, &env.ex_bssbase,
1557 1610 &env.ex_brkbase, &env.ex_brksize, NULL, NULL);
1558 1611 }
1559 1612 #if defined(_LP64)
1560 1613 else {
1561 1614 Elf32_Ehdr ehdr32;
1562 1615 Elf32_Addr uphdr_vaddr32;
1563 1616
1564 1617 error = mapexec32_brand(vp, args, &ehdr32, &uphdr_vaddr32,
1565 1618 &voffset, exec_file, &interp, &env.ex_bssbase,
1566 1619 &env.ex_brkbase, &env.ex_brksize, NULL, NULL);
1567 1620
1568 1621 Ehdr32to64(&ehdr32, &ehdr);
1569 1622
1570 1623 if (uphdr_vaddr32 == (Elf32_Addr)-1)
1571 1624 uphdr_vaddr = (Addr)-1;
1572 1625 else
1573 1626 uphdr_vaddr = uphdr_vaddr32;
1574 1627 }
1575 1628 #endif
1576 1629 if (error != 0) {
1577 1630 restoreexecenv(&origenv, &orig_sigaltstack);
1578 1631
1579 1632 if (interp != NULL)
1580 1633 kmem_free(interp, MAXPATHLEN);
1581 1634
1582 1635 return (error);
1583 1636 }
1584 1637
1585 1638 /*
1586 1639 * Save off the important properties of the lx executable. The brand
1587 1640 * library will ask us for this data later, when it is ready to set
1588 1641 * things up for the lx executable.
1589 1642 */
1590 1643 edp->ed_phdr = (uphdr_vaddr == -1) ? voffset + ehdr.e_phoff :
1591 1644 voffset + uphdr_vaddr;
1592 1645 edp->ed_entry = voffset + ehdr.e_entry;
1593 1646 edp->ed_phent = ehdr.e_phentsize;
1594 1647 edp->ed_phnum = ehdr.e_phnum;
1595 1648
1596 1649 if (interp != NULL) {
1597 1650 if (ehdr.e_type == ET_DYN) {
1598 1651 /*
1599 1652 * This is a shared object executable, so we need to
1600 1653 * pick a reasonable place to put the heap. Just don't
1601 1654 * use the first page.
1602 1655 */
1603 1656 env.ex_brkbase = (caddr_t)PAGESIZE;
1604 1657 env.ex_bssbase = (caddr_t)PAGESIZE;
1605 1658 }
1606 1659
1607 1660 /*
1608 1661 * If the program needs an interpreter (most do), map it in and
1609 1662 * store relevant information about it in the aux vector, where
1610 1663 * the brand library can find it.
1611 1664 */
1612 1665 if ((error = lookupname(interp, UIO_SYSSPACE, FOLLOW,
1613 1666 NULLVPP, &nvp))) {
1614 1667 uprintf("%s: not found.", interp);
1615 1668 restoreexecenv(&origenv, &orig_sigaltstack);
1616 1669 kmem_free(interp, MAXPATHLEN);
1617 1670 return (error);
1618 1671 }
1619 1672
1620 1673 kmem_free(interp, MAXPATHLEN);
1621 1674 interp = NULL;
1622 1675
1623 1676 /*
1624 1677 * map in the Linux linker
1625 1678 */
1626 1679 if (args->to_model == DATAMODEL_NATIVE) {
1627 1680 error = mapexec_brand(nvp, args, &ehdr,
1628 1681 &uphdr_vaddr, &voffset, exec_file, NULL, NULL,
1629 1682 NULL, NULL, NULL, &ldaddr);
1630 1683 }
1631 1684 #if defined(_LP64)
1632 1685 else {
1633 1686 Elf32_Ehdr ehdr32;
1634 1687 Elf32_Addr uphdr_vaddr32;
1635 1688
1636 1689 error = mapexec32_brand(nvp, args, &ehdr32,
1637 1690 &uphdr_vaddr32, &voffset, exec_file, NULL, NULL,
1638 1691 NULL, NULL, NULL, &ldaddr);
1639 1692
1640 1693 Ehdr32to64(&ehdr32, &ehdr);
1641 1694
1642 1695 if (uphdr_vaddr32 == (Elf32_Addr)-1)
1643 1696 uphdr_vaddr = (Addr)-1;
1644 1697 else
1645 1698 uphdr_vaddr = uphdr_vaddr32;
1646 1699 }
1647 1700 #endif
1648 1701
1649 1702 VN_RELE(nvp);
1650 1703 if (error != 0) {
1651 1704 restoreexecenv(&origenv, &orig_sigaltstack);
1652 1705 return (error);
1653 1706 }
1654 1707
1655 1708 /*
1656 1709 * Now that we know the base address of the brand's linker,
1657 1710 * we also save this for later use by the brand library.
1658 1711 */
1659 1712 edp->ed_base = voffset;
1660 1713 edp->ed_ldentry = voffset + ehdr.e_entry;
1661 1714 } else {
1662 1715 /*
1663 1716 * This program has no interpreter. The lx brand library will
1664 1717 * jump to the address in the AT_SUN_BRAND_LDENTRY aux vector,
1665 1718 * so in this case, put the entry point of the main executable
1666 1719 * there.
1667 1720 */
1668 1721 if (ehdr.e_type == ET_EXEC) {
1669 1722 /*
1670 1723 * An executable with no interpreter, this must be a
1671 1724 * statically linked executable, which means we loaded
1672 1725 * it at the address specified in the elf header, in
1673 1726 * which case the e_entry field of the elf header is an
1674 1727 * absolute address.
1675 1728 */
1676 1729 edp->ed_ldentry = ehdr.e_entry;
1677 1730 edp->ed_entry = ehdr.e_entry;
1678 1731 } else {
1679 1732 /*
1680 1733 * A shared object with no interpreter, we use the
1681 1734 * calculated address from above.
1682 1735 */
1683 1736 edp->ed_ldentry = edp->ed_entry;
1684 1737
1685 1738 /*
1686 1739 * In all situations except an ET_DYN elf object with no
1687 1740 * interpreter, we want to leave the brk and base
1688 1741 * values set by mapexec_brand alone. Normally when
1689 1742 * running ET_DYN objects on Solaris (most likely
1690 1743 * /lib/ld.so.1) the kernel sets brk and base to 0 since
1691 1744 * it doesn't know where to put the heap, and later the
1692 1745 * linker will call brk() to initialize the heap in:
1693 1746 * usr/src/cmd/sgs/rtld/common/setup.c:setup()
1694 1747 * after it has determined where to put it. (This
1695 1748 * decision is made after the linker loads and inspects
1696 1749 * elf properties of the target executable being run.)
1697 1750 *
1698 1751 * So for ET_DYN Linux executables, we also don't know
1699 1752 * where the heap should go, so we'll set the brk and
1700 1753 * base to 0. But in this case the Solaris linker will
1701 1754 * not initialize the heap, so when the Linux linker
1702 1755 * starts running there is no heap allocated. This
1703 1756 * seems to be ok on Linux 2.4 based systems because the
1704 1757 * Linux linker/libc fall back to using mmap() to
1705 1758 * allocate memory. But on 2.6 systems, running
1706 1759 * applications by specifying them as command line
1707 1760 * arguments to the linker results in segfaults for an
1708 1761 * as yet undetermined reason (which seems to indicatej
1709 1762 * that a more permanent fix for heap initalization in
1710 1763 * these cases may be necessary).
1711 1764 */
1712 1765 if (ehdr.e_type == ET_DYN) {
1713 1766 env.ex_bssbase = (caddr_t)0;
1714 1767 env.ex_brkbase = (caddr_t)0;
1715 1768 env.ex_brksize = 0;
1716 1769 }
1717 1770 }
1718 1771
1719 1772 }
1720 1773
1721 1774 env.ex_vp = vp;
1722 1775 setexecenv(&env);
1723 1776
1724 1777 /*
1725 1778 * We try to keep /proc's view of the aux vector consistent with
1726 1779 * what's on the process stack.
1727 1780 */
1728 1781 if (args->to_model == DATAMODEL_NATIVE) {
1729 1782 auxv_t phdr_auxv[4] = {
1730 1783 { AT_SUN_BRAND_LX_PHDR, 0 },
1731 1784 { AT_SUN_BRAND_LX_INTERP, 0 },
1732 1785 { AT_SUN_BRAND_LX_SYSINFO_EHDR, 0 },
1733 1786 { AT_SUN_BRAND_AUX4, 0 }
1734 1787 };
1735 1788 phdr_auxv[0].a_un.a_val = edp->ed_phdr;
1736 1789 phdr_auxv[1].a_un.a_val = ldaddr;
1737 1790 phdr_auxv[2].a_un.a_val = 1; /* set in lx_init */
1738 1791 phdr_auxv[3].a_type = AT_CLKTCK;
1739 1792 phdr_auxv[3].a_un.a_val = hz;
1740 1793
1741 1794 if (copyout(&phdr_auxv, args->auxp_brand,
1742 1795 sizeof (phdr_auxv)) == -1)
1743 1796 return (EFAULT);
1744 1797 }
1745 1798 #if defined(_LP64)
1746 1799 else {
1747 1800 auxv32_t phdr_auxv32[3] = {
1748 1801 { AT_SUN_BRAND_LX_PHDR, 0 },
1749 1802 { AT_SUN_BRAND_LX_INTERP, 0 },
1750 1803 { AT_SUN_BRAND_AUX3, 0 }
1751 1804 };
1752 1805 phdr_auxv32[0].a_un.a_val = edp->ed_phdr;
1753 1806 phdr_auxv32[1].a_un.a_val = ldaddr;
1754 1807 phdr_auxv32[2].a_type = AT_CLKTCK;
1755 1808 phdr_auxv32[2].a_un.a_val = hz;
1756 1809
1757 1810 if (copyout(&phdr_auxv32, args->auxp_brand,
1758 1811 sizeof (phdr_auxv32)) == -1)
1759 1812 return (EFAULT);
1760 1813 }
1761 1814 #endif
1762 1815
1763 1816 /*
1764 1817 * /proc uses the AT_ENTRY aux vector entry to deduce
1765 1818 * the location of the executable in the address space. The user
1766 1819 * structure contains a copy of the aux vector that needs to have those
1767 1820 * entries patched with the values of the real lx executable (they
1768 1821 * currently contain the values from the lx brand library that was
1769 1822 * elfexec'd, above).
1770 1823 *
1771 1824 * For live processes, AT_BASE is used to locate the linker segment,
1772 1825 * which /proc and friends will later use to find Solaris symbols
1773 1826 * (such as rtld_db_preinit). However, for core files, /proc uses
1774 1827 * AT_ENTRY to find the right segment to label as the executable.
1775 1828 * So we set AT_ENTRY to be the entry point of the linux executable,
1776 1829 * but leave AT_BASE to be the address of the Solaris linker.
1777 1830 */
1778 1831 for (i = 0; i < __KERN_NAUXV_IMPL; i++) {
1779 1832 switch (up->u_auxv[i].a_type) {
1780 1833 case AT_ENTRY:
1781 1834 up->u_auxv[i].a_un.a_val = edp->ed_entry;
1782 1835 break;
1783 1836
1784 1837 case AT_SUN_BRAND_LX_PHDR:
1785 1838 up->u_auxv[i].a_un.a_val = edp->ed_phdr;
1786 1839 break;
1787 1840
1788 1841 case AT_SUN_BRAND_LX_INTERP:
1789 1842 up->u_auxv[i].a_un.a_val = ldaddr;
1790 1843 break;
1791 1844
1792 1845 default:
1793 1846 break;
1794 1847 }
1795 1848 }
1796 1849
1797 1850 return (0);
1798 1851 }
1799 1852
1800 1853 boolean_t
1801 1854 lx_native_exec(uint8_t osabi, const char **interp)
1802 1855 {
1803 1856 if (osabi != ELFOSABI_SOLARIS)
1804 1857 return (B_FALSE);
1805 1858
1806 1859 /*
1807 1860 * If the process root matches the zone root, prepend /native to the
1808 1861 * interpreter path for native executables. Absolute precision from
1809 1862 * VN_CMP is not necessary since any change of process root is likely
1810 1863 * to make native binaries inaccessible via /native.
1811 1864 *
1812 1865 * Processes which chroot directly into /native will be able to
1813 1866 * function as expected with no need for the prefix.
1814 1867 */
1815 1868 if (VN_CMP(curproc->p_user.u_rdir, curproc->p_zone->zone_rootvp)) {
1816 1869 *interp = "/native";
1817 1870 }
1818 1871
1819 1872 return (B_TRUE);
1820 1873 }
1821 1874
1822 1875 static void
1823 1876 lx_syscall_init(void)
1824 1877 {
1825 1878 int i;
1826 1879
1827 1880 /*
1828 1881 * Count up the 32-bit Linux system calls. Note that lx_sysent32
1829 1882 * has (LX_NSYSCALLS + 1) entries.
1830 1883 */
1831 1884 for (i = 0; i <= LX_NSYSCALLS && lx_sysent32[i].sy_name != NULL; i++)
1832 1885 continue;
1833 1886 lx_nsysent32 = i;
1834 1887
1835 1888 #if defined(_LP64)
1836 1889 /*
1837 1890 * Count up the 64-bit Linux system calls. Note that lx_sysent64
1838 1891 * has (LX_NSYSCALLS + 1) entries.
1839 1892 */
1840 1893 for (i = 0; i <= LX_NSYSCALLS && lx_sysent64[i].sy_name != NULL; i++)
1841 1894 continue;
1842 1895 lx_nsysent64 = i;
1843 1896 #endif
1844 1897 }
1845 1898
1846 1899 int
1847 1900 _init(void)
1848 1901 {
1849 1902 int err = 0;
1850 1903
1851 1904 lx_syscall_init();
1852 1905 lx_pid_init();
1853 1906 lx_ioctl_init();
1854 1907 lx_futex_init();
1855 1908 lx_ptrace_init();
1856 1909 lx_socket_init();
1857 1910
1858 1911 err = mod_install(&modlinkage);
1859 1912 if (err != 0) {
1860 1913 cmn_err(CE_WARN, "Couldn't install lx brand module");
1861 1914
1862 1915 /*
1863 1916 * This looks drastic, but it should never happen. These
1864 1917 * two data structures should be completely free-able until
1865 1918 * they are used by Linux processes. Since the brand
1866 1919 * wasn't loaded there should be no Linux processes, and
1867 1920 * thus no way for these data structures to be modified.
1868 1921 */
1869 1922 lx_pid_fini();
1870 1923 lx_ioctl_fini();
1871 1924 if (lx_futex_fini())
1872 1925 panic("lx brand module cannot be loaded or unloaded.");
1873 1926 }
1874 1927 return (err);
1875 1928 }
1876 1929
1877 1930 int
1878 1931 _info(struct modinfo *modinfop)
1879 1932 {
1880 1933 return (mod_info(&modlinkage, modinfop));
1881 1934 }
1882 1935
1883 1936 int
1884 1937 _fini(void)
1885 1938 {
1886 1939 int err;
1887 1940 int futex_done = 0;
1888 1941
1889 1942 /*
1890 1943 * If there are any zones using this brand, we can't allow it to be
1891 1944 * unloaded.
1892 1945 */
1893 1946 if (brand_zone_count(&lx_brand))
1894 1947 return (EBUSY);
1895 1948
1896 1949 lx_ptrace_fini();
1897 1950 lx_pid_fini();
1898 1951 lx_ioctl_fini();
1899 1952 lx_socket_fini();
1900 1953
1901 1954 if ((err = lx_futex_fini()) != 0) {
1902 1955 goto done;
1903 1956 }
1904 1957 futex_done = 1;
1905 1958
1906 1959 err = mod_remove(&modlinkage);
1907 1960
1908 1961 done:
1909 1962 if (err) {
1910 1963 /*
1911 1964 * If we can't unload the module, then we have to get it
1912 1965 * back into a sane state.
1913 1966 */
1914 1967 lx_ptrace_init();
1915 1968 lx_pid_init();
1916 1969 lx_ioctl_init();
1917 1970 lx_socket_init();
1918 1971
1919 1972 if (futex_done) {
1920 1973 lx_futex_init();
1921 1974 }
1922 1975 }
1923 1976
1924 1977 return (err);
1925 1978 }
|
↓ open down ↓ |
923 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX