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 /*
23 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #include <errno.h>
28 #include <sys/types.h>
29 #include <sys/param.h>
30 #include <sys/lx_misc.h>
31 #include <sys/lx_debug.h>
32 #include <sys/lx_syscall.h>
33 #include <sys/lx_signal.h>
34 #include <sys/lx_thread.h>
35 #include <sys/lwp.h>
36 #include <unistd.h>
37 #include <fcntl.h>
38 #include <procfs.h>
39 #include <sys/frame.h>
40 #include <strings.h>
41 #include <signal.h>
42 #include <stddef.h>
43 #include <stdlib.h>
44 #include <sys/wait.h>
45 #include <sys/auxv.h>
46 #include <thread.h>
47 #include <pthread.h>
48 #include <synch.h>
49 #include <elf.h>
50 #include <ieeefp.h>
51 #include <assert.h>
52 #include <libintl.h>
53
54 /*
55 * Linux ptrace compatibility.
56 *
57 * The brand support for ptrace(2) is built on top of the Solaris /proc
58 * interfaces, mounted at /native/proc in the zone. This gets quite
59 * complicated due to the way ptrace works and the Solaris realization of the
60 * Linux threading model.
61 *
62 * ptrace can only interact with a process if we are tracing it, and it is
63 * currently stopped. There are two ways a process can begin tracing another
64 * process:
65 *
66 * PTRACE_TRACEME
67 *
68 * A child process can use PTRACE_TRACEME to indicate that it wants to be
69 * traced by the parent. This sets the ptrace compatibility flag in /proc
70 * which causes ths ptrace consumer to be notified through the wait(2)
71 * system call of events of interest. PTRACE_TRACEME is typically used by
72 * the debugger by forking a process, using PTRACE_TRACEME, and finally
73 * doing an exec of the specified program.
74 *
75 *
76 * PTRACE_ATTACH
77 *
78 * We can attach to a process using PTRACE_ATTACH. This is considerably
79 * more complicated than the previous case. On Linux, the traced process is
80 * effectively reparented to the ptrace consumer so that event notification
81 * can go through the normal wait(2) system call. Solaris has no such
82 * ability to reparent a process (nor should it) so some trickery was
83 * required.
84 *
85 * When the ptrace consumer uses PTRACE_ATTACH it forks a monitor child
86 * process. The monitor enables the /proc ptrace flag for itself and uses
87 * the native /proc mechanisms to observe the traced process and wait for
88 * events of interest. When the traced process stops, the monitor process
89 * sends itself a SIGTRAP thus rousting its parent process (the ptrace
90 * consumer) out of wait(2). We then translate the process id and status
91 * code from wait(2) to those of the traced process.
92 *
93 * To detach from the process we just have to clean up tracing flags and
94 * clean up the monitor.
95 *
96 * ptrace can only interact with a process if we have traced it, and it is
97 * currently stopped (see is_traced()). For threads, there's no way to
98 * distinguish whether ptrace() has been called for all threads or some
99 * subset. Since most clients will be tracing all threads, and erroneously
100 * allowing ptrace to access a non-traced thread is non-fatal (or at least
101 * would be fatal on linux), we ignore this aspect of the problem.
102 */
103
104 #define LX_PTRACE_TRACEME 0
105 #define LX_PTRACE_PEEKTEXT 1
106 #define LX_PTRACE_PEEKDATA 2
107 #define LX_PTRACE_PEEKUSER 3
108 #define LX_PTRACE_POKETEXT 4
109 #define LX_PTRACE_POKEDATA 5
110 #define LX_PTRACE_POKEUSER 6
111 #define LX_PTRACE_CONT 7
112 #define LX_PTRACE_KILL 8
113 #define LX_PTRACE_SINGLESTEP 9
114 #define LX_PTRACE_GETREGS 12
115 #define LX_PTRACE_SETREGS 13
116 #define LX_PTRACE_GETFPREGS 14
117 #define LX_PTRACE_SETFPREGS 15
118 #define LX_PTRACE_ATTACH 16
119 #define LX_PTRACE_DETACH 17
120 #define LX_PTRACE_GETFPXREGS 18
121 #define LX_PTRACE_SETFPXREGS 19
122 #define LX_PTRACE_SYSCALL 24
123
124 /*
125 * This corresponds to the user_i387_struct Linux structure.
126 */
127 typedef struct lx_user_fpregs {
128 long lxuf_cwd;
129 long lxuf_swd;
130 long lxuf_twd;
131 long lxuf_fip;
132 long lxuf_fcs;
133 long lxuf_foo;
134 long lxuf_fos;
135 long lxuf_st_space[20];
136 } lx_user_fpregs_t;
137
138 /*
139 * This corresponds to the user_fxsr_struct Linux structure.
140 */
141 typedef struct lx_user_fpxregs {
142 uint16_t lxux_cwd;
143 uint16_t lxux_swd;
144 uint16_t lxux_twd;
145 uint16_t lxux_fop;
146 long lxux_fip;
147 long lxux_fcs;
148 long lxux_foo;
149 long lxux_fos;
150 long lxux_mxcsr;
151 long lxux_reserved;
152 long lxux_st_space[32];
153 long lxux_xmm_space[32];
154 long lxux_padding[56];
155 } lx_user_fpxregs_t;
156
157 /*
158 * This corresponds to the user_regs_struct Linux structure.
159 */
160 typedef struct lx_user_regs {
161 long lxur_ebx;
162 long lxur_ecx;
163 long lxur_edx;
164 long lxur_esi;
165 long lxur_edi;
166 long lxur_ebp;
167 long lxur_eax;
168 long lxur_xds;
169 long lxur_xes;
170 long lxur_xfs;
171 long lxur_xgs;
172 long lxur_orig_eax;
173 long lxur_eip;
174 long lxur_xcs;
175 long lxur_eflags;
176 long lxur_esp;
177 long lxur_xss;
178 } lx_user_regs_t;
179
180 typedef struct lx_user {
181 lx_user_regs_t lxu_regs;
182 int lxu_fpvalid;
183 lx_user_fpregs_t lxu_i387;
184 ulong_t lxu_tsize;
185 ulong_t lxu_dsize;
186 ulong_t lxu_ssize;
187 ulong_t lxu_start_code;
188 ulong_t lxu_start_stack;
189 long lxu_signal;
190 int lxu_reserved;
191 lx_user_regs_t *lxu_ar0;
192 lx_user_fpregs_t *lxu_fpstate;
193 ulong_t lxu_magic;
194 char lxu_comm[32];
195 int lxu_debugreg[8];
196 } lx_user_t;
197
198 typedef struct ptrace_monitor_map {
199 struct ptrace_monitor_map *pmm_next; /* next pointer */
200 pid_t pmm_monitor; /* monitor child process */
201 pid_t pmm_target; /* traced Linux pid */
202 pid_t pmm_pid; /* Solaris pid */
203 lwpid_t pmm_lwpid; /* Solaris lwpid */
204 uint_t pmm_exiting; /* detached */
205 } ptrace_monitor_map_t;
206
207 typedef struct ptrace_state_map {
208 struct ptrace_state_map *psm_next; /* next pointer */
209 pid_t psm_pid; /* Solaris pid */
210 uintptr_t psm_debugreg[8]; /* debug registers */
211 } ptrace_state_map_t;
212
213 static ptrace_monitor_map_t *ptrace_monitor_map = NULL;
214 static ptrace_state_map_t *ptrace_state_map = NULL;
215 static mutex_t ptrace_map_mtx = DEFAULTMUTEX;
216
217 extern void *_START_;
218
219 static sigset_t blockable_sigs;
220
221 #pragma init(ptrace_init)
222 void
223 ptrace_init(void)
224 {
225 (void) sigfillset(&blockable_sigs);
226 (void) sigdelset(&blockable_sigs, SIGKILL);
227 (void) sigdelset(&blockable_sigs, SIGSTOP);
228 }
229
230 /*
231 * Given a pid, open the named file under /native/proc/<pid>/name using the
232 * given mode.
233 */
234 static int
235 open_procfile(pid_t pid, int mode, const char *name)
236 {
237 char path[MAXPATHLEN];
238
239 (void) snprintf(path, sizeof (path), "/native/proc/%d/%s", pid, name);
240
241 return (open(path, mode));
242 }
243
244 /*
245 * Given a pid and lwpid, open the named file under
246 * /native/proc/<pid>/<lwpid>/name using the given mode.
247 */
248 static int
249 open_lwpfile(pid_t pid, lwpid_t lwpid, int mode, const char *name)
250 {
251 char path[MAXPATHLEN];
252
253 (void) snprintf(path, sizeof (path), "/native/proc/%d/lwp/%d/%s",
254 pid, lwpid, name);
255
256 return (open(path, mode));
257 }
258
259 static int
260 get_status(pid_t pid, pstatus_t *psp)
261 {
262 int fd;
263
264 if ((fd = open_procfile(pid, O_RDONLY, "status")) < 0)
265 return (-ESRCH);
266
267 if (read(fd, psp, sizeof (pstatus_t)) != sizeof (pstatus_t)) {
268 (void) close(fd);
269 return (-EIO);
270 }
271
272 (void) close(fd);
273
274 return (0);
275 }
276
277 static int
278 get_lwpstatus(pid_t pid, lwpid_t lwpid, lwpstatus_t *lsp)
279 {
280 int fd;
281
282 if ((fd = open_lwpfile(pid, lwpid, O_RDONLY, "lwpstatus")) < 0)
283 return (-ESRCH);
284
285 if (read(fd, lsp, sizeof (lwpstatus_t)) != sizeof (lwpstatus_t)) {
286 (void) close(fd);
287 return (-EIO);
288 }
289
290 (void) close(fd);
291
292 return (0);
293 }
294
295 static uintptr_t
296 syscall_regs(int fd, uintptr_t fp, pid_t pid)
297 {
298 uintptr_t addr, done;
299 struct frame fr;
300 auxv_t auxv;
301 int afd;
302 Elf32_Phdr phdr;
303
304 /*
305 * Try to walk the stack looking for a return address that corresponds
306 * to the traced process's lx_emulate_done symbol. This relies on the
307 * fact that the brand library in the traced process is the same as the
308 * brand library in this process (indeed, this is true of all processes
309 * in a given branded zone).
310 */
311
312 /*
313 * Find the base address for the brand library in the traced process
314 * by grabbing the AT_PHDR auxv entry, reading in the program header
315 * at that location and subtracting off the p_vaddr member. We use
316 * this to compute the location of lx_emulate done in the traced
317 * process.
318 */
319 if ((afd = open_procfile(pid, O_RDONLY, "auxv")) < 0)
320 return (0);
321
322 do {
323 if (read(afd, &auxv, sizeof (auxv)) != sizeof (auxv)) {
324 (void) close(afd);
325 return (0);
326 }
327 } while (auxv.a_type != AT_PHDR);
328
329 (void) close(afd);
330
331 if (pread(fd, &phdr, sizeof (phdr), auxv.a_un.a_val) != sizeof (phdr)) {
332 lx_debug("failed to read brand library's phdr");
333 return (0);
334 }
335
336 addr = auxv.a_un.a_val - phdr.p_vaddr;
337 done = (uintptr_t)&lx_emulate_done - (uintptr_t)&_START_ + addr;
338
339 fr.fr_savfp = fp;
340
341 do {
342 addr = fr.fr_savfp;
343 if (pread(fd, &fr, sizeof (fr), addr) != sizeof (fr)) {
344 lx_debug("ptrace read failed for stack walk");
345 return (0);
346 }
347
348 if (addr >= fr.fr_savfp) {
349 lx_debug("ptrace stack not monotonically increasing "
350 "%p %p (%p)", addr, fr.fr_savfp, done);
351 return (0);
352 }
353 } while (fr.fr_savpc != done);
354
355 /*
356 * The first argument to lx_emulate is known to be an lx_regs_t
357 * structure and the ABI specifies that it will be placed on the stack
358 * immediately preceeding the return address.
359 */
360 addr += sizeof (fr);
361 if (pread(fd, &addr, sizeof (addr), addr) != sizeof (addr)) {
362 lx_debug("ptrace stack failed to read register set address");
363 return (0);
364 }
365
366 return (addr);
367 }
368
369 static int
370 getregs(pid_t pid, lwpid_t lwpid, lx_user_regs_t *rp)
371 {
372 lwpstatus_t status;
373 uintptr_t addr;
374 int fd, ret;
375
376 if ((ret = get_lwpstatus(pid, lwpid, &status)) != 0)
377 return (ret);
378
379 if ((fd = open_procfile(pid, O_RDONLY, "as")) < 0)
380 return (-ESRCH);
381
382 /*
383 * If we find the syscall regs (and are therefore in an emulated
384 * syscall, use the register set at given address. Otherwise, use the
385 * registers as reported by /proc.
386 */
387 if ((addr = syscall_regs(fd, status.pr_reg[EBP], pid)) != 0) {
388 lx_regs_t regs;
389
390 if (pread(fd, ®s, sizeof (regs), addr) != sizeof (regs)) {
391 (void) close(fd);
392 lx_debug("ptrace failed to read register set");
393 return (-EIO);
394 }
395
396 (void) close(fd);
397
398 rp->lxur_ebx = regs.lxr_ebx;
399 rp->lxur_ecx = regs.lxr_ecx;
400 rp->lxur_edx = regs.lxr_edx;
401 rp->lxur_esi = regs.lxr_esi;
402 rp->lxur_edi = regs.lxr_edi;
403 rp->lxur_ebp = regs.lxr_ebp;
404 rp->lxur_eax = regs.lxr_eax;
405 rp->lxur_xds = status.pr_reg[DS];
406 rp->lxur_xes = status.pr_reg[ES];
407 rp->lxur_xfs = status.pr_reg[FS];
408 rp->lxur_xgs = regs.lxr_gs;
409 rp->lxur_orig_eax = regs.lxr_orig_eax;
410 rp->lxur_eip = regs.lxr_eip;
411 rp->lxur_xcs = status.pr_reg[CS];
412 rp->lxur_eflags = status.pr_reg[EFL];
413 rp->lxur_esp = regs.lxr_esp;
414 rp->lxur_xss = status.pr_reg[SS];
415
416 } else {
417 (void) close(fd);
418
419 rp->lxur_ebx = status.pr_reg[EBX];
420 rp->lxur_ecx = status.pr_reg[ECX];
421 rp->lxur_edx = status.pr_reg[EDX];
422 rp->lxur_esi = status.pr_reg[ESI];
423 rp->lxur_edi = status.pr_reg[EDI];
424 rp->lxur_ebp = status.pr_reg[EBP];
425 rp->lxur_eax = status.pr_reg[EAX];
426 rp->lxur_xds = status.pr_reg[DS];
427 rp->lxur_xes = status.pr_reg[ES];
428 rp->lxur_xfs = status.pr_reg[FS];
429 rp->lxur_xgs = status.pr_reg[GS];
430 rp->lxur_orig_eax = 0;
431 rp->lxur_eip = status.pr_reg[EIP];
432 rp->lxur_xcs = status.pr_reg[CS];
433 rp->lxur_eflags = status.pr_reg[EFL];
434 rp->lxur_esp = status.pr_reg[UESP];
435 rp->lxur_xss = status.pr_reg[SS];
436
437 /*
438 * If the target process has just returned from exec, it's not
439 * going to be sitting in the emulation function. In that case
440 * we need to manually fake up the values for %eax and orig_eax
441 * to indicate a successful return and that the traced process
442 * had called execve (respectively).
443 */
444 if (status.pr_why == PR_SYSEXIT &&
445 status.pr_what == SYS_execve) {
446 rp->lxur_eax = 0;
447 rp->lxur_orig_eax = LX_SYS_execve;
448 }
449 }
450
451 return (0);
452 }
453
454 static int
455 setregs(pid_t pid, lwpid_t lwpid, const lx_user_regs_t *rp)
456 {
457 long ctl[1 + sizeof (prgregset_t) / sizeof (long)];
458 lwpstatus_t status;
459 uintptr_t addr;
460 int fd, ret;
461
462 if ((ret = get_lwpstatus(pid, lwpid, &status)) != 0)
463 return (ret);
464
465 if ((fd = open_procfile(pid, O_RDWR, "as")) < 0)
466 return (-ESRCH);
467
468 /*
469 * If we find the syscall regs (and are therefore in an emulated
470 * syscall, modify the register set at given address and set the
471 * remaining registers through the /proc interface. Otherwise just use
472 * the /proc interface to set register values;
473 */
474 if ((addr = syscall_regs(fd, status.pr_reg[EBP], pid)) != 0) {
475 lx_regs_t regs;
476
477 regs.lxr_ebx = rp->lxur_ebx;
478 regs.lxr_ecx = rp->lxur_ecx;
479 regs.lxr_edx = rp->lxur_edx;
480 regs.lxr_esi = rp->lxur_esi;
481 regs.lxr_edi = rp->lxur_edi;
482 regs.lxr_ebp = rp->lxur_ebp;
483 regs.lxr_eax = rp->lxur_eax;
484 regs.lxr_gs = rp->lxur_xgs;
485 regs.lxr_orig_eax = rp->lxur_orig_eax;
486 regs.lxr_eip = rp->lxur_eip;
487 regs.lxr_esp = rp->lxur_esp;
488
489 if (pwrite(fd, ®s, sizeof (regs), addr) != sizeof (regs)) {
490 (void) close(fd);
491 lx_debug("ptrace failed to write register set");
492 return (-EIO);
493 }
494
495 (void) close(fd);
496
497 status.pr_reg[DS] = rp->lxur_xds;
498 status.pr_reg[ES] = rp->lxur_xes;
499 status.pr_reg[FS] = rp->lxur_xfs;
500 status.pr_reg[CS] = rp->lxur_xcs;
501 status.pr_reg[EFL] = rp->lxur_eflags;
502 status.pr_reg[SS] = rp->lxur_xss;
503
504 } else {
505 (void) close(fd);
506
507 status.pr_reg[EBX] = rp->lxur_ebx;
508 status.pr_reg[ECX] = rp->lxur_ecx;
509 status.pr_reg[EDX] = rp->lxur_edx;
510 status.pr_reg[ESI] = rp->lxur_esi;
511 status.pr_reg[EDI] = rp->lxur_edi;
512 status.pr_reg[EBP] = rp->lxur_ebp;
513 status.pr_reg[EAX] = rp->lxur_eax;
514 status.pr_reg[DS] = rp->lxur_xds;
515 status.pr_reg[ES] = rp->lxur_xes;
516 status.pr_reg[FS] = rp->lxur_xfs;
517 status.pr_reg[GS] = rp->lxur_xgs;
518 status.pr_reg[EIP] = rp->lxur_eip;
519 status.pr_reg[CS] = rp->lxur_xcs;
520 status.pr_reg[EFL] = rp->lxur_eflags;
521 status.pr_reg[UESP] = rp->lxur_esp;
522 status.pr_reg[SS] = rp->lxur_xss;
523 status.pr_reg[SS] = rp->lxur_xss;
524 }
525
526 if ((fd = open_lwpfile(pid, lwpid, O_WRONLY, "lwpctl")) < 0)
527 return (-ESRCH);
528
529 ctl[0] = PCSREG;
530 bcopy(status.pr_reg, &ctl[1], sizeof (prgregset_t));
531
532 if (write(fd, &ctl, sizeof (ctl)) != sizeof (ctl)) {
533 (void) close(fd);
534 return (-EIO);
535 }
536
537 (void) close(fd);
538
539 return (0);
540 }
541
542 static int
543 getfpregs(pid_t pid, lwpid_t lwpid, lx_user_fpregs_t *rp)
544 {
545 lwpstatus_t status;
546 struct _fpstate *fp;
547 char *data;
548 int ret, i;
549
550 if ((ret = get_lwpstatus(pid, lwpid, &status)) != 0)
551 return (ret);
552
553 fp = (struct _fpstate *)&status.pr_fpreg.fp_reg_set.fpchip_state;
554
555 rp->lxuf_cwd = fp->cw;
556 rp->lxuf_swd = fp->sw;
557 rp->lxuf_twd = fp->tag;
558 rp->lxuf_fip = fp->ipoff;
559 rp->lxuf_fcs = fp->cssel;
560 rp->lxuf_foo = fp->dataoff;
561 rp->lxuf_fos = fp->datasel;
562
563 /*
564 * The Linux structure uses 10 bytes per floating-point register.
565 */
566 data = (char *)&rp->lxuf_st_space[0];
567 for (i = 0; i < 8; i++) {
568 bcopy(&fp->_st[i], data, 10);
569 data += 10;
570 }
571
572 return (0);
573 }
574
575 static int
576 setfpregs(pid_t pid, lwpid_t lwpid, const lx_user_fpregs_t *rp)
577 {
578 lwpstatus_t status;
579 struct {
580 long cmd;
581 prfpregset_t regs;
582 } ctl;
583 struct _fpstate *fp = (struct _fpstate *)&ctl.regs;
584 char *data;
585 int ret, i, fd;
586
587 if ((ret = get_lwpstatus(pid, lwpid, &status)) != 0)
588 return (ret);
589
590 bcopy(&status.pr_fpreg, &ctl.regs, sizeof (ctl.regs));
591
592 fp->cw = rp->lxuf_cwd;
593 fp->sw = rp->lxuf_swd;
594 fp->tag = rp->lxuf_twd;
595 fp->ipoff = rp->lxuf_fip;
596 fp->cssel = rp->lxuf_fcs;
597 fp->dataoff = rp->lxuf_foo;
598 fp->datasel = rp->lxuf_fos;
599
600 /*
601 * The Linux structure uses 10 bytes per floating-point register.
602 */
603 data = (char *)&rp->lxuf_st_space[0];
604 for (i = 0; i < 8; i++) {
605 bcopy(data, &fp->_st[i], 10);
606 data += 10;
607 }
608
609 if ((fd = open_lwpfile(pid, lwpid, O_WRONLY, "lwpctl")) < 0)
610 return (-ESRCH);
611
612 ctl.cmd = PCSFPREG;
613 if (write(fd, &ctl, sizeof (ctl)) != sizeof (ctl)) {
614 (void) close(fd);
615 return (-EIO);
616 }
617
618 (void) close(fd);
619
620 return (0);
621 }
622
623
624 static int
625 getfpxregs(pid_t pid, lwpid_t lwpid, lx_user_fpxregs_t *rp)
626 {
627 lwpstatus_t status;
628 struct _fpstate *fp;
629 int ret, i;
630
631 if ((ret = get_lwpstatus(pid, lwpid, &status)) != 0)
632 return (ret);
633
634 fp = (struct _fpstate *)&status.pr_fpreg.fp_reg_set.fpchip_state;
635
636 rp->lxux_cwd = (uint16_t)fp->cw;
637 rp->lxux_swd = (uint16_t)fp->sw;
638 rp->lxux_twd = (uint16_t)fp->tag;
639 rp->lxux_fop = (uint16_t)(fp->cssel >> 16);
640 rp->lxux_fip = fp->ipoff;
641 rp->lxux_fcs = (uint16_t)fp->cssel;
642 rp->lxux_foo = fp->dataoff;
643 rp->lxux_fos = fp->datasel;
644 rp->lxux_mxcsr = status.pr_fpreg.fp_reg_set.fpchip_state.mxcsr;
645
646 bcopy(fp->xmm, rp->lxux_xmm_space, sizeof (rp->lxux_xmm_space));
647 bzero(rp->lxux_st_space, sizeof (rp->lxux_st_space));
648 for (i = 0; i < 8; i++) {
649 bcopy(&fp->_st[i], &rp->lxux_st_space[i * 4],
650 sizeof (fp->_st[i]));
651 }
652
653 return (0);
654 }
655
656 static int
657 setfpxregs(pid_t pid, lwpid_t lwpid, const lx_user_fpxregs_t *rp)
658 {
659 lwpstatus_t status;
660 struct {
661 long cmd;
662 prfpregset_t regs;
663 } ctl;
664 struct _fpstate *fp = (struct _fpstate *)&ctl.regs;
665 int ret, i, fd;
666
667 if ((ret = get_lwpstatus(pid, lwpid, &status)) != 0)
668 return (ret);
669
670 bcopy(&status.pr_fpreg, &ctl.regs, sizeof (ctl.regs));
671
672 fp->cw = rp->lxux_cwd;
673 fp->sw = rp->lxux_swd;
674 fp->tag = rp->lxux_twd;
675 fp->ipoff = rp->lxux_fip;
676 fp->cssel = rp->lxux_fcs | (rp->lxux_fop << 16);
677 fp->dataoff = rp->lxux_foo;
678 fp->datasel = rp->lxux_fos;
679
680 bcopy(rp->lxux_xmm_space, fp->xmm, sizeof (rp->lxux_xmm_space));
681 for (i = 0; i < 8; i++) {
682 bcopy(&rp->lxux_st_space[i * 4], &fp->_st[i],
683 sizeof (fp->_st[i]));
684 }
685
686 if ((fd = open_lwpfile(pid, lwpid, O_WRONLY, "lwpctl")) < 0)
687 return (-ESRCH);
688
689 ctl.cmd = PCSFPREG;
690 if (write(fd, &ctl, sizeof (ctl)) != sizeof (ctl)) {
691 (void) close(fd);
692 return (-EIO);
693 }
694
695 (void) close(fd);
696
697 return (0);
698 }
699
700 /*
701 * Solaris does not allow a process to manipulate its own or some
702 * other process's debug registers. Linux ptrace(2) allows this
703 * and gdb manipulates them for its watchpoint implementation.
704 *
705 * We keep a pseudo set of debug registers for each traced process
706 * and map their contents into the appropriate PCWATCH /proc
707 * operations when they are activated by gdb.
708 *
709 * To understand how the debug registers work on x86 machines,
710 * see section 13.1 of the AMD x86-64 Architecture Programmer's
711 * Manual, Volume 2, System Programming.
712 */
713 static uintptr_t *
714 debug_registers(pid_t pid)
715 {
716 ptrace_state_map_t *p;
717
718 (void) mutex_lock(&ptrace_map_mtx);
719 for (p = ptrace_state_map; p != NULL; p = p->psm_next) {
720 if (p->psm_pid == pid)
721 break;
722 }
723 if (p == NULL && (p = malloc(sizeof (*p))) != NULL) {
724 bzero(p, sizeof (*p));
725 p->psm_pid = pid;
726 p->psm_next = ptrace_state_map;
727 p->psm_debugreg[6] = 0xffff0ff0; /* read as ones */
728 ptrace_state_map = p;
729 }
730 (void) mutex_unlock(&ptrace_map_mtx);
731 return (p != NULL? p->psm_debugreg : NULL);
732 }
733
734 static void
735 free_debug_registers(pid_t pid)
736 {
737 ptrace_state_map_t **pp;
738 ptrace_state_map_t *p;
739
740 /* ASSERT(MUTEX_HELD(&ptrace_map_mtx) */
741 for (pp = &ptrace_state_map; (p = *pp) != NULL; pp = &p->psm_next) {
742 if (p->psm_pid == pid) {
743 *pp = p->psm_next;
744 free(p);
745 break;
746 }
747 }
748 }
749
750 static int
751 setup_watchpoints(pid_t pid, uintptr_t *debugreg)
752 {
753 int dr7 = debugreg[7];
754 int lrw;
755 int fd;
756 size_t size = NULL;
757 prwatch_t prwatch[4];
758 int nwatch;
759 int i;
760 int wflags = NULL;
761 int error;
762 struct {
763 long req;
764 prwatch_t prwatch;
765 } ctl;
766
767 /* find all watched areas */
768 if ((fd = open_procfile(pid, O_RDONLY, "watch")) < 0)
769 return (-ESRCH);
770 nwatch = read(fd, prwatch, sizeof (prwatch)) / sizeof (prwatch_t);
771 (void) close(fd);
772 if ((fd = open_procfile(pid, O_WRONLY, "ctl")) < 0)
773 return (-ESRCH);
774 /* clear all watched areas */
775 for (i = 0; i < nwatch; i++) {
776 ctl.req = PCWATCH;
777 ctl.prwatch = prwatch[i];
778 ctl.prwatch.pr_wflags = 0;
779 if (write(fd, &ctl, sizeof (ctl)) != sizeof (ctl)) {
780 error = -errno;
781 (void) close(fd);
782 return (error);
783 }
784 }
785 /* establish all new watched areas */
786 for (i = 0; i < 4; i++) {
787 if ((dr7 & (1 << (2 * i))) == 0) /* enabled? */
788 continue;
789 lrw = (dr7 >> (16 + (4 * i))) & 0xf;
790 switch (lrw >> 2) { /* length */
791 case 0: size = 1; break;
792 case 1: size = 2; break;
793 case 2: size = 8; break;
794 case 3: size = 4; break;
795 }
796 switch (lrw & 0x3) { /* mode */
797 case 0: wflags = WA_EXEC; break;
798 case 1: wflags = WA_WRITE; break;
799 case 2: continue;
800 case 3: wflags = WA_READ | WA_WRITE; break;
801 }
802 ctl.req = PCWATCH;
803 ctl.prwatch.pr_vaddr = debugreg[i];
804 ctl.prwatch.pr_size = size;
805 ctl.prwatch.pr_wflags = wflags | WA_TRAPAFTER;
806 if (write(fd, &ctl, sizeof (ctl)) != sizeof (ctl)) {
807 error = -errno;
808 (void) close(fd);
809 return (error);
810 }
811 }
812 (void) close(fd);
813 return (0);
814 }
815
816 /*
817 * Returns TRUE if the process is traced, FALSE otherwise. This is only true
818 * if the process is currently stopped, and has been traced using PTRACE_TRACEME
819 * or PTRACE_ATTACH.
820 */
821 static int
822 is_traced(pid_t pid)
823 {
824 ptrace_monitor_map_t *p;
825 pstatus_t status;
826
827 if (get_status(pid, &status) != 0)
828 return (0);
829
830 if ((status.pr_flags & PR_PTRACE) &&
831 (status.pr_ppid == getpid()) &&
832 (status.pr_lwp.pr_flags & PR_ISTOP))
833 return (1);
834
835 (void) mutex_lock(&ptrace_map_mtx);
836 for (p = ptrace_monitor_map; p != NULL; p = p->pmm_next) {
837 if (p->pmm_target == pid) {
838 (void) mutex_unlock(&ptrace_map_mtx);
839 return (1);
840 }
841 }
842 (void) mutex_unlock(&ptrace_map_mtx);
843
844 return (0);
845 }
846
847 static int
848 ptrace_trace_common(int fd)
849 {
850 struct {
851 long cmd;
852 union {
853 long flags;
854 sigset_t signals;
855 fltset_t faults;
856 } arg;
857 } ctl;
858 size_t size;
859
860 ctl.cmd = PCSTRACE;
861 prfillset(&ctl.arg.signals);
862 size = sizeof (long) + sizeof (sigset_t);
863 if (write(fd, &ctl, size) != size)
864 return (-1);
865
866 ctl.cmd = PCSFAULT;
867 premptyset(&ctl.arg.faults);
868 size = sizeof (long) + sizeof (fltset_t);
869 if (write(fd, &ctl, size) != size)
870 return (-1);
871
872 ctl.cmd = PCUNSET;
873 ctl.arg.flags = PR_FORK;
874 size = sizeof (long) + sizeof (long);
875 if (write(fd, &ctl, size) != size)
876 return (-1);
877
878 return (0);
879 }
880
881 /*
882 * Notify that parent that we wish to be traced. This is the equivalent of:
883 *
884 * 1. Stop on all signals, and nothing else
885 * 2. Turn off inherit-on-fork flag
886 * 3. Set ptrace compatible flag
887 *
888 * If we are not the main thread, then the client is trying to request behavior
889 * by which one of its own thread is to be traced. We don't support this mode
890 * of operation.
891 */
892 static int
893 ptrace_traceme(void)
894 {
895 int fd, ret;
896 int error;
897 long ctl[2];
898 pstatus_t status;
899 pid_t pid = getpid();
900
901 if (_lwp_self() != 1) {
902 lx_unsupported(gettext(
903 "thread %d calling PTRACE_TRACEME is unsupported"),
904 _lwp_self());
905 return (-ENOTSUP);
906 }
907
908 if ((ret = get_status(pid, &status)) != 0)
909 return (ret);
910
911 /*
912 * Why would a process try to do this twice? I'm not sure, but there's
913 * a conformance test which wants this to fail just so.
914 */
915 if (status.pr_flags & PR_PTRACE)
916 return (-EPERM);
917
918 if ((fd = open_procfile(pid, O_WRONLY, "ctl")) < 0)
919 return (-errno);
920
921 ctl[0] = PCSET;
922 ctl[1] = PR_PTRACE;
923 error = 0;
924 if (write(fd, ctl, sizeof (ctl)) != sizeof (ctl) ||
925 ptrace_trace_common(fd) != 0)
926 error = -errno;
927
928 (void) close(fd);
929 return (error);
930 }
931
932 /*
933 * Read a word of data from the given address. Because this is a process-wide
934 * action, we don't need the lwpid.
935 */
936 static int
937 ptrace_peek(pid_t pid, uintptr_t addr, int *ret)
938 {
939 int fd, data;
940
941 if (!is_traced(pid))
942 return (-ESRCH);
943
944 if ((fd = open_procfile(pid, O_RDONLY, "as")) < 0)
945 return (-ESRCH);
946
947 if (pread(fd, &data, sizeof (data), addr) != sizeof (data)) {
948 (void) close(fd);
949 return (-EIO);
950 }
951
952 (void) close(fd);
953
954 if (uucopy(&data, ret, sizeof (data)) != 0)
955 return (-errno);
956
957 return (0);
958 }
959
960 #define LX_USER_BOUND(m) \
961 (offsetof(lx_user_t, m) + sizeof (((lx_user_t *)NULL)->m))
962
963 static int
964 ptrace_peek_user(pid_t pid, lwpid_t lwpid, uintptr_t off, int *ret)
965 {
966 int err, data;
967 uintptr_t *debugreg;
968 int dreg;
969
970 if (!is_traced(pid))
971 return (-ESRCH);
972
973 /*
974 * The offset specified by the user is an offset into the Linux
975 * user structure (seriously). Rather than constructing a full
976 * user structure, we figure out which part of the user structure
977 * the offset is in, and fill in just that component.
978 */
979 if (off < LX_USER_BOUND(lxu_regs)) {
980 lx_user_regs_t regs;
981
982 if ((err = getregs(pid, lwpid, ®s)) != 0)
983 return (err);
984
985 data = *(int *)((uintptr_t)®s + off -
986 offsetof(lx_user_t, lxu_regs));
987
988 } else if (off < LX_USER_BOUND(lxu_fpvalid)) {
989 lx_err(gettext("offset = %lu\n"), off);
990 assert(0);
991 } else if (off < LX_USER_BOUND(lxu_i387)) {
992 lx_user_fpregs_t regs;
993
994 if ((err = getfpregs(pid, lwpid, ®s)) != 0)
995 return (err);
996
997 data = *(int *)((uintptr_t)®s + off -
998 offsetof(lx_user_t, lxu_i387));
999
1000 } else if (off < LX_USER_BOUND(lxu_tsize)) {
1001 lx_err(gettext("offset = %lu\n"), off);
1002 assert(0);
1003 } else if (off < LX_USER_BOUND(lxu_dsize)) {
1004 lx_err(gettext("offset = %lu\n"), off);
1005 assert(0);
1006 } else if (off < LX_USER_BOUND(lxu_ssize)) {
1007 lx_err(gettext("offset = %lu\n"), off);
1008 assert(0);
1009 } else if (off < LX_USER_BOUND(lxu_start_code)) {
1010 lx_err(gettext("offset = %lu\n"), off);
1011 assert(0);
1012 } else if (off < LX_USER_BOUND(lxu_start_stack)) {
1013 lx_err(gettext("offset = %lu\n"), off);
1014 assert(0);
1015 } else if (off < LX_USER_BOUND(lxu_signal)) {
1016 lx_err(gettext("offset = %lu\n"), off);
1017 assert(0);
1018 } else if (off < LX_USER_BOUND(lxu_reserved)) {
1019 lx_err(gettext("offset = %lu\n"), off);
1020 assert(0);
1021 } else if (off < LX_USER_BOUND(lxu_ar0)) {
1022 lx_err(gettext("offset = %lu\n"), off);
1023 assert(0);
1024 } else if (off < LX_USER_BOUND(lxu_fpstate)) {
1025 lx_err(gettext("offset = %lu\n"), off);
1026 assert(0);
1027 } else if (off < LX_USER_BOUND(lxu_magic)) {
1028 lx_err(gettext("offset = %lu\n"), off);
1029 assert(0);
1030 } else if (off < LX_USER_BOUND(lxu_comm)) {
1031 lx_err(gettext("offset = %lu\n"), off);
1032 assert(0);
1033 } else if (off < LX_USER_BOUND(lxu_debugreg)) {
1034 dreg = (off - offsetof(lx_user_t, lxu_debugreg)) / sizeof (int);
1035 if (dreg == 4) /* aliased */
1036 dreg = 6;
1037 else if (dreg == 5) /* aliased */
1038 dreg = 7;
1039 if ((debugreg = debug_registers(pid)) != NULL)
1040 data = debugreg[dreg];
1041 else
1042 data = 0;
1043 } else {
1044 lx_unsupported(gettext(
1045 "unsupported ptrace %s user offset: 0x%x\n"), "peek", off);
1046 assert(0);
1047 return (-ENOTSUP);
1048 }
1049
1050 if (uucopy(&data, ret, sizeof (data)) != 0)
1051 return (-errno);
1052
1053 return (0);
1054 }
1055
1056 /*
1057 * Write a word of data to the given address. Because this is a process-wide
1058 * action, we don't need the lwpid. Returns EINVAL if the address is not
1059 * word-aligned.
1060 */
1061 static int
1062 ptrace_poke(pid_t pid, uintptr_t addr, int data)
1063 {
1064 int fd;
1065
1066 if (!is_traced(pid))
1067 return (-ESRCH);
1068
1069 if (addr & 0x3)
1070 return (-EINVAL);
1071
1072 if ((fd = open_procfile(pid, O_WRONLY, "as")) < 0)
1073 return (-ESRCH);
1074
1075 if (pwrite(fd, &data, sizeof (data), addr) != sizeof (data)) {
1076 (void) close(fd);
1077 return (-EIO);
1078 }
1079
1080 (void) close(fd);
1081 return (0);
1082 }
1083
1084 static int
1085 ptrace_poke_user(pid_t pid, lwpid_t lwpid, uintptr_t off, int data)
1086 {
1087 lx_user_regs_t regs;
1088 int err = 0;
1089 uintptr_t *debugreg;
1090 int dreg;
1091
1092 if (!is_traced(pid))
1093 return (-ESRCH);
1094
1095 if (off & 0x3)
1096 return (-EINVAL);
1097
1098 if (off < offsetof(lx_user_t, lxu_regs) + sizeof (lx_user_regs_t)) {
1099 if ((err = getregs(pid, lwpid, ®s)) != 0)
1100 return (err);
1101 *(int *)((uintptr_t)®s + off -
1102 offsetof(lx_user_t, lxu_regs)) = data;
1103 return (setregs(pid, lwpid, ®s));
1104 }
1105
1106 if (off >= offsetof(lx_user_t, lxu_debugreg) &&
1107 off < offsetof(lx_user_t, lxu_debugreg) + 8 * sizeof (int)) {
1108 dreg = (off - offsetof(lx_user_t, lxu_debugreg)) / sizeof (int);
1109 if (dreg == 4) /* aliased */
1110 dreg = 6;
1111 else if (dreg == 5) /* aliased */
1112 dreg = 7;
1113 if ((debugreg = debug_registers(pid)) != NULL) {
1114 debugreg[dreg] = data;
1115 if (dreg == 7)
1116 err = setup_watchpoints(pid, debugreg);
1117 }
1118 return (err);
1119 }
1120
1121 lx_unsupported(gettext("unsupported ptrace %s user offset: 0x%x\n"),
1122 "poke", off);
1123 assert(0);
1124 return (-ENOTSUP);
1125 }
1126
1127 static int
1128 ptrace_cont_common(int fd, int sig, int run, int step)
1129 {
1130 long ctl[1 + 1 + sizeof (siginfo_t) / sizeof (long) + 2];
1131 long *ctlp = ctl;
1132 size_t size;
1133
1134 assert(0 <= sig && sig < LX_NSIG);
1135 assert(!step || run);
1136
1137 /*
1138 * Clear the current signal.
1139 */
1140 *ctlp++ = PCCSIG;
1141
1142 /*
1143 * Send a signal if one was specified.
1144 */
1145 if (sig != 0 && sig != LX_SIGSTOP) {
1146 siginfo_t *infop;
1147
1148 *ctlp++ = PCSSIG;
1149 infop = (siginfo_t *)ctlp;
1150 bzero(infop, sizeof (siginfo_t));
1151 infop->si_signo = ltos_signo[sig];
1152
1153 ctlp += sizeof (siginfo_t) / sizeof (long);
1154 }
1155
1156 /*
1157 * If run is true, set the lwp running.
1158 */
1159 if (run) {
1160 *ctlp++ = PCRUN;
1161 *ctlp++ = step ? PRSTEP : 0;
1162 }
1163
1164 size = (char *)ctlp - (char *)&ctl[0];
1165 assert(size <= sizeof (ctl));
1166
1167 if (write(fd, ctl, size) != size) {
1168 lx_debug("failed to continue %s", strerror(errno));
1169 return (-EIO);
1170 }
1171
1172 return (0);
1173 }
1174
1175 static int
1176 ptrace_cont_monitor(ptrace_monitor_map_t *p)
1177 {
1178 long ctl[2];
1179 int fd;
1180
1181 fd = open_procfile(p->pmm_monitor, O_WRONLY, "ctl");
1182 if (fd < 0) {
1183 lx_debug("failed to open monitor ctl %d",
1184 errno);
1185 return (-EIO);
1186 }
1187
1188 ctl[0] = PCRUN;
1189 ctl[1] = PRCSIG;
1190 if (write(fd, ctl, sizeof (ctl)) != sizeof (ctl)) {
1191 (void) close(fd);
1192 return (-EIO);
1193 }
1194
1195 (void) close(fd);
1196
1197 return (0);
1198 }
1199
1200 static int
1201 ptrace_cont(pid_t lxpid, pid_t pid, lwpid_t lwpid, int sig, int step)
1202 {
1203 ptrace_monitor_map_t *p;
1204 uintptr_t *debugreg;
1205 int fd, ret;
1206
1207 if (!is_traced(pid))
1208 return (-ESRCH);
1209
1210 if (sig < 0 || sig >= LX_NSIG)
1211 return (-EINVAL);
1212
1213 if ((fd = open_lwpfile(pid, lwpid, O_WRONLY, "lwpctl")) < 0)
1214 return (-ESRCH);
1215
1216 if ((ret = ptrace_cont_common(fd, sig, 1, step)) != 0) {
1217 (void) close(fd);
1218 return (ret);
1219 }
1220
1221 (void) close(fd);
1222
1223 /* kludge: use debugreg[4] to remember the single-step flag */
1224 if ((debugreg = debug_registers(pid)) != NULL)
1225 debugreg[4] = step;
1226
1227 /*
1228 * Check for a monitor and get it moving if we find it. If any of the
1229 * /proc operations fail, we're kind of sunk so just return an error.
1230 */
1231 (void) mutex_lock(&ptrace_map_mtx);
1232 for (p = ptrace_monitor_map; p != NULL; p = p->pmm_next) {
1233 if (p->pmm_target == lxpid) {
1234 if ((ret = ptrace_cont_monitor(p)) != 0)
1235 return (ret);
1236 break;
1237 }
1238 }
1239 (void) mutex_unlock(&ptrace_map_mtx);
1240
1241 return (0);
1242 }
1243
1244 /*
1245 * If a monitor exists for this traced process, dispose of it.
1246 * First turn off its ptrace flag so we won't be notified of its
1247 * impending demise. We ignore errors for this step since they
1248 * indicate only that the monitor has been damaged due to pilot
1249 * error. Then kill the monitor, and wait for it. If the wait
1250 * succeeds we can dispose of the corpse, otherwise another thread's
1251 * wait call has collected it and we need to set a flag in the
1252 * structure so that if can be picked up in wait.
1253 */
1254 static void
1255 monitor_kill(pid_t lxpid, pid_t pid)
1256 {
1257 ptrace_monitor_map_t *p, **pp;
1258 pid_t mpid;
1259 int fd;
1260 long ctl[2];
1261
1262 (void) mutex_lock(&ptrace_map_mtx);
1263 free_debug_registers(pid);
1264 for (pp = &ptrace_monitor_map; (p = *pp) != NULL; pp = &p->pmm_next) {
1265 if (p->pmm_target == lxpid) {
1266 mpid = p->pmm_monitor;
1267 if ((fd = open_procfile(mpid, O_WRONLY, "ctl")) >= 0) {
1268 ctl[0] = PCUNSET;
1269 ctl[1] = PR_PTRACE;
1270 (void) write(fd, ctl, sizeof (ctl));
1271 (void) close(fd);
1272 }
1273
1274 (void) kill(mpid, SIGKILL);
1275
1276 if (waitpid(mpid, NULL, 0) == mpid) {
1277 *pp = p->pmm_next;
1278 free(p);
1279 } else {
1280 p->pmm_exiting = 1;
1281 }
1282
1283 break;
1284 }
1285 }
1286 (void) mutex_unlock(&ptrace_map_mtx);
1287 }
1288
1289 static int
1290 ptrace_kill(pid_t lxpid, pid_t pid)
1291 {
1292 int ret;
1293
1294 if (!is_traced(pid))
1295 return (-ESRCH);
1296
1297 ret = kill(pid, SIGKILL);
1298
1299 /* kill off the monitor process, if any */
1300 monitor_kill(lxpid, pid);
1301
1302 return (ret);
1303 }
1304
1305 static int
1306 ptrace_step(pid_t lxpid, pid_t pid, lwpid_t lwpid, int sig)
1307 {
1308 return (ptrace_cont(lxpid, pid, lwpid, sig, 1));
1309 }
1310
1311 static int
1312 ptrace_getregs(pid_t pid, lwpid_t lwpid, uintptr_t addr)
1313 {
1314 lx_user_regs_t regs;
1315 int ret;
1316
1317 if (!is_traced(pid))
1318 return (-ESRCH);
1319
1320 if ((ret = getregs(pid, lwpid, ®s)) != 0)
1321 return (ret);
1322
1323 if (uucopy(®s, (void *)addr, sizeof (regs)) != 0)
1324 return (-errno);
1325
1326 return (0);
1327 }
1328
1329 static int
1330 ptrace_setregs(pid_t pid, lwpid_t lwpid, uintptr_t addr)
1331 {
1332 lx_user_regs_t regs;
1333
1334 if (!is_traced(pid))
1335 return (-ESRCH);
1336
1337 if (uucopy((void *)addr, ®s, sizeof (regs)) != 0)
1338 return (-errno);
1339
1340 return (setregs(pid, lwpid, ®s));
1341 }
1342
1343 static int
1344 ptrace_getfpregs(pid_t pid, lwpid_t lwpid, uintptr_t addr)
1345 {
1346 lx_user_fpregs_t regs;
1347 int ret;
1348
1349 if (!is_traced(pid))
1350 return (-ESRCH);
1351
1352 if ((ret = getfpregs(pid, lwpid, ®s)) != 0)
1353 return (ret);
1354
1355 if (uucopy(®s, (void *)addr, sizeof (regs)) != 0)
1356 return (-errno);
1357
1358 return (0);
1359 }
1360
1361 static int
1362 ptrace_setfpregs(pid_t pid, lwpid_t lwpid, uintptr_t addr)
1363 {
1364 lx_user_fpregs_t regs;
1365
1366 if (!is_traced(pid))
1367 return (-ESRCH);
1368
1369 if (uucopy((void *)addr, ®s, sizeof (regs)) != 0)
1370 return (-errno);
1371
1372 return (setfpregs(pid, lwpid, ®s));
1373 }
1374
1375 static int
1376 ptrace_getfpxregs(pid_t pid, lwpid_t lwpid, uintptr_t addr)
1377 {
1378 lx_user_fpxregs_t regs;
1379 int ret;
1380
1381 if (!is_traced(pid))
1382 return (-ESRCH);
1383
1384 if ((ret = getfpxregs(pid, lwpid, ®s)) != 0)
1385 return (ret);
1386
1387 if (uucopy(®s, (void *)addr, sizeof (regs)) != 0)
1388 return (-errno);
1389
1390 return (0);
1391 }
1392
1393 static int
1394 ptrace_setfpxregs(pid_t pid, lwpid_t lwpid, uintptr_t addr)
1395 {
1396 lx_user_fpxregs_t regs;
1397
1398 if (!is_traced(pid))
1399 return (-ESRCH);
1400
1401 if (uucopy((void *)addr, ®s, sizeof (regs)) != 0)
1402 return (-errno);
1403
1404 return (setfpxregs(pid, lwpid, ®s));
1405 }
1406
1407 static void __NORETURN
1408 ptrace_monitor(int fd)
1409 {
1410 struct {
1411 long cmd;
1412 union {
1413 long flags;
1414 sigset_t signals;
1415 fltset_t faults;
1416 } arg;
1417 } ctl;
1418 size_t size;
1419 int monfd;
1420 int rv;
1421
1422 monfd = open_procfile(getpid(), O_WRONLY, "ctl");
1423
1424 ctl.cmd = PCSTRACE; /* trace only SIGTRAP */
1425 premptyset(&ctl.arg.signals);
1426 praddset(&ctl.arg.signals, SIGTRAP);
1427 size = sizeof (long) + sizeof (sigset_t);
1428 (void) write(monfd, &ctl, size); /* can't fail */
1429
1430 ctl.cmd = PCSFAULT;
1431 premptyset(&ctl.arg.faults);
1432 size = sizeof (long) + sizeof (fltset_t);
1433 (void) write(monfd, &ctl, size); /* can't fail */
1434
1435 ctl.cmd = PCUNSET;
1436 ctl.arg.flags = PR_FORK;
1437 size = sizeof (long) + sizeof (long);
1438 (void) write(monfd, &ctl, size); /* can't fail */
1439
1440 ctl.cmd = PCSET; /* wait()able by the parent */
1441 ctl.arg.flags = PR_PTRACE;
1442 size = sizeof (long) + sizeof (long);
1443 (void) write(monfd, &ctl, size); /* can't fail */
1444
1445 (void) close(monfd);
1446
1447 ctl.cmd = PCWSTOP;
1448 size = sizeof (long);
1449
1450 for (;;) {
1451 /*
1452 * Wait for the traced process to stop.
1453 */
1454 if (write(fd, &ctl, size) != size) {
1455 rv = (errno == ENOENT)? 0 : 1;
1456 lx_debug("monitor failed to wait for LWP to stop: %s",
1457 strerror(errno));
1458 _exit(rv);
1459 }
1460
1461 lx_debug("monitor caught traced LWP");
1462
1463 /*
1464 * Pull the ptrace trigger by sending ourself a SIGTRAP. This
1465 * will cause this, the monitor process, to stop which will
1466 * cause the parent's waitid(2) call to return this process
1467 * id. In lx_wait(), we remap the monitor process's pid and
1468 * status to those of the traced LWP. When the parent process
1469 * uses ptrace to resume the traced LWP, it will additionally
1470 * restart this process.
1471 */
1472 (void) _lwp_kill(_lwp_self(), SIGTRAP);
1473
1474 lx_debug("monitor was resumed");
1475 }
1476 }
1477
1478 static int
1479 ptrace_attach_common(int fd, pid_t lxpid, pid_t pid, lwpid_t lwpid, int run)
1480 {
1481 pid_t child;
1482 ptrace_monitor_map_t *p;
1483 sigset_t unblock;
1484 pstatus_t status;
1485 long ctl[1 + sizeof (sysset_t) / sizeof (long) + 2];
1486 long *ctlp = ctl;
1487 size_t size;
1488 sysset_t *sysp;
1489 int ret;
1490
1491 /*
1492 * We're going to need this structure so better to fail now before its
1493 * too late to turn back.
1494 */
1495 if ((p = malloc(sizeof (ptrace_monitor_map_t))) == NULL)
1496 return (-EIO);
1497
1498 if ((ret = get_status(pid, &status)) != 0) {
1499 free(p);
1500 return (ret);
1501 }
1502
1503 /*
1504 * If this process is already traced, bail.
1505 */
1506 if (status.pr_flags & PR_PTRACE) {
1507 free(p);
1508 return (-EPERM);
1509 }
1510
1511 /*
1512 * Turn on the appropriate tracing flags. It's exceedingly unlikely
1513 * that this operation will fail; any failure would probably be due
1514 * to another /proc consumer mucking around.
1515 */
1516 if (ptrace_trace_common(fd) != 0) {
1517 free(p);
1518 return (-EIO);
1519 }
1520
1521 /*
1522 * Native ptrace automatically catches processes when they exec so we
1523 * have to do that explicitly here.
1524 */
1525 *ctlp++ = PCSEXIT;
1526 sysp = (sysset_t *)ctlp;
1527 ctlp += sizeof (sysset_t) / sizeof (long);
1528 premptyset(sysp);
1529 praddset(sysp, SYS_execve);
1530 if (run) {
1531 *ctlp++ = PCRUN;
1532 *ctlp++ = 0;
1533 }
1534
1535 size = (char *)ctlp - (char *)&ctl[0];
1536
1537 if (write(fd, ctl, size) != size) {
1538 free(p);
1539 return (-EIO);
1540 }
1541
1542 /*
1543 * Spawn the monitor proceses to notify this process of events of
1544 * interest in the traced process. We block signals here both so
1545 * we're not interrupted during this operation and so that the
1546 * monitor process doesn't accept signals.
1547 */
1548 (void) sigprocmask(SIG_BLOCK, &blockable_sigs, &unblock);
1549 if ((child = fork1()) == 0)
1550 ptrace_monitor(fd);
1551 (void) sigprocmask(SIG_SETMASK, &unblock, NULL);
1552
1553 if (child == -1) {
1554 lx_debug("failed to fork monitor process\n");
1555 free(p);
1556 return (-EIO);
1557 }
1558
1559 p->pmm_monitor = child;
1560 p->pmm_target = lxpid;
1561 p->pmm_pid = pid;
1562 p->pmm_lwpid = lwpid;
1563 p->pmm_exiting = 0;
1564
1565 (void) mutex_lock(&ptrace_map_mtx);
1566 p->pmm_next = ptrace_monitor_map;
1567 ptrace_monitor_map = p;
1568 (void) mutex_unlock(&ptrace_map_mtx);
1569
1570 return (0);
1571 }
1572
1573 static int
1574 ptrace_attach(pid_t lxpid, pid_t pid, lwpid_t lwpid)
1575 {
1576 int fd, ret;
1577 long ctl;
1578
1579 /*
1580 * Linux doesn't let you trace process 1 -- go figure.
1581 */
1582 if (lxpid == 1)
1583 return (-EPERM);
1584
1585 if ((fd = open_lwpfile(pid, lwpid, O_WRONLY | O_EXCL, "lwpctl")) < 0)
1586 return (errno == EBUSY ? -EPERM : -ESRCH);
1587
1588 ctl = PCSTOP;
1589 if (write(fd, &ctl, sizeof (ctl)) != sizeof (ctl)) {
1590 lx_err(gettext("failed to stop %d/%d\n"), (int)pid, (int)lwpid);
1591 assert(0);
1592 }
1593
1594 ret = ptrace_attach_common(fd, lxpid, pid, lwpid, 0);
1595
1596 (void) close(fd);
1597
1598 return (ret);
1599 }
1600
1601 static int
1602 ptrace_detach(pid_t lxpid, pid_t pid, lwpid_t lwpid, int sig)
1603 {
1604 long ctl[2];
1605 int fd, ret;
1606
1607 if (!is_traced(pid))
1608 return (-ESRCH);
1609
1610 if (sig < 0 || sig >= LX_NSIG)
1611 return (-EINVAL);
1612
1613 if ((fd = open_lwpfile(pid, lwpid, O_WRONLY, "lwpctl")) < 0)
1614 return (-ESRCH);
1615
1616 /*
1617 * The /proc ptrace flag may not be set, but we clear it
1618 * unconditionally since doing so doesn't hurt anything.
1619 */
1620 ctl[0] = PCUNSET;
1621 ctl[1] = PR_PTRACE;
1622 if (write(fd, ctl, sizeof (ctl)) != sizeof (ctl)) {
1623 (void) close(fd);
1624 return (-EIO);
1625 }
1626
1627 /*
1628 * Clear the brand-specific system call tracing flag to ensure that
1629 * the target doesn't stop unexpectedly some time in the future.
1630 */
1631 if ((ret = syscall(SYS_brand, B_PTRACE_SYSCALL, pid, lwpid, 0)) != 0) {
1632 (void) close(fd);
1633 return (-ret);
1634 }
1635
1636 /* kill off the monitor process, if any */
1637 monitor_kill(lxpid, pid);
1638
1639 /*
1640 * Turn on the run-on-last-close flag so that all tracing flags will be
1641 * cleared when we close the control file descriptor.
1642 */
1643 ctl[0] = PCSET;
1644 ctl[1] = PR_RLC;
1645 if (write(fd, ctl, sizeof (ctl)) != sizeof (ctl)) {
1646 (void) close(fd);
1647 return (-EIO);
1648 }
1649
1650 /*
1651 * Clear the current signal (if any) and possibly send the traced
1652 * process a new signal.
1653 */
1654 ret = ptrace_cont_common(fd, sig, 0, 0);
1655
1656 (void) close(fd);
1657
1658 return (ret);
1659 }
1660
1661 static int
1662 ptrace_syscall(pid_t lxpid, pid_t pid, lwpid_t lwpid, int sig)
1663 {
1664 int ret;
1665
1666 if (!is_traced(pid))
1667 return (-ESRCH);
1668
1669 if ((ret = syscall(SYS_brand, B_PTRACE_SYSCALL, pid, lwpid, 1)) != 0)
1670 return (-ret);
1671
1672 return (ptrace_cont(lxpid, pid, lwpid, sig, 0));
1673 }
1674
1675 int
1676 lx_ptrace(uintptr_t p1, uintptr_t p2, uintptr_t p3, uintptr_t p4)
1677 {
1678 pid_t pid, lxpid = (pid_t)p2;
1679 lwpid_t lwpid;
1680
1681 if ((p1 != LX_PTRACE_TRACEME) &&
1682 (lx_lpid_to_spair(lxpid, &pid, &lwpid) < 0))
1683 return (-ESRCH);
1684
1685 switch (p1) {
1686 case LX_PTRACE_TRACEME:
1687 return (ptrace_traceme());
1688
1689 case LX_PTRACE_PEEKTEXT:
1690 case LX_PTRACE_PEEKDATA:
1691 return (ptrace_peek(pid, p3, (int *)p4));
1692
1693 case LX_PTRACE_PEEKUSER:
1694 return (ptrace_peek_user(pid, lwpid, p3, (int *)p4));
1695
1696 case LX_PTRACE_POKETEXT:
1697 case LX_PTRACE_POKEDATA:
1698 return (ptrace_poke(pid, p3, (int)p4));
1699
1700 case LX_PTRACE_POKEUSER:
1701 return (ptrace_poke_user(pid, lwpid, p3, (int)p4));
1702
1703 case LX_PTRACE_CONT:
1704 return (ptrace_cont(lxpid, pid, lwpid, (int)p4, 0));
1705
1706 case LX_PTRACE_KILL:
1707 return (ptrace_kill(lxpid, pid));
1708
1709 case LX_PTRACE_SINGLESTEP:
1710 return (ptrace_step(lxpid, pid, lwpid, (int)p4));
1711
1712 case LX_PTRACE_GETREGS:
1713 return (ptrace_getregs(pid, lwpid, p4));
1714
1715 case LX_PTRACE_SETREGS:
1716 return (ptrace_setregs(pid, lwpid, p4));
1717
1718 case LX_PTRACE_GETFPREGS:
1719 return (ptrace_getfpregs(pid, lwpid, p4));
1720
1721 case LX_PTRACE_SETFPREGS:
1722 return (ptrace_setfpregs(pid, lwpid, p4));
1723
1724 case LX_PTRACE_ATTACH:
1725 return (ptrace_attach(lxpid, pid, lwpid));
1726
1727 case LX_PTRACE_DETACH:
1728 return (ptrace_detach(lxpid, pid, lwpid, (int)p4));
1729
1730 case LX_PTRACE_GETFPXREGS:
1731 return (ptrace_getfpxregs(pid, lwpid, p4));
1732
1733 case LX_PTRACE_SETFPXREGS:
1734 return (ptrace_setfpxregs(pid, lwpid, p4));
1735
1736 case LX_PTRACE_SYSCALL:
1737 return (ptrace_syscall(lxpid, pid, lwpid, (int)p4));
1738
1739 default:
1740 return (-EINVAL);
1741 }
1742 }
1743
1744 void
1745 lx_ptrace_fork(void)
1746 {
1747 /*
1748 * Send a special signal (that has no Linux equivalent) to indicate
1749 * that we're in this particularly special case. The signal will be
1750 * ignored by this process, but noticed by /proc consumers tracing
1751 * this process.
1752 */
1753 (void) _lwp_kill(_lwp_self(), SIGWAITING);
1754 }
1755
1756 static void
1757 ptrace_catch_fork(pid_t pid, int monitor)
1758 {
1759 long ctl[14 + 2 * sizeof (sysset_t) / sizeof (long)];
1760 long *ctlp;
1761 sysset_t *sysp;
1762 size_t size;
1763 pstatus_t ps;
1764 pid_t child;
1765 int fd, err;
1766
1767 /*
1768 * If any of this fails, we're really sunk since the child
1769 * will be stuck in the middle of lx_ptrace_fork().
1770 * Fortunately it's practically assured to succeed unless
1771 * something is seriously wrong on the system.
1772 */
1773 if ((fd = open_procfile(pid, O_WRONLY, "ctl")) < 0) {
1774 lx_debug("lx_catch_fork: failed to control %d",
1775 (int)pid);
1776 return;
1777 }
1778
1779 /*
1780 * Turn off the /proc PR_PTRACE flag so the parent doesn't get
1781 * spurious wake ups while we're working our dark magic. Arrange to
1782 * catch the process when it exits from fork, and turn on the /proc
1783 * inherit-on-fork flag so we catcht the child as well. We then run
1784 * the process, wait for it to stop on the fork1(2) call and reset
1785 * the tracing flags to their original state.
1786 */
1787 ctlp = ctl;
1788 *ctlp++ = PCCSIG;
1789 if (!monitor) {
1790 *ctlp++ = PCUNSET;
1791 *ctlp++ = PR_PTRACE;
1792 }
1793 *ctlp++ = PCSET;
1794 *ctlp++ = PR_FORK;
1795 *ctlp++ = PCSEXIT;
1796 sysp = (sysset_t *)ctlp;
1797 ctlp += sizeof (sysset_t) / sizeof (long);
1798 premptyset(sysp);
1799 praddset(sysp, SYS_forksys); /* fork1() is forksys(0, 0) */
1800 *ctlp++ = PCRUN;
1801 *ctlp++ = 0;
1802 *ctlp++ = PCWSTOP;
1803 if (!monitor) {
1804 *ctlp++ = PCSET;
1805 *ctlp++ = PR_PTRACE;
1806 }
1807 *ctlp++ = PCUNSET;
1808 *ctlp++ = PR_FORK;
1809 *ctlp++ = PCSEXIT;
1810 sysp = (sysset_t *)ctlp;
1811 ctlp += sizeof (sysset_t) / sizeof (long);
1812 premptyset(sysp);
1813 if (monitor)
1814 praddset(sysp, SYS_execve);
1815
1816 size = (char *)ctlp - (char *)&ctl[0];
1817 assert(size <= sizeof (ctl));
1818
1819 if (write(fd, ctl, size) != size) {
1820 (void) close(fd);
1821 lx_debug("lx_catch_fork: failed to set %d running",
1822 (int)pid);
1823 return;
1824 }
1825
1826 /*
1827 * Get the status so we can find the value returned from fork1() --
1828 * the child process's pid.
1829 */
1830 if (get_status(pid, &ps) != 0) {
1831 (void) close(fd);
1832 lx_debug("lx_catch_fork: failed to get status for %d",
1833 (int)pid);
1834 return;
1835 }
1836
1837 child = (pid_t)ps.pr_lwp.pr_reg[R_R0];
1838
1839 /*
1840 * We're done with the parent -- off you go.
1841 */
1842 ctl[0] = PCRUN;
1843 ctl[1] = 0;
1844 size = 2 * sizeof (long);
1845
1846 if (write(fd, ctl, size) != size) {
1847 (void) close(fd);
1848 lx_debug("lx_catch_fork: failed to set %d running",
1849 (int)pid);
1850 return;
1851 }
1852
1853 (void) close(fd);
1854
1855 /*
1856 * If fork1(2) failed, we're done.
1857 */
1858 if (child < 0) {
1859 lx_debug("lx_catch_fork: fork1 failed");
1860 return;
1861 }
1862
1863 /*
1864 * Now we need to screw with the child process.
1865 */
1866 if ((fd = open_lwpfile(child, 1, O_WRONLY, "lwpctl")) < 0) {
1867 lx_debug("lx_catch_fork: failed to control %d",
1868 (int)child);
1869 return;
1870 }
1871
1872 ctlp = ctl;
1873 *ctlp++ = PCUNSET;
1874 *ctlp++ = PR_FORK;
1875 *ctlp++ = PCSEXIT;
1876 sysp = (sysset_t *)ctlp;
1877 ctlp += sizeof (sysset_t) / sizeof (long);
1878 premptyset(sysp);
1879 size = (char *)ctlp - (char *)&ctl[0];
1880
1881 if (write(fd, ctl, size) != size) {
1882 (void) close(fd);
1883 lx_debug("lx_catch_fork: failed to clear trace flags for %d",
1884 (int)child);
1885 return;
1886 }
1887
1888 /*
1889 * Now treat the child as though we had attached to it explicitly.
1890 */
1891 err = ptrace_attach_common(fd, child, child, 1, 1);
1892 assert(err == 0);
1893
1894 (void) close(fd);
1895 }
1896
1897 static void
1898 set_dr6(pid_t pid, siginfo_t *infop)
1899 {
1900 uintptr_t *debugreg;
1901 uintptr_t addr;
1902 uintptr_t base;
1903 size_t size = NULL;
1904 int dr7;
1905 int lrw;
1906 int i;
1907
1908 if ((debugreg = debug_registers(pid)) == NULL)
1909 return;
1910
1911 debugreg[6] = 0xffff0ff0; /* read as ones */
1912 switch (infop->si_code) {
1913 case TRAP_TRACE:
1914 debugreg[6] |= 0x4000; /* single-step */
1915 break;
1916 case TRAP_RWATCH:
1917 case TRAP_WWATCH:
1918 case TRAP_XWATCH:
1919 dr7 = debugreg[7];
1920 addr = (uintptr_t)infop->si_addr;
1921 for (i = 0; i < 4; i++) {
1922 if ((dr7 & (1 << (2 * i))) == 0) /* enabled? */
1923 continue;
1924 lrw = (dr7 >> (16 + (4 * i))) & 0xf;
1925 switch (lrw >> 2) { /* length */
1926 case 0: size = 1; break;
1927 case 1: size = 2; break;
1928 case 2: size = 8; break;
1929 case 3: size = 4; break;
1930 }
1931 base = debugreg[i];
1932 if (addr >= base && addr < base + size)
1933 debugreg[6] |= (1 << i);
1934 }
1935 /*
1936 * Were we also attempting a single-step?
1937 * (kludge: we use debugreg[4] for this flag.)
1938 */
1939 if (debugreg[4])
1940 debugreg[6] |= 0x4000;
1941 break;
1942 default:
1943 break;
1944 }
1945 }
1946
1947 /*
1948 * This is called from the emulation of the wait4 and waitpid system call to
1949 * take into account the monitor processes which we spawn to observe other
1950 * processes from ptrace_attach().
1951 */
1952 int
1953 lx_ptrace_wait(siginfo_t *infop)
1954 {
1955 ptrace_monitor_map_t *p, **pp;
1956 pid_t lxpid, pid = infop->si_pid;
1957 lwpid_t lwpid;
1958 int fd;
1959 pstatus_t status;
1960
1961 /*
1962 * If the process observed by waitid(2) corresponds to the monitor
1963 * process for a traced thread, we need to rewhack the siginfo_t to
1964 * look like it came from the traced thread with the flags set
1965 * according to the current state.
1966 */
1967 (void) mutex_lock(&ptrace_map_mtx);
1968 for (pp = &ptrace_monitor_map; (p = *pp) != NULL; pp = &p->pmm_next) {
1969 if (p->pmm_monitor == pid) {
1970 assert(infop->si_code == CLD_EXITED ||
1971 infop->si_code == CLD_KILLED ||
1972 infop->si_code == CLD_DUMPED ||
1973 infop->si_code == CLD_TRAPPED);
1974 goto found;
1975 }
1976 }
1977 (void) mutex_unlock(&ptrace_map_mtx);
1978
1979 /*
1980 * If the traced process got a SIGWAITING, we must be in the middle
1981 * of a clone(2) with CLONE_PTRACE set.
1982 */
1983 if (infop->si_code == CLD_TRAPPED && infop->si_status == SIGWAITING) {
1984 ptrace_catch_fork(pid, 0);
1985 return (-1);
1986 }
1987
1988 if (get_status(pid, &status) == 0 &&
1989 (status.pr_lwp.pr_flags & PR_STOPPED) &&
1990 status.pr_lwp.pr_why == PR_SIGNALLED &&
1991 status.pr_lwp.pr_info.si_signo == SIGTRAP)
1992 set_dr6(pid, &status.pr_lwp.pr_info);
1993
1994 return (0);
1995
1996 found:
1997 /*
1998 * If the monitor is in the exiting state, ignore the event and free
1999 * the monitor structure if the monitor has exited. By returning -1 we
2000 * indicate to the caller that this was a spurious return from
2001 * waitid(2) and that it should ignore the result and try again.
2002 */
2003 if (p->pmm_exiting) {
2004 if (infop->si_code == CLD_EXITED ||
2005 infop->si_code == CLD_KILLED ||
2006 infop->si_code == CLD_DUMPED) {
2007 *pp = p->pmm_next;
2008 (void) mutex_unlock(&ptrace_map_mtx);
2009 free(p);
2010 }
2011 return (-1);
2012 }
2013
2014 lxpid = p->pmm_target;
2015 pid = p->pmm_pid;
2016 lwpid = p->pmm_lwpid;
2017 (void) mutex_unlock(&ptrace_map_mtx);
2018
2019 /*
2020 * If we can't find the traced process, kill off its monitor.
2021 */
2022 if ((fd = open_lwpfile(pid, lwpid, O_RDONLY, "lwpstatus")) < 0) {
2023 assert(errno == ENOENT);
2024 monitor_kill(lxpid, pid);
2025 infop->si_code = CLD_EXITED;
2026 infop->si_status = 0;
2027 infop->si_pid = lxpid;
2028 return (0);
2029 }
2030
2031 if (read(fd, &status.pr_lwp, sizeof (status.pr_lwp)) !=
2032 sizeof (status.pr_lwp)) {
2033 lx_err(gettext("read lwpstatus failed %d %s"),
2034 fd, strerror(errno));
2035 assert(0);
2036 }
2037
2038 (void) close(fd);
2039
2040 /*
2041 * If the traced process isn't stopped, this is a truly spurious
2042 * event probably caused by another /proc consumer tracing the
2043 * monitor.
2044 */
2045 if (!(status.pr_lwp.pr_flags & PR_STOPPED)) {
2046 (void) ptrace_cont_monitor(p);
2047 return (-1);
2048 }
2049
2050 switch (status.pr_lwp.pr_why) {
2051 case PR_SIGNALLED:
2052 /*
2053 * If the traced process got a SIGWAITING, we must be in the
2054 * middle of a clone(2) with CLONE_PTRACE set.
2055 */
2056 if (status.pr_lwp.pr_what == SIGWAITING) {
2057 ptrace_catch_fork(lxpid, 1);
2058 (void) ptrace_cont_monitor(p);
2059 return (-1);
2060 }
2061 infop->si_code = CLD_TRAPPED;
2062 infop->si_status = status.pr_lwp.pr_what;
2063 if (status.pr_lwp.pr_info.si_signo == SIGTRAP)
2064 set_dr6(pid, &status.pr_lwp.pr_info);
2065 break;
2066
2067 case PR_REQUESTED:
2068 /*
2069 * Make it look like the traced process stopped on an
2070 * event of interest.
2071 */
2072 infop->si_code = CLD_TRAPPED;
2073 infop->si_status = SIGTRAP;
2074 break;
2075
2076 case PR_JOBCONTROL:
2077 /*
2078 * Ignore this as it was probably caused by another /proc
2079 * consumer tracing the monitor.
2080 */
2081 (void) ptrace_cont_monitor(p);
2082 return (-1);
2083
2084 case PR_SYSEXIT:
2085 /*
2086 * Processes traced via a monitor (rather than using the
2087 * native Solaris ptrace support) explicitly trace returns
2088 * from exec system calls since it's an implicit ptrace
2089 * trace point. Accordingly we need to present a process
2090 * in that state as though it had reached the ptrace trace
2091 * point.
2092 */
2093 if (status.pr_lwp.pr_what == SYS_execve) {
2094 infop->si_code = CLD_TRAPPED;
2095 infop->si_status = SIGTRAP;
2096 break;
2097 }
2098
2099 /*FALLTHROUGH*/
2100
2101 case PR_SYSENTRY:
2102 case PR_FAULTED:
2103 case PR_SUSPENDED:
2104 default:
2105 lx_err(gettext("didn't expect %d (%d %d)"),
2106 status.pr_lwp.pr_why,
2107 status.pr_lwp.pr_what, status.pr_lwp.pr_flags);
2108 assert(0);
2109 }
2110
2111 infop->si_pid = lxpid;
2112
2113 return (0);
2114 }