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