1*b725ae77Skettenis /* Low level interface to ptrace, for the remote server for GDB. 2*b725ae77Skettenis Copyright 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004 3*b725ae77Skettenis Free Software Foundation, Inc. 4*b725ae77Skettenis 5*b725ae77Skettenis This file is part of GDB. 6*b725ae77Skettenis 7*b725ae77Skettenis This program is free software; you can redistribute it and/or modify 8*b725ae77Skettenis it under the terms of the GNU General Public License as published by 9*b725ae77Skettenis the Free Software Foundation; either version 2 of the License, or 10*b725ae77Skettenis (at your option) any later version. 11*b725ae77Skettenis 12*b725ae77Skettenis This program is distributed in the hope that it will be useful, 13*b725ae77Skettenis but WITHOUT ANY WARRANTY; without even the implied warranty of 14*b725ae77Skettenis MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15*b725ae77Skettenis GNU General Public License for more details. 16*b725ae77Skettenis 17*b725ae77Skettenis You should have received a copy of the GNU General Public License 18*b725ae77Skettenis along with this program; if not, write to the Free Software 19*b725ae77Skettenis Foundation, Inc., 59 Temple Place - Suite 330, 20*b725ae77Skettenis Boston, MA 02111-1307, USA. */ 21*b725ae77Skettenis 22*b725ae77Skettenis #include "server.h" 23*b725ae77Skettenis #include "linux-low.h" 24*b725ae77Skettenis 25*b725ae77Skettenis #include <sys/wait.h> 26*b725ae77Skettenis #include <stdio.h> 27*b725ae77Skettenis #include <sys/param.h> 28*b725ae77Skettenis #include <sys/dir.h> 29*b725ae77Skettenis #include <sys/ptrace.h> 30*b725ae77Skettenis #include <sys/user.h> 31*b725ae77Skettenis #include <signal.h> 32*b725ae77Skettenis #include <sys/ioctl.h> 33*b725ae77Skettenis #include <fcntl.h> 34*b725ae77Skettenis #include <string.h> 35*b725ae77Skettenis #include <stdlib.h> 36*b725ae77Skettenis #include <unistd.h> 37*b725ae77Skettenis #include <errno.h> 38*b725ae77Skettenis 39*b725ae77Skettenis /* ``all_threads'' is keyed by the LWP ID - it should be the thread ID instead, 40*b725ae77Skettenis however. This requires changing the ID in place when we go from !using_threads 41*b725ae77Skettenis to using_threads, immediately. 42*b725ae77Skettenis 43*b725ae77Skettenis ``all_processes'' is keyed by the process ID - which on Linux is (presently) 44*b725ae77Skettenis the same as the LWP ID. */ 45*b725ae77Skettenis 46*b725ae77Skettenis struct inferior_list all_processes; 47*b725ae77Skettenis 48*b725ae77Skettenis /* FIXME this is a bit of a hack, and could be removed. */ 49*b725ae77Skettenis int stopping_threads; 50*b725ae77Skettenis 51*b725ae77Skettenis /* FIXME make into a target method? */ 52*b725ae77Skettenis int using_threads; 53*b725ae77Skettenis 54*b725ae77Skettenis static void linux_resume_one_process (struct inferior_list_entry *entry, 55*b725ae77Skettenis int step, int signal); 56*b725ae77Skettenis static void linux_resume (struct thread_resume *resume_info); 57*b725ae77Skettenis static void stop_all_processes (void); 58*b725ae77Skettenis static int linux_wait_for_event (struct thread_info *child); 59*b725ae77Skettenis 60*b725ae77Skettenis struct pending_signals 61*b725ae77Skettenis { 62*b725ae77Skettenis int signal; 63*b725ae77Skettenis struct pending_signals *prev; 64*b725ae77Skettenis }; 65*b725ae77Skettenis 66*b725ae77Skettenis #define PTRACE_ARG3_TYPE long 67*b725ae77Skettenis #define PTRACE_XFER_TYPE long 68*b725ae77Skettenis 69*b725ae77Skettenis #ifdef HAVE_LINUX_REGSETS 70*b725ae77Skettenis static int use_regsets_p = 1; 71*b725ae77Skettenis #endif 72*b725ae77Skettenis 73*b725ae77Skettenis int debug_threads = 0; 74*b725ae77Skettenis 75*b725ae77Skettenis #define pid_of(proc) ((proc)->head.id) 76*b725ae77Skettenis 77*b725ae77Skettenis /* FIXME: Delete eventually. */ 78*b725ae77Skettenis #define inferior_pid (pid_of (get_thread_process (current_inferior))) 79*b725ae77Skettenis 80*b725ae77Skettenis /* This function should only be called if the process got a SIGTRAP. 81*b725ae77Skettenis The SIGTRAP could mean several things. 82*b725ae77Skettenis 83*b725ae77Skettenis On i386, where decr_pc_after_break is non-zero: 84*b725ae77Skettenis If we were single-stepping this process using PTRACE_SINGLESTEP, 85*b725ae77Skettenis we will get only the one SIGTRAP (even if the instruction we 86*b725ae77Skettenis stepped over was a breakpoint). The value of $eip will be the 87*b725ae77Skettenis next instruction. 88*b725ae77Skettenis If we continue the process using PTRACE_CONT, we will get a 89*b725ae77Skettenis SIGTRAP when we hit a breakpoint. The value of $eip will be 90*b725ae77Skettenis the instruction after the breakpoint (i.e. needs to be 91*b725ae77Skettenis decremented). If we report the SIGTRAP to GDB, we must also 92*b725ae77Skettenis report the undecremented PC. If we cancel the SIGTRAP, we 93*b725ae77Skettenis must resume at the decremented PC. 94*b725ae77Skettenis 95*b725ae77Skettenis (Presumably, not yet tested) On a non-decr_pc_after_break machine 96*b725ae77Skettenis with hardware or kernel single-step: 97*b725ae77Skettenis If we single-step over a breakpoint instruction, our PC will 98*b725ae77Skettenis point at the following instruction. If we continue and hit a 99*b725ae77Skettenis breakpoint instruction, our PC will point at the breakpoint 100*b725ae77Skettenis instruction. */ 101*b725ae77Skettenis 102*b725ae77Skettenis static CORE_ADDR 103*b725ae77Skettenis get_stop_pc (void) 104*b725ae77Skettenis { 105*b725ae77Skettenis CORE_ADDR stop_pc = (*the_low_target.get_pc) (); 106*b725ae77Skettenis 107*b725ae77Skettenis if (get_thread_process (current_inferior)->stepping) 108*b725ae77Skettenis return stop_pc; 109*b725ae77Skettenis else 110*b725ae77Skettenis return stop_pc - the_low_target.decr_pc_after_break; 111*b725ae77Skettenis } 112*b725ae77Skettenis 113*b725ae77Skettenis static void * 114*b725ae77Skettenis add_process (int pid) 115*b725ae77Skettenis { 116*b725ae77Skettenis struct process_info *process; 117*b725ae77Skettenis 118*b725ae77Skettenis process = (struct process_info *) malloc (sizeof (*process)); 119*b725ae77Skettenis memset (process, 0, sizeof (*process)); 120*b725ae77Skettenis 121*b725ae77Skettenis process->head.id = pid; 122*b725ae77Skettenis 123*b725ae77Skettenis /* Default to tid == lwpid == pid. */ 124*b725ae77Skettenis process->tid = pid; 125*b725ae77Skettenis process->lwpid = pid; 126*b725ae77Skettenis 127*b725ae77Skettenis add_inferior_to_list (&all_processes, &process->head); 128*b725ae77Skettenis 129*b725ae77Skettenis return process; 130*b725ae77Skettenis } 131*b725ae77Skettenis 132*b725ae77Skettenis /* Start an inferior process and returns its pid. 133*b725ae77Skettenis ALLARGS is a vector of program-name and args. */ 134*b725ae77Skettenis 135*b725ae77Skettenis static int 136*b725ae77Skettenis linux_create_inferior (char *program, char **allargs) 137*b725ae77Skettenis { 138*b725ae77Skettenis void *new_process; 139*b725ae77Skettenis int pid; 140*b725ae77Skettenis 141*b725ae77Skettenis pid = fork (); 142*b725ae77Skettenis if (pid < 0) 143*b725ae77Skettenis perror_with_name ("fork"); 144*b725ae77Skettenis 145*b725ae77Skettenis if (pid == 0) 146*b725ae77Skettenis { 147*b725ae77Skettenis ptrace (PTRACE_TRACEME, 0, 0, 0); 148*b725ae77Skettenis 149*b725ae77Skettenis signal (__SIGRTMIN + 1, SIG_DFL); 150*b725ae77Skettenis 151*b725ae77Skettenis setpgid (0, 0); 152*b725ae77Skettenis 153*b725ae77Skettenis execv (program, allargs); 154*b725ae77Skettenis 155*b725ae77Skettenis fprintf (stderr, "Cannot exec %s: %s.\n", program, 156*b725ae77Skettenis strerror (errno)); 157*b725ae77Skettenis fflush (stderr); 158*b725ae77Skettenis _exit (0177); 159*b725ae77Skettenis } 160*b725ae77Skettenis 161*b725ae77Skettenis new_process = add_process (pid); 162*b725ae77Skettenis add_thread (pid, new_process); 163*b725ae77Skettenis 164*b725ae77Skettenis return pid; 165*b725ae77Skettenis } 166*b725ae77Skettenis 167*b725ae77Skettenis /* Attach to an inferior process. */ 168*b725ae77Skettenis 169*b725ae77Skettenis void 170*b725ae77Skettenis linux_attach_lwp (int pid, int tid) 171*b725ae77Skettenis { 172*b725ae77Skettenis struct process_info *new_process; 173*b725ae77Skettenis 174*b725ae77Skettenis if (ptrace (PTRACE_ATTACH, pid, 0, 0) != 0) 175*b725ae77Skettenis { 176*b725ae77Skettenis fprintf (stderr, "Cannot attach to process %d: %s (%d)\n", pid, 177*b725ae77Skettenis strerror (errno), errno); 178*b725ae77Skettenis fflush (stderr); 179*b725ae77Skettenis 180*b725ae77Skettenis /* If we fail to attach to an LWP, just return. */ 181*b725ae77Skettenis if (!using_threads) 182*b725ae77Skettenis _exit (0177); 183*b725ae77Skettenis return; 184*b725ae77Skettenis } 185*b725ae77Skettenis 186*b725ae77Skettenis new_process = (struct process_info *) add_process (pid); 187*b725ae77Skettenis add_thread (tid, new_process); 188*b725ae77Skettenis 189*b725ae77Skettenis /* The next time we wait for this LWP we'll see a SIGSTOP as PTRACE_ATTACH 190*b725ae77Skettenis brings it to a halt. We should ignore that SIGSTOP and resume the process 191*b725ae77Skettenis (unless this is the first process, in which case the flag will be cleared 192*b725ae77Skettenis in linux_attach). 193*b725ae77Skettenis 194*b725ae77Skettenis On the other hand, if we are currently trying to stop all threads, we 195*b725ae77Skettenis should treat the new thread as if we had sent it a SIGSTOP. This works 196*b725ae77Skettenis because we are guaranteed that add_process added us to the end of the 197*b725ae77Skettenis list, and so the new thread has not yet reached wait_for_sigstop (but 198*b725ae77Skettenis will). */ 199*b725ae77Skettenis if (! stopping_threads) 200*b725ae77Skettenis new_process->stop_expected = 1; 201*b725ae77Skettenis } 202*b725ae77Skettenis 203*b725ae77Skettenis int 204*b725ae77Skettenis linux_attach (int pid) 205*b725ae77Skettenis { 206*b725ae77Skettenis struct process_info *process; 207*b725ae77Skettenis 208*b725ae77Skettenis linux_attach_lwp (pid, pid); 209*b725ae77Skettenis 210*b725ae77Skettenis /* Don't ignore the initial SIGSTOP if we just attached to this process. */ 211*b725ae77Skettenis process = (struct process_info *) find_inferior_id (&all_processes, pid); 212*b725ae77Skettenis process->stop_expected = 0; 213*b725ae77Skettenis 214*b725ae77Skettenis return 0; 215*b725ae77Skettenis } 216*b725ae77Skettenis 217*b725ae77Skettenis /* Kill the inferior process. Make us have no inferior. */ 218*b725ae77Skettenis 219*b725ae77Skettenis static void 220*b725ae77Skettenis linux_kill_one_process (struct inferior_list_entry *entry) 221*b725ae77Skettenis { 222*b725ae77Skettenis struct thread_info *thread = (struct thread_info *) entry; 223*b725ae77Skettenis struct process_info *process = get_thread_process (thread); 224*b725ae77Skettenis int wstat; 225*b725ae77Skettenis 226*b725ae77Skettenis do 227*b725ae77Skettenis { 228*b725ae77Skettenis ptrace (PTRACE_KILL, pid_of (process), 0, 0); 229*b725ae77Skettenis 230*b725ae77Skettenis /* Make sure it died. The loop is most likely unnecessary. */ 231*b725ae77Skettenis wstat = linux_wait_for_event (thread); 232*b725ae77Skettenis } while (WIFSTOPPED (wstat)); 233*b725ae77Skettenis } 234*b725ae77Skettenis 235*b725ae77Skettenis static void 236*b725ae77Skettenis linux_kill (void) 237*b725ae77Skettenis { 238*b725ae77Skettenis for_each_inferior (&all_threads, linux_kill_one_process); 239*b725ae77Skettenis } 240*b725ae77Skettenis 241*b725ae77Skettenis static void 242*b725ae77Skettenis linux_detach_one_process (struct inferior_list_entry *entry) 243*b725ae77Skettenis { 244*b725ae77Skettenis struct thread_info *thread = (struct thread_info *) entry; 245*b725ae77Skettenis struct process_info *process = get_thread_process (thread); 246*b725ae77Skettenis 247*b725ae77Skettenis ptrace (PTRACE_DETACH, pid_of (process), 0, 0); 248*b725ae77Skettenis } 249*b725ae77Skettenis 250*b725ae77Skettenis static void 251*b725ae77Skettenis linux_detach (void) 252*b725ae77Skettenis { 253*b725ae77Skettenis for_each_inferior (&all_threads, linux_detach_one_process); 254*b725ae77Skettenis } 255*b725ae77Skettenis 256*b725ae77Skettenis /* Return nonzero if the given thread is still alive. */ 257*b725ae77Skettenis static int 258*b725ae77Skettenis linux_thread_alive (int tid) 259*b725ae77Skettenis { 260*b725ae77Skettenis if (find_inferior_id (&all_threads, tid) != NULL) 261*b725ae77Skettenis return 1; 262*b725ae77Skettenis else 263*b725ae77Skettenis return 0; 264*b725ae77Skettenis } 265*b725ae77Skettenis 266*b725ae77Skettenis /* Return nonzero if this process stopped at a breakpoint which 267*b725ae77Skettenis no longer appears to be inserted. Also adjust the PC 268*b725ae77Skettenis appropriately to resume where the breakpoint used to be. */ 269*b725ae77Skettenis static int 270*b725ae77Skettenis check_removed_breakpoint (struct process_info *event_child) 271*b725ae77Skettenis { 272*b725ae77Skettenis CORE_ADDR stop_pc; 273*b725ae77Skettenis struct thread_info *saved_inferior; 274*b725ae77Skettenis 275*b725ae77Skettenis if (event_child->pending_is_breakpoint == 0) 276*b725ae77Skettenis return 0; 277*b725ae77Skettenis 278*b725ae77Skettenis if (debug_threads) 279*b725ae77Skettenis fprintf (stderr, "Checking for breakpoint.\n"); 280*b725ae77Skettenis 281*b725ae77Skettenis saved_inferior = current_inferior; 282*b725ae77Skettenis current_inferior = get_process_thread (event_child); 283*b725ae77Skettenis 284*b725ae77Skettenis stop_pc = get_stop_pc (); 285*b725ae77Skettenis 286*b725ae77Skettenis /* If the PC has changed since we stopped, then we shouldn't do 287*b725ae77Skettenis anything. This happens if, for instance, GDB handled the 288*b725ae77Skettenis decr_pc_after_break subtraction itself. */ 289*b725ae77Skettenis if (stop_pc != event_child->pending_stop_pc) 290*b725ae77Skettenis { 291*b725ae77Skettenis if (debug_threads) 292*b725ae77Skettenis fprintf (stderr, "Ignoring, PC was changed.\n"); 293*b725ae77Skettenis 294*b725ae77Skettenis event_child->pending_is_breakpoint = 0; 295*b725ae77Skettenis current_inferior = saved_inferior; 296*b725ae77Skettenis return 0; 297*b725ae77Skettenis } 298*b725ae77Skettenis 299*b725ae77Skettenis /* If the breakpoint is still there, we will report hitting it. */ 300*b725ae77Skettenis if ((*the_low_target.breakpoint_at) (stop_pc)) 301*b725ae77Skettenis { 302*b725ae77Skettenis if (debug_threads) 303*b725ae77Skettenis fprintf (stderr, "Ignoring, breakpoint is still present.\n"); 304*b725ae77Skettenis current_inferior = saved_inferior; 305*b725ae77Skettenis return 0; 306*b725ae77Skettenis } 307*b725ae77Skettenis 308*b725ae77Skettenis if (debug_threads) 309*b725ae77Skettenis fprintf (stderr, "Removed breakpoint.\n"); 310*b725ae77Skettenis 311*b725ae77Skettenis /* For decr_pc_after_break targets, here is where we perform the 312*b725ae77Skettenis decrement. We go immediately from this function to resuming, 313*b725ae77Skettenis and can not safely call get_stop_pc () again. */ 314*b725ae77Skettenis if (the_low_target.set_pc != NULL) 315*b725ae77Skettenis (*the_low_target.set_pc) (stop_pc); 316*b725ae77Skettenis 317*b725ae77Skettenis /* We consumed the pending SIGTRAP. */ 318*b725ae77Skettenis event_child->pending_is_breakpoint = 0; 319*b725ae77Skettenis event_child->status_pending_p = 0; 320*b725ae77Skettenis event_child->status_pending = 0; 321*b725ae77Skettenis 322*b725ae77Skettenis current_inferior = saved_inferior; 323*b725ae77Skettenis return 1; 324*b725ae77Skettenis } 325*b725ae77Skettenis 326*b725ae77Skettenis /* Return 1 if this process has an interesting status pending. This function 327*b725ae77Skettenis may silently resume an inferior process. */ 328*b725ae77Skettenis static int 329*b725ae77Skettenis status_pending_p (struct inferior_list_entry *entry, void *dummy) 330*b725ae77Skettenis { 331*b725ae77Skettenis struct process_info *process = (struct process_info *) entry; 332*b725ae77Skettenis 333*b725ae77Skettenis if (process->status_pending_p) 334*b725ae77Skettenis if (check_removed_breakpoint (process)) 335*b725ae77Skettenis { 336*b725ae77Skettenis /* This thread was stopped at a breakpoint, and the breakpoint 337*b725ae77Skettenis is now gone. We were told to continue (or step...) all threads, 338*b725ae77Skettenis so GDB isn't trying to single-step past this breakpoint. 339*b725ae77Skettenis So instead of reporting the old SIGTRAP, pretend we got to 340*b725ae77Skettenis the breakpoint just after it was removed instead of just 341*b725ae77Skettenis before; resume the process. */ 342*b725ae77Skettenis linux_resume_one_process (&process->head, 0, 0); 343*b725ae77Skettenis return 0; 344*b725ae77Skettenis } 345*b725ae77Skettenis 346*b725ae77Skettenis return process->status_pending_p; 347*b725ae77Skettenis } 348*b725ae77Skettenis 349*b725ae77Skettenis static void 350*b725ae77Skettenis linux_wait_for_process (struct process_info **childp, int *wstatp) 351*b725ae77Skettenis { 352*b725ae77Skettenis int ret; 353*b725ae77Skettenis int to_wait_for = -1; 354*b725ae77Skettenis 355*b725ae77Skettenis if (*childp != NULL) 356*b725ae77Skettenis to_wait_for = (*childp)->lwpid; 357*b725ae77Skettenis 358*b725ae77Skettenis while (1) 359*b725ae77Skettenis { 360*b725ae77Skettenis ret = waitpid (to_wait_for, wstatp, WNOHANG); 361*b725ae77Skettenis 362*b725ae77Skettenis if (ret == -1) 363*b725ae77Skettenis { 364*b725ae77Skettenis if (errno != ECHILD) 365*b725ae77Skettenis perror_with_name ("waitpid"); 366*b725ae77Skettenis } 367*b725ae77Skettenis else if (ret > 0) 368*b725ae77Skettenis break; 369*b725ae77Skettenis 370*b725ae77Skettenis ret = waitpid (to_wait_for, wstatp, WNOHANG | __WCLONE); 371*b725ae77Skettenis 372*b725ae77Skettenis if (ret == -1) 373*b725ae77Skettenis { 374*b725ae77Skettenis if (errno != ECHILD) 375*b725ae77Skettenis perror_with_name ("waitpid (WCLONE)"); 376*b725ae77Skettenis } 377*b725ae77Skettenis else if (ret > 0) 378*b725ae77Skettenis break; 379*b725ae77Skettenis 380*b725ae77Skettenis usleep (1000); 381*b725ae77Skettenis } 382*b725ae77Skettenis 383*b725ae77Skettenis if (debug_threads 384*b725ae77Skettenis && (!WIFSTOPPED (*wstatp) 385*b725ae77Skettenis || (WSTOPSIG (*wstatp) != 32 386*b725ae77Skettenis && WSTOPSIG (*wstatp) != 33))) 387*b725ae77Skettenis fprintf (stderr, "Got an event from %d (%x)\n", ret, *wstatp); 388*b725ae77Skettenis 389*b725ae77Skettenis if (to_wait_for == -1) 390*b725ae77Skettenis *childp = (struct process_info *) find_inferior_id (&all_processes, ret); 391*b725ae77Skettenis 392*b725ae77Skettenis (*childp)->stopped = 1; 393*b725ae77Skettenis (*childp)->pending_is_breakpoint = 0; 394*b725ae77Skettenis 395*b725ae77Skettenis if (debug_threads 396*b725ae77Skettenis && WIFSTOPPED (*wstatp)) 397*b725ae77Skettenis { 398*b725ae77Skettenis current_inferior = (struct thread_info *) 399*b725ae77Skettenis find_inferior_id (&all_threads, (*childp)->tid); 400*b725ae77Skettenis /* For testing only; i386_stop_pc prints out a diagnostic. */ 401*b725ae77Skettenis if (the_low_target.get_pc != NULL) 402*b725ae77Skettenis get_stop_pc (); 403*b725ae77Skettenis } 404*b725ae77Skettenis } 405*b725ae77Skettenis 406*b725ae77Skettenis static int 407*b725ae77Skettenis linux_wait_for_event (struct thread_info *child) 408*b725ae77Skettenis { 409*b725ae77Skettenis CORE_ADDR stop_pc; 410*b725ae77Skettenis struct process_info *event_child; 411*b725ae77Skettenis int wstat; 412*b725ae77Skettenis 413*b725ae77Skettenis /* Check for a process with a pending status. */ 414*b725ae77Skettenis /* It is possible that the user changed the pending task's registers since 415*b725ae77Skettenis it stopped. We correctly handle the change of PC if we hit a breakpoint 416*b725ae77Skettenis (in check_removed_breakpoint); signals should be reported anyway. */ 417*b725ae77Skettenis if (child == NULL) 418*b725ae77Skettenis { 419*b725ae77Skettenis event_child = (struct process_info *) 420*b725ae77Skettenis find_inferior (&all_processes, status_pending_p, NULL); 421*b725ae77Skettenis if (debug_threads && event_child) 422*b725ae77Skettenis fprintf (stderr, "Got a pending child %d\n", event_child->lwpid); 423*b725ae77Skettenis } 424*b725ae77Skettenis else 425*b725ae77Skettenis { 426*b725ae77Skettenis event_child = get_thread_process (child); 427*b725ae77Skettenis if (event_child->status_pending_p 428*b725ae77Skettenis && check_removed_breakpoint (event_child)) 429*b725ae77Skettenis event_child = NULL; 430*b725ae77Skettenis } 431*b725ae77Skettenis 432*b725ae77Skettenis if (event_child != NULL) 433*b725ae77Skettenis { 434*b725ae77Skettenis if (event_child->status_pending_p) 435*b725ae77Skettenis { 436*b725ae77Skettenis if (debug_threads) 437*b725ae77Skettenis fprintf (stderr, "Got an event from pending child %d (%04x)\n", 438*b725ae77Skettenis event_child->lwpid, event_child->status_pending); 439*b725ae77Skettenis wstat = event_child->status_pending; 440*b725ae77Skettenis event_child->status_pending_p = 0; 441*b725ae77Skettenis event_child->status_pending = 0; 442*b725ae77Skettenis current_inferior = get_process_thread (event_child); 443*b725ae77Skettenis return wstat; 444*b725ae77Skettenis } 445*b725ae77Skettenis } 446*b725ae77Skettenis 447*b725ae77Skettenis /* We only enter this loop if no process has a pending wait status. Thus 448*b725ae77Skettenis any action taken in response to a wait status inside this loop is 449*b725ae77Skettenis responding as soon as we detect the status, not after any pending 450*b725ae77Skettenis events. */ 451*b725ae77Skettenis while (1) 452*b725ae77Skettenis { 453*b725ae77Skettenis if (child == NULL) 454*b725ae77Skettenis event_child = NULL; 455*b725ae77Skettenis else 456*b725ae77Skettenis event_child = get_thread_process (child); 457*b725ae77Skettenis 458*b725ae77Skettenis linux_wait_for_process (&event_child, &wstat); 459*b725ae77Skettenis 460*b725ae77Skettenis if (event_child == NULL) 461*b725ae77Skettenis error ("event from unknown child"); 462*b725ae77Skettenis 463*b725ae77Skettenis current_inferior = (struct thread_info *) 464*b725ae77Skettenis find_inferior_id (&all_threads, event_child->tid); 465*b725ae77Skettenis 466*b725ae77Skettenis if (using_threads) 467*b725ae77Skettenis { 468*b725ae77Skettenis /* Check for thread exit. */ 469*b725ae77Skettenis if (! WIFSTOPPED (wstat)) 470*b725ae77Skettenis { 471*b725ae77Skettenis if (debug_threads) 472*b725ae77Skettenis fprintf (stderr, "Thread %d (LWP %d) exiting\n", 473*b725ae77Skettenis event_child->tid, event_child->head.id); 474*b725ae77Skettenis 475*b725ae77Skettenis /* If the last thread is exiting, just return. */ 476*b725ae77Skettenis if (all_threads.head == all_threads.tail) 477*b725ae77Skettenis return wstat; 478*b725ae77Skettenis 479*b725ae77Skettenis dead_thread_notify (event_child->tid); 480*b725ae77Skettenis 481*b725ae77Skettenis remove_inferior (&all_processes, &event_child->head); 482*b725ae77Skettenis free (event_child); 483*b725ae77Skettenis remove_thread (current_inferior); 484*b725ae77Skettenis current_inferior = (struct thread_info *) all_threads.head; 485*b725ae77Skettenis 486*b725ae77Skettenis /* If we were waiting for this particular child to do something... 487*b725ae77Skettenis well, it did something. */ 488*b725ae77Skettenis if (child != NULL) 489*b725ae77Skettenis return wstat; 490*b725ae77Skettenis 491*b725ae77Skettenis /* Wait for a more interesting event. */ 492*b725ae77Skettenis continue; 493*b725ae77Skettenis } 494*b725ae77Skettenis 495*b725ae77Skettenis if (WIFSTOPPED (wstat) 496*b725ae77Skettenis && WSTOPSIG (wstat) == SIGSTOP 497*b725ae77Skettenis && event_child->stop_expected) 498*b725ae77Skettenis { 499*b725ae77Skettenis if (debug_threads) 500*b725ae77Skettenis fprintf (stderr, "Expected stop.\n"); 501*b725ae77Skettenis event_child->stop_expected = 0; 502*b725ae77Skettenis linux_resume_one_process (&event_child->head, 503*b725ae77Skettenis event_child->stepping, 0); 504*b725ae77Skettenis continue; 505*b725ae77Skettenis } 506*b725ae77Skettenis 507*b725ae77Skettenis /* FIXME drow/2002-06-09: Get signal numbers from the inferior's 508*b725ae77Skettenis thread library? */ 509*b725ae77Skettenis if (WIFSTOPPED (wstat) 510*b725ae77Skettenis && (WSTOPSIG (wstat) == __SIGRTMIN 511*b725ae77Skettenis || WSTOPSIG (wstat) == __SIGRTMIN + 1)) 512*b725ae77Skettenis { 513*b725ae77Skettenis if (debug_threads) 514*b725ae77Skettenis fprintf (stderr, "Ignored signal %d for %d (LWP %d).\n", 515*b725ae77Skettenis WSTOPSIG (wstat), event_child->tid, 516*b725ae77Skettenis event_child->head.id); 517*b725ae77Skettenis linux_resume_one_process (&event_child->head, 518*b725ae77Skettenis event_child->stepping, 519*b725ae77Skettenis WSTOPSIG (wstat)); 520*b725ae77Skettenis continue; 521*b725ae77Skettenis } 522*b725ae77Skettenis } 523*b725ae77Skettenis 524*b725ae77Skettenis /* If this event was not handled above, and is not a SIGTRAP, report 525*b725ae77Skettenis it. */ 526*b725ae77Skettenis if (!WIFSTOPPED (wstat) || WSTOPSIG (wstat) != SIGTRAP) 527*b725ae77Skettenis return wstat; 528*b725ae77Skettenis 529*b725ae77Skettenis /* If this target does not support breakpoints, we simply report the 530*b725ae77Skettenis SIGTRAP; it's of no concern to us. */ 531*b725ae77Skettenis if (the_low_target.get_pc == NULL) 532*b725ae77Skettenis return wstat; 533*b725ae77Skettenis 534*b725ae77Skettenis stop_pc = get_stop_pc (); 535*b725ae77Skettenis 536*b725ae77Skettenis /* bp_reinsert will only be set if we were single-stepping. 537*b725ae77Skettenis Notice that we will resume the process after hitting 538*b725ae77Skettenis a gdbserver breakpoint; single-stepping to/over one 539*b725ae77Skettenis is not supported (yet). */ 540*b725ae77Skettenis if (event_child->bp_reinsert != 0) 541*b725ae77Skettenis { 542*b725ae77Skettenis if (debug_threads) 543*b725ae77Skettenis fprintf (stderr, "Reinserted breakpoint.\n"); 544*b725ae77Skettenis reinsert_breakpoint (event_child->bp_reinsert); 545*b725ae77Skettenis event_child->bp_reinsert = 0; 546*b725ae77Skettenis 547*b725ae77Skettenis /* Clear the single-stepping flag and SIGTRAP as we resume. */ 548*b725ae77Skettenis linux_resume_one_process (&event_child->head, 0, 0); 549*b725ae77Skettenis continue; 550*b725ae77Skettenis } 551*b725ae77Skettenis 552*b725ae77Skettenis if (debug_threads) 553*b725ae77Skettenis fprintf (stderr, "Hit a (non-reinsert) breakpoint.\n"); 554*b725ae77Skettenis 555*b725ae77Skettenis if (check_breakpoints (stop_pc) != 0) 556*b725ae77Skettenis { 557*b725ae77Skettenis /* We hit one of our own breakpoints. We mark it as a pending 558*b725ae77Skettenis breakpoint, so that check_removed_breakpoint () will do the PC 559*b725ae77Skettenis adjustment for us at the appropriate time. */ 560*b725ae77Skettenis event_child->pending_is_breakpoint = 1; 561*b725ae77Skettenis event_child->pending_stop_pc = stop_pc; 562*b725ae77Skettenis 563*b725ae77Skettenis /* Now we need to put the breakpoint back. We continue in the event 564*b725ae77Skettenis loop instead of simply replacing the breakpoint right away, 565*b725ae77Skettenis in order to not lose signals sent to the thread that hit the 566*b725ae77Skettenis breakpoint. Unfortunately this increases the window where another 567*b725ae77Skettenis thread could sneak past the removed breakpoint. For the current 568*b725ae77Skettenis use of server-side breakpoints (thread creation) this is 569*b725ae77Skettenis acceptable; but it needs to be considered before this breakpoint 570*b725ae77Skettenis mechanism can be used in more general ways. For some breakpoints 571*b725ae77Skettenis it may be necessary to stop all other threads, but that should 572*b725ae77Skettenis be avoided where possible. 573*b725ae77Skettenis 574*b725ae77Skettenis If breakpoint_reinsert_addr is NULL, that means that we can 575*b725ae77Skettenis use PTRACE_SINGLESTEP on this platform. Uninsert the breakpoint, 576*b725ae77Skettenis mark it for reinsertion, and single-step. 577*b725ae77Skettenis 578*b725ae77Skettenis Otherwise, call the target function to figure out where we need 579*b725ae77Skettenis our temporary breakpoint, create it, and continue executing this 580*b725ae77Skettenis process. */ 581*b725ae77Skettenis if (the_low_target.breakpoint_reinsert_addr == NULL) 582*b725ae77Skettenis { 583*b725ae77Skettenis event_child->bp_reinsert = stop_pc; 584*b725ae77Skettenis uninsert_breakpoint (stop_pc); 585*b725ae77Skettenis linux_resume_one_process (&event_child->head, 1, 0); 586*b725ae77Skettenis } 587*b725ae77Skettenis else 588*b725ae77Skettenis { 589*b725ae77Skettenis reinsert_breakpoint_by_bp 590*b725ae77Skettenis (stop_pc, (*the_low_target.breakpoint_reinsert_addr) ()); 591*b725ae77Skettenis linux_resume_one_process (&event_child->head, 0, 0); 592*b725ae77Skettenis } 593*b725ae77Skettenis 594*b725ae77Skettenis continue; 595*b725ae77Skettenis } 596*b725ae77Skettenis 597*b725ae77Skettenis /* If we were single-stepping, we definitely want to report the 598*b725ae77Skettenis SIGTRAP. The single-step operation has completed, so also 599*b725ae77Skettenis clear the stepping flag; in general this does not matter, 600*b725ae77Skettenis because the SIGTRAP will be reported to the client, which 601*b725ae77Skettenis will give us a new action for this thread, but clear it for 602*b725ae77Skettenis consistency anyway. It's safe to clear the stepping flag 603*b725ae77Skettenis because the only consumer of get_stop_pc () after this point 604*b725ae77Skettenis is check_removed_breakpoint, and pending_is_breakpoint is not 605*b725ae77Skettenis set. It might be wiser to use a step_completed flag instead. */ 606*b725ae77Skettenis if (event_child->stepping) 607*b725ae77Skettenis { 608*b725ae77Skettenis event_child->stepping = 0; 609*b725ae77Skettenis return wstat; 610*b725ae77Skettenis } 611*b725ae77Skettenis 612*b725ae77Skettenis /* A SIGTRAP that we can't explain. It may have been a breakpoint. 613*b725ae77Skettenis Check if it is a breakpoint, and if so mark the process information 614*b725ae77Skettenis accordingly. This will handle both the necessary fiddling with the 615*b725ae77Skettenis PC on decr_pc_after_break targets and suppressing extra threads 616*b725ae77Skettenis hitting a breakpoint if two hit it at once and then GDB removes it 617*b725ae77Skettenis after the first is reported. Arguably it would be better to report 618*b725ae77Skettenis multiple threads hitting breakpoints simultaneously, but the current 619*b725ae77Skettenis remote protocol does not allow this. */ 620*b725ae77Skettenis if ((*the_low_target.breakpoint_at) (stop_pc)) 621*b725ae77Skettenis { 622*b725ae77Skettenis event_child->pending_is_breakpoint = 1; 623*b725ae77Skettenis event_child->pending_stop_pc = stop_pc; 624*b725ae77Skettenis } 625*b725ae77Skettenis 626*b725ae77Skettenis return wstat; 627*b725ae77Skettenis } 628*b725ae77Skettenis 629*b725ae77Skettenis /* NOTREACHED */ 630*b725ae77Skettenis return 0; 631*b725ae77Skettenis } 632*b725ae77Skettenis 633*b725ae77Skettenis /* Wait for process, returns status. */ 634*b725ae77Skettenis 635*b725ae77Skettenis static unsigned char 636*b725ae77Skettenis linux_wait (char *status) 637*b725ae77Skettenis { 638*b725ae77Skettenis int w; 639*b725ae77Skettenis struct thread_info *child = NULL; 640*b725ae77Skettenis 641*b725ae77Skettenis retry: 642*b725ae77Skettenis /* If we were only supposed to resume one thread, only wait for 643*b725ae77Skettenis that thread - if it's still alive. If it died, however - which 644*b725ae77Skettenis can happen if we're coming from the thread death case below - 645*b725ae77Skettenis then we need to make sure we restart the other threads. We could 646*b725ae77Skettenis pick a thread at random or restart all; restarting all is less 647*b725ae77Skettenis arbitrary. */ 648*b725ae77Skettenis if (cont_thread > 0) 649*b725ae77Skettenis { 650*b725ae77Skettenis child = (struct thread_info *) find_inferior_id (&all_threads, 651*b725ae77Skettenis cont_thread); 652*b725ae77Skettenis 653*b725ae77Skettenis /* No stepping, no signal - unless one is pending already, of course. */ 654*b725ae77Skettenis if (child == NULL) 655*b725ae77Skettenis { 656*b725ae77Skettenis struct thread_resume resume_info; 657*b725ae77Skettenis resume_info.thread = -1; 658*b725ae77Skettenis resume_info.step = resume_info.sig = resume_info.leave_stopped = 0; 659*b725ae77Skettenis linux_resume (&resume_info); 660*b725ae77Skettenis } 661*b725ae77Skettenis } 662*b725ae77Skettenis 663*b725ae77Skettenis enable_async_io (); 664*b725ae77Skettenis unblock_async_io (); 665*b725ae77Skettenis w = linux_wait_for_event (child); 666*b725ae77Skettenis stop_all_processes (); 667*b725ae77Skettenis disable_async_io (); 668*b725ae77Skettenis 669*b725ae77Skettenis /* If we are waiting for a particular child, and it exited, 670*b725ae77Skettenis linux_wait_for_event will return its exit status. Similarly if 671*b725ae77Skettenis the last child exited. If this is not the last child, however, 672*b725ae77Skettenis do not report it as exited until there is a 'thread exited' response 673*b725ae77Skettenis available in the remote protocol. Instead, just wait for another event. 674*b725ae77Skettenis This should be safe, because if the thread crashed we will already 675*b725ae77Skettenis have reported the termination signal to GDB; that should stop any 676*b725ae77Skettenis in-progress stepping operations, etc. 677*b725ae77Skettenis 678*b725ae77Skettenis Report the exit status of the last thread to exit. This matches 679*b725ae77Skettenis LinuxThreads' behavior. */ 680*b725ae77Skettenis 681*b725ae77Skettenis if (all_threads.head == all_threads.tail) 682*b725ae77Skettenis { 683*b725ae77Skettenis if (WIFEXITED (w)) 684*b725ae77Skettenis { 685*b725ae77Skettenis fprintf (stderr, "\nChild exited with retcode = %x \n", WEXITSTATUS (w)); 686*b725ae77Skettenis *status = 'W'; 687*b725ae77Skettenis clear_inferiors (); 688*b725ae77Skettenis free (all_processes.head); 689*b725ae77Skettenis all_processes.head = all_processes.tail = NULL; 690*b725ae77Skettenis return ((unsigned char) WEXITSTATUS (w)); 691*b725ae77Skettenis } 692*b725ae77Skettenis else if (!WIFSTOPPED (w)) 693*b725ae77Skettenis { 694*b725ae77Skettenis fprintf (stderr, "\nChild terminated with signal = %x \n", WTERMSIG (w)); 695*b725ae77Skettenis *status = 'X'; 696*b725ae77Skettenis clear_inferiors (); 697*b725ae77Skettenis free (all_processes.head); 698*b725ae77Skettenis all_processes.head = all_processes.tail = NULL; 699*b725ae77Skettenis return ((unsigned char) WTERMSIG (w)); 700*b725ae77Skettenis } 701*b725ae77Skettenis } 702*b725ae77Skettenis else 703*b725ae77Skettenis { 704*b725ae77Skettenis if (!WIFSTOPPED (w)) 705*b725ae77Skettenis goto retry; 706*b725ae77Skettenis } 707*b725ae77Skettenis 708*b725ae77Skettenis *status = 'T'; 709*b725ae77Skettenis return ((unsigned char) WSTOPSIG (w)); 710*b725ae77Skettenis } 711*b725ae77Skettenis 712*b725ae77Skettenis static void 713*b725ae77Skettenis send_sigstop (struct inferior_list_entry *entry) 714*b725ae77Skettenis { 715*b725ae77Skettenis struct process_info *process = (struct process_info *) entry; 716*b725ae77Skettenis 717*b725ae77Skettenis if (process->stopped) 718*b725ae77Skettenis return; 719*b725ae77Skettenis 720*b725ae77Skettenis /* If we already have a pending stop signal for this process, don't 721*b725ae77Skettenis send another. */ 722*b725ae77Skettenis if (process->stop_expected) 723*b725ae77Skettenis { 724*b725ae77Skettenis process->stop_expected = 0; 725*b725ae77Skettenis return; 726*b725ae77Skettenis } 727*b725ae77Skettenis 728*b725ae77Skettenis if (debug_threads) 729*b725ae77Skettenis fprintf (stderr, "Sending sigstop to process %d\n", process->head.id); 730*b725ae77Skettenis 731*b725ae77Skettenis kill (process->head.id, SIGSTOP); 732*b725ae77Skettenis process->sigstop_sent = 1; 733*b725ae77Skettenis } 734*b725ae77Skettenis 735*b725ae77Skettenis static void 736*b725ae77Skettenis wait_for_sigstop (struct inferior_list_entry *entry) 737*b725ae77Skettenis { 738*b725ae77Skettenis struct process_info *process = (struct process_info *) entry; 739*b725ae77Skettenis struct thread_info *saved_inferior, *thread; 740*b725ae77Skettenis int wstat, saved_tid; 741*b725ae77Skettenis 742*b725ae77Skettenis if (process->stopped) 743*b725ae77Skettenis return; 744*b725ae77Skettenis 745*b725ae77Skettenis saved_inferior = current_inferior; 746*b725ae77Skettenis saved_tid = ((struct inferior_list_entry *) saved_inferior)->id; 747*b725ae77Skettenis thread = (struct thread_info *) find_inferior_id (&all_threads, 748*b725ae77Skettenis process->tid); 749*b725ae77Skettenis wstat = linux_wait_for_event (thread); 750*b725ae77Skettenis 751*b725ae77Skettenis /* If we stopped with a non-SIGSTOP signal, save it for later 752*b725ae77Skettenis and record the pending SIGSTOP. If the process exited, just 753*b725ae77Skettenis return. */ 754*b725ae77Skettenis if (WIFSTOPPED (wstat) 755*b725ae77Skettenis && WSTOPSIG (wstat) != SIGSTOP) 756*b725ae77Skettenis { 757*b725ae77Skettenis if (debug_threads) 758*b725ae77Skettenis fprintf (stderr, "Stopped with non-sigstop signal\n"); 759*b725ae77Skettenis process->status_pending_p = 1; 760*b725ae77Skettenis process->status_pending = wstat; 761*b725ae77Skettenis process->stop_expected = 1; 762*b725ae77Skettenis } 763*b725ae77Skettenis 764*b725ae77Skettenis if (linux_thread_alive (saved_tid)) 765*b725ae77Skettenis current_inferior = saved_inferior; 766*b725ae77Skettenis else 767*b725ae77Skettenis { 768*b725ae77Skettenis if (debug_threads) 769*b725ae77Skettenis fprintf (stderr, "Previously current thread died.\n"); 770*b725ae77Skettenis 771*b725ae77Skettenis /* Set a valid thread as current. */ 772*b725ae77Skettenis set_desired_inferior (0); 773*b725ae77Skettenis } 774*b725ae77Skettenis } 775*b725ae77Skettenis 776*b725ae77Skettenis static void 777*b725ae77Skettenis stop_all_processes (void) 778*b725ae77Skettenis { 779*b725ae77Skettenis stopping_threads = 1; 780*b725ae77Skettenis for_each_inferior (&all_processes, send_sigstop); 781*b725ae77Skettenis for_each_inferior (&all_processes, wait_for_sigstop); 782*b725ae77Skettenis stopping_threads = 0; 783*b725ae77Skettenis } 784*b725ae77Skettenis 785*b725ae77Skettenis /* Resume execution of the inferior process. 786*b725ae77Skettenis If STEP is nonzero, single-step it. 787*b725ae77Skettenis If SIGNAL is nonzero, give it that signal. */ 788*b725ae77Skettenis 789*b725ae77Skettenis static void 790*b725ae77Skettenis linux_resume_one_process (struct inferior_list_entry *entry, 791*b725ae77Skettenis int step, int signal) 792*b725ae77Skettenis { 793*b725ae77Skettenis struct process_info *process = (struct process_info *) entry; 794*b725ae77Skettenis struct thread_info *saved_inferior; 795*b725ae77Skettenis 796*b725ae77Skettenis if (process->stopped == 0) 797*b725ae77Skettenis return; 798*b725ae77Skettenis 799*b725ae77Skettenis /* If we have pending signals or status, and a new signal, enqueue the 800*b725ae77Skettenis signal. Also enqueue the signal if we are waiting to reinsert a 801*b725ae77Skettenis breakpoint; it will be picked up again below. */ 802*b725ae77Skettenis if (signal != 0 803*b725ae77Skettenis && (process->status_pending_p || process->pending_signals != NULL 804*b725ae77Skettenis || process->bp_reinsert != 0)) 805*b725ae77Skettenis { 806*b725ae77Skettenis struct pending_signals *p_sig; 807*b725ae77Skettenis p_sig = malloc (sizeof (*p_sig)); 808*b725ae77Skettenis p_sig->prev = process->pending_signals; 809*b725ae77Skettenis p_sig->signal = signal; 810*b725ae77Skettenis process->pending_signals = p_sig; 811*b725ae77Skettenis } 812*b725ae77Skettenis 813*b725ae77Skettenis if (process->status_pending_p && !check_removed_breakpoint (process)) 814*b725ae77Skettenis return; 815*b725ae77Skettenis 816*b725ae77Skettenis saved_inferior = current_inferior; 817*b725ae77Skettenis current_inferior = get_process_thread (process); 818*b725ae77Skettenis 819*b725ae77Skettenis if (debug_threads) 820*b725ae77Skettenis fprintf (stderr, "Resuming process %d (%s, signal %d, stop %s)\n", inferior_pid, 821*b725ae77Skettenis step ? "step" : "continue", signal, 822*b725ae77Skettenis process->stop_expected ? "expected" : "not expected"); 823*b725ae77Skettenis 824*b725ae77Skettenis /* This bit needs some thinking about. If we get a signal that 825*b725ae77Skettenis we must report while a single-step reinsert is still pending, 826*b725ae77Skettenis we often end up resuming the thread. It might be better to 827*b725ae77Skettenis (ew) allow a stack of pending events; then we could be sure that 828*b725ae77Skettenis the reinsert happened right away and not lose any signals. 829*b725ae77Skettenis 830*b725ae77Skettenis Making this stack would also shrink the window in which breakpoints are 831*b725ae77Skettenis uninserted (see comment in linux_wait_for_process) but not enough for 832*b725ae77Skettenis complete correctness, so it won't solve that problem. It may be 833*b725ae77Skettenis worthwhile just to solve this one, however. */ 834*b725ae77Skettenis if (process->bp_reinsert != 0) 835*b725ae77Skettenis { 836*b725ae77Skettenis if (debug_threads) 837*b725ae77Skettenis fprintf (stderr, " pending reinsert at %08lx", (long)process->bp_reinsert); 838*b725ae77Skettenis if (step == 0) 839*b725ae77Skettenis fprintf (stderr, "BAD - reinserting but not stepping.\n"); 840*b725ae77Skettenis step = 1; 841*b725ae77Skettenis 842*b725ae77Skettenis /* Postpone any pending signal. It was enqueued above. */ 843*b725ae77Skettenis signal = 0; 844*b725ae77Skettenis } 845*b725ae77Skettenis 846*b725ae77Skettenis check_removed_breakpoint (process); 847*b725ae77Skettenis 848*b725ae77Skettenis if (debug_threads && the_low_target.get_pc != NULL) 849*b725ae77Skettenis { 850*b725ae77Skettenis fprintf (stderr, " "); 851*b725ae77Skettenis (long) (*the_low_target.get_pc) (); 852*b725ae77Skettenis } 853*b725ae77Skettenis 854*b725ae77Skettenis /* If we have pending signals, consume one unless we are trying to reinsert 855*b725ae77Skettenis a breakpoint. */ 856*b725ae77Skettenis if (process->pending_signals != NULL && process->bp_reinsert == 0) 857*b725ae77Skettenis { 858*b725ae77Skettenis struct pending_signals **p_sig; 859*b725ae77Skettenis 860*b725ae77Skettenis p_sig = &process->pending_signals; 861*b725ae77Skettenis while ((*p_sig)->prev != NULL) 862*b725ae77Skettenis p_sig = &(*p_sig)->prev; 863*b725ae77Skettenis 864*b725ae77Skettenis signal = (*p_sig)->signal; 865*b725ae77Skettenis free (*p_sig); 866*b725ae77Skettenis *p_sig = NULL; 867*b725ae77Skettenis } 868*b725ae77Skettenis 869*b725ae77Skettenis regcache_invalidate_one ((struct inferior_list_entry *) 870*b725ae77Skettenis get_process_thread (process)); 871*b725ae77Skettenis errno = 0; 872*b725ae77Skettenis process->stopped = 0; 873*b725ae77Skettenis process->stepping = step; 874*b725ae77Skettenis ptrace (step ? PTRACE_SINGLESTEP : PTRACE_CONT, process->lwpid, 0, signal); 875*b725ae77Skettenis 876*b725ae77Skettenis current_inferior = saved_inferior; 877*b725ae77Skettenis if (errno) 878*b725ae77Skettenis perror_with_name ("ptrace"); 879*b725ae77Skettenis } 880*b725ae77Skettenis 881*b725ae77Skettenis static struct thread_resume *resume_ptr; 882*b725ae77Skettenis 883*b725ae77Skettenis /* This function is called once per thread. We look up the thread 884*b725ae77Skettenis in RESUME_PTR, and mark the thread with a pointer to the appropriate 885*b725ae77Skettenis resume request. 886*b725ae77Skettenis 887*b725ae77Skettenis This algorithm is O(threads * resume elements), but resume elements 888*b725ae77Skettenis is small (and will remain small at least until GDB supports thread 889*b725ae77Skettenis suspension). */ 890*b725ae77Skettenis static void 891*b725ae77Skettenis linux_set_resume_request (struct inferior_list_entry *entry) 892*b725ae77Skettenis { 893*b725ae77Skettenis struct process_info *process; 894*b725ae77Skettenis struct thread_info *thread; 895*b725ae77Skettenis int ndx; 896*b725ae77Skettenis 897*b725ae77Skettenis thread = (struct thread_info *) entry; 898*b725ae77Skettenis process = get_thread_process (thread); 899*b725ae77Skettenis 900*b725ae77Skettenis ndx = 0; 901*b725ae77Skettenis while (resume_ptr[ndx].thread != -1 && resume_ptr[ndx].thread != entry->id) 902*b725ae77Skettenis ndx++; 903*b725ae77Skettenis 904*b725ae77Skettenis process->resume = &resume_ptr[ndx]; 905*b725ae77Skettenis } 906*b725ae77Skettenis 907*b725ae77Skettenis /* This function is called once per thread. We check the thread's resume 908*b725ae77Skettenis request, which will tell us whether to resume, step, or leave the thread 909*b725ae77Skettenis stopped; and what signal, if any, it should be sent. For threads which 910*b725ae77Skettenis we aren't explicitly told otherwise, we preserve the stepping flag; this 911*b725ae77Skettenis is used for stepping over gdbserver-placed breakpoints. */ 912*b725ae77Skettenis 913*b725ae77Skettenis static void 914*b725ae77Skettenis linux_continue_one_thread (struct inferior_list_entry *entry) 915*b725ae77Skettenis { 916*b725ae77Skettenis struct process_info *process; 917*b725ae77Skettenis struct thread_info *thread; 918*b725ae77Skettenis int step; 919*b725ae77Skettenis 920*b725ae77Skettenis thread = (struct thread_info *) entry; 921*b725ae77Skettenis process = get_thread_process (thread); 922*b725ae77Skettenis 923*b725ae77Skettenis if (process->resume->leave_stopped) 924*b725ae77Skettenis return; 925*b725ae77Skettenis 926*b725ae77Skettenis if (process->resume->thread == -1) 927*b725ae77Skettenis step = process->stepping || process->resume->step; 928*b725ae77Skettenis else 929*b725ae77Skettenis step = process->resume->step; 930*b725ae77Skettenis 931*b725ae77Skettenis linux_resume_one_process (&process->head, step, process->resume->sig); 932*b725ae77Skettenis 933*b725ae77Skettenis process->resume = NULL; 934*b725ae77Skettenis } 935*b725ae77Skettenis 936*b725ae77Skettenis /* This function is called once per thread. We check the thread's resume 937*b725ae77Skettenis request, which will tell us whether to resume, step, or leave the thread 938*b725ae77Skettenis stopped; and what signal, if any, it should be sent. We queue any needed 939*b725ae77Skettenis signals, since we won't actually resume. We already have a pending event 940*b725ae77Skettenis to report, so we don't need to preserve any step requests; they should 941*b725ae77Skettenis be re-issued if necessary. */ 942*b725ae77Skettenis 943*b725ae77Skettenis static void 944*b725ae77Skettenis linux_queue_one_thread (struct inferior_list_entry *entry) 945*b725ae77Skettenis { 946*b725ae77Skettenis struct process_info *process; 947*b725ae77Skettenis struct thread_info *thread; 948*b725ae77Skettenis 949*b725ae77Skettenis thread = (struct thread_info *) entry; 950*b725ae77Skettenis process = get_thread_process (thread); 951*b725ae77Skettenis 952*b725ae77Skettenis if (process->resume->leave_stopped) 953*b725ae77Skettenis return; 954*b725ae77Skettenis 955*b725ae77Skettenis /* If we have a new signal, enqueue the signal. */ 956*b725ae77Skettenis if (process->resume->sig != 0) 957*b725ae77Skettenis { 958*b725ae77Skettenis struct pending_signals *p_sig; 959*b725ae77Skettenis p_sig = malloc (sizeof (*p_sig)); 960*b725ae77Skettenis p_sig->prev = process->pending_signals; 961*b725ae77Skettenis p_sig->signal = process->resume->sig; 962*b725ae77Skettenis process->pending_signals = p_sig; 963*b725ae77Skettenis } 964*b725ae77Skettenis 965*b725ae77Skettenis process->resume = NULL; 966*b725ae77Skettenis } 967*b725ae77Skettenis 968*b725ae77Skettenis /* Set DUMMY if this process has an interesting status pending. */ 969*b725ae77Skettenis static int 970*b725ae77Skettenis resume_status_pending_p (struct inferior_list_entry *entry, void *flag_p) 971*b725ae77Skettenis { 972*b725ae77Skettenis struct process_info *process = (struct process_info *) entry; 973*b725ae77Skettenis 974*b725ae77Skettenis /* Processes which will not be resumed are not interesting, because 975*b725ae77Skettenis we might not wait for them next time through linux_wait. */ 976*b725ae77Skettenis if (process->resume->leave_stopped) 977*b725ae77Skettenis return 0; 978*b725ae77Skettenis 979*b725ae77Skettenis /* If this thread has a removed breakpoint, we won't have any 980*b725ae77Skettenis events to report later, so check now. check_removed_breakpoint 981*b725ae77Skettenis may clear status_pending_p. We avoid calling check_removed_breakpoint 982*b725ae77Skettenis for any thread that we are not otherwise going to resume - this 983*b725ae77Skettenis lets us preserve stopped status when two threads hit a breakpoint. 984*b725ae77Skettenis GDB removes the breakpoint to single-step a particular thread 985*b725ae77Skettenis past it, then re-inserts it and resumes all threads. We want 986*b725ae77Skettenis to report the second thread without resuming it in the interim. */ 987*b725ae77Skettenis if (process->status_pending_p) 988*b725ae77Skettenis check_removed_breakpoint (process); 989*b725ae77Skettenis 990*b725ae77Skettenis if (process->status_pending_p) 991*b725ae77Skettenis * (int *) flag_p = 1; 992*b725ae77Skettenis 993*b725ae77Skettenis return 0; 994*b725ae77Skettenis } 995*b725ae77Skettenis 996*b725ae77Skettenis static void 997*b725ae77Skettenis linux_resume (struct thread_resume *resume_info) 998*b725ae77Skettenis { 999*b725ae77Skettenis int pending_flag; 1000*b725ae77Skettenis 1001*b725ae77Skettenis /* Yes, the use of a global here is rather ugly. */ 1002*b725ae77Skettenis resume_ptr = resume_info; 1003*b725ae77Skettenis 1004*b725ae77Skettenis for_each_inferior (&all_threads, linux_set_resume_request); 1005*b725ae77Skettenis 1006*b725ae77Skettenis /* If there is a thread which would otherwise be resumed, which 1007*b725ae77Skettenis has a pending status, then don't resume any threads - we can just 1008*b725ae77Skettenis report the pending status. Make sure to queue any signals 1009*b725ae77Skettenis that would otherwise be sent. */ 1010*b725ae77Skettenis pending_flag = 0; 1011*b725ae77Skettenis find_inferior (&all_processes, resume_status_pending_p, &pending_flag); 1012*b725ae77Skettenis 1013*b725ae77Skettenis if (debug_threads) 1014*b725ae77Skettenis { 1015*b725ae77Skettenis if (pending_flag) 1016*b725ae77Skettenis fprintf (stderr, "Not resuming, pending status\n"); 1017*b725ae77Skettenis else 1018*b725ae77Skettenis fprintf (stderr, "Resuming, no pending status\n"); 1019*b725ae77Skettenis } 1020*b725ae77Skettenis 1021*b725ae77Skettenis if (pending_flag) 1022*b725ae77Skettenis for_each_inferior (&all_threads, linux_queue_one_thread); 1023*b725ae77Skettenis else 1024*b725ae77Skettenis { 1025*b725ae77Skettenis block_async_io (); 1026*b725ae77Skettenis enable_async_io (); 1027*b725ae77Skettenis for_each_inferior (&all_threads, linux_continue_one_thread); 1028*b725ae77Skettenis } 1029*b725ae77Skettenis } 1030*b725ae77Skettenis 1031*b725ae77Skettenis #ifdef HAVE_LINUX_USRREGS 1032*b725ae77Skettenis 1033*b725ae77Skettenis int 1034*b725ae77Skettenis register_addr (int regnum) 1035*b725ae77Skettenis { 1036*b725ae77Skettenis int addr; 1037*b725ae77Skettenis 1038*b725ae77Skettenis if (regnum < 0 || regnum >= the_low_target.num_regs) 1039*b725ae77Skettenis error ("Invalid register number %d.", regnum); 1040*b725ae77Skettenis 1041*b725ae77Skettenis addr = the_low_target.regmap[regnum]; 1042*b725ae77Skettenis 1043*b725ae77Skettenis return addr; 1044*b725ae77Skettenis } 1045*b725ae77Skettenis 1046*b725ae77Skettenis /* Fetch one register. */ 1047*b725ae77Skettenis static void 1048*b725ae77Skettenis fetch_register (int regno) 1049*b725ae77Skettenis { 1050*b725ae77Skettenis CORE_ADDR regaddr; 1051*b725ae77Skettenis register int i; 1052*b725ae77Skettenis char *buf; 1053*b725ae77Skettenis 1054*b725ae77Skettenis if (regno >= the_low_target.num_regs) 1055*b725ae77Skettenis return; 1056*b725ae77Skettenis if ((*the_low_target.cannot_fetch_register) (regno)) 1057*b725ae77Skettenis return; 1058*b725ae77Skettenis 1059*b725ae77Skettenis regaddr = register_addr (regno); 1060*b725ae77Skettenis if (regaddr == -1) 1061*b725ae77Skettenis return; 1062*b725ae77Skettenis buf = alloca (register_size (regno)); 1063*b725ae77Skettenis for (i = 0; i < register_size (regno); i += sizeof (PTRACE_XFER_TYPE)) 1064*b725ae77Skettenis { 1065*b725ae77Skettenis errno = 0; 1066*b725ae77Skettenis *(PTRACE_XFER_TYPE *) (buf + i) = 1067*b725ae77Skettenis ptrace (PTRACE_PEEKUSER, inferior_pid, (PTRACE_ARG3_TYPE) regaddr, 0); 1068*b725ae77Skettenis regaddr += sizeof (PTRACE_XFER_TYPE); 1069*b725ae77Skettenis if (errno != 0) 1070*b725ae77Skettenis { 1071*b725ae77Skettenis /* Warning, not error, in case we are attached; sometimes the 1072*b725ae77Skettenis kernel doesn't let us at the registers. */ 1073*b725ae77Skettenis char *err = strerror (errno); 1074*b725ae77Skettenis char *msg = alloca (strlen (err) + 128); 1075*b725ae77Skettenis sprintf (msg, "reading register %d: %s", regno, err); 1076*b725ae77Skettenis error (msg); 1077*b725ae77Skettenis goto error_exit; 1078*b725ae77Skettenis } 1079*b725ae77Skettenis } 1080*b725ae77Skettenis supply_register (regno, buf); 1081*b725ae77Skettenis 1082*b725ae77Skettenis error_exit:; 1083*b725ae77Skettenis } 1084*b725ae77Skettenis 1085*b725ae77Skettenis /* Fetch all registers, or just one, from the child process. */ 1086*b725ae77Skettenis static void 1087*b725ae77Skettenis usr_fetch_inferior_registers (int regno) 1088*b725ae77Skettenis { 1089*b725ae77Skettenis if (regno == -1 || regno == 0) 1090*b725ae77Skettenis for (regno = 0; regno < the_low_target.num_regs; regno++) 1091*b725ae77Skettenis fetch_register (regno); 1092*b725ae77Skettenis else 1093*b725ae77Skettenis fetch_register (regno); 1094*b725ae77Skettenis } 1095*b725ae77Skettenis 1096*b725ae77Skettenis /* Store our register values back into the inferior. 1097*b725ae77Skettenis If REGNO is -1, do this for all registers. 1098*b725ae77Skettenis Otherwise, REGNO specifies which register (so we can save time). */ 1099*b725ae77Skettenis static void 1100*b725ae77Skettenis usr_store_inferior_registers (int regno) 1101*b725ae77Skettenis { 1102*b725ae77Skettenis CORE_ADDR regaddr; 1103*b725ae77Skettenis int i; 1104*b725ae77Skettenis char *buf; 1105*b725ae77Skettenis 1106*b725ae77Skettenis if (regno >= 0) 1107*b725ae77Skettenis { 1108*b725ae77Skettenis if (regno >= the_low_target.num_regs) 1109*b725ae77Skettenis return; 1110*b725ae77Skettenis 1111*b725ae77Skettenis if ((*the_low_target.cannot_store_register) (regno) == 1) 1112*b725ae77Skettenis return; 1113*b725ae77Skettenis 1114*b725ae77Skettenis regaddr = register_addr (regno); 1115*b725ae77Skettenis if (regaddr == -1) 1116*b725ae77Skettenis return; 1117*b725ae77Skettenis errno = 0; 1118*b725ae77Skettenis buf = alloca (register_size (regno)); 1119*b725ae77Skettenis collect_register (regno, buf); 1120*b725ae77Skettenis for (i = 0; i < register_size (regno); i += sizeof (PTRACE_XFER_TYPE)) 1121*b725ae77Skettenis { 1122*b725ae77Skettenis errno = 0; 1123*b725ae77Skettenis ptrace (PTRACE_POKEUSER, inferior_pid, (PTRACE_ARG3_TYPE) regaddr, 1124*b725ae77Skettenis *(PTRACE_XFER_TYPE *) (buf + i)); 1125*b725ae77Skettenis if (errno != 0) 1126*b725ae77Skettenis { 1127*b725ae77Skettenis if ((*the_low_target.cannot_store_register) (regno) == 0) 1128*b725ae77Skettenis { 1129*b725ae77Skettenis char *err = strerror (errno); 1130*b725ae77Skettenis char *msg = alloca (strlen (err) + 128); 1131*b725ae77Skettenis sprintf (msg, "writing register %d: %s", 1132*b725ae77Skettenis regno, err); 1133*b725ae77Skettenis error (msg); 1134*b725ae77Skettenis return; 1135*b725ae77Skettenis } 1136*b725ae77Skettenis } 1137*b725ae77Skettenis regaddr += sizeof (PTRACE_XFER_TYPE); 1138*b725ae77Skettenis } 1139*b725ae77Skettenis } 1140*b725ae77Skettenis else 1141*b725ae77Skettenis for (regno = 0; regno < the_low_target.num_regs; regno++) 1142*b725ae77Skettenis usr_store_inferior_registers (regno); 1143*b725ae77Skettenis } 1144*b725ae77Skettenis #endif /* HAVE_LINUX_USRREGS */ 1145*b725ae77Skettenis 1146*b725ae77Skettenis 1147*b725ae77Skettenis 1148*b725ae77Skettenis #ifdef HAVE_LINUX_REGSETS 1149*b725ae77Skettenis 1150*b725ae77Skettenis static int 1151*b725ae77Skettenis regsets_fetch_inferior_registers () 1152*b725ae77Skettenis { 1153*b725ae77Skettenis struct regset_info *regset; 1154*b725ae77Skettenis 1155*b725ae77Skettenis regset = target_regsets; 1156*b725ae77Skettenis 1157*b725ae77Skettenis while (regset->size >= 0) 1158*b725ae77Skettenis { 1159*b725ae77Skettenis void *buf; 1160*b725ae77Skettenis int res; 1161*b725ae77Skettenis 1162*b725ae77Skettenis if (regset->size == 0) 1163*b725ae77Skettenis { 1164*b725ae77Skettenis regset ++; 1165*b725ae77Skettenis continue; 1166*b725ae77Skettenis } 1167*b725ae77Skettenis 1168*b725ae77Skettenis buf = malloc (regset->size); 1169*b725ae77Skettenis res = ptrace (regset->get_request, inferior_pid, 0, buf); 1170*b725ae77Skettenis if (res < 0) 1171*b725ae77Skettenis { 1172*b725ae77Skettenis if (errno == EIO) 1173*b725ae77Skettenis { 1174*b725ae77Skettenis /* If we get EIO on the first regset, do not try regsets again. 1175*b725ae77Skettenis If we get EIO on a later regset, disable that regset. */ 1176*b725ae77Skettenis if (regset == target_regsets) 1177*b725ae77Skettenis { 1178*b725ae77Skettenis use_regsets_p = 0; 1179*b725ae77Skettenis return -1; 1180*b725ae77Skettenis } 1181*b725ae77Skettenis else 1182*b725ae77Skettenis { 1183*b725ae77Skettenis regset->size = 0; 1184*b725ae77Skettenis continue; 1185*b725ae77Skettenis } 1186*b725ae77Skettenis } 1187*b725ae77Skettenis else 1188*b725ae77Skettenis { 1189*b725ae77Skettenis char s[256]; 1190*b725ae77Skettenis sprintf (s, "ptrace(regsets_fetch_inferior_registers) PID=%d", 1191*b725ae77Skettenis inferior_pid); 1192*b725ae77Skettenis perror (s); 1193*b725ae77Skettenis } 1194*b725ae77Skettenis } 1195*b725ae77Skettenis regset->store_function (buf); 1196*b725ae77Skettenis regset ++; 1197*b725ae77Skettenis } 1198*b725ae77Skettenis return 0; 1199*b725ae77Skettenis } 1200*b725ae77Skettenis 1201*b725ae77Skettenis static int 1202*b725ae77Skettenis regsets_store_inferior_registers () 1203*b725ae77Skettenis { 1204*b725ae77Skettenis struct regset_info *regset; 1205*b725ae77Skettenis 1206*b725ae77Skettenis regset = target_regsets; 1207*b725ae77Skettenis 1208*b725ae77Skettenis while (regset->size >= 0) 1209*b725ae77Skettenis { 1210*b725ae77Skettenis void *buf; 1211*b725ae77Skettenis int res; 1212*b725ae77Skettenis 1213*b725ae77Skettenis if (regset->size == 0) 1214*b725ae77Skettenis { 1215*b725ae77Skettenis regset ++; 1216*b725ae77Skettenis continue; 1217*b725ae77Skettenis } 1218*b725ae77Skettenis 1219*b725ae77Skettenis buf = malloc (regset->size); 1220*b725ae77Skettenis regset->fill_function (buf); 1221*b725ae77Skettenis res = ptrace (regset->set_request, inferior_pid, 0, buf); 1222*b725ae77Skettenis if (res < 0) 1223*b725ae77Skettenis { 1224*b725ae77Skettenis if (errno == EIO) 1225*b725ae77Skettenis { 1226*b725ae77Skettenis /* If we get EIO on the first regset, do not try regsets again. 1227*b725ae77Skettenis If we get EIO on a later regset, disable that regset. */ 1228*b725ae77Skettenis if (regset == target_regsets) 1229*b725ae77Skettenis { 1230*b725ae77Skettenis use_regsets_p = 0; 1231*b725ae77Skettenis return -1; 1232*b725ae77Skettenis } 1233*b725ae77Skettenis else 1234*b725ae77Skettenis { 1235*b725ae77Skettenis regset->size = 0; 1236*b725ae77Skettenis continue; 1237*b725ae77Skettenis } 1238*b725ae77Skettenis } 1239*b725ae77Skettenis else 1240*b725ae77Skettenis { 1241*b725ae77Skettenis perror ("Warning: ptrace(regsets_store_inferior_registers)"); 1242*b725ae77Skettenis } 1243*b725ae77Skettenis } 1244*b725ae77Skettenis regset ++; 1245*b725ae77Skettenis free (buf); 1246*b725ae77Skettenis } 1247*b725ae77Skettenis return 0; 1248*b725ae77Skettenis } 1249*b725ae77Skettenis 1250*b725ae77Skettenis #endif /* HAVE_LINUX_REGSETS */ 1251*b725ae77Skettenis 1252*b725ae77Skettenis 1253*b725ae77Skettenis void 1254*b725ae77Skettenis linux_fetch_registers (int regno) 1255*b725ae77Skettenis { 1256*b725ae77Skettenis #ifdef HAVE_LINUX_REGSETS 1257*b725ae77Skettenis if (use_regsets_p) 1258*b725ae77Skettenis { 1259*b725ae77Skettenis if (regsets_fetch_inferior_registers () == 0) 1260*b725ae77Skettenis return; 1261*b725ae77Skettenis } 1262*b725ae77Skettenis #endif 1263*b725ae77Skettenis #ifdef HAVE_LINUX_USRREGS 1264*b725ae77Skettenis usr_fetch_inferior_registers (regno); 1265*b725ae77Skettenis #endif 1266*b725ae77Skettenis } 1267*b725ae77Skettenis 1268*b725ae77Skettenis void 1269*b725ae77Skettenis linux_store_registers (int regno) 1270*b725ae77Skettenis { 1271*b725ae77Skettenis #ifdef HAVE_LINUX_REGSETS 1272*b725ae77Skettenis if (use_regsets_p) 1273*b725ae77Skettenis { 1274*b725ae77Skettenis if (regsets_store_inferior_registers () == 0) 1275*b725ae77Skettenis return; 1276*b725ae77Skettenis } 1277*b725ae77Skettenis #endif 1278*b725ae77Skettenis #ifdef HAVE_LINUX_USRREGS 1279*b725ae77Skettenis usr_store_inferior_registers (regno); 1280*b725ae77Skettenis #endif 1281*b725ae77Skettenis } 1282*b725ae77Skettenis 1283*b725ae77Skettenis 1284*b725ae77Skettenis /* Copy LEN bytes from inferior's memory starting at MEMADDR 1285*b725ae77Skettenis to debugger memory starting at MYADDR. */ 1286*b725ae77Skettenis 1287*b725ae77Skettenis static int 1288*b725ae77Skettenis linux_read_memory (CORE_ADDR memaddr, char *myaddr, int len) 1289*b725ae77Skettenis { 1290*b725ae77Skettenis register int i; 1291*b725ae77Skettenis /* Round starting address down to longword boundary. */ 1292*b725ae77Skettenis register CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE); 1293*b725ae77Skettenis /* Round ending address up; get number of longwords that makes. */ 1294*b725ae77Skettenis register int count 1295*b725ae77Skettenis = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1) 1296*b725ae77Skettenis / sizeof (PTRACE_XFER_TYPE); 1297*b725ae77Skettenis /* Allocate buffer of that many longwords. */ 1298*b725ae77Skettenis register PTRACE_XFER_TYPE *buffer 1299*b725ae77Skettenis = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE)); 1300*b725ae77Skettenis 1301*b725ae77Skettenis /* Read all the longwords */ 1302*b725ae77Skettenis for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE)) 1303*b725ae77Skettenis { 1304*b725ae77Skettenis errno = 0; 1305*b725ae77Skettenis buffer[i] = ptrace (PTRACE_PEEKTEXT, inferior_pid, (PTRACE_ARG3_TYPE) addr, 0); 1306*b725ae77Skettenis if (errno) 1307*b725ae77Skettenis return errno; 1308*b725ae77Skettenis } 1309*b725ae77Skettenis 1310*b725ae77Skettenis /* Copy appropriate bytes out of the buffer. */ 1311*b725ae77Skettenis memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)), len); 1312*b725ae77Skettenis 1313*b725ae77Skettenis return 0; 1314*b725ae77Skettenis } 1315*b725ae77Skettenis 1316*b725ae77Skettenis /* Copy LEN bytes of data from debugger memory at MYADDR 1317*b725ae77Skettenis to inferior's memory at MEMADDR. 1318*b725ae77Skettenis On failure (cannot write the inferior) 1319*b725ae77Skettenis returns the value of errno. */ 1320*b725ae77Skettenis 1321*b725ae77Skettenis static int 1322*b725ae77Skettenis linux_write_memory (CORE_ADDR memaddr, const char *myaddr, int len) 1323*b725ae77Skettenis { 1324*b725ae77Skettenis register int i; 1325*b725ae77Skettenis /* Round starting address down to longword boundary. */ 1326*b725ae77Skettenis register CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE); 1327*b725ae77Skettenis /* Round ending address up; get number of longwords that makes. */ 1328*b725ae77Skettenis register int count 1329*b725ae77Skettenis = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1) / sizeof (PTRACE_XFER_TYPE); 1330*b725ae77Skettenis /* Allocate buffer of that many longwords. */ 1331*b725ae77Skettenis register PTRACE_XFER_TYPE *buffer = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE)); 1332*b725ae77Skettenis extern int errno; 1333*b725ae77Skettenis 1334*b725ae77Skettenis if (debug_threads) 1335*b725ae77Skettenis { 1336*b725ae77Skettenis fprintf (stderr, "Writing %02x to %08lx\n", (unsigned)myaddr[0], (long)memaddr); 1337*b725ae77Skettenis } 1338*b725ae77Skettenis 1339*b725ae77Skettenis /* Fill start and end extra bytes of buffer with existing memory data. */ 1340*b725ae77Skettenis 1341*b725ae77Skettenis buffer[0] = ptrace (PTRACE_PEEKTEXT, inferior_pid, 1342*b725ae77Skettenis (PTRACE_ARG3_TYPE) addr, 0); 1343*b725ae77Skettenis 1344*b725ae77Skettenis if (count > 1) 1345*b725ae77Skettenis { 1346*b725ae77Skettenis buffer[count - 1] 1347*b725ae77Skettenis = ptrace (PTRACE_PEEKTEXT, inferior_pid, 1348*b725ae77Skettenis (PTRACE_ARG3_TYPE) (addr + (count - 1) 1349*b725ae77Skettenis * sizeof (PTRACE_XFER_TYPE)), 1350*b725ae77Skettenis 0); 1351*b725ae77Skettenis } 1352*b725ae77Skettenis 1353*b725ae77Skettenis /* Copy data to be written over corresponding part of buffer */ 1354*b725ae77Skettenis 1355*b725ae77Skettenis memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)), myaddr, len); 1356*b725ae77Skettenis 1357*b725ae77Skettenis /* Write the entire buffer. */ 1358*b725ae77Skettenis 1359*b725ae77Skettenis for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE)) 1360*b725ae77Skettenis { 1361*b725ae77Skettenis errno = 0; 1362*b725ae77Skettenis ptrace (PTRACE_POKETEXT, inferior_pid, (PTRACE_ARG3_TYPE) addr, buffer[i]); 1363*b725ae77Skettenis if (errno) 1364*b725ae77Skettenis return errno; 1365*b725ae77Skettenis } 1366*b725ae77Skettenis 1367*b725ae77Skettenis return 0; 1368*b725ae77Skettenis } 1369*b725ae77Skettenis 1370*b725ae77Skettenis static void 1371*b725ae77Skettenis linux_look_up_symbols (void) 1372*b725ae77Skettenis { 1373*b725ae77Skettenis #ifdef USE_THREAD_DB 1374*b725ae77Skettenis if (using_threads) 1375*b725ae77Skettenis return; 1376*b725ae77Skettenis 1377*b725ae77Skettenis using_threads = thread_db_init (); 1378*b725ae77Skettenis #endif 1379*b725ae77Skettenis } 1380*b725ae77Skettenis 1381*b725ae77Skettenis static void 1382*b725ae77Skettenis linux_send_signal (int signum) 1383*b725ae77Skettenis { 1384*b725ae77Skettenis extern int signal_pid; 1385*b725ae77Skettenis 1386*b725ae77Skettenis if (cont_thread > 0) 1387*b725ae77Skettenis { 1388*b725ae77Skettenis struct process_info *process; 1389*b725ae77Skettenis 1390*b725ae77Skettenis process = get_thread_process (current_inferior); 1391*b725ae77Skettenis kill (process->lwpid, signum); 1392*b725ae77Skettenis } 1393*b725ae77Skettenis else 1394*b725ae77Skettenis kill (signal_pid, signum); 1395*b725ae77Skettenis } 1396*b725ae77Skettenis 1397*b725ae77Skettenis /* Copy LEN bytes from inferior's auxiliary vector starting at OFFSET 1398*b725ae77Skettenis to debugger memory starting at MYADDR. */ 1399*b725ae77Skettenis 1400*b725ae77Skettenis static int 1401*b725ae77Skettenis linux_read_auxv (CORE_ADDR offset, char *myaddr, unsigned int len) 1402*b725ae77Skettenis { 1403*b725ae77Skettenis char filename[PATH_MAX]; 1404*b725ae77Skettenis int fd, n; 1405*b725ae77Skettenis 1406*b725ae77Skettenis snprintf (filename, sizeof filename, "/proc/%d/auxv", inferior_pid); 1407*b725ae77Skettenis 1408*b725ae77Skettenis fd = open (filename, O_RDONLY); 1409*b725ae77Skettenis if (fd < 0) 1410*b725ae77Skettenis return -1; 1411*b725ae77Skettenis 1412*b725ae77Skettenis if (offset != (CORE_ADDR) 0 1413*b725ae77Skettenis && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset) 1414*b725ae77Skettenis n = -1; 1415*b725ae77Skettenis else 1416*b725ae77Skettenis n = read (fd, myaddr, len); 1417*b725ae77Skettenis 1418*b725ae77Skettenis close (fd); 1419*b725ae77Skettenis 1420*b725ae77Skettenis return n; 1421*b725ae77Skettenis } 1422*b725ae77Skettenis 1423*b725ae77Skettenis 1424*b725ae77Skettenis static struct target_ops linux_target_ops = { 1425*b725ae77Skettenis linux_create_inferior, 1426*b725ae77Skettenis linux_attach, 1427*b725ae77Skettenis linux_kill, 1428*b725ae77Skettenis linux_detach, 1429*b725ae77Skettenis linux_thread_alive, 1430*b725ae77Skettenis linux_resume, 1431*b725ae77Skettenis linux_wait, 1432*b725ae77Skettenis linux_fetch_registers, 1433*b725ae77Skettenis linux_store_registers, 1434*b725ae77Skettenis linux_read_memory, 1435*b725ae77Skettenis linux_write_memory, 1436*b725ae77Skettenis linux_look_up_symbols, 1437*b725ae77Skettenis linux_send_signal, 1438*b725ae77Skettenis linux_read_auxv, 1439*b725ae77Skettenis }; 1440*b725ae77Skettenis 1441*b725ae77Skettenis static void 1442*b725ae77Skettenis linux_init_signals () 1443*b725ae77Skettenis { 1444*b725ae77Skettenis /* FIXME drow/2002-06-09: As above, we should check with LinuxThreads 1445*b725ae77Skettenis to find what the cancel signal actually is. */ 1446*b725ae77Skettenis signal (__SIGRTMIN+1, SIG_IGN); 1447*b725ae77Skettenis } 1448*b725ae77Skettenis 1449*b725ae77Skettenis void 1450*b725ae77Skettenis initialize_low (void) 1451*b725ae77Skettenis { 1452*b725ae77Skettenis using_threads = 0; 1453*b725ae77Skettenis set_target_ops (&linux_target_ops); 1454*b725ae77Skettenis set_breakpoint_data (the_low_target.breakpoint, 1455*b725ae77Skettenis the_low_target.breakpoint_len); 1456*b725ae77Skettenis init_registers (); 1457*b725ae77Skettenis linux_init_signals (); 1458*b725ae77Skettenis } 1459