2 * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
3 * Licensed under the GPL
18 #include "sysdep/ptrace.h"
19 #include "sigcontext.h"
20 #include "sysdep/sigcontext.h"
22 #include "signal_user.h"
23 #include "user_util.h"
26 #include "kern_util.h"
27 #include "chan_user.h"
28 #include "ptrace_user.h"
32 static int tracer_winch[2];
34 int is_tracer_winch(int pid, int fd, void *data)
36 if(pid != tracing_pid)
39 register_winch_irq(tracer_winch[0], fd, -1, data);
43 static void tracer_winch_handler(int sig)
48 n = os_write_file(tracer_winch[1], &c, sizeof(c));
50 printk("tracer_winch_handler - write failed, err = %d\n", -n);
53 /* Called only by the tracing thread during initialization */
55 static void setup_tracer_winch(void)
59 err = os_pipe(tracer_winch, 1, 1);
61 printk("setup_tracer_winch : os_pipe failed, err = %d\n", -err);
64 signal(SIGWINCH, tracer_winch_handler);
67 void attach_process(int pid)
69 if((ptrace(PTRACE_ATTACH, pid, 0, 0) < 0) ||
70 (ptrace(PTRACE_CONT, pid, 0, 0) < 0))
71 tracer_panic("OP_FORK failed to attach pid");
72 wait_for_stop(pid, SIGSTOP, PTRACE_CONT, NULL);
73 if (ptrace(PTRACE_OLDSETOPTIONS, pid, 0, (void *)PTRACE_O_TRACESYSGOOD) < 0)
74 tracer_panic("OP_FORK: PTRACE_SETOPTIONS failed, errno = %d", errno);
75 if(ptrace(PTRACE_CONT, pid, 0, 0) < 0)
76 tracer_panic("OP_FORK failed to continue process");
79 void tracer_panic(char *format, ...)
90 static void tracer_segv(int sig, struct sigcontext sc)
93 GET_FAULTINFO_FROM_SC(fi, &sc);
94 printf("Tracing thread segfault at address 0x%lx, ip 0x%lx\n",
95 FAULT_ADDRESS(fi), SC_IP(&sc));
100 /* Changed early in boot, and then only read */
103 int debug_parent = 0;
106 static int signal_tramp(void *arg)
110 if(honeypot && munmap((void *) (host_task_size - 0x10000000),
112 panic("Unmapping stack failed");
113 if(ptrace(PTRACE_TRACEME, 0, 0, 0) < 0)
114 panic("ptrace PTRACE_TRACEME failed");
115 os_stop_process(os_getpid());
116 change_sig(SIGWINCH, 0);
117 signal(SIGUSR1, SIG_IGN);
118 change_sig(SIGCHLD, 0);
119 signal(SIGSEGV, (__sighandler_t) sig_handler);
120 set_cmdline("(idle thread)");
121 set_init_pid(os_getpid());
123 return((*proc)(NULL));
126 static void sleeping_process_signal(int pid, int sig)
129 /* These two result from UML being ^Z-ed and bg-ed. PTRACE_CONT is
130 * right because the process must be in the kernel already.
134 if(ptrace(PTRACE_CONT, pid, 0, sig) < 0)
135 tracer_panic("sleeping_process_signal : Failed to "
136 "continue pid %d, signal = %d, "
137 "errno = %d\n", pid, sig, errno);
140 /* This happens when the debugger (e.g. strace) is doing system call
141 * tracing on the kernel. During a context switch, the current task
142 * will be set to the incoming process and the outgoing process will
143 * hop into write and then read. Since it's not the current process
144 * any more, the trace of those will land here. So, we need to just
147 case (SIGTRAP + 0x80):
148 if(ptrace(PTRACE_SYSCALL, pid, 0, 0) < 0)
149 tracer_panic("sleeping_process_signal : Failed to "
150 "PTRACE_SYSCALL pid %d, errno = %d\n",
156 tracer_panic("sleeping process %d got unexpected "
157 "signal : %d\n", pid, sig);
162 /* Accessed only by the tracing thread */
163 int debugger_pid = -1;
164 int debugger_parent = -1;
165 int debugger_fd = -1;
173 } signal_record[1024][32];
175 int signal_index[32];
178 extern int io_nsignals, io_count, intr_count;
180 extern void signal_usr1(int sig);
182 int tracing_pid = -1;
184 int tracer(int (*init_proc)(void *), void *sp)
187 int status, pid = 0, sig = 0, cont_type, tracing = 0, op = 0;
188 int proc_id = 0, n, err, old_tracing = 0, strace = 0;
189 int local_using_sysemu = 0;
190 #ifdef UML_CONFIG_SYSCALL_DEBUG
191 unsigned long eip = 0;
194 signal(SIGPIPE, SIG_IGN);
195 setup_tracer_winch();
196 tracing_pid = os_getpid();
197 printf("tracing thread pid = %d\n", tracing_pid);
199 pid = clone(signal_tramp, sp, CLONE_FILES | SIGCHLD, init_proc);
200 CATCH_EINTR(n = waitpid(pid, &status, WUNTRACED));
202 printf("waitpid on idle thread failed, errno = %d\n", errno);
205 if (ptrace(PTRACE_OLDSETOPTIONS, pid, 0, (void *)PTRACE_O_TRACESYSGOOD) < 0) {
206 printf("Failed to PTRACE_SETOPTIONS for idle thread, errno = %d\n", errno);
209 if((ptrace(PTRACE_CONT, pid, 0, 0) < 0)){
210 printf("Failed to continue idle thread, errno = %d\n", errno);
214 signal(SIGSEGV, (sighandler_t) tracer_segv);
215 signal(SIGUSR1, signal_usr1);
217 printf("Tracing thread pausing to be attached\n");
222 debugger_pid = attach_debugger(pid, gdb_pid, 1);
223 else debugger_pid = init_ptrace_proxy(pid, 1, debug_stop);
225 debugger_parent = os_process_parent(debugger_pid);
226 init_parent_proxy(debugger_parent);
227 err = attach(debugger_parent);
229 printf("Failed to attach debugger parent %d, "
230 "errno = %d\n", debugger_parent, -err);
231 debugger_parent = -1;
234 if(ptrace(PTRACE_SYSCALL, debugger_parent,
236 printf("Failed to continue debugger "
237 "parent, errno = %d\n", errno);
238 debugger_parent = -1;
243 set_cmdline("(tracing thread)");
245 CATCH_EINTR(pid = waitpid(-1, &status, WUNTRACED));
248 printf("wait failed - errno = %d\n", errno);
252 if(pid == debugger_pid){
255 if(WIFEXITED(status) || WIFSIGNALED(status))
257 /* XXX Figure out how to deal with gdb and SMP */
258 else cont = debugger_signal(status, cpu_tasks[0].pid);
259 if(cont == PTRACE_SYSCALL) strace = 1;
262 else if(pid == debugger_parent){
263 debugger_parent_signal(status, pid);
267 if(WIFEXITED(status)) ;
270 printf("Child %d exited with status %d\n", pid,
271 WEXITSTATUS(status));
274 else if(WIFSIGNALED(status)){
275 sig = WTERMSIG(status);
277 printf("Child %d exited with signal %d\n", pid,
281 else if(WIFSTOPPED(status)){
282 proc_id = pid_to_processor_id(pid);
283 sig = WSTOPSIG(status);
284 #ifdef UML_CONFIG_SYSCALL_DEBUG
285 if(signal_index[proc_id] == 1024){
286 signal_index[proc_id] = 0;
289 else last_index = signal_index[proc_id] - 1;
290 if(((sig == SIGPROF) || (sig == SIGVTALRM) ||
292 (signal_record[proc_id][last_index].signal == sig)&&
293 (signal_record[proc_id][last_index].pid == pid))
294 signal_index[proc_id] = last_index;
295 signal_record[proc_id][signal_index[proc_id]].pid = pid;
296 gettimeofday(&signal_record[proc_id][signal_index[proc_id]].time, NULL);
297 eip = ptrace(PTRACE_PEEKUSR, pid, PT_IP_OFFSET, 0);
298 signal_record[proc_id][signal_index[proc_id]].addr = eip;
299 signal_record[proc_id][signal_index[proc_id]++].signal = sig;
302 sleeping_process_signal(pid, sig);
306 task = cpu_tasks[proc_id].task;
307 tracing = is_tracing(task);
308 old_tracing = tracing;
310 /* Assume: no syscall, when coming from user */
317 op = do_proc_op(task, proc_id);
320 * This is called when entering user mode; after
321 * this, we start intercepting syscalls.
323 * In fact, a process is started in kernel mode,
324 * so with is_tracing() == 0 (and that is reset
325 * when executing syscalls, since UML kernel has
326 * the right to do syscalls);
329 arch_leave_kernel(task, pid);
336 os_kill_ptraced_process(pid, 0);
337 /* Now let's reap remaining zombies */
342 } while (errno != ECHILD);
343 return(op == OP_REBOOT);
345 printf("Detaching pid %d\n", pid);
346 detach(pid, SIGSTOP);
351 /* OP_EXEC switches host processes on us,
352 * we want to continue the new one.
354 pid = cpu_tasks[proc_id].pid;
356 case (SIGTRAP + 0x80):
357 if(!tracing && (debugger_pid != -1)){
358 child_signal(pid, status & 0x7fff);
362 /* local_using_sysemu has been already set
363 * below, since if we are here, is_tracing() on
364 * the traced task was 1, i.e. the process had
365 * already run through one iteration of the
366 * loop which executed a OP_TRACE_ON request.*/
367 do_syscall(task, pid, local_using_sysemu);
371 if(!tracing && (debugger_pid != -1)){
372 child_signal(pid, status);
397 set_tracing(task, tracing);
399 if(!tracing && old_tracing)
400 arch_enter_kernel(task, pid);
402 if(!tracing && (debugger_pid != -1) && (sig != 0) &&
403 (sig != SIGALRM) && (sig != SIGVTALRM) &&
404 (sig != SIGSEGV) && (sig != SIGTRAP) &&
405 (sig != SIGUSR2) && (sig != SIGIO) &&
407 child_signal(pid, status);
411 local_using_sysemu = get_using_sysemu();
414 cont_type = SELECT_PTRACE_OPERATION(local_using_sysemu,
415 singlestepping(task));
416 else if((debugger_pid != -1) && strace)
417 cont_type = PTRACE_SYSCALL;
419 cont_type = PTRACE_CONT;
421 if(ptrace(cont_type, pid, 0, sig) != 0){
422 tracer_panic("ptrace failed to continue "
423 "process - errno = %d\n",
431 static int __init uml_debug_setup(char *line, int *add)
437 if(*line != '=') return(0);
441 next = strchr(line, ',');
442 if(next) *next++ = '\0';
444 if(!strcmp(line, "go")) debug_stop = 0;
445 else if(!strcmp(line, "parent")) debug_parent = 1;
446 else printf("Unknown debug option : '%s'\n", line);
453 __uml_setup("debug", uml_debug_setup,
455 " Starts up the kernel under the control of gdb. See the \n"
456 " kernel debugging tutorial and the debugging session pages\n"
457 " at http://user-mode-linux.sourceforge.net/ for more information.\n\n"
460 static int __init uml_debugtrace_setup(char *line, int *add)
465 __uml_setup("debugtrace", uml_debugtrace_setup,
467 " Causes the tracing thread to pause until it is attached by a\n"
468 " debugger and continued. This is mostly for debugging crashes\n"
469 " early during boot, and should be pretty much obsoleted by\n"
470 " the debug switch.\n\n"
474 * Overrides for Emacs so that we follow Linus's tabbing style.
475 * Emacs will notice this stuff at the end of the file and automatically
476 * adjust the settings for this buffer only. This must remain at the end
478 * ---------------------------------------------------------------------------
480 * c-file-style: "linux"