1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2017 Edward Tomasz Napierala <trasz@FreeBSD.org> 5 * 6 * This software was developed by SRI International and the University of 7 * Cambridge Computer Laboratory under DARPA/AFRL contract (FA8750-10-C-0237) 8 * ("CTSRD"), as part of the DARPA CRASH research programme. 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 AUTHOR AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 __FBSDID("$FreeBSD$"); 34 35 #include <sys/param.h> 36 #include <sys/lock.h> 37 #include <sys/proc.h> 38 #include <sys/ptrace.h> 39 #include <sys/sx.h> 40 #include <sys/syscallsubr.h> 41 42 #include <machine/../linux/linux.h> 43 #include <machine/../linux/linux_proto.h> 44 #include <compat/linux/linux_emul.h> 45 #include <compat/linux/linux_errno.h> 46 #include <compat/linux/linux_misc.h> 47 #include <compat/linux/linux_signal.h> 48 #include <compat/linux/linux_util.h> 49 50 #define LINUX_PTRACE_TRACEME 0 51 #define LINUX_PTRACE_PEEKTEXT 1 52 #define LINUX_PTRACE_PEEKDATA 2 53 #define LINUX_PTRACE_PEEKUSER 3 54 #define LINUX_PTRACE_POKETEXT 4 55 #define LINUX_PTRACE_POKEDATA 5 56 #define LINUX_PTRACE_POKEUSER 6 57 #define LINUX_PTRACE_CONT 7 58 #define LINUX_PTRACE_KILL 8 59 #define LINUX_PTRACE_SINGLESTEP 9 60 #define LINUX_PTRACE_GETREGS 12 61 #define LINUX_PTRACE_SETREGS 13 62 #define LINUX_PTRACE_GETFPREGS 14 63 #define LINUX_PTRACE_SETFPREGS 15 64 #define LINUX_PTRACE_ATTACH 16 65 #define LINUX_PTRACE_DETACH 17 66 #define LINUX_PTRACE_SYSCALL 24 67 #define LINUX_PTRACE_SETOPTIONS 0x4200 68 #define LINUX_PTRACE_GETEVENTMSG 0x4201 69 #define LINUX_PTRACE_GETSIGINFO 0x4202 70 #define LINUX_PTRACE_GETREGSET 0x4204 71 #define LINUX_PTRACE_SEIZE 0x4206 72 #define LINUX_PTRACE_GET_SYSCALL_INFO 0x420e 73 74 #define LINUX_PTRACE_EVENT_EXEC 4 75 #define LINUX_PTRACE_EVENT_EXIT 6 76 77 #define LINUX_PTRACE_O_TRACESYSGOOD 1 78 #define LINUX_PTRACE_O_TRACEFORK 2 79 #define LINUX_PTRACE_O_TRACEVFORK 4 80 #define LINUX_PTRACE_O_TRACECLONE 8 81 #define LINUX_PTRACE_O_TRACEEXEC 16 82 #define LINUX_PTRACE_O_TRACEVFORKDONE 32 83 #define LINUX_PTRACE_O_TRACEEXIT 64 84 #define LINUX_PTRACE_O_TRACESECCOMP 128 85 #define LINUX_PTRACE_O_EXITKILL 1048576 86 #define LINUX_PTRACE_O_SUSPEND_SECCOMP 2097152 87 88 #define LINUX_NT_PRSTATUS 0x1 89 #define LINUX_NT_PRFPREG 0x2 90 #define LINUX_NT_X86_XSTATE 0x202 91 92 #define LINUX_PTRACE_O_MASK (LINUX_PTRACE_O_TRACESYSGOOD | \ 93 LINUX_PTRACE_O_TRACEFORK | LINUX_PTRACE_O_TRACEVFORK | \ 94 LINUX_PTRACE_O_TRACECLONE | LINUX_PTRACE_O_TRACEEXEC | \ 95 LINUX_PTRACE_O_TRACEVFORKDONE | LINUX_PTRACE_O_TRACEEXIT | \ 96 LINUX_PTRACE_O_TRACESECCOMP | LINUX_PTRACE_O_EXITKILL | \ 97 LINUX_PTRACE_O_SUSPEND_SECCOMP) 98 99 #define LINUX_PTRACE_SYSCALL_INFO_NONE 0 100 #define LINUX_PTRACE_SYSCALL_INFO_ENTRY 1 101 #define LINUX_PTRACE_SYSCALL_INFO_EXIT 2 102 103 #define LINUX_PTRACE_PEEKUSER_ORIG_RAX 120 104 #define LINUX_PTRACE_PEEKUSER_RIP 128 105 #define LINUX_PTRACE_PEEKUSER_CS 136 106 #define LINUX_PTRACE_PEEKUSER_DS 184 107 108 static int 109 map_signum(int lsig, int *bsigp) 110 { 111 int bsig; 112 113 if (lsig == 0) { 114 *bsigp = 0; 115 return (0); 116 } 117 118 if (lsig < 0 || lsig > LINUX_SIGRTMAX) 119 return (EINVAL); 120 121 bsig = linux_to_bsd_signal(lsig); 122 if (bsig == SIGSTOP) 123 bsig = 0; 124 125 *bsigp = bsig; 126 return (0); 127 } 128 129 int 130 linux_ptrace_status(struct thread *td, pid_t pid, int status) 131 { 132 struct ptrace_lwpinfo lwpinfo; 133 struct linux_pemuldata *pem; 134 register_t saved_retval; 135 int error; 136 137 saved_retval = td->td_retval[0]; 138 error = kern_ptrace(td, PT_LWPINFO, pid, &lwpinfo, sizeof(lwpinfo)); 139 td->td_retval[0] = saved_retval; 140 if (error != 0) { 141 linux_msg(td, "PT_LWPINFO failed with error %d", error); 142 return (status); 143 } 144 145 pem = pem_find(td->td_proc); 146 KASSERT(pem != NULL, ("%s: proc emuldata not found.\n", __func__)); 147 148 LINUX_PEM_SLOCK(pem); 149 if ((pem->ptrace_flags & LINUX_PTRACE_O_TRACESYSGOOD) && 150 lwpinfo.pl_flags & PL_FLAG_SCE) 151 status |= (LINUX_SIGTRAP | 0x80) << 8; 152 if ((pem->ptrace_flags & LINUX_PTRACE_O_TRACESYSGOOD) && 153 lwpinfo.pl_flags & PL_FLAG_SCX) { 154 if (lwpinfo.pl_flags & PL_FLAG_EXEC) 155 status |= (LINUX_SIGTRAP | LINUX_PTRACE_EVENT_EXEC << 8) << 8; 156 else 157 status |= (LINUX_SIGTRAP | 0x80) << 8; 158 } 159 if ((pem->ptrace_flags & LINUX_PTRACE_O_TRACEEXIT) && 160 lwpinfo.pl_flags & PL_FLAG_EXITED) 161 status |= (LINUX_SIGTRAP | LINUX_PTRACE_EVENT_EXIT << 8) << 8; 162 LINUX_PEM_SUNLOCK(pem); 163 164 return (status); 165 } 166 167 static int 168 linux_ptrace_peek(struct thread *td, pid_t pid, void *addr, void *data) 169 { 170 int error; 171 172 error = kern_ptrace(td, PT_READ_I, pid, addr, 0); 173 if (error == 0) 174 error = copyout(td->td_retval, data, sizeof(l_int)); 175 else if (error == ENOMEM) 176 error = EIO; 177 td->td_retval[0] = error; 178 179 return (error); 180 } 181 182 static int 183 linux_ptrace_peekuser(struct thread *td, pid_t pid, void *addr, void *data) 184 { 185 struct reg b_reg; 186 uint64_t val; 187 int error; 188 189 error = kern_ptrace(td, PT_GETREGS, pid, &b_reg, 0); 190 if (error != 0) 191 return (error); 192 193 switch ((uintptr_t)addr) { 194 #ifdef __amd64__ 195 case LINUX_PTRACE_PEEKUSER_ORIG_RAX: 196 val = b_reg.r_rax; 197 break; 198 case LINUX_PTRACE_PEEKUSER_RIP: 199 val = b_reg.r_rip; 200 break; 201 case LINUX_PTRACE_PEEKUSER_CS: 202 val = b_reg.r_cs; 203 break; 204 case LINUX_PTRACE_PEEKUSER_DS: 205 val = b_reg.r_ds; 206 break; 207 #endif /* __amd64__ */ 208 default: 209 linux_msg(td, "PTRACE_PEEKUSER offset %ld not implemented; " 210 "returning EINVAL", (uintptr_t)addr); 211 return (EINVAL); 212 } 213 214 error = copyout(&val, data, sizeof(val)); 215 td->td_retval[0] = error; 216 217 return (error); 218 } 219 220 static int 221 linux_ptrace_pokeuser(struct thread *td, pid_t pid, void *addr, void *data) 222 { 223 224 linux_msg(td, "PTRACE_POKEUSER not implemented; returning EINVAL"); 225 return (EINVAL); 226 } 227 228 static int 229 linux_ptrace_setoptions(struct thread *td, pid_t pid, l_ulong data) 230 { 231 struct linux_pemuldata *pem; 232 int mask; 233 234 mask = 0; 235 236 if (data & ~LINUX_PTRACE_O_MASK) { 237 linux_msg(td, "unknown ptrace option %lx set; " 238 "returning EINVAL", 239 data & ~LINUX_PTRACE_O_MASK); 240 return (EINVAL); 241 } 242 243 pem = pem_find(td->td_proc); 244 KASSERT(pem != NULL, ("%s: proc emuldata not found.\n", __func__)); 245 246 /* 247 * PTRACE_O_EXITKILL is ignored, we do that by default. 248 */ 249 250 LINUX_PEM_XLOCK(pem); 251 if (data & LINUX_PTRACE_O_TRACESYSGOOD) { 252 pem->ptrace_flags |= LINUX_PTRACE_O_TRACESYSGOOD; 253 } else { 254 pem->ptrace_flags &= ~LINUX_PTRACE_O_TRACESYSGOOD; 255 } 256 LINUX_PEM_XUNLOCK(pem); 257 258 if (data & LINUX_PTRACE_O_TRACEFORK) 259 mask |= PTRACE_FORK; 260 261 if (data & LINUX_PTRACE_O_TRACEVFORK) 262 mask |= PTRACE_VFORK; 263 264 if (data & LINUX_PTRACE_O_TRACECLONE) 265 mask |= PTRACE_VFORK; 266 267 if (data & LINUX_PTRACE_O_TRACEEXEC) 268 mask |= PTRACE_EXEC; 269 270 if (data & LINUX_PTRACE_O_TRACEVFORKDONE) 271 mask |= PTRACE_VFORK; /* XXX: Close enough? */ 272 273 if (data & LINUX_PTRACE_O_TRACEEXIT) { 274 pem->ptrace_flags |= LINUX_PTRACE_O_TRACEEXIT; 275 } else { 276 pem->ptrace_flags &= ~LINUX_PTRACE_O_TRACEEXIT; 277 } 278 279 return (kern_ptrace(td, PT_SET_EVENT_MASK, pid, &mask, sizeof(mask))); 280 } 281 282 static int 283 linux_ptrace_geteventmsg(struct thread *td, pid_t pid, l_ulong data) 284 { 285 286 linux_msg(td, "PTRACE_GETEVENTMSG not implemented; returning EINVAL"); 287 return (EINVAL); 288 } 289 290 static int 291 linux_ptrace_getsiginfo(struct thread *td, pid_t pid, l_ulong data) 292 { 293 struct ptrace_lwpinfo lwpinfo; 294 l_siginfo_t l_siginfo; 295 int error, sig; 296 297 error = kern_ptrace(td, PT_LWPINFO, pid, &lwpinfo, sizeof(lwpinfo)); 298 if (error != 0) { 299 linux_msg(td, "PT_LWPINFO failed with error %d", error); 300 return (error); 301 } 302 303 if ((lwpinfo.pl_flags & PL_FLAG_SI) == 0) { 304 error = EINVAL; 305 linux_msg(td, "no PL_FLAG_SI, returning %d", error); 306 return (error); 307 } 308 309 sig = bsd_to_linux_signal(lwpinfo.pl_siginfo.si_signo); 310 memset(&l_siginfo, 0, sizeof(l_siginfo)); 311 siginfo_to_lsiginfo(&lwpinfo.pl_siginfo, &l_siginfo, sig); 312 error = copyout(&l_siginfo, (void *)data, sizeof(l_siginfo)); 313 return (error); 314 } 315 316 static int 317 linux_ptrace_getregs(struct thread *td, pid_t pid, void *data) 318 { 319 struct reg b_reg; 320 struct linux_pt_regset l_regset; 321 int error; 322 323 error = kern_ptrace(td, PT_GETREGS, pid, &b_reg, 0); 324 if (error != 0) 325 return (error); 326 327 bsd_to_linux_regset(&b_reg, &l_regset); 328 error = linux_ptrace_getregs_machdep(td, pid, &l_regset); 329 if (error != 0) 330 return (error); 331 332 error = copyout(&l_regset, (void *)data, sizeof(l_regset)); 333 return (error); 334 } 335 336 static int 337 linux_ptrace_setregs(struct thread *td, pid_t pid, void *data) 338 { 339 struct reg b_reg; 340 struct linux_pt_regset l_regset; 341 int error; 342 343 error = copyin(data, &l_regset, sizeof(l_regset)); 344 if (error != 0) 345 return (error); 346 linux_to_bsd_regset(&b_reg, &l_regset); 347 error = kern_ptrace(td, PT_SETREGS, pid, &b_reg, 0); 348 return (error); 349 } 350 351 static int 352 linux_ptrace_getregset_prstatus(struct thread *td, pid_t pid, l_ulong data) 353 { 354 struct reg b_reg; 355 struct linux_pt_regset l_regset; 356 struct iovec iov; 357 size_t len; 358 int error; 359 360 error = copyin((const void *)data, &iov, sizeof(iov)); 361 if (error != 0) { 362 linux_msg(td, "copyin error %d", error); 363 return (error); 364 } 365 366 error = kern_ptrace(td, PT_GETREGS, pid, &b_reg, 0); 367 if (error != 0) 368 return (error); 369 370 bsd_to_linux_regset(&b_reg, &l_regset); 371 error = linux_ptrace_getregs_machdep(td, pid, &l_regset); 372 if (error != 0) 373 return (error); 374 375 len = MIN(iov.iov_len, sizeof(l_regset)); 376 error = copyout(&l_regset, (void *)iov.iov_base, len); 377 if (error != 0) { 378 linux_msg(td, "copyout error %d", error); 379 return (error); 380 } 381 382 iov.iov_len = len; 383 error = copyout(&iov, (void *)data, sizeof(iov)); 384 if (error != 0) { 385 linux_msg(td, "iov copyout error %d", error); 386 return (error); 387 } 388 389 return (error); 390 } 391 392 static int 393 linux_ptrace_getregset(struct thread *td, pid_t pid, l_ulong addr, l_ulong data) 394 { 395 396 switch (addr) { 397 case LINUX_NT_PRSTATUS: 398 return (linux_ptrace_getregset_prstatus(td, pid, data)); 399 case LINUX_NT_PRFPREG: 400 linux_msg(td, "PTRAGE_GETREGSET NT_PRFPREG not implemented; " 401 "returning EINVAL"); 402 return (EINVAL); 403 case LINUX_NT_X86_XSTATE: 404 linux_msg(td, "PTRAGE_GETREGSET NT_X86_XSTATE not implemented; " 405 "returning EINVAL"); 406 return (EINVAL); 407 default: 408 linux_msg(td, "PTRACE_GETREGSET request %#lx not implemented; " 409 "returning EINVAL", addr); 410 return (EINVAL); 411 } 412 } 413 414 static int 415 linux_ptrace_seize(struct thread *td, pid_t pid, l_ulong addr, l_ulong data) 416 { 417 418 linux_msg(td, "PTRACE_SEIZE not implemented; returning EINVAL"); 419 return (EINVAL); 420 } 421 422 static int 423 linux_ptrace_get_syscall_info(struct thread *td, pid_t pid, 424 l_ulong len, l_ulong data) 425 { 426 struct ptrace_lwpinfo lwpinfo; 427 struct ptrace_sc_ret sr; 428 struct reg b_reg; 429 struct syscall_info si; 430 int error; 431 432 error = kern_ptrace(td, PT_LWPINFO, pid, &lwpinfo, sizeof(lwpinfo)); 433 if (error != 0) { 434 linux_msg(td, "PT_LWPINFO failed with error %d", error); 435 return (error); 436 } 437 438 memset(&si, 0, sizeof(si)); 439 440 if (lwpinfo.pl_flags & PL_FLAG_SCE) { 441 si.op = LINUX_PTRACE_SYSCALL_INFO_ENTRY; 442 si.entry.nr = lwpinfo.pl_syscall_code; 443 /* 444 * The use of PT_GET_SC_ARGS there is special, 445 * implementation of PT_GET_SC_ARGS for Linux-ABI 446 * callers emulates Linux bug which strace(1) depends 447 * on: at initialization it tests whether ptrace works 448 * by calling close(2), or some other single-argument 449 * syscall, _with six arguments_, and then verifies 450 * whether it can fetch them all using this API; 451 * otherwise it bails out. 452 */ 453 error = kern_ptrace(td, PT_GET_SC_ARGS, pid, 454 &si.entry.args, sizeof(si.entry.args)); 455 if (error != 0) { 456 linux_msg(td, "PT_GET_SC_ARGS failed with error %d", 457 error); 458 return (error); 459 } 460 } else if (lwpinfo.pl_flags & PL_FLAG_SCX) { 461 si.op = LINUX_PTRACE_SYSCALL_INFO_EXIT; 462 error = kern_ptrace(td, PT_GET_SC_RET, pid, &sr, sizeof(sr)); 463 464 if (error != 0) { 465 linux_msg(td, "PT_GET_SC_RET failed with error %d", 466 error); 467 return (error); 468 } 469 470 if (sr.sr_error == 0) { 471 si.exit.rval = sr.sr_retval[0]; 472 si.exit.is_error = 0; 473 } else if (sr.sr_error == EJUSTRETURN) { 474 /* 475 * EJUSTRETURN means the actual value to return 476 * has already been put into td_frame; instead 477 * of extracting it and trying to determine whether 478 * it's an error or not just bail out and let 479 * the ptracing process fall back to another method. 480 */ 481 si.op = LINUX_PTRACE_SYSCALL_INFO_NONE; 482 } else if (sr.sr_error == ERESTART) { 483 si.exit.rval = -LINUX_ERESTARTSYS; 484 si.exit.is_error = 1; 485 } else { 486 si.exit.rval = bsd_to_linux_errno(sr.sr_error); 487 si.exit.is_error = 1; 488 } 489 } else { 490 si.op = LINUX_PTRACE_SYSCALL_INFO_NONE; 491 } 492 493 error = kern_ptrace(td, PT_GETREGS, pid, &b_reg, 0); 494 if (error != 0) 495 return (error); 496 497 linux_ptrace_get_syscall_info_machdep(&b_reg, &si); 498 499 len = MIN(len, sizeof(si)); 500 error = copyout(&si, (void *)data, len); 501 if (error == 0) 502 td->td_retval[0] = sizeof(si); 503 504 return (error); 505 } 506 507 int 508 linux_ptrace(struct thread *td, struct linux_ptrace_args *uap) 509 { 510 void *addr; 511 pid_t pid; 512 int error, sig; 513 514 if (!allow_ptrace) 515 return (ENOSYS); 516 517 pid = (pid_t)uap->pid; 518 addr = (void *)uap->addr; 519 520 switch (uap->req) { 521 case LINUX_PTRACE_TRACEME: 522 error = kern_ptrace(td, PT_TRACE_ME, 0, 0, 0); 523 break; 524 case LINUX_PTRACE_PEEKTEXT: 525 case LINUX_PTRACE_PEEKDATA: 526 error = linux_ptrace_peek(td, pid, addr, (void *)uap->data); 527 if (error != 0) 528 goto out; 529 /* 530 * Linux expects this syscall to read 64 bits, not 32. 531 */ 532 error = linux_ptrace_peek(td, pid, 533 (void *)(uap->addr + 4), (void *)(uap->data + 4)); 534 break; 535 case LINUX_PTRACE_PEEKUSER: 536 error = linux_ptrace_peekuser(td, pid, addr, (void *)uap->data); 537 break; 538 case LINUX_PTRACE_POKETEXT: 539 case LINUX_PTRACE_POKEDATA: 540 error = kern_ptrace(td, PT_WRITE_D, pid, addr, uap->data); 541 if (error != 0) 542 goto out; 543 /* 544 * Linux expects this syscall to write 64 bits, not 32. 545 */ 546 error = kern_ptrace(td, PT_WRITE_D, pid, 547 (void *)(uap->addr + 4), uap->data >> 32); 548 break; 549 case LINUX_PTRACE_POKEUSER: 550 error = linux_ptrace_pokeuser(td, pid, addr, (void *)uap->data); 551 break; 552 case LINUX_PTRACE_CONT: 553 error = map_signum(uap->data, &sig); 554 if (error != 0) 555 break; 556 error = kern_ptrace(td, PT_CONTINUE, pid, (void *)1, sig); 557 break; 558 case LINUX_PTRACE_KILL: 559 error = kern_ptrace(td, PT_KILL, pid, addr, uap->data); 560 break; 561 case LINUX_PTRACE_SINGLESTEP: 562 error = map_signum(uap->data, &sig); 563 if (error != 0) 564 break; 565 error = kern_ptrace(td, PT_STEP, pid, (void *)1, sig); 566 break; 567 case LINUX_PTRACE_GETREGS: 568 error = linux_ptrace_getregs(td, pid, (void *)uap->data); 569 break; 570 case LINUX_PTRACE_SETREGS: 571 error = linux_ptrace_setregs(td, pid, (void *)uap->data); 572 break; 573 case LINUX_PTRACE_ATTACH: 574 error = kern_ptrace(td, PT_ATTACH, pid, addr, uap->data); 575 break; 576 case LINUX_PTRACE_DETACH: 577 error = map_signum(uap->data, &sig); 578 if (error != 0) 579 break; 580 error = kern_ptrace(td, PT_DETACH, pid, (void *)1, sig); 581 break; 582 case LINUX_PTRACE_SYSCALL: 583 error = map_signum(uap->data, &sig); 584 if (error != 0) 585 break; 586 error = kern_ptrace(td, PT_SYSCALL, pid, (void *)1, sig); 587 break; 588 case LINUX_PTRACE_SETOPTIONS: 589 error = linux_ptrace_setoptions(td, pid, uap->data); 590 break; 591 case LINUX_PTRACE_GETEVENTMSG: 592 error = linux_ptrace_geteventmsg(td, pid, uap->data); 593 break; 594 case LINUX_PTRACE_GETSIGINFO: 595 error = linux_ptrace_getsiginfo(td, pid, uap->data); 596 break; 597 case LINUX_PTRACE_GETREGSET: 598 error = linux_ptrace_getregset(td, pid, uap->addr, uap->data); 599 break; 600 case LINUX_PTRACE_SEIZE: 601 error = linux_ptrace_seize(td, pid, uap->addr, uap->data); 602 break; 603 case LINUX_PTRACE_GET_SYSCALL_INFO: 604 error = linux_ptrace_get_syscall_info(td, pid, uap->addr, uap->data); 605 break; 606 default: 607 linux_msg(td, "ptrace(%ld, ...) not implemented; " 608 "returning EINVAL", uap->req); 609 error = EINVAL; 610 break; 611 } 612 613 out: 614 if (error == EBUSY) 615 error = ESRCH; 616 617 return (error); 618 } 619