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