sys_ptrace_common.c revision 1.22.2.4
1 /* $NetBSD: sys_ptrace_common.c,v 1.22.2.4 2018/11/29 14:58:25 martin 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.22.2.4 2018/11/29 14:58:25 martin 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 #ifdef PT_SETDBREGS 222 extern int user_set_dbregs; 223 #endif 224 225 result = KAUTH_RESULT_DEFER; 226 p = arg0; 227 228 #if 0 229 mutex_enter(&ptrace_mtx); 230 ptrace_cbref++; 231 mutex_exit(&ptrace_mtx); 232 #endif 233 if (action != KAUTH_PROCESS_PTRACE) 234 goto out; 235 236 switch ((u_long)arg1) { 237 #ifdef PT_SETDBREGS 238 case_PT_SETDBREGS 239 if (kauth_cred_getuid(cred) != 0 && user_set_dbregs == 0) { 240 result = KAUTH_RESULT_DENY; 241 break; 242 } 243 #endif 244 case PT_TRACE_ME: 245 case PT_ATTACH: 246 case PT_WRITE_I: 247 case PT_WRITE_D: 248 case PT_READ_I: 249 case PT_READ_D: 250 case PT_IO: 251 case_PT_GETREGS 252 case_PT_SETREGS 253 case_PT_GETFPREGS 254 case_PT_SETFPREGS 255 case_PT_GETDBREGS 256 case PT_SET_EVENT_MASK: 257 case PT_GET_EVENT_MASK: 258 case PT_GET_PROCESS_STATE: 259 case PT_SET_SIGINFO: 260 case PT_GET_SIGINFO: 261 #ifdef __HAVE_PTRACE_MACHDEP 262 PTRACE_MACHDEP_REQUEST_CASES 263 #endif 264 if (kauth_cred_getuid(cred) != kauth_cred_getuid(p->p_cred) || 265 ISSET(p->p_flag, PK_SUGID)) { 266 break; 267 } 268 269 result = KAUTH_RESULT_ALLOW; 270 271 break; 272 273 #ifdef PT_STEP 274 case PT_STEP: 275 case PT_SETSTEP: 276 case PT_CLEARSTEP: 277 #endif 278 case PT_CONTINUE: 279 case PT_KILL: 280 case PT_DETACH: 281 case PT_LWPINFO: 282 case PT_SYSCALL: 283 case PT_SYSCALLEMU: 284 case PT_DUMPCORE: 285 case PT_RESUME: 286 case PT_SUSPEND: 287 result = KAUTH_RESULT_ALLOW; 288 break; 289 290 default: 291 break; 292 } 293 294 out: 295 #if 0 296 mutex_enter(&ptrace_mtx); 297 if (--ptrace_cbref == 0) 298 cv_broadcast(&ptrace_cv); 299 mutex_exit(&ptrace_mtx); 300 #endif 301 302 return result; 303 } 304 305 int 306 ptrace_init(void) 307 { 308 309 #if 0 310 mutex_init(&ptrace_mtx, MUTEX_DEFAULT, IPL_NONE); 311 cv_init(&ptrace_cv, "ptracecb"); 312 ptrace_cbref = 0; 313 #endif 314 ptrace_listener = kauth_listen_scope(KAUTH_SCOPE_PROCESS, 315 ptrace_listener_cb, NULL); 316 return 0; 317 } 318 319 int 320 ptrace_fini(void) 321 { 322 323 kauth_unlisten_scope(ptrace_listener); 324 325 #if 0 326 /* Make sure no-one is executing our kauth listener */ 327 328 mutex_enter(&ptrace_mtx); 329 while (ptrace_cbref != 0) 330 cv_wait(&ptrace_cv, &ptrace_mtx); 331 mutex_exit(&ptrace_mtx); 332 mutex_destroy(&ptrace_mtx); 333 cv_destroy(&ptrace_cv); 334 #endif 335 336 return 0; 337 } 338 339 static struct proc * 340 ptrace_find(struct lwp *l, int req, pid_t pid) 341 { 342 struct proc *t; 343 344 /* "A foolish consistency..." XXX */ 345 if (req == PT_TRACE_ME) { 346 t = l->l_proc; 347 mutex_enter(t->p_lock); 348 return t; 349 } 350 351 /* Find the process we're supposed to be operating on. */ 352 t = proc_find(pid); 353 if (t == NULL) 354 return NULL; 355 356 /* XXX-elad */ 357 mutex_enter(t->p_lock); 358 int error = kauth_authorize_process(l->l_cred, KAUTH_PROCESS_CANSEE, 359 t, KAUTH_ARG(KAUTH_REQ_PROCESS_CANSEE_ENTRY), NULL, NULL); 360 if (error) { 361 mutex_exit(t->p_lock); 362 return NULL; 363 } 364 return t; 365 } 366 367 static int 368 ptrace_allowed(struct lwp *l, int req, struct proc *t, struct proc *p) 369 { 370 /* 371 * Grab a reference on the process to prevent it from execing or 372 * exiting. 373 */ 374 if (!rw_tryenter(&t->p_reflock, RW_READER)) 375 return EBUSY; 376 377 /* Make sure we can operate on it. */ 378 switch (req) { 379 case PT_TRACE_ME: 380 /* 381 * You can't say to the parent of a process to start tracing if: 382 * (1) the parent is initproc, 383 */ 384 if (p->p_pptr == initproc) 385 return EPERM; 386 387 /* 388 * (2) the child is already traced. 389 */ 390 if (ISSET(p->p_slflag, PSL_TRACED)) 391 return EBUSY; 392 393 return 0; 394 395 case PT_ATTACH: 396 /* 397 * You can't attach to a process if: 398 * (1) it's the process that's doing the attaching, 399 */ 400 if (t->p_pid == p->p_pid) 401 return EINVAL; 402 403 /* 404 * (2) it's a system process 405 */ 406 if (t->p_flag & PK_SYSTEM) 407 return EPERM; 408 409 /* 410 * (3) it's already being traced, or 411 */ 412 if (ISSET(t->p_slflag, PSL_TRACED)) 413 return EBUSY; 414 415 /* 416 * (4) the tracer is chrooted, and its root directory is 417 * not at or above the root directory of the tracee 418 */ 419 mutex_exit(t->p_lock); /* XXXSMP */ 420 int tmp = proc_isunder(t, l); 421 mutex_enter(t->p_lock); /* XXXSMP */ 422 if (!tmp) 423 return EPERM; 424 return 0; 425 426 case PT_READ_I: 427 case PT_READ_D: 428 case PT_WRITE_I: 429 case PT_WRITE_D: 430 case PT_IO: 431 case PT_SET_SIGINFO: 432 case PT_GET_SIGINFO: 433 case_PT_GETREGS 434 case_PT_SETREGS 435 case_PT_GETFPREGS 436 case_PT_SETFPREGS 437 case_PT_GETDBREGS 438 case_PT_SETDBREGS 439 #ifdef __HAVE_PTRACE_MACHDEP 440 PTRACE_MACHDEP_REQUEST_CASES 441 #endif 442 /* 443 * You can't read/write the memory or registers of a process 444 * if the tracer is chrooted, and its root directory is not at 445 * or above the root directory of the tracee. 446 */ 447 mutex_exit(t->p_lock); /* XXXSMP */ 448 tmp = proc_isunder(t, l); 449 mutex_enter(t->p_lock); /* XXXSMP */ 450 if (!tmp) 451 return EPERM; 452 /*FALLTHROUGH*/ 453 454 case PT_CONTINUE: 455 case PT_KILL: 456 case PT_DETACH: 457 case PT_LWPINFO: 458 case PT_SYSCALL: 459 case PT_SYSCALLEMU: 460 case PT_DUMPCORE: 461 #ifdef PT_STEP 462 case PT_STEP: 463 case PT_SETSTEP: 464 case PT_CLEARSTEP: 465 #endif 466 case PT_SET_EVENT_MASK: 467 case PT_GET_EVENT_MASK: 468 case PT_GET_PROCESS_STATE: 469 case PT_RESUME: 470 case PT_SUSPEND: 471 /* 472 * You can't do what you want to the process if: 473 * (1) It's not being traced at all, 474 */ 475 if (!ISSET(t->p_slflag, PSL_TRACED)) 476 return EPERM; 477 478 /* 479 * (2) it's not being traced by _you_, or 480 */ 481 if (t->p_pptr != p) { 482 DPRINTF(("parent %d != %d\n", t->p_pptr->p_pid, 483 p->p_pid)); 484 return EBUSY; 485 } 486 487 /* 488 * (3) it's not currently stopped. 489 */ 490 if (t->p_stat != SSTOP || !t->p_waited /* XXXSMP */) { 491 DPRINTF(("stat %d flag %d\n", t->p_stat, 492 !t->p_waited)); 493 return EBUSY; 494 } 495 return 0; 496 497 default: /* It was not a legal request. */ 498 return EINVAL; 499 } 500 } 501 502 static int 503 ptrace_needs_hold(int req) 504 { 505 switch (req) { 506 #ifdef PT_STEP 507 case PT_STEP: 508 #endif 509 case PT_CONTINUE: 510 case PT_DETACH: 511 case PT_KILL: 512 case PT_SYSCALL: 513 case PT_SYSCALLEMU: 514 case PT_ATTACH: 515 case PT_TRACE_ME: 516 case PT_GET_SIGINFO: 517 case PT_SET_SIGINFO: 518 return 1; 519 default: 520 return 0; 521 } 522 } 523 524 static int 525 ptrace_update_lwp(struct proc *t, struct lwp **lt, lwpid_t lid) 526 { 527 if (lid == 0 || lid == (*lt)->l_lid || t->p_nlwps == 1) 528 return 0; 529 530 lwp_delref(*lt); 531 532 mutex_enter(t->p_lock); 533 *lt = lwp_find(t, lid); 534 if (*lt == NULL) { 535 mutex_exit(t->p_lock); 536 return ESRCH; 537 } 538 539 if ((*lt)->l_flag & LW_SYSTEM) { 540 *lt = NULL; 541 return EINVAL; 542 } 543 544 lwp_addref(*lt); 545 mutex_exit(t->p_lock); 546 547 return 0; 548 } 549 550 static int 551 ptrace_get_siginfo(struct proc *t, struct ptrace_methods *ptm, void *addr, 552 size_t data) 553 { 554 struct ptrace_siginfo psi; 555 556 memset(&psi, 0, sizeof(psi)); 557 psi.psi_siginfo._info = t->p_sigctx.ps_info; 558 psi.psi_lwpid = t->p_sigctx.ps_lwp; 559 560 return ptm->ptm_copyout_siginfo(&psi, addr, data); 561 } 562 563 static int 564 ptrace_set_siginfo(struct proc *t, struct lwp **lt, struct ptrace_methods *ptm, 565 void *addr, size_t data) 566 { 567 struct ptrace_siginfo psi; 568 569 int error = ptm->ptm_copyin_siginfo(&psi, addr, data); 570 if (error) 571 return error; 572 573 /* Check that the data is a valid signal number or zero. */ 574 if (psi.psi_siginfo.si_signo < 0 || psi.psi_siginfo.si_signo >= NSIG) 575 return EINVAL; 576 577 if ((error = ptrace_update_lwp(t, lt, psi.psi_lwpid)) != 0) 578 return error; 579 580 t->p_sigctx.ps_faked = true; 581 t->p_sigctx.ps_info = psi.psi_siginfo._info; 582 t->p_sigctx.ps_lwp = psi.psi_lwpid; 583 return 0; 584 } 585 586 static int 587 ptrace_get_event_mask(struct proc *t, void *addr, size_t data) 588 { 589 struct ptrace_event pe; 590 591 if (data != sizeof(pe)) { 592 DPRINTF(("%s: %zu != %zu\n", __func__, data, sizeof(pe))); 593 return EINVAL; 594 } 595 memset(&pe, 0, sizeof(pe)); 596 pe.pe_set_event = ISSET(t->p_slflag, PSL_TRACEFORK) ? 597 PTRACE_FORK : 0; 598 pe.pe_set_event |= ISSET(t->p_slflag, PSL_TRACEVFORK) ? 599 PTRACE_VFORK : 0; 600 pe.pe_set_event |= ISSET(t->p_slflag, PSL_TRACEVFORK_DONE) ? 601 PTRACE_VFORK_DONE : 0; 602 pe.pe_set_event |= ISSET(t->p_slflag, PSL_TRACELWP_CREATE) ? 603 PTRACE_LWP_CREATE : 0; 604 pe.pe_set_event |= ISSET(t->p_slflag, PSL_TRACELWP_EXIT) ? 605 PTRACE_LWP_EXIT : 0; 606 return copyout(&pe, addr, sizeof(pe)); 607 } 608 609 static int 610 ptrace_set_event_mask(struct proc *t, void *addr, size_t data) 611 { 612 struct ptrace_event pe; 613 int error; 614 615 if (data != sizeof(pe)) { 616 DPRINTF(("%s: %zu != %zu\n", __func__, data, sizeof(pe))); 617 return EINVAL; 618 } 619 if ((error = copyin(addr, &pe, sizeof(pe))) != 0) 620 return error; 621 622 if (pe.pe_set_event & PTRACE_FORK) 623 SET(t->p_slflag, PSL_TRACEFORK); 624 else 625 CLR(t->p_slflag, PSL_TRACEFORK); 626 #if notyet 627 if (pe.pe_set_event & PTRACE_VFORK) 628 SET(t->p_slflag, PSL_TRACEVFORK); 629 else 630 CLR(t->p_slflag, PSL_TRACEVFORK); 631 #else 632 if (pe.pe_set_event & PTRACE_VFORK) 633 return ENOTSUP; 634 #endif 635 if (pe.pe_set_event & PTRACE_VFORK_DONE) 636 SET(t->p_slflag, PSL_TRACEVFORK_DONE); 637 else 638 CLR(t->p_slflag, PSL_TRACEVFORK_DONE); 639 if (pe.pe_set_event & PTRACE_LWP_CREATE) 640 SET(t->p_slflag, PSL_TRACELWP_CREATE); 641 else 642 CLR(t->p_slflag, PSL_TRACELWP_CREATE); 643 if (pe.pe_set_event & PTRACE_LWP_EXIT) 644 SET(t->p_slflag, PSL_TRACELWP_EXIT); 645 else 646 CLR(t->p_slflag, PSL_TRACELWP_EXIT); 647 return 0; 648 } 649 650 static int 651 ptrace_get_process_state(struct proc *t, void *addr, size_t data) 652 { 653 struct ptrace_state ps; 654 655 if (data != sizeof(ps)) { 656 DPRINTF(("%s: %zu != %zu\n", __func__, data, sizeof(ps))); 657 return EINVAL; 658 } 659 memset(&ps, 0, sizeof(ps)); 660 661 if (t->p_fpid) { 662 ps.pe_report_event = PTRACE_FORK; 663 ps.pe_other_pid = t->p_fpid; 664 } else if (t->p_vfpid) { 665 ps.pe_report_event = PTRACE_VFORK; 666 ps.pe_other_pid = t->p_vfpid; 667 } else if (t->p_vfpid_done) { 668 ps.pe_report_event = PTRACE_VFORK_DONE; 669 ps.pe_other_pid = t->p_vfpid_done; 670 } else if (t->p_lwp_created) { 671 ps.pe_report_event = PTRACE_LWP_CREATE; 672 ps.pe_lwp = t->p_lwp_created; 673 } else if (t->p_lwp_exited) { 674 ps.pe_report_event = PTRACE_LWP_EXIT; 675 ps.pe_lwp = t->p_lwp_exited; 676 } 677 return copyout(&ps, addr, sizeof(ps)); 678 } 679 680 static int 681 ptrace_lwpinfo(struct proc *t, struct lwp **lt, void *addr, size_t data) 682 { 683 struct ptrace_lwpinfo pl; 684 685 if (data != sizeof(pl)) { 686 DPRINTF(("%s: %zu != %zu\n", __func__, data, sizeof(pl))); 687 return EINVAL; 688 } 689 int error = copyin(addr, &pl, sizeof(pl)); 690 if (error) 691 return error; 692 693 lwpid_t tmp = pl.pl_lwpid; 694 lwp_delref(*lt); 695 mutex_enter(t->p_lock); 696 if (tmp == 0) 697 *lt = lwp_find_first(t); 698 else { 699 *lt = lwp_find(t, tmp); 700 if (*lt == NULL) { 701 mutex_exit(t->p_lock); 702 return ESRCH; 703 } 704 *lt = LIST_NEXT(*lt, l_sibling); 705 } 706 707 while (*lt != NULL && !lwp_alive(*lt)) 708 *lt = LIST_NEXT(*lt, l_sibling); 709 710 pl.pl_lwpid = 0; 711 pl.pl_event = 0; 712 if (*lt) { 713 lwp_addref(*lt); 714 pl.pl_lwpid = (*lt)->l_lid; 715 716 if ((*lt)->l_flag & LW_WSUSPEND) 717 pl.pl_event = PL_EVENT_SUSPENDED; 718 /* 719 * If we match the lwp, or it was sent to every lwp, 720 * we set PL_EVENT_SIGNAL. 721 * XXX: ps_lwp == 0 means everyone and noone, so 722 * check ps_signo too. 723 */ 724 else if ((*lt)->l_lid == t->p_sigctx.ps_lwp 725 || (t->p_sigctx.ps_lwp == 0 && 726 t->p_sigctx.ps_info._signo)) 727 pl.pl_event = PL_EVENT_SIGNAL; 728 } 729 mutex_exit(t->p_lock); 730 731 return copyout(&pl, addr, sizeof(pl)); 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_RESUME: 1294 case PT_SUSPEND: 1295 error = ptrace_startstop(t, <, req, addr, data); 1296 break; 1297 1298 #ifdef PT_REGISTERS 1299 case_PT_SETREGS 1300 case_PT_GETREGS 1301 case_PT_SETFPREGS 1302 case_PT_GETFPREGS 1303 case_PT_SETDBREGS 1304 case_PT_GETDBREGS 1305 error = ptrace_regs(l, <, req, ptm, addr, data); 1306 break; 1307 #endif 1308 1309 #ifdef __HAVE_PTRACE_MACHDEP 1310 PTRACE_MACHDEP_REQUEST_CASES 1311 error = ptrace_machdep_dorequest(l, lt, req, addr, data); 1312 break; 1313 #endif 1314 } 1315 1316 out: 1317 if (pheld) { 1318 mutex_exit(t->p_lock); 1319 mutex_exit(proc_lock); 1320 } 1321 if (lt != NULL) 1322 lwp_delref(lt); 1323 rw_exit(&t->p_reflock); 1324 1325 return error; 1326 } 1327 1328 typedef int (*regrfunc_t)(struct lwp *, void *, size_t *); 1329 typedef int (*regwfunc_t)(struct lwp *, void *, size_t); 1330 1331 #ifdef PT_REGISTERS 1332 static int 1333 proc_regio(struct lwp *l, struct uio *uio, size_t ks, regrfunc_t r, 1334 regwfunc_t w) 1335 { 1336 char buf[1024]; 1337 int error; 1338 char *kv; 1339 size_t kl; 1340 1341 if (ks > sizeof(buf)) 1342 return E2BIG; 1343 1344 if (uio->uio_offset < 0 || uio->uio_offset > (off_t)ks) 1345 return EINVAL; 1346 1347 kv = buf + uio->uio_offset; 1348 kl = ks - uio->uio_offset; 1349 1350 if (kl > uio->uio_resid) 1351 kl = uio->uio_resid; 1352 1353 error = (*r)(l, buf, &ks); 1354 if (error == 0) 1355 error = uiomove(kv, kl, uio); 1356 if (error == 0 && uio->uio_rw == UIO_WRITE) { 1357 if (l->l_stat != LSSTOP) 1358 error = EBUSY; 1359 else 1360 error = (*w)(l, buf, ks); 1361 } 1362 1363 uio->uio_offset = 0; 1364 return error; 1365 } 1366 #endif 1367 1368 int 1369 process_doregs(struct lwp *curl /*tracer*/, 1370 struct lwp *l /*traced*/, 1371 struct uio *uio) 1372 { 1373 #if defined(PT_GETREGS) || defined(PT_SETREGS) 1374 size_t s; 1375 regrfunc_t r; 1376 regwfunc_t w; 1377 1378 #ifdef COMPAT_NETBSD32 1379 const bool pk32 = (l->l_proc->p_flag & PK_32) != 0; 1380 1381 if (__predict_false(pk32)) { 1382 s = sizeof(process_reg32); 1383 r = (regrfunc_t)process_read_regs32; 1384 w = (regwfunc_t)process_write_regs32; 1385 } else 1386 #endif 1387 { 1388 s = sizeof(struct reg); 1389 r = (regrfunc_t)process_read_regs; 1390 w = (regwfunc_t)process_write_regs; 1391 } 1392 return proc_regio(l, uio, s, r, w); 1393 #else 1394 return EINVAL; 1395 #endif 1396 } 1397 1398 int 1399 process_validregs(struct lwp *l) 1400 { 1401 1402 #if defined(PT_SETREGS) || defined(PT_GETREGS) 1403 return (l->l_flag & LW_SYSTEM) == 0; 1404 #else 1405 return 0; 1406 #endif 1407 } 1408 1409 int 1410 process_dofpregs(struct lwp *curl /*tracer*/, 1411 struct lwp *l /*traced*/, 1412 struct uio *uio) 1413 { 1414 #if defined(PT_GETFPREGS) || defined(PT_SETFPREGS) 1415 size_t s; 1416 regrfunc_t r; 1417 regwfunc_t w; 1418 1419 #ifdef COMPAT_NETBSD32 1420 const bool pk32 = (l->l_proc->p_flag & PK_32) != 0; 1421 1422 if (__predict_false(pk32)) { 1423 s = sizeof(process_fpreg32); 1424 r = (regrfunc_t)process_read_fpregs32; 1425 w = (regwfunc_t)process_write_fpregs32; 1426 } else 1427 #endif 1428 { 1429 s = sizeof(struct fpreg); 1430 r = (regrfunc_t)process_read_fpregs; 1431 w = (regwfunc_t)process_write_fpregs; 1432 } 1433 return proc_regio(l, uio, s, r, w); 1434 #else 1435 return EINVAL; 1436 #endif 1437 } 1438 1439 int 1440 process_validfpregs(struct lwp *l) 1441 { 1442 1443 #if defined(PT_SETFPREGS) || defined(PT_GETFPREGS) 1444 return (l->l_flag & LW_SYSTEM) == 0; 1445 #else 1446 return 0; 1447 #endif 1448 } 1449 1450 int 1451 process_dodbregs(struct lwp *curl /*tracer*/, 1452 struct lwp *l /*traced*/, 1453 struct uio *uio) 1454 { 1455 #if defined(PT_GETDBREGS) || defined(PT_SETDBREGS) 1456 size_t s; 1457 regrfunc_t r; 1458 regwfunc_t w; 1459 1460 #ifdef COMPAT_NETBSD32 1461 const bool pk32 = (l->l_proc->p_flag & PK_32) != 0; 1462 1463 if (__predict_false(pk32)) { 1464 s = sizeof(process_dbreg32); 1465 r = (regrfunc_t)process_read_dbregs32; 1466 w = (regwfunc_t)process_write_dbregs32; 1467 } else 1468 #endif 1469 { 1470 s = sizeof(struct dbreg); 1471 r = (regrfunc_t)process_read_dbregs; 1472 w = (regwfunc_t)process_write_dbregs; 1473 } 1474 return proc_regio(l, uio, s, r, w); 1475 #else 1476 return EINVAL; 1477 #endif 1478 } 1479 1480 int 1481 process_validdbregs(struct lwp *l) 1482 { 1483 1484 #if defined(PT_SETDBREGS) || defined(PT_GETDBREGS) 1485 return (l->l_flag & LW_SYSTEM) == 0; 1486 #else 1487 return 0; 1488 #endif 1489 } 1490 1491 static int 1492 process_auxv_offset(struct proc *p, struct uio *uio) 1493 { 1494 struct ps_strings pss; 1495 int error; 1496 off_t off = (off_t)p->p_psstrp; 1497 1498 if ((error = copyin_psstrings(p, &pss)) != 0) 1499 return error; 1500 1501 if (pss.ps_envstr == NULL) 1502 return EIO; 1503 1504 uio->uio_offset += (off_t)(vaddr_t)(pss.ps_envstr + pss.ps_nenvstr + 1); 1505 #ifdef __MACHINE_STACK_GROWS_UP 1506 if (uio->uio_offset < off) 1507 return EIO; 1508 #else 1509 if (uio->uio_offset > off) 1510 return EIO; 1511 if ((uio->uio_offset + uio->uio_resid) > off) 1512 uio->uio_resid = off - uio->uio_offset; 1513 #endif 1514 return 0; 1515 } 1516 #endif /* PTRACE */ 1517 1518 MODULE(MODULE_CLASS_EXEC, ptrace_common, ""); 1519 1520 static int 1521 ptrace_common_modcmd(modcmd_t cmd, void *arg) 1522 { 1523 int error; 1524 1525 switch (cmd) { 1526 case MODULE_CMD_INIT: 1527 error = ptrace_init(); 1528 break; 1529 case MODULE_CMD_FINI: 1530 error = ptrace_fini(); 1531 break; 1532 default: 1533 ptrace_hooks(); 1534 error = ENOTTY; 1535 break; 1536 } 1537 return error; 1538 } 1539
Indexes created Tue Sep 30 20:09:53 GMT 2025