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 }
Cache object: 7de8ecf282cef339918166879f49b48c
|