1 /* $NetBSD: sys_ptrace_common.c,v 1.34 2018/01/08 06:10:30 christos Exp $ */ 2 3 /*- 4 * Copyright (c) 2008, 2009 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Andrew Doran. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 /*- 33 * Copyright (c) 1982, 1986, 1989, 1993 34 * The Regents of the University of California. All rights reserved. 35 * (c) UNIX System Laboratories, Inc. 36 * All or some portions of this file are derived from material licensed 37 * to the University of California by American Telephone and Telegraph 38 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 39 * the permission of UNIX System Laboratories, Inc. 40 * 41 * This code is derived from software contributed to Berkeley by 42 * Jan-Simon Pendry. 43 * 44 * Redistribution and use in source and binary forms, with or without 45 * modification, are permitted provided that the following conditions 46 * are met: 47 * 1. Redistributions of source code must retain the above copyright 48 * notice, this list of conditions and the following disclaimer. 49 * 2. Redistributions in binary form must reproduce the above copyright 50 * notice, this list of conditions and the following disclaimer in the 51 * documentation and/or other materials provided with the distribution. 52 * 3. Neither the name of the University nor the names of its contributors 53 * may be used to endorse or promote products derived from this software 54 * without specific prior written permission. 55 * 56 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 57 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 58 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 59 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 60 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 61 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 62 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 63 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 64 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 65 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 66 * SUCH DAMAGE. 67 * 68 * from: @(#)sys_process.c 8.1 (Berkeley) 6/10/93 69 */ 70 71 /*- 72 * Copyright (c) 1993 Jan-Simon Pendry. 73 * Copyright (c) 1994 Christopher G. Demetriou. All rights reserved. 74 * 75 * This code is derived from software contributed to Berkeley by 76 * Jan-Simon Pendry. 77 * 78 * Redistribution and use in source and binary forms, with or without 79 * modification, are permitted provided that the following conditions 80 * are met: 81 * 1. Redistributions of source code must retain the above copyright 82 * notice, this list of conditions and the following disclaimer. 83 * 2. Redistributions in binary form must reproduce the above copyright 84 * notice, this list of conditions and the following disclaimer in the 85 * documentation and/or other materials provided with the distribution. 86 * 3. All advertising materials mentioning features or use of this software 87 * must display the following acknowledgement: 88 * This product includes software developed by the University of 89 * California, Berkeley and its contributors. 90 * 4. Neither the name of the University nor the names of its contributors 91 * may be used to endorse or promote products derived from this software 92 * without specific prior written permission. 93 * 94 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 95 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 96 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 97 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 98 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 99 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 100 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 101 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 102 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 103 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 104 * SUCH DAMAGE. 105 * 106 * from: @(#)sys_process.c 8.1 (Berkeley) 6/10/93 107 */ 108 109 /* 110 * References: 111 * (1) Bach's "The Design of the UNIX Operating System", 112 * (2) sys/miscfs/procfs from UCB's 4.4BSD-Lite distribution, 113 * (3) the "4.4BSD Programmer's Reference Manual" published 114 * by USENIX and O'Reilly & Associates. 115 * The 4.4BSD PRM does a reasonably good job of documenting what the various 116 * ptrace() requests should actually do, and its text is quoted several times 117 * in this file. 118 */ 119 120 #include <sys/cdefs.h> 121 __KERNEL_RCSID(0, "$NetBSD: sys_ptrace_common.c,v 1.34 2018/01/08 06:10:30 christos Exp $"); 122 123 #ifdef _KERNEL_OPT 124 #include "opt_ptrace.h" 125 #include "opt_ktrace.h" 126 #include "opt_pax.h" 127 #include "opt_compat_netbsd32.h" 128 #endif 129 130 #if defined(__HAVE_COMPAT_NETBSD32) && !defined(COMPAT_NETBSD32) \ 131 && !defined(_RUMPKERNEL) 132 #define COMPAT_NETBSD32 133 #endif 134 135 #include <sys/param.h> 136 #include <sys/systm.h> 137 #include <sys/proc.h> 138 #include <sys/errno.h> 139 #include <sys/exec.h> 140 #include <sys/pax.h> 141 #include <sys/ptrace.h> 142 #include <sys/uio.h> 143 #include <sys/ras.h> 144 #include <sys/kmem.h> 145 #include <sys/kauth.h> 146 #include <sys/mount.h> 147 #include <sys/syscallargs.h> 148 #include <sys/module.h> 149 #include <sys/condvar.h> 150 #include <sys/mutex.h> 151 152 #include <uvm/uvm_extern.h> 153 154 #include <machine/reg.h> 155 156 #ifdef PTRACE 157 158 # ifdef DEBUG 159 # define DPRINTF(a) uprintf a 160 # else 161 # define DPRINTF(a) 162 # endif 163 164 static kauth_listener_t ptrace_listener; 165 static int process_auxv_offset(struct proc *, struct uio *); 166 167 #if 0 168 static int ptrace_cbref; 169 static kmutex_t ptrace_mtx; 170 static kcondvar_t ptrace_cv; 171 #endif 172 173 #ifdef PT_GETREGS 174 # define case_PT_GETREGS case PT_GETREGS: 175 #else 176 # define case_PT_GETREGS 177 #endif 178 179 #ifdef PT_SETREGS 180 # define case_PT_SETREGS case PT_SETREGS: 181 #else 182 # define case_PT_SETREGS 183 #endif 184 185 #ifdef PT_GETFPREGS 186 # define case_PT_GETFPREGS case PT_GETFPREGS: 187 #else 188 # define case_PT_GETFPREGS 189 #endif 190 191 #ifdef PT_SETFPREGS 192 # define case_PT_SETFPREGS case PT_SETFPREGS: 193 #else 194 # define case_PT_SETFPREGS 195 #endif 196 197 #ifdef PT_GETDBREGS 198 # define case_PT_GETDBREGS case PT_GETDBREGS: 199 #else 200 # define case_PT_GETDBREGS 201 #endif 202 203 #ifdef PT_SETDBREGS 204 # define case_PT_SETDBREGS case PT_SETDBREGS: 205 #else 206 # define case_PT_SETDBREGS 207 #endif 208 209 #if defined(PT_SETREGS) || defined(PT_GETREGS) || \ 210 defined(PT_SETFPREGS) || defined(PT_GETFOREGS) || \ 211 defined(PT_SETDBREGS) || defined(PT_GETDBREGS) 212 # define PT_REGISTERS 213 #endif 214 215 static int 216 ptrace_listener_cb(kauth_cred_t cred, kauth_action_t action, void *cookie, 217 void *arg0, void *arg1, void *arg2, void *arg3) 218 { 219 struct proc *p; 220 int result; 221 222 result = KAUTH_RESULT_DEFER; 223 p = arg0; 224 225 #if 0 226 mutex_enter(&ptrace_mtx); 227 ptrace_cbref++; 228 mutex_exit(&ptrace_mtx); 229 #endif 230 if (action != KAUTH_PROCESS_PTRACE) 231 goto out; 232 233 switch ((u_long)arg1) { 234 case PT_TRACE_ME: 235 case PT_ATTACH: 236 case PT_WRITE_I: 237 case PT_WRITE_D: 238 case PT_READ_I: 239 case PT_READ_D: 240 case PT_IO: 241 case_PT_GETREGS 242 case_PT_SETREGS 243 case_PT_GETFPREGS 244 case_PT_SETFPREGS 245 case_PT_GETDBREGS 246 case_PT_SETDBREGS 247 case PT_SET_EVENT_MASK: 248 case PT_GET_EVENT_MASK: 249 case PT_GET_PROCESS_STATE: 250 case PT_SET_SIGINFO: 251 case PT_GET_SIGINFO: 252 case PT_SET_SIGMASK: 253 case PT_GET_SIGMASK: 254 #ifdef __HAVE_PTRACE_MACHDEP 255 PTRACE_MACHDEP_REQUEST_CASES 256 #endif 257 if (kauth_cred_getuid(cred) != kauth_cred_getuid(p->p_cred) || 258 ISSET(p->p_flag, PK_SUGID)) { 259 break; 260 } 261 262 result = KAUTH_RESULT_ALLOW; 263 264 break; 265 266 #ifdef PT_STEP 267 case PT_STEP: 268 case PT_SETSTEP: 269 case PT_CLEARSTEP: 270 #endif 271 case PT_CONTINUE: 272 case PT_KILL: 273 case PT_DETACH: 274 case PT_LWPINFO: 275 case PT_SYSCALL: 276 case PT_SYSCALLEMU: 277 case PT_DUMPCORE: 278 case PT_RESUME: 279 case PT_SUSPEND: 280 result = KAUTH_RESULT_ALLOW; 281 break; 282 283 default: 284 break; 285 } 286 287 out: 288 #if 0 289 mutex_enter(&ptrace_mtx); 290 if (--ptrace_cbref == 0) 291 cv_broadcast(&ptrace_cv); 292 mutex_exit(&ptrace_mtx); 293 #endif 294 295 return result; 296 } 297 298 int 299 ptrace_init(void) 300 { 301 302 #if 0 303 mutex_init(&ptrace_mtx, MUTEX_DEFAULT, IPL_NONE); 304 cv_init(&ptrace_cv, "ptracecb"); 305 ptrace_cbref = 0; 306 #endif 307 ptrace_listener = kauth_listen_scope(KAUTH_SCOPE_PROCESS, 308 ptrace_listener_cb, NULL); 309 return 0; 310 } 311 312 int 313 ptrace_fini(void) 314 { 315 316 kauth_unlisten_scope(ptrace_listener); 317 318 #if 0 319 /* Make sure no-one is executing our kauth listener */ 320 321 mutex_enter(&ptrace_mtx); 322 while (ptrace_cbref != 0) 323 cv_wait(&ptrace_cv, &ptrace_mtx); 324 mutex_exit(&ptrace_mtx); 325 mutex_destroy(&ptrace_mtx); 326 cv_destroy(&ptrace_cv); 327 #endif 328 329 return 0; 330 } 331 332 static struct proc * 333 ptrace_find(struct lwp *l, int req, pid_t pid) 334 { 335 struct proc *t; 336 337 /* "A foolish consistency..." XXX */ 338 if (req == PT_TRACE_ME) { 339 t = l->l_proc; 340 mutex_enter(t->p_lock); 341 return t; 342 } 343 344 /* Find the process we're supposed to be operating on. */ 345 t = proc_find(pid); 346 if (t == NULL) 347 return NULL; 348 349 /* XXX-elad */ 350 mutex_enter(t->p_lock); 351 int error = kauth_authorize_process(l->l_cred, KAUTH_PROCESS_CANSEE, 352 t, KAUTH_ARG(KAUTH_REQ_PROCESS_CANSEE_ENTRY), NULL, NULL); 353 if (error) { 354 mutex_exit(t->p_lock); 355 return NULL; 356 } 357 return t; 358 } 359 360 static int 361 ptrace_allowed(struct lwp *l, int req, struct proc *t, struct proc *p) 362 { 363 /* 364 * Grab a reference on the process to prevent it from execing or 365 * exiting. 366 */ 367 if (!rw_tryenter(&t->p_reflock, RW_READER)) 368 return EBUSY; 369 370 /* Make sure we can operate on it. */ 371 switch (req) { 372 case PT_TRACE_ME: 373 /* Saying that you're being traced is always legal. */ 374 return 0; 375 376 case PT_ATTACH: 377 /* 378 * You can't attach to a process if: 379 * (1) it's the process that's doing the attaching, 380 */ 381 if (t->p_pid == p->p_pid) 382 return EINVAL; 383 384 /* 385 * (2) it's a system process 386 */ 387 if (t->p_flag & PK_SYSTEM) 388 return EPERM; 389 390 /* 391 * (3) it's already being traced, or 392 */ 393 if (ISSET(t->p_slflag, PSL_TRACED)) 394 return EBUSY; 395 396 /* 397 * (4) the tracer is chrooted, and its root directory is 398 * not at or above the root directory of the tracee 399 */ 400 mutex_exit(t->p_lock); /* XXXSMP */ 401 int tmp = proc_isunder(t, l); 402 mutex_enter(t->p_lock); /* XXXSMP */ 403 if (!tmp) 404 return EPERM; 405 return 0; 406 407 case PT_READ_I: 408 case PT_READ_D: 409 case PT_WRITE_I: 410 case PT_WRITE_D: 411 case PT_IO: 412 case PT_SET_SIGINFO: 413 case PT_GET_SIGINFO: 414 case PT_SET_SIGMASK: 415 case PT_GET_SIGMASK: 416 case_PT_GETREGS 417 case_PT_SETREGS 418 case_PT_GETFPREGS 419 case_PT_SETFPREGS 420 case_PT_GETDBREGS 421 case_PT_SETDBREGS 422 #ifdef __HAVE_PTRACE_MACHDEP 423 PTRACE_MACHDEP_REQUEST_CASES 424 #endif 425 /* 426 * You can't read/write the memory or registers of a process 427 * if the tracer is chrooted, and its root directory is not at 428 * or above the root directory of the tracee. 429 */ 430 mutex_exit(t->p_lock); /* XXXSMP */ 431 tmp = proc_isunder(t, l); 432 mutex_enter(t->p_lock); /* XXXSMP */ 433 if (!tmp) 434 return EPERM; 435 /*FALLTHROUGH*/ 436 437 case PT_CONTINUE: 438 case PT_KILL: 439 case PT_DETACH: 440 case PT_LWPINFO: 441 case PT_SYSCALL: 442 case PT_SYSCALLEMU: 443 case PT_DUMPCORE: 444 #ifdef PT_STEP 445 case PT_STEP: 446 case PT_SETSTEP: 447 case PT_CLEARSTEP: 448 #endif 449 case PT_SET_EVENT_MASK: 450 case PT_GET_EVENT_MASK: 451 case PT_GET_PROCESS_STATE: 452 case PT_RESUME: 453 case PT_SUSPEND: 454 /* 455 * You can't do what you want to the process if: 456 * (1) It's not being traced at all, 457 */ 458 if (!ISSET(t->p_slflag, PSL_TRACED)) 459 return EPERM; 460 461 /* 462 * (2) it's not being traced by _you_, or 463 */ 464 if (t->p_pptr != p) { 465 DPRINTF(("parent %d != %d\n", t->p_pptr->p_pid, 466 p->p_pid)); 467 return EBUSY; 468 } 469 470 /* 471 * (3) it's not currently stopped. 472 */ 473 if (t->p_stat != SSTOP || !t->p_waited /* XXXSMP */) { 474 DPRINTF(("stat %d flag %d\n", t->p_stat, 475 !t->p_waited)); 476 return EBUSY; 477 } 478 return 0; 479 480 default: /* It was not a legal request. */ 481 return EINVAL; 482 } 483 } 484 485 static int 486 ptrace_needs_hold(int req) 487 { 488 switch (req) { 489 #ifdef PT_STEP 490 case PT_STEP: 491 #endif 492 case PT_CONTINUE: 493 case PT_DETACH: 494 case PT_KILL: 495 case PT_SYSCALL: 496 case PT_SYSCALLEMU: 497 case PT_ATTACH: 498 case PT_TRACE_ME: 499 case PT_GET_SIGINFO: 500 case PT_SET_SIGINFO: 501 return 1; 502 default: 503 return 0; 504 } 505 } 506 507 static int 508 ptrace_update_lwp(struct proc *t, struct lwp **lt, lwpid_t lid) 509 { 510 if (lid == 0 || lid == (*lt)->l_lid || t->p_nlwps == 1) 511 return 0; 512 513 lwp_delref(*lt); 514 515 mutex_enter(t->p_lock); 516 *lt = lwp_find(t, lid); 517 if (*lt == NULL) { 518 mutex_exit(t->p_lock); 519 return ESRCH; 520 } 521 522 if ((*lt)->l_flag & LW_SYSTEM) { 523 *lt = NULL; 524 return EINVAL; 525 } 526 527 lwp_addref(*lt); 528 mutex_exit(t->p_lock); 529 530 return 0; 531 } 532 533 static int 534 ptrace_get_siginfo(struct proc *t, struct ptrace_methods *ptm, void *addr, 535 size_t data) 536 { 537 struct ptrace_siginfo psi; 538 539 psi.psi_siginfo._info = t->p_sigctx.ps_info; 540 psi.psi_lwpid = t->p_sigctx.ps_lwp; 541 542 return ptm->ptm_copyout_siginfo(&psi, addr, data); 543 } 544 545 static int 546 ptrace_set_siginfo(struct proc *t, struct lwp **lt, struct ptrace_methods *ptm, 547 void *addr, size_t data) 548 { 549 struct ptrace_siginfo psi; 550 551 int error = ptm->ptm_copyin_siginfo(&psi, addr, data); 552 if (error) 553 return error; 554 555 /* Check that the data is a valid signal number or zero. */ 556 if (psi.psi_siginfo.si_signo < 0 || psi.psi_siginfo.si_signo >= NSIG) 557 return EINVAL; 558 559 if ((error = ptrace_update_lwp(t, lt, psi.psi_lwpid)) != 0) 560 return error; 561 562 t->p_sigctx.ps_faked = true; 563 t->p_sigctx.ps_info = psi.psi_siginfo._info; 564 t->p_sigctx.ps_lwp = psi.psi_lwpid; 565 return 0; 566 } 567 568 static int 569 ptrace_get_event_mask(struct proc *t, void *addr, size_t data) 570 { 571 struct ptrace_event pe; 572 573 if (data != sizeof(pe)) { 574 DPRINTF(("%s: %zu != %zu\n", __func__, data, sizeof(pe))); 575 return EINVAL; 576 } 577 memset(&pe, 0, sizeof(pe)); 578 pe.pe_set_event = ISSET(t->p_slflag, PSL_TRACEFORK) ? 579 PTRACE_FORK : 0; 580 pe.pe_set_event |= ISSET(t->p_slflag, PSL_TRACEVFORK) ? 581 PTRACE_VFORK : 0; 582 pe.pe_set_event |= ISSET(t->p_slflag, PSL_TRACEVFORK_DONE) ? 583 PTRACE_VFORK_DONE : 0; 584 pe.pe_set_event |= ISSET(t->p_slflag, PSL_TRACELWP_CREATE) ? 585 PTRACE_LWP_CREATE : 0; 586 pe.pe_set_event |= ISSET(t->p_slflag, PSL_TRACELWP_EXIT) ? 587 PTRACE_LWP_EXIT : 0; 588 return copyout(&pe, addr, sizeof(pe)); 589 } 590 591 static int 592 ptrace_set_event_mask(struct proc *t, void *addr, size_t data) 593 { 594 struct ptrace_event pe; 595 int error; 596 597 if (data != sizeof(pe)) { 598 DPRINTF(("%s: %zu != %zu\n", __func__, data, sizeof(pe))); 599 return EINVAL; 600 } 601 if ((error = copyin(addr, &pe, sizeof(pe))) != 0) 602 return error; 603 604 if (pe.pe_set_event & PTRACE_FORK) 605 SET(t->p_slflag, PSL_TRACEFORK); 606 else 607 CLR(t->p_slflag, PSL_TRACEFORK); 608 #if notyet 609 if (pe.pe_set_event & PTRACE_VFORK) 610 SET(t->p_slflag, PSL_TRACEVFORK); 611 else 612 CLR(t->p_slflag, PSL_TRACEVFORK); 613 #else 614 if (pe.pe_set_event & PTRACE_VFORK) 615 return ENOTSUP; 616 #endif 617 if (pe.pe_set_event & PTRACE_VFORK_DONE) 618 SET(t->p_slflag, PSL_TRACEVFORK_DONE); 619 else 620 CLR(t->p_slflag, PSL_TRACEVFORK_DONE); 621 if (pe.pe_set_event & PTRACE_LWP_CREATE) 622 SET(t->p_slflag, PSL_TRACELWP_CREATE); 623 else 624 CLR(t->p_slflag, PSL_TRACELWP_CREATE); 625 if (pe.pe_set_event & PTRACE_LWP_EXIT) 626 SET(t->p_slflag, PSL_TRACELWP_EXIT); 627 else 628 CLR(t->p_slflag, PSL_TRACELWP_EXIT); 629 return 0; 630 } 631 632 static int 633 ptrace_get_process_state(struct proc *t, void *addr, size_t data) 634 { 635 struct ptrace_state ps; 636 637 if (data != sizeof(ps)) { 638 DPRINTF(("%s: %zu != %zu\n", __func__, data, sizeof(ps))); 639 return EINVAL; 640 } 641 memset(&ps, 0, sizeof(ps)); 642 643 if (t->p_fpid) { 644 ps.pe_report_event = PTRACE_FORK; 645 ps.pe_other_pid = t->p_fpid; 646 } else if (t->p_vfpid) { 647 ps.pe_report_event = PTRACE_VFORK; 648 ps.pe_other_pid = t->p_vfpid; 649 } else if (t->p_vfpid_done) { 650 ps.pe_report_event = PTRACE_VFORK_DONE; 651 ps.pe_other_pid = t->p_vfpid_done; 652 } else if (t->p_lwp_created) { 653 ps.pe_report_event = PTRACE_LWP_CREATE; 654 ps.pe_lwp = t->p_lwp_created; 655 } else if (t->p_lwp_exited) { 656 ps.pe_report_event = PTRACE_LWP_EXIT; 657 ps.pe_lwp = t->p_lwp_exited; 658 } 659 return copyout(&ps, addr, sizeof(ps)); 660 } 661 662 static int 663 ptrace_lwpinfo(struct proc *t, struct lwp **lt, void *addr, size_t data) 664 { 665 struct ptrace_lwpinfo pl; 666 667 if (data != sizeof(pl)) { 668 DPRINTF(("%s: %zu != %zu\n", __func__, data, sizeof(pl))); 669 return EINVAL; 670 } 671 int error = copyin(addr, &pl, sizeof(pl)); 672 if (error) 673 return error; 674 675 lwpid_t tmp = pl.pl_lwpid; 676 lwp_delref(*lt); 677 mutex_enter(t->p_lock); 678 if (tmp == 0) 679 *lt = lwp_find_first(t); 680 else { 681 *lt = lwp_find(t, tmp); 682 if (*lt == NULL) { 683 mutex_exit(t->p_lock); 684 return ESRCH; 685 } 686 *lt = LIST_NEXT(*lt, l_sibling); 687 } 688 689 while (*lt != NULL && !lwp_alive(*lt)) 690 *lt = LIST_NEXT(*lt, l_sibling); 691 692 pl.pl_lwpid = 0; 693 pl.pl_event = 0; 694 if (*lt) { 695 lwp_addref(*lt); 696 pl.pl_lwpid = (*lt)->l_lid; 697 698 if ((*lt)->l_flag & LW_WSUSPEND) 699 pl.pl_event = PL_EVENT_SUSPENDED; 700 /* 701 * If we match the lwp, or it was sent to every lwp, 702 * we set PL_EVENT_SIGNAL. 703 * XXX: ps_lwp == 0 means everyone and noone, so 704 * check ps_signo too. 705 */ 706 else if ((*lt)->l_lid == t->p_sigctx.ps_lwp 707 || (t->p_sigctx.ps_lwp == 0 && 708 t->p_sigctx.ps_info._signo)) 709 pl.pl_event = PL_EVENT_SIGNAL; 710 } 711 mutex_exit(t->p_lock); 712 713 return copyout(&pl, addr, sizeof(pl)); 714 } 715 716 static int 717 ptrace_sigmask(struct proc *t, struct lwp **lt, int rq, void *addr, size_t data) 718 { 719 int error; 720 721 if ((error = ptrace_update_lwp(t, lt, data)) != 0) 722 return error; 723 724 if (rq == PT_GET_SIGMASK) 725 return copyout(&(*lt)->l_sigmask, addr, sizeof(sigset_t)); 726 727 error = copyin(addr, &(*lt)->l_sigmask, sizeof(sigset_t)); 728 if (error) 729 return error; 730 sigminusset(&sigcantmask, &(*lt)->l_sigmask); 731 return 0; 732 } 733 734 static int 735 ptrace_startstop(struct proc *t, struct lwp **lt, int rq, void *addr, 736 size_t data) 737 { 738 int error; 739 740 if ((error = ptrace_update_lwp(t, lt, data)) != 0) 741 return error; 742 743 lwp_lock(*lt); 744 if (rq == PT_SUSPEND) 745 (*lt)->l_flag |= LW_WSUSPEND; 746 else 747 (*lt)->l_flag &= ~LW_WSUSPEND; 748 lwp_unlock(*lt); 749 return 0; 750 } 751 752 #ifdef PT_REGISTERS 753 static int 754 ptrace_uio_dir(int req) 755 { 756 switch (req) { 757 case_PT_GETREGS 758 case_PT_GETFPREGS 759 case_PT_GETDBREGS 760 return UIO_READ; 761 case_PT_SETREGS 762 case_PT_SETFPREGS 763 case_PT_SETDBREGS 764 return UIO_WRITE; 765 default: 766 return -1; 767 } 768 } 769 770 static int 771 ptrace_regs(struct lwp *l, struct lwp **lt, int rq, struct ptrace_methods *ptm, 772 void *addr, size_t data) 773 { 774 int error; 775 struct proc *t = (*lt)->l_proc; 776 struct vmspace *vm; 777 778 if ((error = ptrace_update_lwp(t, lt, data)) != 0) 779 return error; 780 781 int dir = ptrace_uio_dir(rq); 782 size_t size; 783 int (*func)(struct lwp *, struct lwp *, struct uio *); 784 785 switch (rq) { 786 #if defined(PT_SETREGS) || defined(PT_GETREGS) 787 case_PT_GETREGS 788 case_PT_SETREGS 789 if (!process_validregs(*lt)) 790 return EINVAL; 791 size = PROC_REGSZ(t); 792 func = ptm->ptm_doregs; 793 break; 794 #endif 795 #if defined(PT_SETFPREGS) || defined(PT_GETFPREGS) 796 case_PT_GETFPREGS 797 case_PT_SETFPREGS 798 if (!process_validfpregs(*lt)) 799 return EINVAL; 800 size = PROC_FPREGSZ(t); 801 func = ptm->ptm_dofpregs; 802 break; 803 #endif 804 #if defined(PT_SETDBREGS) || defined(PT_GETDBREGS) 805 case_PT_GETDBREGS 806 case_PT_SETDBREGS 807 if (!process_validdbregs(*lt)) 808 return EINVAL; 809 size = PROC_DBREGSZ(t); 810 func = ptm->ptm_dodbregs; 811 break; 812 #endif 813 default: 814 return EINVAL; 815 } 816 817 error = proc_vmspace_getref(l->l_proc, &vm); 818 if (error) 819 return error; 820 821 struct uio uio; 822 struct iovec iov; 823 824 iov.iov_base = addr; 825 iov.iov_len = size; 826 uio.uio_iov = &iov; 827 uio.uio_iovcnt = 1; 828 uio.uio_offset = 0; 829 uio.uio_resid = iov.iov_len; 830 uio.uio_rw = dir; 831 uio.uio_vmspace = vm; 832 833 error = (*func)(l, *lt, &uio); 834 uvmspace_free(vm); 835 return error; 836 } 837 #endif 838 839 static int 840 ptrace_sendsig(struct proc *t, struct lwp *lt, int signo, int resume_all) 841 { 842 ksiginfo_t ksi; 843 844 t->p_fpid = 0; 845 t->p_vfpid = 0; 846 t->p_vfpid_done = 0; 847 t->p_lwp_created = 0; 848 t->p_lwp_exited = 0; 849 850 /* Finally, deliver the requested signal (or none). */ 851 if (t->p_stat == SSTOP) { 852 /* 853 * Unstop the process. If it needs to take a 854 * signal, make all efforts to ensure that at 855 * an LWP runs to see it. 856 */ 857 t->p_xsig = signo; 858 if (resume_all) 859 proc_unstop(t); 860 else 861 lwp_unstop(lt); 862 return 0; 863 } 864 865 KSI_INIT_EMPTY(&ksi); 866 if (t->p_sigctx.ps_faked) { 867 if (signo != t->p_sigctx.ps_info._signo) 868 return EINVAL; 869 t->p_sigctx.ps_faked = false; 870 ksi.ksi_info = t->p_sigctx.ps_info; 871 ksi.ksi_lid = t->p_sigctx.ps_lwp; 872 } else if (signo == 0) { 873 return 0; 874 } else { 875 ksi.ksi_signo = signo; 876 } 877 878 kpsignal2(t, &ksi); 879 return 0; 880 } 881 882 static int 883 ptrace_dumpcore(struct lwp *lt, char *path, size_t len) 884 { 885 int error; 886 if (path != NULL) { 887 888 if (len >= MAXPATHLEN) 889 return EINVAL; 890 891 char *src = path; 892 path = kmem_alloc(len + 1, KM_SLEEP); 893 error = copyin(src, path, len); 894 if (error) 895 goto out; 896 path[len] = '\0'; 897 } 898 error = (*coredump_vec)(lt, path); 899 out: 900 if (path) 901 kmem_free(path, len + 1); 902 return error; 903 } 904 905 static int 906 ptrace_doio(struct lwp *l, struct proc *t, struct lwp *lt, 907 struct ptrace_io_desc *piod, void *addr, bool sysspace) 908 { 909 struct uio uio; 910 struct iovec iov; 911 int error, tmp; 912 913 error = 0; 914 iov.iov_base = piod->piod_addr; 915 iov.iov_len = piod->piod_len; 916 uio.uio_iov = &iov; 917 uio.uio_iovcnt = 1; 918 uio.uio_offset = (off_t)(unsigned long)piod->piod_offs; 919 uio.uio_resid = piod->piod_len; 920 921 switch (piod->piod_op) { 922 case PIOD_READ_D: 923 case PIOD_READ_I: 924 uio.uio_rw = UIO_READ; 925 break; 926 case PIOD_WRITE_D: 927 case PIOD_WRITE_I: 928 /* 929 * Can't write to a RAS 930 */ 931 if (ras_lookup(t, addr) != (void *)-1) { 932 return EACCES; 933 } 934 uio.uio_rw = UIO_WRITE; 935 break; 936 case PIOD_READ_AUXV: 937 uio.uio_rw = UIO_READ; 938 tmp = t->p_execsw->es_arglen; 939 if (uio.uio_offset > tmp) 940 return EIO; 941 if (uio.uio_resid > tmp - uio.uio_offset) 942 uio.uio_resid = tmp - uio.uio_offset; 943 piod->piod_len = iov.iov_len = uio.uio_resid; 944 error = process_auxv_offset(t, &uio); 945 break; 946 default: 947 error = EINVAL; 948 break; 949 } 950 951 if (error) 952 return error; 953 954 if (sysspace) { 955 uio.uio_vmspace = vmspace_kernel(); 956 } else { 957 error = proc_vmspace_getref(l->l_proc, &uio.uio_vmspace); 958 if (error) 959 return error; 960 } 961 962 error = process_domem(l, lt, &uio); 963 if (!sysspace) 964 uvmspace_free(uio.uio_vmspace); 965 if (error) 966 return error; 967 piod->piod_len -= uio.uio_resid; 968 return 0; 969 } 970 971 int 972 do_ptrace(struct ptrace_methods *ptm, struct lwp *l, int req, pid_t pid, 973 void *addr, int data, register_t *retval) 974 { 975 struct proc *p = l->l_proc; 976 struct lwp *lt = NULL; 977 struct lwp *lt2; 978 struct proc *t; /* target process */ 979 struct ptrace_io_desc piod; 980 int error, write, tmp, pheld; 981 int signo = 0; 982 int resume_all; 983 error = 0; 984 985 /* 986 * If attaching or detaching, we need to get a write hold on the 987 * proclist lock so that we can re-parent the target process. 988 */ 989 mutex_enter(proc_lock); 990 991 t = ptrace_find(l, req, pid); 992 if (t == NULL) { 993 mutex_exit(proc_lock); 994 return ESRCH; 995 } 996 997 pheld = 1; 998 if ((error = ptrace_allowed(l, req, t, p)) != 0) 999 goto out; 1000 1001 if ((error = kauth_authorize_process(l->l_cred, 1002 KAUTH_PROCESS_PTRACE, t, KAUTH_ARG(req), NULL, NULL)) != 0) 1003 goto out; 1004 1005 if ((lt = lwp_find_first(t)) == NULL) { 1006 error = ESRCH; 1007 goto out; 1008 } 1009 1010 /* Do single-step fixup if needed. */ 1011 FIX_SSTEP(t); 1012 KASSERT(lt != NULL); 1013 lwp_addref(lt); 1014 1015 /* 1016 * Which locks do we need held? XXX Ugly. 1017 */ 1018 if ((pheld = ptrace_needs_hold(req)) == 0) { 1019 mutex_exit(t->p_lock); 1020 mutex_exit(proc_lock); 1021 } 1022 1023 /* Now do the operation. */ 1024 write = 0; 1025 *retval = 0; 1026 tmp = 0; 1027 resume_all = 1; 1028 1029 switch (req) { 1030 case PT_TRACE_ME: 1031 /* Just set the trace flag. */ 1032 SET(t->p_slflag, PSL_TRACED); 1033 t->p_opptr = t->p_pptr; 1034 break; 1035 1036 case PT_WRITE_I: /* XXX no separate I and D spaces */ 1037 case PT_WRITE_D: 1038 write = 1; 1039 tmp = data; 1040 /* FALLTHROUGH */ 1041 case PT_READ_I: /* XXX no separate I and D spaces */ 1042 case PT_READ_D: 1043 piod.piod_addr = &tmp; 1044 piod.piod_len = sizeof(tmp); 1045 piod.piod_offs = addr; 1046 piod.piod_op = write ? PIOD_WRITE_D : PIOD_READ_D; 1047 if ((error = ptrace_doio(l, t, lt, &piod, addr, true)) != 0) 1048 break; 1049 if (!write) 1050 *retval = tmp; 1051 break; 1052 1053 case PT_IO: 1054 if ((error = ptm->ptm_copyin_piod(&piod, addr, data)) != 0) 1055 break; 1056 if ((error = ptrace_doio(l, t, lt, &piod, addr, false)) != 0) 1057 break; 1058 error = ptm->ptm_copyout_piod(&piod, addr, data); 1059 break; 1060 1061 case PT_DUMPCORE: 1062 error = ptrace_dumpcore(lt, addr, data); 1063 break; 1064 1065 #ifdef PT_STEP 1066 case PT_STEP: 1067 /* 1068 * From the 4.4BSD PRM: 1069 * "Execution continues as in request PT_CONTINUE; however 1070 * as soon as possible after execution of at least one 1071 * instruction, execution stops again. [ ... ]" 1072 */ 1073 #endif 1074 case PT_CONTINUE: 1075 case PT_SYSCALL: 1076 case PT_DETACH: 1077 if (req == PT_SYSCALL) { 1078 if (!ISSET(t->p_slflag, PSL_SYSCALL)) { 1079 SET(t->p_slflag, PSL_SYSCALL); 1080 #ifdef __HAVE_SYSCALL_INTERN 1081 (*t->p_emul->e_syscall_intern)(t); 1082 #endif 1083 } 1084 } else { 1085 if (ISSET(t->p_slflag, PSL_SYSCALL)) { 1086 CLR(t->p_slflag, PSL_SYSCALL); 1087 #ifdef __HAVE_SYSCALL_INTERN 1088 (*t->p_emul->e_syscall_intern)(t); 1089 #endif 1090 } 1091 } 1092 t->p_trace_enabled = trace_is_enabled(t); 1093 1094 /* 1095 * Pick up the LWPID, if supplied. There are two cases: 1096 * data < 0 : step or continue single thread, lwp = -data 1097 * data > 0 in PT_STEP : step this thread, continue others 1098 * For operations other than PT_STEP, data > 0 means 1099 * data is the signo to deliver to the process. 1100 */ 1101 tmp = data; 1102 if (tmp >= 0) { 1103 #ifdef PT_STEP 1104 if (req == PT_STEP) 1105 signo = 0; 1106 else 1107 #endif 1108 { 1109 signo = tmp; 1110 tmp = 0; /* don't search for LWP */ 1111 } 1112 } else 1113 tmp = -tmp; 1114 1115 if (tmp > 0) { 1116 if (req == PT_DETACH) { 1117 error = EINVAL; 1118 break; 1119 } 1120 lwp_delref2 (lt); 1121 lt = lwp_find(t, tmp); 1122 if (lt == NULL) { 1123 error = ESRCH; 1124 break; 1125 } 1126 lwp_addref(lt); 1127 resume_all = 0; 1128 signo = 0; 1129 } 1130 1131 /* 1132 * From the 4.4BSD PRM: 1133 * "The data argument is taken as a signal number and the 1134 * child's execution continues at location addr as if it 1135 * incurred that signal. Normally the signal number will 1136 * be either 0 to indicate that the signal that caused the 1137 * stop should be ignored, or that value fetched out of 1138 * the process's image indicating which signal caused 1139 * the stop. If addr is (int *)1 then execution continues 1140 * from where it stopped." 1141 */ 1142 1143 /* Check that the data is a valid signal number or zero. */ 1144 if (signo < 0 || signo >= NSIG) { 1145 error = EINVAL; 1146 break; 1147 } 1148 1149 /* Prevent process deadlock */ 1150 if (resume_all) { 1151 #ifdef PT_STEP 1152 if (req == PT_STEP) { 1153 if (lt->l_flag & LW_WSUSPEND) { 1154 error = EDEADLK; 1155 break; 1156 } 1157 } else 1158 #endif 1159 { 1160 error = EDEADLK; 1161 LIST_FOREACH(lt2, &t->p_lwps, l_sibling) { 1162 if ((lt2->l_flag & LW_WSUSPEND) == 0) { 1163 error = 0; 1164 break; 1165 } 1166 } 1167 if (error != 0) 1168 break; 1169 } 1170 } else { 1171 if (lt->l_flag & LW_WSUSPEND) { 1172 error = EDEADLK; 1173 break; 1174 } 1175 } 1176 1177 /* If the address parameter is not (int *)1, set the pc. */ 1178 if ((int *)addr != (int *)1) { 1179 error = process_set_pc(lt, addr); 1180 if (error != 0) 1181 break; 1182 } 1183 #ifdef PT_STEP 1184 /* 1185 * Arrange for a single-step, if that's requested and possible. 1186 * More precisely, set the single step status as requested for 1187 * the requested thread, and clear it for other threads. 1188 */ 1189 LIST_FOREACH(lt2, &t->p_lwps, l_sibling) { 1190 if (ISSET(lt2->l_pflag, LP_SINGLESTEP)) { 1191 lwp_lock(lt2); 1192 process_sstep(lt2, 1); 1193 lwp_unlock(lt2); 1194 } else if (lt != lt2) { 1195 lwp_lock(lt2); 1196 process_sstep(lt2, 0); 1197 lwp_unlock(lt2); 1198 } 1199 } 1200 error = process_sstep(lt, 1201 ISSET(lt->l_pflag, LP_SINGLESTEP) || req == PT_STEP); 1202 if (error) 1203 break; 1204 #endif 1205 if (req == PT_DETACH) { 1206 CLR(t->p_slflag, PSL_TRACED|PSL_SYSCALL); 1207 1208 /* give process back to original parent or init */ 1209 if (t->p_opptr != t->p_pptr) { 1210 struct proc *pp = t->p_opptr; 1211 proc_reparent(t, pp ? pp : initproc); 1212 } 1213 1214 /* not being traced any more */ 1215 t->p_opptr = NULL; 1216 1217 /* clear single step */ 1218 LIST_FOREACH(lt2, &t->p_lwps, l_sibling) { 1219 CLR(lt2->l_pflag, LP_SINGLESTEP); 1220 } 1221 CLR(lt->l_pflag, LP_SINGLESTEP); 1222 } 1223 sendsig: 1224 error = ptrace_sendsig(t, lt, signo, resume_all); 1225 break; 1226 1227 case PT_SYSCALLEMU: 1228 if (!ISSET(t->p_slflag, PSL_SYSCALL) || t->p_stat != SSTOP) { 1229 error = EINVAL; 1230 break; 1231 } 1232 SET(t->p_slflag, PSL_SYSCALLEMU); 1233 break; 1234 1235 #ifdef PT_STEP 1236 case PT_SETSTEP: 1237 write = 1; 1238 1239 case PT_CLEARSTEP: 1240 /* write = 0 done above. */ 1241 if ((error = ptrace_update_lwp(t, <, data)) != 0) 1242 break; 1243 1244 if (write) 1245 SET(lt->l_pflag, LP_SINGLESTEP); 1246 else 1247 CLR(lt->l_pflag, LP_SINGLESTEP); 1248 break; 1249 #endif 1250 1251 case PT_KILL: 1252 /* just send the process a KILL signal. */ 1253 signo = SIGKILL; 1254 goto sendsig; /* in PT_CONTINUE, above. */ 1255 1256 case PT_ATTACH: 1257 /* 1258 * Go ahead and set the trace flag. 1259 * Save the old parent (it's reset in 1260 * _DETACH, and also in kern_exit.c:wait4() 1261 * Reparent the process so that the tracing 1262 * proc gets to see all the action. 1263 * Stop the target. 1264 */ 1265 proc_changeparent(t, p); 1266 signo = SIGSTOP; 1267 goto sendsig; 1268 1269 case PT_GET_EVENT_MASK: 1270 error = ptrace_get_event_mask(t, addr, data); 1271 break; 1272 1273 case PT_SET_EVENT_MASK: 1274 error = ptrace_set_event_mask(t, addr, data); 1275 break; 1276 1277 case PT_GET_PROCESS_STATE: 1278 error = ptrace_get_process_state(t, addr, data); 1279 break; 1280 1281 case PT_LWPINFO: 1282 error = ptrace_lwpinfo(t, <, addr, data); 1283 break; 1284 1285 case PT_SET_SIGINFO: 1286 error = ptrace_set_siginfo(t, <, ptm, addr, data); 1287 break; 1288 1289 case PT_GET_SIGINFO: 1290 error = ptrace_get_siginfo(t, ptm, addr, data); 1291 break; 1292 1293 case PT_SET_SIGMASK: 1294 case PT_GET_SIGMASK: 1295 error = ptrace_sigmask(t, <, req, addr, data); 1296 break; 1297 1298 case PT_RESUME: 1299 case PT_SUSPEND: 1300 error = ptrace_startstop(t, <, req, addr, data); 1301 break; 1302 1303 #ifdef PT_REGISTERS 1304 case_PT_SETREGS 1305 case_PT_GETREGS 1306 case_PT_SETFPREGS 1307 case_PT_GETFPREGS 1308 case_PT_SETDBREGS 1309 case_PT_GETDBREGS 1310 error = ptrace_regs(l, <, req, ptm, addr, data); 1311 break; 1312 #endif 1313 1314 #ifdef __HAVE_PTRACE_MACHDEP 1315 PTRACE_MACHDEP_REQUEST_CASES 1316 error = ptrace_machdep_dorequest(l, lt, req, addr, data); 1317 break; 1318 #endif 1319 } 1320 1321 out: 1322 if (pheld) { 1323 mutex_exit(t->p_lock); 1324 mutex_exit(proc_lock); 1325 } 1326 if (lt != NULL) 1327 lwp_delref(lt); 1328 rw_exit(&t->p_reflock); 1329 1330 return error; 1331 } 1332 1333 typedef int (*regrfunc_t)(struct lwp *, void *, size_t *); 1334 typedef int (*regwfunc_t)(struct lwp *, void *, size_t); 1335 1336 #ifdef PT_REGISTERS 1337 static int 1338 proc_regio(struct lwp *l, struct uio *uio, size_t ks, regrfunc_t r, 1339 regwfunc_t w) 1340 { 1341 char buf[1024]; 1342 int error; 1343 char *kv; 1344 size_t kl; 1345 1346 if (ks > sizeof(buf)) 1347 return E2BIG; 1348 1349 if (uio->uio_offset < 0 || uio->uio_offset > (off_t)ks) 1350 return EINVAL; 1351 1352 kv = buf + uio->uio_offset; 1353 kl = ks - uio->uio_offset; 1354 1355 if (kl > uio->uio_resid) 1356 kl = uio->uio_resid; 1357 1358 error = (*r)(l, buf, &ks); 1359 if (error == 0) 1360 error = uiomove(kv, kl, uio); 1361 if (error == 0 && uio->uio_rw == UIO_WRITE) { 1362 if (l->l_stat != LSSTOP) 1363 error = EBUSY; 1364 else 1365 error = (*w)(l, buf, ks); 1366 } 1367 1368 uio->uio_offset = 0; 1369 return error; 1370 } 1371 #endif 1372 1373 int 1374 process_doregs(struct lwp *curl /*tracer*/, 1375 struct lwp *l /*traced*/, 1376 struct uio *uio) 1377 { 1378 #if defined(PT_GETREGS) || defined(PT_SETREGS) 1379 size_t s; 1380 regrfunc_t r; 1381 regwfunc_t w; 1382 1383 #ifdef COMPAT_NETBSD32 1384 const bool pk32 = (l->l_proc->p_flag & PK_32) != 0; 1385 1386 if (__predict_false(pk32)) { 1387 s = sizeof(process_reg32); 1388 r = (regrfunc_t)process_read_regs32; 1389 w = (regwfunc_t)process_write_regs32; 1390 } else 1391 #endif 1392 { 1393 s = sizeof(struct reg); 1394 r = (regrfunc_t)process_read_regs; 1395 w = (regwfunc_t)process_write_regs; 1396 } 1397 return proc_regio(l, uio, s, r, w); 1398 #else 1399 return EINVAL; 1400 #endif 1401 } 1402 1403 int 1404 process_validregs(struct lwp *l) 1405 { 1406 1407 #if defined(PT_SETREGS) || defined(PT_GETREGS) 1408 return (l->l_flag & LW_SYSTEM) == 0; 1409 #else 1410 return 0; 1411 #endif 1412 } 1413 1414 int 1415 process_dofpregs(struct lwp *curl /*tracer*/, 1416 struct lwp *l /*traced*/, 1417 struct uio *uio) 1418 { 1419 #if defined(PT_GETFPREGS) || defined(PT_SETFPREGS) 1420 size_t s; 1421 regrfunc_t r; 1422 regwfunc_t w; 1423 1424 #ifdef COMPAT_NETBSD32 1425 const bool pk32 = (l->l_proc->p_flag & PK_32) != 0; 1426 1427 if (__predict_false(pk32)) { 1428 s = sizeof(process_fpreg32); 1429 r = (regrfunc_t)process_read_fpregs32; 1430 w = (regwfunc_t)process_write_fpregs32; 1431 } else 1432 #endif 1433 { 1434 s = sizeof(struct fpreg); 1435 r = (regrfunc_t)process_read_fpregs; 1436 w = (regwfunc_t)process_write_fpregs; 1437 } 1438 return proc_regio(l, uio, s, r, w); 1439 #else 1440 return EINVAL; 1441 #endif 1442 } 1443 1444 int 1445 process_validfpregs(struct lwp *l) 1446 { 1447 1448 #if defined(PT_SETFPREGS) || defined(PT_GETFPREGS) 1449 return (l->l_flag & LW_SYSTEM) == 0; 1450 #else 1451 return 0; 1452 #endif 1453 } 1454 1455 int 1456 process_dodbregs(struct lwp *curl /*tracer*/, 1457 struct lwp *l /*traced*/, 1458 struct uio *uio) 1459 { 1460 #if defined(PT_GETDBREGS) || defined(PT_SETDBREGS) 1461 size_t s; 1462 regrfunc_t r; 1463 regwfunc_t w; 1464 1465 #ifdef COMPAT_NETBSD32 1466 const bool pk32 = (l->l_proc->p_flag & PK_32) != 0; 1467 1468 if (__predict_false(pk32)) { 1469 s = sizeof(process_dbreg32); 1470 r = (regrfunc_t)process_read_dbregs32; 1471 w = (regwfunc_t)process_write_dbregs32; 1472 } else 1473 #endif 1474 { 1475 s = sizeof(struct dbreg); 1476 r = (regrfunc_t)process_read_dbregs; 1477 w = (regwfunc_t)process_write_dbregs; 1478 } 1479 return proc_regio(l, uio, s, r, w); 1480 #else 1481 return EINVAL; 1482 #endif 1483 } 1484 1485 int 1486 process_validdbregs(struct lwp *l) 1487 { 1488 1489 #if defined(PT_SETDBREGS) || defined(PT_GETDBREGS) 1490 return (l->l_flag & LW_SYSTEM) == 0; 1491 #else 1492 return 0; 1493 #endif 1494 } 1495 1496 static int 1497 process_auxv_offset(struct proc *p, struct uio *uio) 1498 { 1499 struct ps_strings pss; 1500 int error; 1501 off_t off = (off_t)p->p_psstrp; 1502 1503 if ((error = copyin_psstrings(p, &pss)) != 0) 1504 return error; 1505 1506 if (pss.ps_envstr == NULL) 1507 return EIO; 1508 1509 uio->uio_offset += (off_t)(vaddr_t)(pss.ps_envstr + pss.ps_nenvstr + 1); 1510 #ifdef __MACHINE_STACK_GROWS_UP 1511 if (uio->uio_offset < off) 1512 return EIO; 1513 #else 1514 if (uio->uio_offset > off) 1515 return EIO; 1516 if ((uio->uio_offset + uio->uio_resid) > off) 1517 uio->uio_resid = off - uio->uio_offset; 1518 #endif 1519 return 0; 1520 } 1521 #endif /* PTRACE */ 1522 1523 MODULE(MODULE_CLASS_EXEC, ptrace_common, ""); 1524 1525 static int 1526 ptrace_common_modcmd(modcmd_t cmd, void *arg) 1527 { 1528 int error; 1529 1530 switch (cmd) { 1531 case MODULE_CMD_INIT: 1532 error = ptrace_init(); 1533 break; 1534 case MODULE_CMD_FINI: 1535 error = ptrace_fini(); 1536 break; 1537 default: 1538 ptrace_hooks(); 1539 error = ENOTTY; 1540 break; 1541 } 1542 return error; 1543 } 1544