1/* Interface GDB to the GNU Hurd. 2 Copyright (C) 1992, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2006, 2007 3 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 Written by Miles Bader <miles@gnu.ai.mit.edu> 8 9 Some code and ideas from m3-nat.c by Jukka Virtanen <jtv@hut.fi> 10 11 This program is free software; you can redistribute it and/or modify 12 it under the terms of the GNU General Public License as published by 13 the Free Software Foundation; either version 3 of the License, or 14 (at your option) any later version. 15 16 This program is distributed in the hope that it will be useful, 17 but WITHOUT ANY WARRANTY; without even the implied warranty of 18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 GNU General Public License for more details. 20 21 You should have received a copy of the GNU General Public License 22 along with this program. If not, see <http://www.gnu.org/licenses/>. 23 */ 24 25#include <ctype.h> 26#include <errno.h> 27#include <limits.h> 28#include <setjmp.h> 29#include <signal.h> 30#include <stdio.h> 31#include "gdb_string.h" 32#include <sys/ptrace.h> 33 34#include <mach.h> 35#include <mach_error.h> 36#include <mach/exception.h> 37#include <mach/message.h> 38#include <mach/notify.h> 39#include <mach/vm_attributes.h> 40 41#include <hurd.h> 42#include <hurd/interrupt.h> 43#include <hurd/msg.h> 44#include <hurd/msg_request.h> 45#include <hurd/process.h> 46/* Defined in <hurd/process.h>, but we need forward declarations from 47 <hurd/process_request.h> as well. */ 48#undef _process_user_ 49#include <hurd/process_request.h> 50#include <hurd/signal.h> 51#include <hurd/sigpreempt.h> 52 53#include <portinfo.h> 54 55#include "defs.h" 56#include "inferior.h" 57#include "symtab.h" 58#include "value.h" 59#include "language.h" 60#include "target.h" 61#include "gdb_wait.h" 62#include "gdbcmd.h" 63#include "gdbcore.h" 64#include "gdbthread.h" 65#include "gdb_assert.h" 66#include "gdb_obstack.h" 67 68#include "gnu-nat.h" 69 70#include "exc_request_S.h" 71#include "notify_S.h" 72#include "process_reply_S.h" 73#include "msg_reply_S.h" 74#include "exc_request_U.h" 75#include "msg_U.h" 76 77static process_t proc_server = MACH_PORT_NULL; 78 79/* If we've sent a proc_wait_request to the proc server, the pid of the 80 process we asked about. We can only ever have one outstanding. */ 81int proc_wait_pid = 0; 82 83/* The number of wait requests we've sent, and expect replies from. */ 84int proc_waits_pending = 0; 85 86int gnu_debug_flag = 0; 87 88/* Forward decls */ 89 90extern struct target_ops gnu_ops; 91 92struct inf *make_inf (); 93void inf_clear_wait (struct inf *inf); 94void inf_cleanup (struct inf *inf); 95void inf_startup (struct inf *inf, int pid); 96int inf_update_suspends (struct inf *inf); 97void inf_set_pid (struct inf *inf, pid_t pid); 98void inf_validate_procs (struct inf *inf); 99void inf_steal_exc_ports (struct inf *inf); 100void inf_restore_exc_ports (struct inf *inf); 101struct proc *inf_tid_to_proc (struct inf *inf, int tid); 102void inf_set_threads_resume_sc (struct inf *inf, 103 struct proc *run_thread, 104 int run_others); 105int inf_set_threads_resume_sc_for_signal_thread (struct inf *inf); 106void inf_suspend (struct inf *inf); 107void inf_resume (struct inf *inf); 108void inf_set_step_thread (struct inf *inf, struct proc *proc); 109void inf_detach (struct inf *inf); 110void inf_attach (struct inf *inf, int pid); 111void inf_signal (struct inf *inf, enum target_signal sig); 112void inf_continue (struct inf *inf); 113 114#define inf_debug(_inf, msg, args...) \ 115 do { struct inf *__inf = (_inf); \ 116 debug ("{inf %d %p}: " msg, __inf->pid, __inf , ##args); } while (0) 117 118void proc_abort (struct proc *proc, int force); 119struct proc *make_proc (struct inf *inf, mach_port_t port, int tid); 120struct proc *_proc_free (struct proc *proc); 121int proc_update_sc (struct proc *proc); 122error_t proc_get_exception_port (struct proc *proc, mach_port_t * port); 123error_t proc_set_exception_port (struct proc *proc, mach_port_t port); 124static mach_port_t _proc_get_exc_port (struct proc *proc); 125void proc_steal_exc_port (struct proc *proc, mach_port_t exc_port); 126void proc_restore_exc_port (struct proc *proc); 127int proc_trace (struct proc *proc, int set); 128 129/* Evaluate RPC_EXPR in a scope with the variables MSGPORT and REFPORT bound 130 to INF's msg port and task port respectively. If it has no msg port, 131 EIEIO is returned. INF must refer to a running process! */ 132#define INF_MSGPORT_RPC(inf, rpc_expr) \ 133 HURD_MSGPORT_RPC (proc_getmsgport (proc_server, inf->pid, &msgport), \ 134 (refport = inf->task->port, 0), 0, \ 135 msgport ? (rpc_expr) : EIEIO) 136 137/* Like INF_MSGPORT_RPC, but will also resume the signal thread to ensure 138 there's someone around to deal with the RPC (and resuspend things 139 afterwards). This effects INF's threads' resume_sc count. */ 140#define INF_RESUME_MSGPORT_RPC(inf, rpc_expr) \ 141 (inf_set_threads_resume_sc_for_signal_thread (inf) \ 142 ? ({ error_t __e; \ 143 inf_resume (inf); \ 144 __e = INF_MSGPORT_RPC (inf, rpc_expr); \ 145 inf_suspend (inf); \ 146 __e; }) \ 147 : EIEIO) 148 149 150/* The state passed by an exception message. */ 151struct exc_state 152 { 153 int exception; /* The exception code */ 154 int code, subcode; 155 mach_port_t handler; /* The real exception port to handle this. */ 156 mach_port_t reply; /* The reply port from the exception call. */ 157 }; 158 159/* The results of the last wait an inf did. */ 160struct inf_wait 161 { 162 struct target_waitstatus status; /* The status returned to gdb. */ 163 struct exc_state exc; /* The exception that caused us to return. */ 164 struct proc *thread; /* The thread in question. */ 165 int suppress; /* Something trivial happened. */ 166 }; 167 168/* The state of an inferior. */ 169struct inf 170 { 171 /* Fields describing the current inferior. */ 172 173 struct proc *task; /* The mach task. */ 174 struct proc *threads; /* A linked list of all threads in TASK. */ 175 176 /* True if THREADS needn't be validated by querying the task. We assume that 177 we and the task in question are the only ones frobbing the thread list, 178 so as long as we don't let any code run, we don't have to worry about 179 THREADS changing. */ 180 int threads_up_to_date; 181 182 pid_t pid; /* The real system PID. */ 183 184 struct inf_wait wait; /* What to return from target_wait. */ 185 186 /* One thread proc in INF may be in `single-stepping mode'. This is it. */ 187 struct proc *step_thread; 188 189 /* The thread we think is the signal thread. */ 190 struct proc *signal_thread; 191 192 mach_port_t event_port; /* Where we receive various msgs. */ 193 194 /* True if we think at least one thread in the inferior could currently be 195 running. */ 196 unsigned int running:1; 197 198 /* True if the process has stopped (in the proc server sense). Note that 199 since a proc server `stop' leaves the signal thread running, the inf can 200 be RUNNING && STOPPED... */ 201 unsigned int stopped:1; 202 203 /* True if the inferior has no message port. */ 204 unsigned int nomsg:1; 205 206 /* True if the inferior is traced. */ 207 unsigned int traced:1; 208 209 /* True if we shouldn't try waiting for the inferior, usually because we 210 can't for some reason. */ 211 unsigned int no_wait:1; 212 213 /* When starting a new inferior, we don't try to validate threads until all 214 the proper execs have been done. This is a count of how many execs we 215 expect to happen. */ 216 unsigned pending_execs; 217 218 /* Fields describing global state */ 219 220 /* The task suspend count used when gdb has control. This is normally 1 to 221 make things easier for us, but sometimes (like when attaching to vital 222 system servers) it may be desirable to let the task continue to run 223 (pausing individual threads as necessary). */ 224 int pause_sc; 225 226 /* The task suspend count left when detaching from a task. */ 227 int detach_sc; 228 229 /* The initial values used for the run_sc and pause_sc of newly discovered 230 threads -- see the definition of those fields in struct proc. */ 231 int default_thread_run_sc; 232 int default_thread_pause_sc; 233 int default_thread_detach_sc; 234 235 /* True if the process should be traced when started/attached. Newly 236 started processes *must* be traced at first to exec them properly, but 237 if this is false, tracing is turned off as soon it has done so. */ 238 int want_signals; 239 240 /* True if exceptions from the inferior process should be trapped. This 241 must be on to use breakpoints. */ 242 int want_exceptions; 243 }; 244 245 246int 247__proc_pid (struct proc *proc) 248{ 249 return proc->inf->pid; 250} 251 252 253/* Update PROC's real suspend count to match it's desired one. Returns true 254 if we think PROC is now in a runnable state. */ 255int 256proc_update_sc (struct proc *proc) 257{ 258 int running; 259 int err = 0; 260 int delta = proc->sc - proc->cur_sc; 261 262 if (delta) 263 proc_debug (proc, "sc: %d --> %d", proc->cur_sc, proc->sc); 264 265 if (proc->sc == 0 && proc->state_changed) 266 /* Since PROC may start running, we must write back any state changes. */ 267 { 268 gdb_assert (proc_is_thread (proc)); 269 proc_debug (proc, "storing back changed thread state"); 270 err = thread_set_state (proc->port, THREAD_STATE_FLAVOR, 271 (thread_state_t) &proc->state, THREAD_STATE_SIZE); 272 if (!err) 273 proc->state_changed = 0; 274 } 275 276 if (delta > 0) 277 { 278 while (delta-- > 0 && !err) 279 { 280 if (proc_is_task (proc)) 281 err = task_suspend (proc->port); 282 else 283 err = thread_suspend (proc->port); 284 } 285 } 286 else 287 { 288 while (delta++ < 0 && !err) 289 { 290 if (proc_is_task (proc)) 291 err = task_resume (proc->port); 292 else 293 err = thread_resume (proc->port); 294 } 295 } 296 if (!err) 297 proc->cur_sc = proc->sc; 298 299 /* If we got an error, then the task/thread has disappeared. */ 300 running = !err && proc->sc == 0; 301 302 proc_debug (proc, "is %s", err ? "dead" : running ? "running" : "suspended"); 303 if (err) 304 proc_debug (proc, "err = %s", safe_strerror (err)); 305 306 if (running) 307 { 308 proc->aborted = 0; 309 proc->state_valid = proc->state_changed = 0; 310 proc->fetched_regs = 0; 311 } 312 313 return running; 314} 315 316 317/* Thread_abort is called on PROC if needed. PROC must be a thread proc. 318 If PROC is deemed `precious', then nothing is done unless FORCE is true. 319 In particular, a thread is precious if it's running (in which case forcing 320 it includes suspending it first), or if it has an exception pending. */ 321void 322proc_abort (struct proc *proc, int force) 323{ 324 gdb_assert (proc_is_thread (proc)); 325 326 if (!proc->aborted) 327 { 328 struct inf *inf = proc->inf; 329 int running = (proc->cur_sc == 0 && inf->task->cur_sc == 0); 330 331 if (running && force) 332 { 333 proc->sc = 1; 334 inf_update_suspends (proc->inf); 335 running = 0; 336 warning (_("Stopped %s."), proc_string (proc)); 337 } 338 else if (proc == inf->wait.thread && inf->wait.exc.reply && !force) 339 /* An exception is pending on PROC, which don't mess with. */ 340 running = 1; 341 342 if (!running) 343 /* We only abort the thread if it's not actually running. */ 344 { 345 thread_abort (proc->port); 346 proc_debug (proc, "aborted"); 347 proc->aborted = 1; 348 } 349 else 350 proc_debug (proc, "not aborting"); 351 } 352} 353 354/* Make sure that the state field in PROC is up to date, and return a pointer 355 to it, or 0 if something is wrong. If WILL_MODIFY is true, makes sure 356 that the thread is stopped and aborted first, and sets the state_changed 357 field in PROC to true. */ 358thread_state_t 359proc_get_state (struct proc *proc, int will_modify) 360{ 361 int was_aborted = proc->aborted; 362 363 proc_debug (proc, "updating state info%s", 364 will_modify ? " (with intention to modify)" : ""); 365 366 proc_abort (proc, will_modify); 367 368 if (!was_aborted && proc->aborted) 369 /* PROC's state may have changed since we last fetched it. */ 370 proc->state_valid = 0; 371 372 if (!proc->state_valid) 373 { 374 mach_msg_type_number_t state_size = THREAD_STATE_SIZE; 375 error_t err = 376 thread_get_state (proc->port, THREAD_STATE_FLAVOR, 377 (thread_state_t) &proc->state, &state_size); 378 proc_debug (proc, "getting thread state"); 379 proc->state_valid = !err; 380 } 381 382 if (proc->state_valid) 383 { 384 if (will_modify) 385 proc->state_changed = 1; 386 return (thread_state_t) &proc->state; 387 } 388 else 389 return 0; 390} 391 392 393/* Set PORT to PROC's exception port. */ 394error_t 395proc_get_exception_port (struct proc * proc, mach_port_t * port) 396{ 397 if (proc_is_task (proc)) 398 return task_get_exception_port (proc->port, port); 399 else 400 return thread_get_exception_port (proc->port, port); 401} 402 403/* Set PROC's exception port to PORT. */ 404error_t 405proc_set_exception_port (struct proc * proc, mach_port_t port) 406{ 407 proc_debug (proc, "setting exception port: %d", port); 408 if (proc_is_task (proc)) 409 return task_set_exception_port (proc->port, port); 410 else 411 return thread_set_exception_port (proc->port, port); 412} 413 414/* Get PROC's exception port, cleaning up a bit if proc has died. */ 415static mach_port_t 416_proc_get_exc_port (struct proc *proc) 417{ 418 mach_port_t exc_port; 419 error_t err = proc_get_exception_port (proc, &exc_port); 420 421 if (err) 422 /* PROC must be dead. */ 423 { 424 if (proc->exc_port) 425 mach_port_deallocate (mach_task_self (), proc->exc_port); 426 proc->exc_port = MACH_PORT_NULL; 427 if (proc->saved_exc_port) 428 mach_port_deallocate (mach_task_self (), proc->saved_exc_port); 429 proc->saved_exc_port = MACH_PORT_NULL; 430 } 431 432 return exc_port; 433} 434 435/* Replace PROC's exception port with EXC_PORT, unless it's already been 436 done. Stash away any existing exception port so we can restore it later. */ 437void 438proc_steal_exc_port (struct proc *proc, mach_port_t exc_port) 439{ 440 mach_port_t cur_exc_port = _proc_get_exc_port (proc); 441 442 if (cur_exc_port) 443 { 444 error_t err = 0; 445 446 proc_debug (proc, "inserting exception port: %d", exc_port); 447 448 if (cur_exc_port != exc_port) 449 /* Put in our exception port. */ 450 err = proc_set_exception_port (proc, exc_port); 451 452 if (err || cur_exc_port == proc->exc_port) 453 /* We previously set the exception port, and it's still set. So we 454 just keep the old saved port which is what the proc set. */ 455 { 456 if (cur_exc_port) 457 mach_port_deallocate (mach_task_self (), cur_exc_port); 458 } 459 else 460 /* Keep a copy of PROC's old exception port so it can be restored. */ 461 { 462 if (proc->saved_exc_port) 463 mach_port_deallocate (mach_task_self (), proc->saved_exc_port); 464 proc->saved_exc_port = cur_exc_port; 465 } 466 467 proc_debug (proc, "saved exception port: %d", proc->saved_exc_port); 468 469 if (!err) 470 proc->exc_port = exc_port; 471 else 472 warning (_("Error setting exception port for %s: %s"), 473 proc_string (proc), safe_strerror (err)); 474 } 475} 476 477/* If we previously replaced PROC's exception port, put back what we 478 found there at the time, unless *our* exception port has since been 479 overwritten, in which case who knows what's going on. */ 480void 481proc_restore_exc_port (struct proc *proc) 482{ 483 mach_port_t cur_exc_port = _proc_get_exc_port (proc); 484 485 if (cur_exc_port) 486 { 487 error_t err = 0; 488 489 proc_debug (proc, "restoring real exception port"); 490 491 if (proc->exc_port == cur_exc_port) 492 /* Our's is still there. */ 493 err = proc_set_exception_port (proc, proc->saved_exc_port); 494 495 if (proc->saved_exc_port) 496 mach_port_deallocate (mach_task_self (), proc->saved_exc_port); 497 proc->saved_exc_port = MACH_PORT_NULL; 498 499 if (!err) 500 proc->exc_port = MACH_PORT_NULL; 501 else 502 warning (_("Error setting exception port for %s: %s"), 503 proc_string (proc), safe_strerror (err)); 504 } 505} 506 507 508/* Turns hardware tracing in PROC on or off when SET is true or false, 509 respectively. Returns true on success. */ 510int 511proc_trace (struct proc *proc, int set) 512{ 513 thread_state_t state = proc_get_state (proc, 1); 514 515 if (!state) 516 return 0; /* the thread must be dead. */ 517 518 proc_debug (proc, "tracing %s", set ? "on" : "off"); 519 520 if (set) 521 { 522 /* XXX We don't get the exception unless the thread has its own 523 exception port???? */ 524 if (proc->exc_port == MACH_PORT_NULL) 525 proc_steal_exc_port (proc, proc->inf->event_port); 526 THREAD_STATE_SET_TRACED (state); 527 } 528 else 529 THREAD_STATE_CLEAR_TRACED (state); 530 531 return 1; 532} 533 534 535/* A variable from which to assign new TIDs. */ 536static int next_thread_id = 1; 537 538/* Returns a new proc structure with the given fields. Also adds a 539 notification for PORT becoming dead to be sent to INF's notify port. */ 540struct proc * 541make_proc (struct inf *inf, mach_port_t port, int tid) 542{ 543 error_t err; 544 mach_port_t prev_port = MACH_PORT_NULL; 545 struct proc *proc = xmalloc (sizeof (struct proc)); 546 547 proc->port = port; 548 proc->tid = tid; 549 proc->inf = inf; 550 proc->next = 0; 551 proc->saved_exc_port = MACH_PORT_NULL; 552 proc->exc_port = MACH_PORT_NULL; 553 554 proc->sc = 0; 555 proc->cur_sc = 0; 556 557 /* Note that these are all the values for threads; the task simply uses the 558 corresponding field in INF directly. */ 559 proc->run_sc = inf->default_thread_run_sc; 560 proc->pause_sc = inf->default_thread_pause_sc; 561 proc->detach_sc = inf->default_thread_detach_sc; 562 proc->resume_sc = proc->run_sc; 563 564 proc->aborted = 0; 565 proc->dead = 0; 566 proc->state_valid = 0; 567 proc->state_changed = 0; 568 569 proc_debug (proc, "is new"); 570 571 /* Get notified when things die. */ 572 err = 573 mach_port_request_notification (mach_task_self (), port, 574 MACH_NOTIFY_DEAD_NAME, 1, 575 inf->event_port, 576 MACH_MSG_TYPE_MAKE_SEND_ONCE, 577 &prev_port); 578 if (err) 579 warning (_("Couldn't request notification for port %d: %s"), 580 port, safe_strerror (err)); 581 else 582 { 583 proc_debug (proc, "notifications to: %d", inf->event_port); 584 if (prev_port != MACH_PORT_NULL) 585 mach_port_deallocate (mach_task_self (), prev_port); 586 } 587 588 if (inf->want_exceptions) 589 { 590 if (proc_is_task (proc)) 591 /* Make the task exception port point to us. */ 592 proc_steal_exc_port (proc, inf->event_port); 593 else 594 /* Just clear thread exception ports -- they default to the 595 task one. */ 596 proc_steal_exc_port (proc, MACH_PORT_NULL); 597 } 598 599 return proc; 600} 601 602/* Frees PROC and any resources it uses, and returns the value of PROC's 603 next field. */ 604struct proc * 605_proc_free (struct proc *proc) 606{ 607 struct inf *inf = proc->inf; 608 struct proc *next = proc->next; 609 610 proc_debug (proc, "freeing..."); 611 612 if (proc == inf->step_thread) 613 /* Turn off single stepping. */ 614 inf_set_step_thread (inf, 0); 615 if (proc == inf->wait.thread) 616 inf_clear_wait (inf); 617 if (proc == inf->signal_thread) 618 inf->signal_thread = 0; 619 620 if (proc->port != MACH_PORT_NULL) 621 { 622 if (proc->exc_port != MACH_PORT_NULL) 623 /* Restore the original exception port. */ 624 proc_restore_exc_port (proc); 625 if (proc->cur_sc != 0) 626 /* Resume the thread/task. */ 627 { 628 proc->sc = 0; 629 proc_update_sc (proc); 630 } 631 mach_port_deallocate (mach_task_self (), proc->port); 632 } 633 634 xfree (proc); 635 return next; 636} 637 638 639struct inf * 640make_inf (void) 641{ 642 struct inf *inf = xmalloc (sizeof (struct inf)); 643 644 inf->task = 0; 645 inf->threads = 0; 646 inf->threads_up_to_date = 0; 647 inf->pid = 0; 648 inf->wait.status.kind = TARGET_WAITKIND_SPURIOUS; 649 inf->wait.thread = 0; 650 inf->wait.exc.handler = MACH_PORT_NULL; 651 inf->wait.exc.reply = MACH_PORT_NULL; 652 inf->step_thread = 0; 653 inf->signal_thread = 0; 654 inf->event_port = MACH_PORT_NULL; 655 inf->running = 0; 656 inf->stopped = 0; 657 inf->nomsg = 1; 658 inf->traced = 0; 659 inf->no_wait = 0; 660 inf->pending_execs = 0; 661 inf->pause_sc = 1; 662 inf->detach_sc = 0; 663 inf->default_thread_run_sc = 0; 664 inf->default_thread_pause_sc = 0; 665 inf->default_thread_detach_sc = 0; 666 inf->want_signals = 1; /* By default */ 667 inf->want_exceptions = 1; /* By default */ 668 669 return inf; 670} 671 672/* Clear INF's target wait status. */ 673void 674inf_clear_wait (struct inf *inf) 675{ 676 inf_debug (inf, "clearing wait"); 677 inf->wait.status.kind = TARGET_WAITKIND_SPURIOUS; 678 inf->wait.thread = 0; 679 inf->wait.suppress = 0; 680 if (inf->wait.exc.handler != MACH_PORT_NULL) 681 { 682 mach_port_deallocate (mach_task_self (), inf->wait.exc.handler); 683 inf->wait.exc.handler = MACH_PORT_NULL; 684 } 685 if (inf->wait.exc.reply != MACH_PORT_NULL) 686 { 687 mach_port_deallocate (mach_task_self (), inf->wait.exc.reply); 688 inf->wait.exc.reply = MACH_PORT_NULL; 689 } 690} 691 692 693void 694inf_cleanup (struct inf *inf) 695{ 696 inf_debug (inf, "cleanup"); 697 698 inf_clear_wait (inf); 699 700 inf_set_pid (inf, -1); 701 inf->pid = 0; 702 inf->running = 0; 703 inf->stopped = 0; 704 inf->nomsg = 1; 705 inf->traced = 0; 706 inf->no_wait = 0; 707 inf->pending_execs = 0; 708 709 if (inf->event_port) 710 { 711 mach_port_destroy (mach_task_self (), inf->event_port); 712 inf->event_port = MACH_PORT_NULL; 713 } 714} 715 716void 717inf_startup (struct inf *inf, int pid) 718{ 719 error_t err; 720 721 inf_debug (inf, "startup: pid = %d", pid); 722 723 inf_cleanup (inf); 724 725 /* Make the port on which we receive all events. */ 726 err = mach_port_allocate (mach_task_self (), 727 MACH_PORT_RIGHT_RECEIVE, &inf->event_port); 728 if (err) 729 error (_("Error allocating event port: %s"), safe_strerror (err)); 730 731 /* Make a send right for it, so we can easily copy it for other people. */ 732 mach_port_insert_right (mach_task_self (), inf->event_port, 733 inf->event_port, MACH_MSG_TYPE_MAKE_SEND); 734 inf_set_pid (inf, pid); 735} 736 737 738/* Close current process, if any, and attach INF to process PORT. */ 739void 740inf_set_pid (struct inf *inf, pid_t pid) 741{ 742 task_t task_port; 743 struct proc *task = inf->task; 744 745 inf_debug (inf, "setting pid: %d", pid); 746 747 if (pid < 0) 748 task_port = MACH_PORT_NULL; 749 else 750 { 751 error_t err = proc_pid2task (proc_server, pid, &task_port); 752 if (err) 753 error (_("Error getting task for pid %d: %s"), pid, safe_strerror (err)); 754 } 755 756 inf_debug (inf, "setting task: %d", task_port); 757 758 if (inf->pause_sc) 759 task_suspend (task_port); 760 761 if (task && task->port != task_port) 762 { 763 inf->task = 0; 764 inf_validate_procs (inf); /* Trash all the threads. */ 765 _proc_free (task); /* And the task. */ 766 } 767 768 if (task_port != MACH_PORT_NULL) 769 { 770 inf->task = make_proc (inf, task_port, PROC_TID_TASK); 771 inf->threads_up_to_date = 0; 772 } 773 774 if (inf->task) 775 { 776 inf->pid = pid; 777 if (inf->pause_sc) 778 /* Reflect task_suspend above. */ 779 inf->task->sc = inf->task->cur_sc = 1; 780 } 781 else 782 inf->pid = -1; 783} 784 785 786/* Validates INF's stopped, nomsg and traced field from the actual 787 proc server state. Note that the traced field is only updated from 788 the proc server state if we do not have a message port. If we do 789 have a message port we'd better look at the tracemask itself. */ 790static void 791inf_validate_procinfo (struct inf *inf) 792{ 793 char *noise; 794 mach_msg_type_number_t noise_len = 0; 795 struct procinfo *pi; 796 mach_msg_type_number_t pi_len = 0; 797 int info_flags = 0; 798 error_t err = 799 proc_getprocinfo (proc_server, inf->pid, &info_flags, 800 (procinfo_t *) &pi, &pi_len, &noise, &noise_len); 801 802 if (!err) 803 { 804 inf->stopped = !!(pi->state & PI_STOPPED); 805 inf->nomsg = !!(pi->state & PI_NOMSG); 806 if (inf->nomsg) 807 inf->traced = !!(pi->state & PI_TRACED); 808 vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len); 809 if (noise_len > 0) 810 vm_deallocate (mach_task_self (), (vm_address_t) noise, noise_len); 811 } 812} 813 814/* Validates INF's task suspend count. If it's higher than we expect, 815 verify with the user before `stealing' the extra count. */ 816static void 817inf_validate_task_sc (struct inf *inf) 818{ 819 char *noise; 820 mach_msg_type_number_t noise_len = 0; 821 struct procinfo *pi; 822 mach_msg_type_number_t pi_len = 0; 823 int info_flags = PI_FETCH_TASKINFO; 824 int suspend_count = -1; 825 error_t err; 826 827 retry: 828 err = proc_getprocinfo (proc_server, inf->pid, &info_flags, 829 (procinfo_t *) &pi, &pi_len, &noise, &noise_len); 830 if (err) 831 { 832 inf->task->dead = 1; /* oh well */ 833 return; 834 } 835 836 if (inf->task->cur_sc < pi->taskinfo.suspend_count && suspend_count == -1) 837 { 838 /* The proc server might have suspended the task while stopping 839 it. This happens when the task is handling a traced signal. 840 Refetch the suspend count. The proc server should be 841 finished stopping the task by now. */ 842 suspend_count = pi->taskinfo.suspend_count; 843 goto retry; 844 } 845 846 suspend_count = pi->taskinfo.suspend_count; 847 848 vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len); 849 if (noise_len > 0) 850 vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len); 851 852 if (inf->task->cur_sc < suspend_count) 853 { 854 int abort; 855 856 target_terminal_ours (); /* Allow I/O. */ 857 abort = !query ("Pid %d has an additional task suspend count of %d;" 858 " clear it? ", inf->pid, 859 suspend_count - inf->task->cur_sc); 860 target_terminal_inferior (); /* Give it back to the child. */ 861 862 if (abort) 863 error (_("Additional task suspend count left untouched.")); 864 865 inf->task->cur_sc = suspend_count; 866 } 867} 868 869/* Turns tracing for INF on or off, depending on ON, unless it already 870 is. If INF is running, the resume_sc count of INF's threads will 871 be modified, and the signal thread will briefly be run to change 872 the trace state. */ 873void 874inf_set_traced (struct inf *inf, int on) 875{ 876 if (on == inf->traced) 877 return; 878 879 if (inf->task && !inf->task->dead) 880 /* Make it take effect immediately. */ 881 { 882 sigset_t mask = on ? ~(sigset_t) 0 : 0; 883 error_t err = 884 INF_RESUME_MSGPORT_RPC (inf, msg_set_init_int (msgport, refport, 885 INIT_TRACEMASK, mask)); 886 if (err == EIEIO) 887 { 888 if (on) 889 warning (_("Can't modify tracing state for pid %d: %s"), 890 inf->pid, "No signal thread"); 891 inf->traced = on; 892 } 893 else if (err) 894 warning (_("Can't modify tracing state for pid %d: %s"), 895 inf->pid, safe_strerror (err)); 896 else 897 inf->traced = on; 898 } 899 else 900 inf->traced = on; 901} 902 903 904/* Makes all the real suspend count deltas of all the procs in INF 905 match the desired values. Careful to always do thread/task suspend 906 counts in the safe order. Returns true if at least one thread is 907 thought to be running. */ 908int 909inf_update_suspends (struct inf *inf) 910{ 911 struct proc *task = inf->task; 912 /* We don't have to update INF->threads even though we're iterating over it 913 because we'll change a thread only if it already has an existing proc 914 entry. */ 915 916 inf_debug (inf, "updating suspend counts"); 917 918 if (task) 919 { 920 struct proc *thread; 921 int task_running = (task->sc == 0), thread_running = 0; 922 923 if (task->sc > task->cur_sc) 924 /* The task is becoming _more_ suspended; do before any threads. */ 925 task_running = proc_update_sc (task); 926 927 if (inf->pending_execs) 928 /* When we're waiting for an exec, things may be happening behind our 929 back, so be conservative. */ 930 thread_running = 1; 931 932 /* Do all the thread suspend counts. */ 933 for (thread = inf->threads; thread; thread = thread->next) 934 thread_running |= proc_update_sc (thread); 935 936 if (task->sc != task->cur_sc) 937 /* We didn't do the task first, because we wanted to wait for the 938 threads; do it now. */ 939 task_running = proc_update_sc (task); 940 941 inf_debug (inf, "%srunning...", 942 (thread_running && task_running) ? "" : "not "); 943 944 inf->running = thread_running && task_running; 945 946 /* Once any thread has executed some code, we can't depend on the 947 threads list any more. */ 948 if (inf->running) 949 inf->threads_up_to_date = 0; 950 951 return inf->running; 952 } 953 954 return 0; 955} 956 957 958/* Converts a GDB pid to a struct proc. */ 959struct proc * 960inf_tid_to_thread (struct inf *inf, int tid) 961{ 962 struct proc *thread = inf->threads; 963 964 while (thread) 965 if (thread->tid == tid) 966 return thread; 967 else 968 thread = thread->next; 969 return 0; 970} 971 972/* Converts a thread port to a struct proc. */ 973struct proc * 974inf_port_to_thread (struct inf *inf, mach_port_t port) 975{ 976 struct proc *thread = inf->threads; 977 while (thread) 978 if (thread->port == port) 979 return thread; 980 else 981 thread = thread->next; 982 return 0; 983} 984 985 986/* Make INF's list of threads be consistent with reality of TASK. */ 987void 988inf_validate_procs (struct inf *inf) 989{ 990 thread_array_t threads; 991 mach_msg_type_number_t num_threads, i; 992 struct proc *task = inf->task; 993 994 /* If no threads are currently running, this function will guarantee that 995 things are up to date. The exception is if there are zero threads -- 996 then it is almost certainly in an odd state, and probably some outside 997 agent will create threads. */ 998 inf->threads_up_to_date = inf->threads ? !inf->running : 0; 999 1000 if (task) 1001 { 1002 error_t err = task_threads (task->port, &threads, &num_threads); 1003 inf_debug (inf, "fetching threads"); 1004 if (err) 1005 /* TASK must be dead. */ 1006 { 1007 task->dead = 1; 1008 task = 0; 1009 } 1010 } 1011 1012 if (!task) 1013 { 1014 num_threads = 0; 1015 inf_debug (inf, "no task"); 1016 } 1017 1018 { 1019 /* Make things normally linear. */ 1020 mach_msg_type_number_t search_start = 0; 1021 /* Which thread in PROCS corresponds to each task thread, & the task. */ 1022 struct proc *matched[num_threads + 1]; 1023 /* The last thread in INF->threads, so we can add to the end. */ 1024 struct proc *last = 0; 1025 /* The current thread we're considering. */ 1026 struct proc *thread = inf->threads; 1027 1028 memset (matched, 0, sizeof (matched)); 1029 1030 while (thread) 1031 { 1032 mach_msg_type_number_t left; 1033 1034 for (i = search_start, left = num_threads; left; i++, left--) 1035 { 1036 if (i >= num_threads) 1037 i -= num_threads; /* I wrapped around. */ 1038 if (thread->port == threads[i]) 1039 /* We already know about this thread. */ 1040 { 1041 matched[i] = thread; 1042 last = thread; 1043 thread = thread->next; 1044 search_start++; 1045 break; 1046 } 1047 } 1048 1049 if (!left) 1050 { 1051 proc_debug (thread, "died!"); 1052 thread->port = MACH_PORT_NULL; 1053 thread = _proc_free (thread); /* THREAD is dead. */ 1054 if (last) 1055 last->next = thread; 1056 else 1057 inf->threads = thread; 1058 } 1059 } 1060 1061 for (i = 0; i < num_threads; i++) 1062 { 1063 if (matched[i]) 1064 /* Throw away the duplicate send right. */ 1065 mach_port_deallocate (mach_task_self (), threads[i]); 1066 else 1067 /* THREADS[I] is a thread we don't know about yet! */ 1068 { 1069 thread = make_proc (inf, threads[i], next_thread_id++); 1070 if (last) 1071 last->next = thread; 1072 else 1073 inf->threads = thread; 1074 last = thread; 1075 proc_debug (thread, "new thread: %d", threads[i]); 1076 add_thread (pid_to_ptid (thread->tid)); /* Tell GDB's generic thread code. */ 1077 } 1078 } 1079 1080 vm_deallocate (mach_task_self (), 1081 (vm_address_t) threads, (num_threads * sizeof (thread_t))); 1082 } 1083} 1084 1085 1086/* Makes sure that INF's thread list is synced with the actual process. */ 1087int 1088inf_update_procs (struct inf *inf) 1089{ 1090 if (!inf->task) 1091 return 0; 1092 if (!inf->threads_up_to_date) 1093 inf_validate_procs (inf); 1094 return !!inf->task; 1095} 1096 1097/* Sets the resume_sc of each thread in inf. That of RUN_THREAD is set to 0, 1098 and others are set to their run_sc if RUN_OTHERS is true, and otherwise 1099 their pause_sc. */ 1100void 1101inf_set_threads_resume_sc (struct inf *inf, 1102 struct proc *run_thread, int run_others) 1103{ 1104 struct proc *thread; 1105 inf_update_procs (inf); 1106 for (thread = inf->threads; thread; thread = thread->next) 1107 if (thread == run_thread) 1108 thread->resume_sc = 0; 1109 else if (run_others) 1110 thread->resume_sc = thread->run_sc; 1111 else 1112 thread->resume_sc = thread->pause_sc; 1113} 1114 1115 1116/* Cause INF to continue execution immediately; individual threads may still 1117 be suspended (but their suspend counts will be updated). */ 1118void 1119inf_resume (struct inf *inf) 1120{ 1121 struct proc *thread; 1122 1123 inf_update_procs (inf); 1124 1125 for (thread = inf->threads; thread; thread = thread->next) 1126 thread->sc = thread->resume_sc; 1127 1128 if (inf->task) 1129 { 1130 if (!inf->pending_execs) 1131 /* Try to make sure our task count is correct -- in the case where 1132 we're waiting for an exec though, things are too volatile, so just 1133 assume things will be reasonable (which they usually will be). */ 1134 inf_validate_task_sc (inf); 1135 inf->task->sc = 0; 1136 } 1137 1138 inf_update_suspends (inf); 1139} 1140 1141/* Cause INF to stop execution immediately; individual threads may still 1142 be running. */ 1143void 1144inf_suspend (struct inf *inf) 1145{ 1146 struct proc *thread; 1147 1148 inf_update_procs (inf); 1149 1150 for (thread = inf->threads; thread; thread = thread->next) 1151 thread->sc = thread->pause_sc; 1152 1153 if (inf->task) 1154 inf->task->sc = inf->pause_sc; 1155 1156 inf_update_suspends (inf); 1157} 1158 1159 1160/* INF has one thread PROC that is in single-stepping mode. This 1161 function changes it to be PROC, changing any old step_thread to be 1162 a normal one. A PROC of 0 clears any existing value. */ 1163void 1164inf_set_step_thread (struct inf *inf, struct proc *thread) 1165{ 1166 gdb_assert (!thread || proc_is_thread (thread)); 1167 1168 if (thread) 1169 inf_debug (inf, "setting step thread: %d/%d", inf->pid, thread->tid); 1170 else 1171 inf_debug (inf, "clearing step thread"); 1172 1173 if (inf->step_thread != thread) 1174 { 1175 if (inf->step_thread && inf->step_thread->port != MACH_PORT_NULL) 1176 if (!proc_trace (inf->step_thread, 0)) 1177 return; 1178 if (thread && proc_trace (thread, 1)) 1179 inf->step_thread = thread; 1180 else 1181 inf->step_thread = 0; 1182 } 1183} 1184 1185 1186/* Set up the thread resume_sc's so that only the signal thread is running 1187 (plus whatever other thread are set to always run). Returns true if we 1188 did so, or false if we can't find a signal thread. */ 1189int 1190inf_set_threads_resume_sc_for_signal_thread (struct inf *inf) 1191{ 1192 if (inf->signal_thread) 1193 { 1194 inf_set_threads_resume_sc (inf, inf->signal_thread, 0); 1195 return 1; 1196 } 1197 else 1198 return 0; 1199} 1200 1201static void 1202inf_update_signal_thread (struct inf *inf) 1203{ 1204 /* XXX for now we assume that if there's a msgport, the 2nd thread is 1205 the signal thread. */ 1206 inf->signal_thread = inf->threads ? inf->threads->next : 0; 1207} 1208 1209 1210/* Detachs from INF's inferior task, letting it run once again... */ 1211void 1212inf_detach (struct inf *inf) 1213{ 1214 struct proc *task = inf->task; 1215 1216 inf_debug (inf, "detaching..."); 1217 1218 inf_clear_wait (inf); 1219 inf_set_step_thread (inf, 0); 1220 1221 if (task) 1222 { 1223 struct proc *thread; 1224 1225 inf_validate_procinfo (inf); 1226 1227 inf_set_traced (inf, 0); 1228 if (inf->stopped) 1229 { 1230 if (inf->nomsg) 1231 inf_continue (inf); 1232 else 1233 inf_signal (inf, TARGET_SIGNAL_0); 1234 } 1235 1236 proc_restore_exc_port (task); 1237 task->sc = inf->detach_sc; 1238 1239 for (thread = inf->threads; thread; thread = thread->next) 1240 { 1241 proc_restore_exc_port (thread); 1242 thread->sc = thread->detach_sc; 1243 } 1244 1245 inf_update_suspends (inf); 1246 } 1247 1248 inf_cleanup (inf); 1249} 1250 1251/* Attaches INF to the process with process id PID, returning it in a 1252 suspended state suitable for debugging. */ 1253void 1254inf_attach (struct inf *inf, int pid) 1255{ 1256 inf_debug (inf, "attaching: %d", pid); 1257 1258 if (inf->pid) 1259 inf_detach (inf); 1260 1261 inf_startup (inf, pid); 1262} 1263 1264 1265/* Makes sure that we've got our exception ports entrenched in the process. */ 1266void 1267inf_steal_exc_ports (struct inf *inf) 1268{ 1269 struct proc *thread; 1270 1271 inf_debug (inf, "stealing exception ports"); 1272 1273 inf_set_step_thread (inf, 0); /* The step thread is special. */ 1274 1275 proc_steal_exc_port (inf->task, inf->event_port); 1276 for (thread = inf->threads; thread; thread = thread->next) 1277 proc_steal_exc_port (thread, MACH_PORT_NULL); 1278} 1279 1280/* Makes sure the process has its own exception ports. */ 1281void 1282inf_restore_exc_ports (struct inf *inf) 1283{ 1284 struct proc *thread; 1285 1286 inf_debug (inf, "restoring exception ports"); 1287 1288 inf_set_step_thread (inf, 0); /* The step thread is special. */ 1289 1290 proc_restore_exc_port (inf->task); 1291 for (thread = inf->threads; thread; thread = thread->next) 1292 proc_restore_exc_port (thread); 1293} 1294 1295 1296/* Deliver signal SIG to INF. If INF is stopped, delivering a signal, even 1297 signal 0, will continue it. INF is assumed to be in a paused state, and 1298 the resume_sc's of INF's threads may be affected. */ 1299void 1300inf_signal (struct inf *inf, enum target_signal sig) 1301{ 1302 error_t err = 0; 1303 int host_sig = target_signal_to_host (sig); 1304 1305#define NAME target_signal_to_name (sig) 1306 1307 if (host_sig >= _NSIG) 1308 /* A mach exception. Exceptions are encoded in the signal space by 1309 putting them after _NSIG; this assumes they're positive (and not 1310 extremely large)! */ 1311 { 1312 struct inf_wait *w = &inf->wait; 1313 if (w->status.kind == TARGET_WAITKIND_STOPPED 1314 && w->status.value.sig == sig 1315 && w->thread && !w->thread->aborted) 1316 /* We're passing through the last exception we received. This is 1317 kind of bogus, because exceptions are per-thread whereas gdb 1318 treats signals as per-process. We just forward the exception to 1319 the correct handler, even it's not for the same thread as TID -- 1320 i.e., we pretend it's global. */ 1321 { 1322 struct exc_state *e = &w->exc; 1323 inf_debug (inf, "passing through exception:" 1324 " task = %d, thread = %d, exc = %d" 1325 ", code = %d, subcode = %d", 1326 w->thread->port, inf->task->port, 1327 e->exception, e->code, e->subcode); 1328 err = 1329 exception_raise_request (e->handler, 1330 e->reply, MACH_MSG_TYPE_MOVE_SEND_ONCE, 1331 w->thread->port, inf->task->port, 1332 e->exception, e->code, e->subcode); 1333 } 1334 else 1335 error (_("Can't forward spontaneous exception (%s)."), NAME); 1336 } 1337 else 1338 /* A Unix signal. */ 1339 if (inf->stopped) 1340 /* The process is stopped and expecting a signal. Just send off a 1341 request and let it get handled when we resume everything. */ 1342 { 1343 inf_debug (inf, "sending %s to stopped process", NAME); 1344 err = 1345 INF_MSGPORT_RPC (inf, 1346 msg_sig_post_untraced_request (msgport, 1347 inf->event_port, 1348 MACH_MSG_TYPE_MAKE_SEND_ONCE, 1349 host_sig, 0, 1350 refport)); 1351 if (!err) 1352 /* Posting an untraced signal automatically continues it. 1353 We clear this here rather than when we get the reply 1354 because we'd rather assume it's not stopped when it 1355 actually is, than the reverse. */ 1356 inf->stopped = 0; 1357 } 1358 else 1359 /* It's not expecting it. We have to let just the signal thread 1360 run, and wait for it to get into a reasonable state before we 1361 can continue the rest of the process. When we finally resume the 1362 process the signal we request will be the very first thing that 1363 happens. */ 1364 { 1365 inf_debug (inf, "sending %s to unstopped process" 1366 " (so resuming signal thread)", NAME); 1367 err = 1368 INF_RESUME_MSGPORT_RPC (inf, 1369 msg_sig_post_untraced (msgport, host_sig, 1370 0, refport)); 1371 } 1372 1373 if (err == EIEIO) 1374 /* Can't do too much... */ 1375 warning (_("Can't deliver signal %s: No signal thread."), NAME); 1376 else if (err) 1377 warning (_("Delivering signal %s: %s"), NAME, safe_strerror (err)); 1378 1379#undef NAME 1380} 1381 1382 1383/* Continue INF without delivering a signal. This is meant to be used 1384 when INF does not have a message port. */ 1385void 1386inf_continue (struct inf *inf) 1387{ 1388 process_t proc; 1389 error_t err = proc_pid2proc (proc_server, inf->pid, &proc); 1390 1391 if (!err) 1392 { 1393 inf_debug (inf, "continuing process"); 1394 1395 err = proc_mark_cont (proc); 1396 if (!err) 1397 { 1398 struct proc *thread; 1399 1400 for (thread = inf->threads; thread; thread = thread->next) 1401 thread_resume (thread->port); 1402 1403 inf->stopped = 0; 1404 } 1405 } 1406 1407 if (err) 1408 warning (_("Can't continue process: %s"), safe_strerror (err)); 1409} 1410 1411 1412/* The inferior used for all gdb target ops. */ 1413struct inf *current_inferior = 0; 1414 1415/* The inferior being waited for by gnu_wait. Since GDB is decidely not 1416 multi-threaded, we don't bother to lock this. */ 1417struct inf *waiting_inf; 1418 1419/* Wait for something to happen in the inferior, returning what in STATUS. */ 1420static ptid_t 1421gnu_wait (ptid_t tid, struct target_waitstatus *status) 1422{ 1423 struct msg 1424 { 1425 mach_msg_header_t hdr; 1426 mach_msg_type_t type; 1427 int data[8000]; 1428 } msg; 1429 error_t err; 1430 struct proc *thread; 1431 struct inf *inf = current_inferior; 1432 1433 extern int exc_server (mach_msg_header_t *, mach_msg_header_t *); 1434 extern int msg_reply_server (mach_msg_header_t *, mach_msg_header_t *); 1435 extern int notify_server (mach_msg_header_t *, mach_msg_header_t *); 1436 extern int process_reply_server (mach_msg_header_t *, mach_msg_header_t *); 1437 1438 gdb_assert (inf->task); 1439 1440 if (!inf->threads && !inf->pending_execs) 1441 /* No threads! Assume that maybe some outside agency is frobbing our 1442 task, and really look for new threads. If we can't find any, just tell 1443 the user to try again later. */ 1444 { 1445 inf_validate_procs (inf); 1446 if (!inf->threads && !inf->task->dead) 1447 error (_("There are no threads; try again later.")); 1448 } 1449 1450 waiting_inf = inf; 1451 1452 inf_debug (inf, "waiting for: %d", PIDGET (tid)); 1453 1454rewait: 1455 if (proc_wait_pid != inf->pid && !inf->no_wait) 1456 /* Always get information on events from the proc server. */ 1457 { 1458 inf_debug (inf, "requesting wait on pid %d", inf->pid); 1459 1460 if (proc_wait_pid) 1461 /* The proc server is single-threaded, and only allows a single 1462 outstanding wait request, so we have to cancel the previous one. */ 1463 { 1464 inf_debug (inf, "cancelling previous wait on pid %d", proc_wait_pid); 1465 interrupt_operation (proc_server, 0); 1466 } 1467 1468 err = 1469 proc_wait_request (proc_server, inf->event_port, inf->pid, WUNTRACED); 1470 if (err) 1471 warning (_("wait request failed: %s"), safe_strerror (err)); 1472 else 1473 { 1474 inf_debug (inf, "waits pending: %d", proc_waits_pending); 1475 proc_wait_pid = inf->pid; 1476 /* Even if proc_waits_pending was > 0 before, we still won't 1477 get any other replies, because it was either from a 1478 different INF, or a different process attached to INF -- 1479 and the event port, which is the wait reply port, changes 1480 when you switch processes. */ 1481 proc_waits_pending = 1; 1482 } 1483 } 1484 1485 inf_clear_wait (inf); 1486 1487 /* What can happen? (1) Dead name notification; (2) Exceptions arrive; 1488 (3) wait reply from the proc server. */ 1489 1490 inf_debug (inf, "waiting for an event..."); 1491 err = mach_msg (&msg.hdr, MACH_RCV_MSG | MACH_RCV_INTERRUPT, 1492 0, sizeof (struct msg), inf->event_port, 1493 MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL); 1494 1495 /* Re-suspend the task. */ 1496 inf_suspend (inf); 1497 1498 if (!inf->task && inf->pending_execs) 1499 /* When doing an exec, it's possible that the old task wasn't reused 1500 (e.g., setuid execs). So if the task seems to have disappeared, 1501 attempt to refetch it, as the pid should still be the same. */ 1502 inf_set_pid (inf, inf->pid); 1503 1504 if (err == EMACH_RCV_INTERRUPTED) 1505 inf_debug (inf, "interrupted"); 1506 else if (err) 1507 error (_("Couldn't wait for an event: %s"), safe_strerror (err)); 1508 else 1509 { 1510 struct 1511 { 1512 mach_msg_header_t hdr; 1513 mach_msg_type_t err_type; 1514 kern_return_t err; 1515 char noise[200]; 1516 } 1517 reply; 1518 1519 inf_debug (inf, "event: msgid = %d", msg.hdr.msgh_id); 1520 1521 /* Handle what we got. */ 1522 if (!notify_server (&msg.hdr, &reply.hdr) 1523 && !exc_server (&msg.hdr, &reply.hdr) 1524 && !process_reply_server (&msg.hdr, &reply.hdr) 1525 && !msg_reply_server (&msg.hdr, &reply.hdr)) 1526 /* Whatever it is, it's something strange. */ 1527 error (_("Got a strange event, msg id = %d."), msg.hdr.msgh_id); 1528 1529 if (reply.err) 1530 error (_("Handling event, msgid = %d: %s"), 1531 msg.hdr.msgh_id, safe_strerror (reply.err)); 1532 } 1533 1534 if (inf->pending_execs) 1535 /* We're waiting for the inferior to finish execing. */ 1536 { 1537 struct inf_wait *w = &inf->wait; 1538 enum target_waitkind kind = w->status.kind; 1539 1540 if (kind == TARGET_WAITKIND_SPURIOUS) 1541 /* Since gdb is actually counting the number of times the inferior 1542 stops, expecting one stop per exec, we only return major events 1543 while execing. */ 1544 { 1545 w->suppress = 1; 1546 inf_debug (inf, "pending_execs = %d, ignoring minor event", 1547 inf->pending_execs); 1548 } 1549 else if (kind == TARGET_WAITKIND_STOPPED 1550 && w->status.value.sig == TARGET_SIGNAL_TRAP) 1551 /* Ah hah! A SIGTRAP from the inferior while starting up probably 1552 means we've succesfully completed an exec! */ 1553 { 1554 if (--inf->pending_execs == 0) 1555 /* We're done! */ 1556 { 1557#if 0 /* do we need this? */ 1558 prune_threads (1); /* Get rid of the old shell threads */ 1559 renumber_threads (0); /* Give our threads reasonable names. */ 1560#endif 1561 } 1562 inf_debug (inf, "pending exec completed, pending_execs => %d", 1563 inf->pending_execs); 1564 } 1565 else if (kind == TARGET_WAITKIND_STOPPED) 1566 /* It's possible that this signal is because of a crashed process 1567 being handled by the hurd crash server; in this case, the process 1568 will have an extra task suspend, which we need to know about. 1569 Since the code in inf_resume that normally checks for this is 1570 disabled while INF->pending_execs, we do the check here instead. */ 1571 inf_validate_task_sc (inf); 1572 } 1573 1574 if (inf->wait.suppress) 1575 /* Some totally spurious event happened that we don't consider 1576 worth returning to gdb. Just keep waiting. */ 1577 { 1578 inf_debug (inf, "suppressing return, rewaiting..."); 1579 inf_resume (inf); 1580 goto rewait; 1581 } 1582 1583 /* Pass back out our results. */ 1584 memcpy (status, &inf->wait.status, sizeof (*status)); 1585 1586 thread = inf->wait.thread; 1587 if (thread) 1588 tid = pid_to_ptid (thread->tid); 1589 else 1590 thread = inf_tid_to_thread (inf, PIDGET (tid)); 1591 1592 if (!thread || thread->port == MACH_PORT_NULL) 1593 { 1594 /* TID is dead; try and find a new thread. */ 1595 if (inf_update_procs (inf) && inf->threads) 1596 tid = pid_to_ptid (inf->threads->tid); /* The first available thread. */ 1597 else 1598 tid = inferior_ptid; /* let wait_for_inferior handle exit case */ 1599 } 1600 1601 if (thread && PIDGET (tid) >= 0 && status->kind != TARGET_WAITKIND_SPURIOUS 1602 && inf->pause_sc == 0 && thread->pause_sc == 0) 1603 /* If something actually happened to THREAD, make sure we 1604 suspend it. */ 1605 { 1606 thread->sc = 1; 1607 inf_update_suspends (inf); 1608 } 1609 1610 inf_debug (inf, "returning tid = %d, status = %s (%d)", PIDGET (tid), 1611 status->kind == TARGET_WAITKIND_EXITED ? "EXITED" 1612 : status->kind == TARGET_WAITKIND_STOPPED ? "STOPPED" 1613 : status->kind == TARGET_WAITKIND_SIGNALLED ? "SIGNALLED" 1614 : status->kind == TARGET_WAITKIND_LOADED ? "LOADED" 1615 : status->kind == TARGET_WAITKIND_SPURIOUS ? "SPURIOUS" 1616 : "?", 1617 status->value.integer); 1618 1619 return tid; 1620} 1621 1622 1623/* The rpc handler called by exc_server. */ 1624error_t 1625S_exception_raise_request (mach_port_t port, mach_port_t reply_port, 1626 thread_t thread_port, task_t task_port, 1627 int exception, int code, int subcode) 1628{ 1629 struct inf *inf = waiting_inf; 1630 struct proc *thread = inf_port_to_thread (inf, thread_port); 1631 1632 inf_debug (waiting_inf, 1633 "thread = %d, task = %d, exc = %d, code = %d, subcode = %d", 1634 thread_port, task_port, exception, code, subcode); 1635 1636 if (!thread) 1637 /* We don't know about thread? */ 1638 { 1639 inf_update_procs (inf); 1640 thread = inf_port_to_thread (inf, thread_port); 1641 if (!thread) 1642 /* Give up, the generating thread is gone. */ 1643 return 0; 1644 } 1645 1646 mach_port_deallocate (mach_task_self (), thread_port); 1647 mach_port_deallocate (mach_task_self (), task_port); 1648 1649 if (!thread->aborted) 1650 /* THREAD hasn't been aborted since this exception happened (abortion 1651 clears any exception state), so it must be real. */ 1652 { 1653 /* Store away the details; this will destroy any previous info. */ 1654 inf->wait.thread = thread; 1655 1656 inf->wait.status.kind = TARGET_WAITKIND_STOPPED; 1657 1658 if (exception == EXC_BREAKPOINT) 1659 /* GDB likes to get SIGTRAP for breakpoints. */ 1660 { 1661 inf->wait.status.value.sig = TARGET_SIGNAL_TRAP; 1662 mach_port_deallocate (mach_task_self (), reply_port); 1663 } 1664 else 1665 /* Record the exception so that we can forward it later. */ 1666 { 1667 if (thread->exc_port == port) 1668 { 1669 inf_debug (waiting_inf, "Handler is thread exception port <%d>", 1670 thread->saved_exc_port); 1671 inf->wait.exc.handler = thread->saved_exc_port; 1672 } 1673 else 1674 { 1675 inf_debug (waiting_inf, "Handler is task exception port <%d>", 1676 inf->task->saved_exc_port); 1677 inf->wait.exc.handler = inf->task->saved_exc_port; 1678 gdb_assert (inf->task->exc_port == port); 1679 } 1680 if (inf->wait.exc.handler != MACH_PORT_NULL) 1681 /* Add a reference to the exception handler. */ 1682 mach_port_mod_refs (mach_task_self (), 1683 inf->wait.exc.handler, MACH_PORT_RIGHT_SEND, 1684 1); 1685 1686 inf->wait.exc.exception = exception; 1687 inf->wait.exc.code = code; 1688 inf->wait.exc.subcode = subcode; 1689 inf->wait.exc.reply = reply_port; 1690 1691 /* Exceptions are encoded in the signal space by putting them after 1692 _NSIG; this assumes they're positive (and not extremely large)! */ 1693 inf->wait.status.value.sig = 1694 target_signal_from_host (_NSIG + exception); 1695 } 1696 } 1697 else 1698 /* A supppressed exception, which ignore. */ 1699 { 1700 inf->wait.suppress = 1; 1701 mach_port_deallocate (mach_task_self (), reply_port); 1702 } 1703 1704 return 0; 1705} 1706 1707 1708/* Fill in INF's wait field after a task has died without giving us more 1709 detailed information. */ 1710void 1711inf_task_died_status (struct inf *inf) 1712{ 1713 warning (_("Pid %d died with unknown exit status, using SIGKILL."), inf->pid); 1714 inf->wait.status.kind = TARGET_WAITKIND_SIGNALLED; 1715 inf->wait.status.value.sig = TARGET_SIGNAL_KILL; 1716} 1717 1718/* Notify server routines. The only real one is dead name notification. */ 1719error_t 1720do_mach_notify_dead_name (mach_port_t notify, mach_port_t dead_port) 1721{ 1722 struct inf *inf = waiting_inf; 1723 1724 inf_debug (waiting_inf, "port = %d", dead_port); 1725 1726 if (inf->task && inf->task->port == dead_port) 1727 { 1728 proc_debug (inf->task, "is dead"); 1729 inf->task->port = MACH_PORT_NULL; 1730 if (proc_wait_pid == inf->pid) 1731 /* We have a wait outstanding on the process, which will return more 1732 detailed information, so delay until we get that. */ 1733 inf->wait.suppress = 1; 1734 else 1735 /* We never waited for the process (maybe it wasn't a child), so just 1736 pretend it got a SIGKILL. */ 1737 inf_task_died_status (inf); 1738 } 1739 else 1740 { 1741 struct proc *thread = inf_port_to_thread (inf, dead_port); 1742 if (thread) 1743 { 1744 proc_debug (thread, "is dead"); 1745 thread->port = MACH_PORT_NULL; 1746 } 1747 1748 if (inf->task->dead) 1749 /* Since the task is dead, its threads are dying with it. */ 1750 inf->wait.suppress = 1; 1751 } 1752 1753 mach_port_deallocate (mach_task_self (), dead_port); 1754 inf->threads_up_to_date = 0; /* Just in case */ 1755 1756 return 0; 1757} 1758 1759 1760static error_t 1761ill_rpc (char *fun) 1762{ 1763 warning (_("illegal rpc: %s"), fun); 1764 return 0; 1765} 1766 1767error_t 1768do_mach_notify_no_senders (mach_port_t notify, mach_port_mscount_t count) 1769{ 1770 return ill_rpc ("do_mach_notify_no_senders"); 1771} 1772 1773error_t 1774do_mach_notify_port_deleted (mach_port_t notify, mach_port_t name) 1775{ 1776 return ill_rpc ("do_mach_notify_port_deleted"); 1777} 1778 1779error_t 1780do_mach_notify_msg_accepted (mach_port_t notify, mach_port_t name) 1781{ 1782 return ill_rpc ("do_mach_notify_msg_accepted"); 1783} 1784 1785error_t 1786do_mach_notify_port_destroyed (mach_port_t notify, mach_port_t name) 1787{ 1788 return ill_rpc ("do_mach_notify_port_destroyed"); 1789} 1790 1791error_t 1792do_mach_notify_send_once (mach_port_t notify) 1793{ 1794 return ill_rpc ("do_mach_notify_send_once"); 1795} 1796 1797 1798/* Process_reply server routines. We only use process_wait_reply. */ 1799 1800error_t 1801S_proc_wait_reply (mach_port_t reply, error_t err, 1802 int status, int sigcode, rusage_t rusage, pid_t pid) 1803{ 1804 struct inf *inf = waiting_inf; 1805 1806 inf_debug (inf, "err = %s, pid = %d, status = 0x%x, sigcode = %d", 1807 err ? safe_strerror (err) : "0", pid, status, sigcode); 1808 1809 if (err && proc_wait_pid && (!inf->task || !inf->task->port)) 1810 /* Ack. The task has died, but the task-died notification code didn't 1811 tell anyone because it thought a more detailed reply from the 1812 procserver was forthcoming. However, we now learn that won't 1813 happen... So we have to act like the task just died, and this time, 1814 tell the world. */ 1815 inf_task_died_status (inf); 1816 1817 if (--proc_waits_pending == 0) 1818 /* PROC_WAIT_PID represents the most recent wait. We will always get 1819 replies in order because the proc server is single threaded. */ 1820 proc_wait_pid = 0; 1821 1822 inf_debug (inf, "waits pending now: %d", proc_waits_pending); 1823 1824 if (err) 1825 { 1826 if (err != EINTR) 1827 { 1828 warning (_("Can't wait for pid %d: %s"), inf->pid, safe_strerror (err)); 1829 inf->no_wait = 1; 1830 1831 /* Since we can't see the inferior's signals, don't trap them. */ 1832 inf_set_traced (inf, 0); 1833 } 1834 } 1835 else if (pid == inf->pid) 1836 { 1837 store_waitstatus (&inf->wait.status, status); 1838 if (inf->wait.status.kind == TARGET_WAITKIND_STOPPED) 1839 /* The process has sent us a signal, and stopped itself in a sane 1840 state pending our actions. */ 1841 { 1842 inf_debug (inf, "process has stopped itself"); 1843 inf->stopped = 1; 1844 } 1845 } 1846 else 1847 inf->wait.suppress = 1; /* Something odd happened. Ignore. */ 1848 1849 return 0; 1850} 1851 1852error_t 1853S_proc_setmsgport_reply (mach_port_t reply, error_t err, 1854 mach_port_t old_msg_port) 1855{ 1856 return ill_rpc ("S_proc_setmsgport_reply"); 1857} 1858 1859error_t 1860S_proc_getmsgport_reply (mach_port_t reply, error_t err, mach_port_t msg_port) 1861{ 1862 return ill_rpc ("S_proc_getmsgport_reply"); 1863} 1864 1865 1866/* Msg_reply server routines. We only use msg_sig_post_untraced_reply. */ 1867 1868error_t 1869S_msg_sig_post_untraced_reply (mach_port_t reply, error_t err) 1870{ 1871 struct inf *inf = waiting_inf; 1872 1873 if (err == EBUSY) 1874 /* EBUSY is what we get when the crash server has grabbed control of the 1875 process and doesn't like what signal we tried to send it. Just act 1876 like the process stopped (using a signal of 0 should mean that the 1877 *next* time the user continues, it will pass signal 0, which the crash 1878 server should like). */ 1879 { 1880 inf->wait.status.kind = TARGET_WAITKIND_STOPPED; 1881 inf->wait.status.value.sig = TARGET_SIGNAL_0; 1882 } 1883 else if (err) 1884 warning (_("Signal delivery failed: %s"), safe_strerror (err)); 1885 1886 if (err) 1887 /* We only get this reply when we've posted a signal to a process which we 1888 thought was stopped, and which we expected to continue after the signal. 1889 Given that the signal has failed for some reason, it's reasonable to 1890 assume it's still stopped. */ 1891 inf->stopped = 1; 1892 else 1893 inf->wait.suppress = 1; 1894 1895 return 0; 1896} 1897 1898error_t 1899S_msg_sig_post_reply (mach_port_t reply, error_t err) 1900{ 1901 return ill_rpc ("S_msg_sig_post_reply"); 1902} 1903 1904 1905/* Returns the number of messages queued for the receive right PORT. */ 1906static mach_port_msgcount_t 1907port_msgs_queued (mach_port_t port) 1908{ 1909 struct mach_port_status status; 1910 error_t err = 1911 mach_port_get_receive_status (mach_task_self (), port, &status); 1912 1913 if (err) 1914 return 0; 1915 else 1916 return status.mps_msgcount; 1917} 1918 1919 1920/* Resume execution of the inferior process. 1921 1922 If STEP is nonzero, single-step it. 1923 If SIGNAL is nonzero, give it that signal. 1924 1925 TID STEP: 1926 -1 true Single step the current thread allowing other threads to run. 1927 -1 false Continue the current thread allowing other threads to run. 1928 X true Single step the given thread, don't allow any others to run. 1929 X false Continue the given thread, do not allow any others to run. 1930 (Where X, of course, is anything except -1) 1931 1932 Note that a resume may not `take' if there are pending exceptions/&c 1933 still unprocessed from the last resume we did (any given resume may result 1934 in multiple events returned by wait). 1935 */ 1936static void 1937gnu_resume (ptid_t tid, int step, enum target_signal sig) 1938{ 1939 struct proc *step_thread = 0; 1940 struct inf *inf = current_inferior; 1941 1942 inf_debug (inf, "tid = %d, step = %d, sig = %d", PIDGET (tid), step, sig); 1943 1944 inf_validate_procinfo (inf); 1945 1946 if (sig != TARGET_SIGNAL_0 || inf->stopped) 1947 { 1948 if (sig == TARGET_SIGNAL_0 && inf->nomsg) 1949 inf_continue (inf); 1950 else 1951 inf_signal (inf, sig); 1952 } 1953 else if (inf->wait.exc.reply != MACH_PORT_NULL) 1954 /* We received an exception to which we have chosen not to forward, so 1955 abort the faulting thread, which will perhaps retake it. */ 1956 { 1957 proc_abort (inf->wait.thread, 1); 1958 warning (_("Aborting %s with unforwarded exception %s."), 1959 proc_string (inf->wait.thread), 1960 target_signal_to_name (inf->wait.status.value.sig)); 1961 } 1962 1963 if (port_msgs_queued (inf->event_port)) 1964 /* If there are still messages in our event queue, don't bother resuming 1965 the process, as we're just going to stop it right away anyway. */ 1966 return; 1967 1968 inf_update_procs (inf); 1969 1970 if (PIDGET (tid) < 0) 1971 /* Allow all threads to run, except perhaps single-stepping one. */ 1972 { 1973 inf_debug (inf, "running all threads; tid = %d", PIDGET (inferior_ptid)); 1974 tid = inferior_ptid; /* What to step. */ 1975 inf_set_threads_resume_sc (inf, 0, 1); 1976 } 1977 else 1978 /* Just allow a single thread to run. */ 1979 { 1980 struct proc *thread = inf_tid_to_thread (inf, PIDGET (tid)); 1981 if (!thread) 1982 error (_("Can't run single thread id %d: no such thread!"), inf->pid); 1983 inf_debug (inf, "running one thread: %d/%d", inf->pid, thread->tid); 1984 inf_set_threads_resume_sc (inf, thread, 0); 1985 } 1986 1987 if (step) 1988 { 1989 step_thread = inf_tid_to_thread (inf, PIDGET (tid)); 1990 if (!step_thread) 1991 warning (_("Can't step thread id %d: no such thread."), PIDGET (tid)); 1992 else 1993 inf_debug (inf, "stepping thread: %d/%d", inf->pid, step_thread->tid); 1994 } 1995 if (step_thread != inf->step_thread) 1996 inf_set_step_thread (inf, step_thread); 1997 1998 inf_debug (inf, "here we go..."); 1999 inf_resume (inf); 2000} 2001 2002 2003static void 2004gnu_kill_inferior (void) 2005{ 2006 struct proc *task = current_inferior->task; 2007 if (task) 2008 { 2009 proc_debug (task, "terminating..."); 2010 task_terminate (task->port); 2011 inf_set_pid (current_inferior, -1); 2012 } 2013 target_mourn_inferior (); 2014} 2015 2016/* Clean up after the inferior dies. */ 2017static void 2018gnu_mourn_inferior (void) 2019{ 2020 inf_debug (current_inferior, "rip"); 2021 inf_detach (current_inferior); 2022 unpush_target (&gnu_ops); 2023 generic_mourn_inferior (); 2024} 2025 2026 2027/* Fork an inferior process, and start debugging it. */ 2028 2029/* Set INFERIOR_PID to the first thread available in the child, if any. */ 2030static int 2031inf_pick_first_thread (void) 2032{ 2033 if (current_inferior->task && current_inferior->threads) 2034 /* The first thread. */ 2035 return current_inferior->threads->tid; 2036 else 2037 /* What may be the next thread. */ 2038 return next_thread_id; 2039} 2040 2041static struct inf * 2042cur_inf (void) 2043{ 2044 if (!current_inferior) 2045 current_inferior = make_inf (); 2046 return current_inferior; 2047} 2048 2049static void 2050gnu_create_inferior (char *exec_file, char *allargs, char **env, 2051 int from_tty) 2052{ 2053 struct inf *inf = cur_inf (); 2054 2055 void trace_me () 2056 { 2057 /* We're in the child; make this process stop as soon as it execs. */ 2058 inf_debug (inf, "tracing self"); 2059 if (ptrace (PTRACE_TRACEME) != 0) 2060 error (_("ptrace (PTRACE_TRACEME) failed!")); 2061 } 2062 void attach_to_child (int pid) 2063 { 2064 /* Attach to the now stopped child, which is actually a shell... */ 2065 inf_debug (inf, "attaching to child: %d", pid); 2066 2067 inf_attach (inf, pid); 2068 2069 attach_flag = 0; 2070 push_target (&gnu_ops); 2071 2072 inf->pending_execs = 2; 2073 inf->nomsg = 1; 2074 inf->traced = 1; 2075 2076 /* Now let the child run again, knowing that it will stop immediately 2077 because of the ptrace. */ 2078 inf_resume (inf); 2079 inferior_ptid = pid_to_ptid (inf_pick_first_thread ()); 2080 2081 startup_inferior (inf->pending_execs); 2082 } 2083 2084 inf_debug (inf, "creating inferior"); 2085 2086 fork_inferior (exec_file, allargs, env, trace_me, attach_to_child, 2087 NULL, NULL); 2088 2089 inf_validate_procinfo (inf); 2090 inf_update_signal_thread (inf); 2091 inf_set_traced (inf, inf->want_signals); 2092 2093 /* Execing the process will have trashed our exception ports; steal them 2094 back (or make sure they're restored if the user wants that). */ 2095 if (inf->want_exceptions) 2096 inf_steal_exc_ports (inf); 2097 else 2098 inf_restore_exc_ports (inf); 2099} 2100 2101/* Mark our target-struct as eligible for stray "run" and "attach" 2102 commands. */ 2103static int 2104gnu_can_run (void) 2105{ 2106 return 1; 2107} 2108 2109 2110/* Attach to process PID, then initialize for debugging it 2111 and wait for the trace-trap that results from attaching. */ 2112static void 2113gnu_attach (char *args, int from_tty) 2114{ 2115 int pid; 2116 char *exec_file; 2117 struct inf *inf = cur_inf (); 2118 2119 if (!args) 2120 error_no_arg (_("process-id to attach")); 2121 2122 pid = atoi (args); 2123 2124 if (pid == getpid ()) /* Trying to masturbate? */ 2125 error (_("I refuse to debug myself!")); 2126 2127 if (from_tty) 2128 { 2129 exec_file = (char *) get_exec_file (0); 2130 2131 if (exec_file) 2132 printf_unfiltered ("Attaching to program `%s', pid %d\n", 2133 exec_file, pid); 2134 else 2135 printf_unfiltered ("Attaching to pid %d\n", pid); 2136 2137 gdb_flush (gdb_stdout); 2138 } 2139 2140 inf_debug (inf, "attaching to pid: %d", pid); 2141 2142 inf_attach (inf, pid); 2143 inf_update_procs (inf); 2144 2145 inferior_ptid = pid_to_ptid (inf_pick_first_thread ()); 2146 2147 attach_flag = 1; 2148 push_target (&gnu_ops); 2149 2150 /* We have to initialize the terminal settings now, since the code 2151 below might try to restore them. */ 2152 target_terminal_init (); 2153 2154 /* If the process was stopped before we attached, make it continue the next 2155 time the user does a continue. */ 2156 inf_validate_procinfo (inf); 2157 2158 inf_update_signal_thread (inf); 2159 inf_set_traced (inf, inf->want_signals); 2160 2161#if 0 /* Do we need this? */ 2162 renumber_threads (0); /* Give our threads reasonable names. */ 2163#endif 2164} 2165 2166 2167/* Take a program previously attached to and detaches it. 2168 The program resumes execution and will no longer stop 2169 on signals, etc. We'd better not have left any breakpoints 2170 in the program or it'll die when it hits one. For this 2171 to work, it may be necessary for the process to have been 2172 previously attached. It *might* work if the program was 2173 started via fork. */ 2174static void 2175gnu_detach (char *args, int from_tty) 2176{ 2177 if (from_tty) 2178 { 2179 char *exec_file = get_exec_file (0); 2180 if (exec_file) 2181 printf_unfiltered ("Detaching from program `%s' pid %d\n", 2182 exec_file, current_inferior->pid); 2183 else 2184 printf_unfiltered ("Detaching from pid %d\n", current_inferior->pid); 2185 gdb_flush (gdb_stdout); 2186 } 2187 2188 inf_detach (current_inferior); 2189 2190 inferior_ptid = null_ptid; 2191 2192 unpush_target (&gnu_ops); /* Pop out of handling an inferior */ 2193} 2194 2195static void 2196gnu_terminal_init_inferior (void) 2197{ 2198 gdb_assert (current_inferior); 2199 terminal_init_inferior_with_pgrp (current_inferior->pid); 2200} 2201 2202/* Get ready to modify the registers array. On machines which store 2203 individual registers, this doesn't need to do anything. On machines 2204 which store all the registers in one fell swoop, this makes sure 2205 that registers contains all the registers from the program being 2206 debugged. */ 2207static void 2208gnu_prepare_to_store (struct regcache *regcache) 2209{ 2210} 2211 2212static void 2213gnu_open (char *arg, int from_tty) 2214{ 2215 error (_("Use the \"run\" command to start a Unix child process.")); 2216} 2217 2218static void 2219gnu_stop (void) 2220{ 2221 error (_("to_stop target function not implemented")); 2222} 2223 2224static char * 2225gnu_pid_to_exec_file (int pid) 2226{ 2227 error (_("to_pid_to_exec_file target function not implemented")); 2228 return NULL; 2229} 2230 2231 2232static int 2233gnu_thread_alive (ptid_t tid) 2234{ 2235 inf_update_procs (current_inferior); 2236 return !!inf_tid_to_thread (current_inferior, PIDGET (tid)); 2237} 2238 2239 2240/* Read inferior task's LEN bytes from ADDR and copy it to MYADDR in 2241 gdb's address space. Return 0 on failure; number of bytes read 2242 otherwise. */ 2243int 2244gnu_read_inferior (task_t task, CORE_ADDR addr, char *myaddr, int length) 2245{ 2246 error_t err; 2247 vm_address_t low_address = (vm_address_t) trunc_page (addr); 2248 vm_size_t aligned_length = 2249 (vm_size_t) round_page (addr + length) - low_address; 2250 pointer_t copied; 2251 int copy_count; 2252 2253 /* Get memory from inferior with page aligned addresses */ 2254 err = vm_read (task, low_address, aligned_length, &copied, ©_count); 2255 if (err) 2256 return 0; 2257 2258 err = hurd_safe_copyin (myaddr, (void *) (addr - low_address + copied), length); 2259 if (err) 2260 { 2261 warning (_("Read from inferior faulted: %s"), safe_strerror (err)); 2262 length = 0; 2263 } 2264 2265 err = vm_deallocate (mach_task_self (), copied, copy_count); 2266 if (err) 2267 warning (_("gnu_read_inferior vm_deallocate failed: %s"), safe_strerror (err)); 2268 2269 return length; 2270} 2271 2272#define CHK_GOTO_OUT(str,ret) \ 2273 do if (ret != KERN_SUCCESS) { errstr = #str; goto out; } while(0) 2274 2275struct vm_region_list 2276{ 2277 struct vm_region_list *next; 2278 vm_prot_t protection; 2279 vm_address_t start; 2280 vm_size_t length; 2281}; 2282 2283struct obstack region_obstack; 2284 2285/* Write gdb's LEN bytes from MYADDR and copy it to ADDR in inferior 2286 task's address space. */ 2287int 2288gnu_write_inferior (task_t task, CORE_ADDR addr, char *myaddr, int length) 2289{ 2290 error_t err = 0; 2291 vm_address_t low_address = (vm_address_t) trunc_page (addr); 2292 vm_size_t aligned_length = 2293 (vm_size_t) round_page (addr + length) - low_address; 2294 pointer_t copied; 2295 int copy_count; 2296 int deallocate = 0; 2297 2298 char *errstr = "Bug in gnu_write_inferior"; 2299 2300 struct vm_region_list *region_element; 2301 struct vm_region_list *region_head = (struct vm_region_list *) NULL; 2302 2303 /* Get memory from inferior with page aligned addresses */ 2304 err = vm_read (task, 2305 low_address, 2306 aligned_length, 2307 &copied, 2308 ©_count); 2309 CHK_GOTO_OUT ("gnu_write_inferior vm_read failed", err); 2310 2311 deallocate++; 2312 2313 err = hurd_safe_copyout ((void *) (addr - low_address + copied), 2314 myaddr, length); 2315 CHK_GOTO_OUT ("Write to inferior faulted", err); 2316 2317 obstack_init (®ion_obstack); 2318 2319 /* Do writes atomically. 2320 First check for holes and unwritable memory. */ 2321 { 2322 vm_size_t remaining_length = aligned_length; 2323 vm_address_t region_address = low_address; 2324 2325 struct vm_region_list *scan; 2326 2327 while (region_address < low_address + aligned_length) 2328 { 2329 vm_prot_t protection; 2330 vm_prot_t max_protection; 2331 vm_inherit_t inheritance; 2332 boolean_t shared; 2333 mach_port_t object_name; 2334 vm_offset_t offset; 2335 vm_size_t region_length = remaining_length; 2336 vm_address_t old_address = region_address; 2337 2338 err = vm_region (task, 2339 ®ion_address, 2340 ®ion_length, 2341 &protection, 2342 &max_protection, 2343 &inheritance, 2344 &shared, 2345 &object_name, 2346 &offset); 2347 CHK_GOTO_OUT ("vm_region failed", err); 2348 2349 /* Check for holes in memory */ 2350 if (old_address != region_address) 2351 { 2352 warning (_("No memory at 0x%x. Nothing written"), 2353 old_address); 2354 err = KERN_SUCCESS; 2355 length = 0; 2356 goto out; 2357 } 2358 2359 if (!(max_protection & VM_PROT_WRITE)) 2360 { 2361 warning (_("Memory at address 0x%x is unwritable. Nothing written"), 2362 old_address); 2363 err = KERN_SUCCESS; 2364 length = 0; 2365 goto out; 2366 } 2367 2368 /* Chain the regions for later use */ 2369 region_element = 2370 (struct vm_region_list *) 2371 obstack_alloc (®ion_obstack, sizeof (struct vm_region_list)); 2372 2373 region_element->protection = protection; 2374 region_element->start = region_address; 2375 region_element->length = region_length; 2376 2377 /* Chain the regions along with protections */ 2378 region_element->next = region_head; 2379 region_head = region_element; 2380 2381 region_address += region_length; 2382 remaining_length = remaining_length - region_length; 2383 } 2384 2385 /* If things fail after this, we give up. 2386 Somebody is messing up inferior_task's mappings. */ 2387 2388 /* Enable writes to the chained vm regions */ 2389 for (scan = region_head; scan; scan = scan->next) 2390 { 2391 if (!(scan->protection & VM_PROT_WRITE)) 2392 { 2393 err = vm_protect (task, 2394 scan->start, 2395 scan->length, 2396 FALSE, 2397 scan->protection | VM_PROT_WRITE); 2398 CHK_GOTO_OUT ("vm_protect: enable write failed", err); 2399 } 2400 } 2401 2402 err = vm_write (task, 2403 low_address, 2404 copied, 2405 aligned_length); 2406 CHK_GOTO_OUT ("vm_write failed", err); 2407 2408 /* Set up the original region protections, if they were changed */ 2409 for (scan = region_head; scan; scan = scan->next) 2410 { 2411 if (!(scan->protection & VM_PROT_WRITE)) 2412 { 2413 err = vm_protect (task, 2414 scan->start, 2415 scan->length, 2416 FALSE, 2417 scan->protection); 2418 CHK_GOTO_OUT ("vm_protect: enable write failed", err); 2419 } 2420 } 2421 } 2422 2423out: 2424 if (deallocate) 2425 { 2426 obstack_free (®ion_obstack, 0); 2427 2428 (void) vm_deallocate (mach_task_self (), 2429 copied, 2430 copy_count); 2431 } 2432 2433 if (err != KERN_SUCCESS) 2434 { 2435 warning (_("%s: %s"), errstr, mach_error_string (err)); 2436 return 0; 2437 } 2438 2439 return length; 2440} 2441 2442 2443/* Return 0 on failure, number of bytes handled otherwise. TARGET 2444 is ignored. */ 2445static int 2446gnu_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write, 2447 struct mem_attrib *attrib, 2448 struct target_ops *target) 2449{ 2450 task_t task = (current_inferior 2451 ? (current_inferior->task 2452 ? current_inferior->task->port : 0) 2453 : 0); 2454 2455 if (task == MACH_PORT_NULL) 2456 return 0; 2457 else 2458 { 2459 inf_debug (current_inferior, "%s %p[%d] %s %p", 2460 write ? "writing" : "reading", (void *) memaddr, len, 2461 write ? "<--" : "-->", myaddr); 2462 if (write) 2463 return gnu_write_inferior (task, memaddr, myaddr, len); 2464 else 2465 return gnu_read_inferior (task, memaddr, myaddr, len); 2466 } 2467} 2468 2469/* Call FUNC on each memory region in the task. */ 2470static int 2471gnu_find_memory_regions (int (*func) (CORE_ADDR, 2472 unsigned long, 2473 int, int, int, 2474 void *), 2475 void *data) 2476{ 2477 error_t err; 2478 task_t task; 2479 vm_address_t region_address, last_region_address, last_region_end; 2480 vm_prot_t last_protection; 2481 2482 if (current_inferior == 0 || current_inferior->task == 0) 2483 return 0; 2484 task = current_inferior->task->port; 2485 if (task == MACH_PORT_NULL) 2486 return 0; 2487 2488 region_address = last_region_address = last_region_end = VM_MIN_ADDRESS; 2489 last_protection = VM_PROT_NONE; 2490 while (region_address < VM_MAX_ADDRESS) 2491 { 2492 vm_prot_t protection; 2493 vm_prot_t max_protection; 2494 vm_inherit_t inheritance; 2495 boolean_t shared; 2496 mach_port_t object_name; 2497 vm_offset_t offset; 2498 vm_size_t region_length = VM_MAX_ADDRESS - region_address; 2499 vm_address_t old_address = region_address; 2500 2501 err = vm_region (task, 2502 ®ion_address, 2503 ®ion_length, 2504 &protection, 2505 &max_protection, 2506 &inheritance, 2507 &shared, 2508 &object_name, 2509 &offset); 2510 if (err == KERN_NO_SPACE) 2511 break; 2512 if (err != KERN_SUCCESS) 2513 { 2514 warning (_("vm_region failed: %s"), mach_error_string (err)); 2515 return -1; 2516 } 2517 2518 if (protection == last_protection && region_address == last_region_end) 2519 /* This region is contiguous with and indistinguishable from 2520 the previous one, so we just extend that one. */ 2521 last_region_end = region_address += region_length; 2522 else 2523 { 2524 /* This region is distinct from the last one we saw, so report 2525 that previous one. */ 2526 if (last_protection != VM_PROT_NONE) 2527 (*func) (last_region_address, 2528 last_region_end - last_region_address, 2529 last_protection & VM_PROT_READ, 2530 last_protection & VM_PROT_WRITE, 2531 last_protection & VM_PROT_EXECUTE, 2532 data); 2533 last_region_address = region_address; 2534 last_region_end = region_address += region_length; 2535 last_protection = protection; 2536 } 2537 } 2538 2539 /* Report the final region. */ 2540 if (last_region_end > last_region_address && last_protection != VM_PROT_NONE) 2541 (*func) (last_region_address, last_region_end - last_region_address, 2542 last_protection & VM_PROT_READ, 2543 last_protection & VM_PROT_WRITE, 2544 last_protection & VM_PROT_EXECUTE, 2545 data); 2546 2547 return 0; 2548} 2549 2550 2551/* Return printable description of proc. */ 2552char * 2553proc_string (struct proc *proc) 2554{ 2555 static char tid_str[80]; 2556 if (proc_is_task (proc)) 2557 sprintf (tid_str, "process %d", proc->inf->pid); 2558 else 2559 sprintf (tid_str, "thread %d.%d", 2560 proc->inf->pid, pid_to_thread_id (MERGEPID (proc->tid, 0))); 2561 return tid_str; 2562} 2563 2564static char * 2565gnu_pid_to_str (ptid_t ptid) 2566{ 2567 struct inf *inf = current_inferior; 2568 int tid = PIDGET (ptid); 2569 struct proc *thread = inf_tid_to_thread (inf, tid); 2570 2571 if (thread) 2572 return proc_string (thread); 2573 else 2574 { 2575 static char tid_str[80]; 2576 sprintf (tid_str, "bogus thread id %d", tid); 2577 return tid_str; 2578 } 2579} 2580 2581 2582extern void gnu_store_registers (struct regcache *regcache, int regno); 2583extern void gnu_fetch_registers (struct regcache *regcache, int regno); 2584 2585struct target_ops gnu_ops; 2586 2587static void 2588init_gnu_ops (void) 2589{ 2590 gnu_ops.to_shortname = "GNU"; /* to_shortname */ 2591 gnu_ops.to_longname = "GNU Hurd process"; /* to_longname */ 2592 gnu_ops.to_doc = "GNU Hurd process"; /* to_doc */ 2593 gnu_ops.to_open = gnu_open; /* to_open */ 2594 gnu_ops.to_attach = gnu_attach; /* to_attach */ 2595 gnu_ops.to_detach = gnu_detach; /* to_detach */ 2596 gnu_ops.to_resume = gnu_resume; /* to_resume */ 2597 gnu_ops.to_wait = gnu_wait; /* to_wait */ 2598 gnu_ops.to_fetch_registers = gnu_fetch_registers; /* to_fetch_registers */ 2599 gnu_ops.to_store_registers = gnu_store_registers; /* to_store_registers */ 2600 gnu_ops.to_prepare_to_store = gnu_prepare_to_store; /* to_prepare_to_store */ 2601 gnu_ops.deprecated_xfer_memory = gnu_xfer_memory; 2602 gnu_ops.to_find_memory_regions = gnu_find_memory_regions; 2603 gnu_ops.to_insert_breakpoint = memory_insert_breakpoint; 2604 gnu_ops.to_remove_breakpoint = memory_remove_breakpoint; 2605 gnu_ops.to_terminal_init = gnu_terminal_init_inferior; 2606 gnu_ops.to_terminal_inferior = terminal_inferior; 2607 gnu_ops.to_terminal_ours_for_output = terminal_ours_for_output; 2608 gnu_ops.to_terminal_save_ours = terminal_save_ours; 2609 gnu_ops.to_terminal_ours = terminal_ours; 2610 gnu_ops.to_terminal_info = child_terminal_info; 2611 gnu_ops.to_kill = gnu_kill_inferior; /* to_kill */ 2612 gnu_ops.to_create_inferior = gnu_create_inferior; /* to_create_inferior */ 2613 gnu_ops.to_mourn_inferior = gnu_mourn_inferior; /* to_mourn_inferior */ 2614 gnu_ops.to_can_run = gnu_can_run; /* to_can_run */ 2615 gnu_ops.to_thread_alive = gnu_thread_alive; /* to_thread_alive */ 2616 gnu_ops.to_pid_to_str = gnu_pid_to_str; /* to_pid_to_str */ 2617 gnu_ops.to_stop = gnu_stop; /* to_stop */ 2618 gnu_ops.to_pid_to_exec_file = gnu_pid_to_exec_file; /* to_pid_to_exec_file */ 2619 gnu_ops.to_stratum = process_stratum; /* to_stratum */ 2620 gnu_ops.to_has_all_memory = 1; /* to_has_all_memory */ 2621 gnu_ops.to_has_memory = 1; /* to_has_memory */ 2622 gnu_ops.to_has_stack = 1; /* to_has_stack */ 2623 gnu_ops.to_has_registers = 1; /* to_has_registers */ 2624 gnu_ops.to_has_execution = 1; /* to_has_execution */ 2625 gnu_ops.to_magic = OPS_MAGIC; /* to_magic */ 2626} /* init_gnu_ops */ 2627 2628 2629/* User task commands. */ 2630 2631struct cmd_list_element *set_task_cmd_list = 0; 2632struct cmd_list_element *show_task_cmd_list = 0; 2633/* User thread commands. */ 2634 2635/* Commands with a prefix of `set/show thread'. */ 2636extern struct cmd_list_element *thread_cmd_list; 2637struct cmd_list_element *set_thread_cmd_list = NULL; 2638struct cmd_list_element *show_thread_cmd_list = NULL; 2639 2640/* Commands with a prefix of `set/show thread default'. */ 2641struct cmd_list_element *set_thread_default_cmd_list = NULL; 2642struct cmd_list_element *show_thread_default_cmd_list = NULL; 2643 2644static void 2645set_thread_cmd (char *args, int from_tty) 2646{ 2647 printf_unfiltered ("\"set thread\" must be followed by the name of a thread property, or \"default\".\n"); 2648} 2649 2650static void 2651show_thread_cmd (char *args, int from_tty) 2652{ 2653 printf_unfiltered ("\"show thread\" must be followed by the name of a thread property, or \"default\".\n"); 2654} 2655 2656static void 2657set_thread_default_cmd (char *args, int from_tty) 2658{ 2659 printf_unfiltered ("\"set thread default\" must be followed by the name of a thread property.\n"); 2660} 2661 2662static void 2663show_thread_default_cmd (char *args, int from_tty) 2664{ 2665 printf_unfiltered ("\"show thread default\" must be followed by the name of a thread property.\n"); 2666} 2667 2668static int 2669parse_int_arg (char *args, char *cmd_prefix) 2670{ 2671 if (args) 2672 { 2673 char *arg_end; 2674 int val = strtoul (args, &arg_end, 10); 2675 if (*args && *arg_end == '\0') 2676 return val; 2677 } 2678 error (_("Illegal argument for \"%s\" command, should be an integer."), cmd_prefix); 2679} 2680 2681static int 2682_parse_bool_arg (char *args, char *t_val, char *f_val, char *cmd_prefix) 2683{ 2684 if (!args || strcmp (args, t_val) == 0) 2685 return 1; 2686 else if (strcmp (args, f_val) == 0) 2687 return 0; 2688 else 2689 error (_("Illegal argument for \"%s\" command, should be \"%s\" or \"%s\"."), 2690 cmd_prefix, t_val, f_val); 2691} 2692 2693#define parse_bool_arg(args, cmd_prefix) \ 2694 _parse_bool_arg (args, "on", "off", cmd_prefix) 2695 2696static void 2697check_empty (char *args, char *cmd_prefix) 2698{ 2699 if (args) 2700 error (_("Garbage after \"%s\" command: `%s'"), cmd_prefix, args); 2701} 2702 2703/* Returns the alive thread named by INFERIOR_PID, or signals an error. */ 2704static struct proc * 2705cur_thread (void) 2706{ 2707 struct inf *inf = cur_inf (); 2708 struct proc *thread = inf_tid_to_thread (inf, PIDGET (inferior_ptid)); 2709 if (!thread) 2710 error (_("No current thread.")); 2711 return thread; 2712} 2713 2714/* Returns the current inferior, but signals an error if it has no task. */ 2715static struct inf * 2716active_inf (void) 2717{ 2718 struct inf *inf = cur_inf (); 2719 if (!inf->task) 2720 error (_("No current process.")); 2721 return inf; 2722} 2723 2724 2725static void 2726set_task_pause_cmd (char *args, int from_tty) 2727{ 2728 struct inf *inf = cur_inf (); 2729 int old_sc = inf->pause_sc; 2730 2731 inf->pause_sc = parse_bool_arg (args, "set task pause"); 2732 2733 if (old_sc == 0 && inf->pause_sc != 0) 2734 /* If the task is currently unsuspended, immediately suspend it, 2735 otherwise wait until the next time it gets control. */ 2736 inf_suspend (inf); 2737} 2738 2739static void 2740show_task_pause_cmd (char *args, int from_tty) 2741{ 2742 struct inf *inf = cur_inf (); 2743 check_empty (args, "show task pause"); 2744 printf_unfiltered ("The inferior task %s suspended while gdb has control.\n", 2745 inf->task 2746 ? (inf->pause_sc == 0 ? "isn't" : "is") 2747 : (inf->pause_sc == 0 ? "won't be" : "will be")); 2748} 2749 2750static void 2751set_task_detach_sc_cmd (char *args, int from_tty) 2752{ 2753 cur_inf ()->detach_sc = parse_int_arg (args, "set task detach-suspend-count"); 2754} 2755 2756static void 2757show_task_detach_sc_cmd (char *args, int from_tty) 2758{ 2759 check_empty (args, "show task detach-suspend-count"); 2760 printf_unfiltered ("The inferior task will be left with a suspend count of %d when detaching.\n", 2761 cur_inf ()->detach_sc); 2762} 2763 2764 2765static void 2766set_thread_default_pause_cmd (char *args, int from_tty) 2767{ 2768 struct inf *inf = cur_inf (); 2769 inf->default_thread_pause_sc = 2770 parse_bool_arg (args, "set thread default pause") ? 0 : 1; 2771} 2772 2773static void 2774show_thread_default_pause_cmd (char *args, int from_tty) 2775{ 2776 struct inf *inf = cur_inf (); 2777 int sc = inf->default_thread_pause_sc; 2778 check_empty (args, "show thread default pause"); 2779 printf_unfiltered ("New threads %s suspended while gdb has control%s.\n", 2780 sc ? "are" : "aren't", 2781 !sc && inf->pause_sc ? " (but the task is)" : ""); 2782} 2783 2784static void 2785set_thread_default_run_cmd (char *args, int from_tty) 2786{ 2787 struct inf *inf = cur_inf (); 2788 inf->default_thread_run_sc = 2789 parse_bool_arg (args, "set thread default run") ? 0 : 1; 2790} 2791 2792static void 2793show_thread_default_run_cmd (char *args, int from_tty) 2794{ 2795 struct inf *inf = cur_inf (); 2796 check_empty (args, "show thread default run"); 2797 printf_unfiltered ("New threads %s allowed to run.\n", 2798 inf->default_thread_run_sc == 0 ? "are" : "aren't"); 2799} 2800 2801static void 2802set_thread_default_detach_sc_cmd (char *args, int from_tty) 2803{ 2804 cur_inf ()->default_thread_detach_sc = 2805 parse_int_arg (args, "set thread default detach-suspend-count"); 2806} 2807 2808static void 2809show_thread_default_detach_sc_cmd (char *args, int from_tty) 2810{ 2811 check_empty (args, "show thread default detach-suspend-count"); 2812 printf_unfiltered ("New threads will get a detach-suspend-count of %d.\n", 2813 cur_inf ()->default_thread_detach_sc); 2814} 2815 2816 2817/* Steal a send right called NAME in the inferior task, and make it PROC's 2818 saved exception port. */ 2819static void 2820steal_exc_port (struct proc *proc, mach_port_t name) 2821{ 2822 error_t err; 2823 mach_port_t port; 2824 mach_msg_type_name_t port_type; 2825 2826 if (!proc || !proc->inf->task) 2827 error (_("No inferior task.")); 2828 2829 err = mach_port_extract_right (proc->inf->task->port, 2830 name, MACH_MSG_TYPE_COPY_SEND, 2831 &port, &port_type); 2832 if (err) 2833 error (_("Couldn't extract send right %d from inferior: %s"), 2834 name, safe_strerror (err)); 2835 2836 if (proc->saved_exc_port) 2837 /* Get rid of our reference to the old one. */ 2838 mach_port_deallocate (mach_task_self (), proc->saved_exc_port); 2839 2840 proc->saved_exc_port = port; 2841 2842 if (!proc->exc_port) 2843 /* If PROC is a thread, we may not have set its exception port before. 2844 We can't use proc_steal_exc_port because it also sets saved_exc_port. */ 2845 { 2846 proc->exc_port = proc->inf->event_port; 2847 err = proc_set_exception_port (proc, proc->exc_port); 2848 error (_("Can't set exception port for %s: %s"), 2849 proc_string (proc), safe_strerror (err)); 2850 } 2851} 2852 2853static void 2854set_task_exc_port_cmd (char *args, int from_tty) 2855{ 2856 struct inf *inf = cur_inf (); 2857 if (!args) 2858 error (_("No argument to \"set task exception-port\" command.")); 2859 steal_exc_port (inf->task, parse_and_eval_address (args)); 2860} 2861 2862static void 2863set_stopped_cmd (char *args, int from_tty) 2864{ 2865 cur_inf ()->stopped = _parse_bool_arg (args, "yes", "no", "set stopped"); 2866} 2867 2868static void 2869show_stopped_cmd (char *args, int from_tty) 2870{ 2871 struct inf *inf = active_inf (); 2872 check_empty (args, "show stopped"); 2873 printf_unfiltered ("The inferior process %s stopped.\n", 2874 inf->stopped ? "is" : "isn't"); 2875} 2876 2877static void 2878set_sig_thread_cmd (char *args, int from_tty) 2879{ 2880 struct inf *inf = cur_inf (); 2881 2882 if (!args || (!isdigit (*args) && strcmp (args, "none") != 0)) 2883 error (_("Illegal argument to \"set signal-thread\" command.\n" 2884 "Should be an integer thread ID, or `none'.")); 2885 2886 if (strcmp (args, "none") == 0) 2887 inf->signal_thread = 0; 2888 else 2889 { 2890 int tid = PIDGET (thread_id_to_pid (atoi (args))); 2891 if (tid < 0) 2892 error (_("Thread ID %s not known. Use the \"info threads\" command to\n" 2893 "see the IDs of currently known threads."), args); 2894 inf->signal_thread = inf_tid_to_thread (inf, tid); 2895 } 2896} 2897 2898static void 2899show_sig_thread_cmd (char *args, int from_tty) 2900{ 2901 struct inf *inf = active_inf (); 2902 check_empty (args, "show signal-thread"); 2903 if (inf->signal_thread) 2904 printf_unfiltered ("The signal thread is %s.\n", 2905 proc_string (inf->signal_thread)); 2906 else 2907 printf_unfiltered ("There is no signal thread.\n"); 2908} 2909 2910 2911static void 2912set_signals_cmd (char *args, int from_tty) 2913{ 2914 struct inf *inf = cur_inf (); 2915 2916 inf->want_signals = parse_bool_arg (args, "set signals"); 2917 2918 if (inf->task && inf->want_signals != inf->traced) 2919 /* Make this take effect immediately in a running process. */ 2920 inf_set_traced (inf, inf->want_signals); 2921} 2922 2923static void 2924show_signals_cmd (char *args, int from_tty) 2925{ 2926 struct inf *inf = cur_inf (); 2927 check_empty (args, "show signals"); 2928 printf_unfiltered ("The inferior process's signals %s intercepted.\n", 2929 inf->task 2930 ? (inf->traced ? "are" : "aren't") 2931 : (inf->want_signals ? "will be" : "won't be")); 2932} 2933 2934static void 2935set_exceptions_cmd (char *args, int from_tty) 2936{ 2937 struct inf *inf = cur_inf (); 2938 int val = parse_bool_arg (args, "set exceptions"); 2939 2940 if (inf->task && inf->want_exceptions != val) 2941 /* Make this take effect immediately in a running process. */ 2942 /* XXX */ ; 2943 2944 inf->want_exceptions = val; 2945} 2946 2947static void 2948show_exceptions_cmd (char *args, int from_tty) 2949{ 2950 struct inf *inf = cur_inf (); 2951 check_empty (args, "show exceptions"); 2952 printf_unfiltered ("Exceptions in the inferior %s trapped.\n", 2953 inf->task 2954 ? (inf->want_exceptions ? "are" : "aren't") 2955 : (inf->want_exceptions ? "will be" : "won't be")); 2956} 2957 2958 2959static void 2960set_task_cmd (char *args, int from_tty) 2961{ 2962 printf_unfiltered ("\"set task\" must be followed by the name" 2963 " of a task property.\n"); 2964} 2965 2966static void 2967show_task_cmd (char *args, int from_tty) 2968{ 2969 struct inf *inf = cur_inf (); 2970 2971 check_empty (args, "show task"); 2972 2973 show_signals_cmd (0, from_tty); 2974 show_exceptions_cmd (0, from_tty); 2975 show_task_pause_cmd (0, from_tty); 2976 2977 if (inf->pause_sc == 0) 2978 show_thread_default_pause_cmd (0, from_tty); 2979 show_thread_default_run_cmd (0, from_tty); 2980 2981 if (inf->task) 2982 { 2983 show_stopped_cmd (0, from_tty); 2984 show_sig_thread_cmd (0, from_tty); 2985 } 2986 2987 if (inf->detach_sc != 0) 2988 show_task_detach_sc_cmd (0, from_tty); 2989 if (inf->default_thread_detach_sc != 0) 2990 show_thread_default_detach_sc_cmd (0, from_tty); 2991} 2992 2993 2994static void 2995set_noninvasive_cmd (char *args, int from_tty) 2996{ 2997 /* Invert the sense of the arg for each component. */ 2998 char *inv_args = parse_bool_arg (args, "set noninvasive") ? "off" : "on"; 2999 3000 set_task_pause_cmd (inv_args, from_tty); 3001 set_signals_cmd (inv_args, from_tty); 3002 set_exceptions_cmd (inv_args, from_tty); 3003} 3004 3005 3006static void 3007info_port_rights (char *args, mach_port_type_t only) 3008{ 3009 struct inf *inf = active_inf (); 3010 struct value *vmark = value_mark (); 3011 3012 if (args) 3013 /* Explicit list of port rights. */ 3014 { 3015 while (*args) 3016 { 3017 struct value *val = parse_to_comma_and_eval (&args); 3018 long right = value_as_long (val); 3019 error_t err = 3020 print_port_info (right, 0, inf->task->port, PORTINFO_DETAILS, 3021 stdout); 3022 if (err) 3023 error (_("%ld: %s."), right, safe_strerror (err)); 3024 } 3025 } 3026 else 3027 /* Print all of them. */ 3028 { 3029 error_t err = 3030 print_task_ports_info (inf->task->port, only, PORTINFO_DETAILS, 3031 stdout); 3032 if (err) 3033 error (_("%s."), safe_strerror (err)); 3034 } 3035 3036 value_free_to_mark (vmark); 3037} 3038 3039static void 3040info_send_rights_cmd (char *args, int from_tty) 3041{ 3042 info_port_rights (args, MACH_PORT_TYPE_SEND); 3043} 3044 3045static void 3046info_recv_rights_cmd (char *args, int from_tty) 3047{ 3048 info_port_rights (args, MACH_PORT_TYPE_RECEIVE); 3049} 3050 3051static void 3052info_port_sets_cmd (char *args, int from_tty) 3053{ 3054 info_port_rights (args, MACH_PORT_TYPE_PORT_SET); 3055} 3056 3057static void 3058info_dead_names_cmd (char *args, int from_tty) 3059{ 3060 info_port_rights (args, MACH_PORT_TYPE_DEAD_NAME); 3061} 3062 3063static void 3064info_port_rights_cmd (char *args, int from_tty) 3065{ 3066 info_port_rights (args, ~0); 3067} 3068 3069 3070static void 3071add_task_commands (void) 3072{ 3073 add_cmd ("pause", class_run, set_thread_default_pause_cmd, _("\ 3074Set whether the new threads are suspended while gdb has control.\n\ 3075This property normally has no effect because the whole task is\n\ 3076suspended, however, that may be disabled with \"set task pause off\".\n\ 3077The default value is \"off\"."), 3078 &set_thread_default_cmd_list); 3079 add_cmd ("pause", no_class, show_thread_default_pause_cmd, _("\ 3080Show whether new threads are suspended while gdb has control."), 3081 &show_thread_default_cmd_list); 3082 3083 add_cmd ("run", class_run, set_thread_default_run_cmd, _("\ 3084Set whether new threads are allowed to run (once gdb has noticed them)."), 3085 &set_thread_default_cmd_list); 3086 add_cmd ("run", no_class, show_thread_default_run_cmd, _("\ 3087Show whether new threads are allowed to run (once gdb has noticed them)."), 3088 &show_thread_default_cmd_list); 3089 3090 add_cmd ("detach-suspend-count", class_run, set_thread_default_detach_sc_cmd, 3091 _("Set the default detach-suspend-count value for new threads."), 3092 &set_thread_default_cmd_list); 3093 add_cmd ("detach-suspend-count", no_class, show_thread_default_detach_sc_cmd, 3094 _("Show the default detach-suspend-count value for new threads."), 3095 &show_thread_default_cmd_list); 3096 3097 add_cmd ("signals", class_run, set_signals_cmd, _("\ 3098Set whether the inferior process's signals will be intercepted.\n\ 3099Mach exceptions (such as breakpoint traps) are not affected."), 3100 &setlist); 3101 add_alias_cmd ("sigs", "signals", class_run, 1, &setlist); 3102 add_cmd ("signals", no_class, show_signals_cmd, _("\ 3103Show whether the inferior process's signals will be intercepted."), 3104 &showlist); 3105 add_alias_cmd ("sigs", "signals", no_class, 1, &showlist); 3106 3107 add_cmd ("signal-thread", class_run, set_sig_thread_cmd, _("\ 3108Set the thread that gdb thinks is the libc signal thread.\n\ 3109This thread is run when delivering a signal to a non-stopped process."), 3110 &setlist); 3111 add_alias_cmd ("sigthread", "signal-thread", class_run, 1, &setlist); 3112 add_cmd ("signal-thread", no_class, show_sig_thread_cmd, _("\ 3113Set the thread that gdb thinks is the libc signal thread."), 3114 &showlist); 3115 add_alias_cmd ("sigthread", "signal-thread", no_class, 1, &showlist); 3116 3117 add_cmd ("stopped", class_run, set_stopped_cmd, _("\ 3118Set whether gdb thinks the inferior process is stopped as with SIGSTOP.\n\ 3119Stopped process will be continued by sending them a signal."), 3120 &setlist); 3121 add_cmd ("stopped", no_class, show_signals_cmd, _("\ 3122Show whether gdb thinks the inferior process is stopped as with SIGSTOP."), 3123 &showlist); 3124 3125 add_cmd ("exceptions", class_run, set_exceptions_cmd, _("\ 3126Set whether exceptions in the inferior process will be trapped.\n\ 3127When exceptions are turned off, neither breakpoints nor single-stepping\n\ 3128will work."), 3129 &setlist); 3130 /* Allow `set exc' despite conflict with `set exception-port'. */ 3131 add_alias_cmd ("exc", "exceptions", class_run, 1, &setlist); 3132 add_cmd ("exceptions", no_class, show_exceptions_cmd, _("\ 3133Show whether exceptions in the inferior process will be trapped."), 3134 &showlist); 3135 3136 add_prefix_cmd ("task", no_class, set_task_cmd, 3137 _("Command prefix for setting task attributes."), 3138 &set_task_cmd_list, "set task ", 0, &setlist); 3139 add_prefix_cmd ("task", no_class, show_task_cmd, 3140 _("Command prefix for showing task attributes."), 3141 &show_task_cmd_list, "show task ", 0, &showlist); 3142 3143 add_cmd ("pause", class_run, set_task_pause_cmd, _("\ 3144Set whether the task is suspended while gdb has control.\n\ 3145A value of \"on\" takes effect immediately, otherwise nothing happens\n\ 3146until the next time the program is continued.\n\ 3147When setting this to \"off\", \"set thread default pause on\" can be\n\ 3148used to pause individual threads by default instead."), 3149 &set_task_cmd_list); 3150 add_cmd ("pause", no_class, show_task_pause_cmd, 3151 _("Show whether the task is suspended while gdb has control."), 3152 &show_task_cmd_list); 3153 3154 add_cmd ("detach-suspend-count", class_run, set_task_detach_sc_cmd, 3155 _("Set the suspend count will leave on the thread when detaching."), 3156 &set_task_cmd_list); 3157 add_cmd ("detach-suspend-count", no_class, show_task_detach_sc_cmd, 3158 _("Show the suspend count will leave on the thread when detaching."), 3159 &show_task_cmd_list); 3160 3161 add_cmd ("exception-port", no_class, set_task_exc_port_cmd, _("\ 3162Set the task exception port to which we forward exceptions.\n\ 3163The argument should be the value of the send right in the task."), 3164 &set_task_cmd_list); 3165 add_alias_cmd ("excp", "exception-port", no_class, 1, &set_task_cmd_list); 3166 add_alias_cmd ("exc-port", "exception-port", no_class, 1, 3167 &set_task_cmd_list); 3168 3169 /* A convenient way of turning on all options require to noninvasively 3170 debug running tasks. */ 3171 add_cmd ("noninvasive", no_class, set_noninvasive_cmd, _("\ 3172Set task options so that we interfere as little as possible.\n\ 3173This is the same as setting `task pause', `exceptions', and\n\ 3174`signals' to the opposite value."), 3175 &setlist); 3176 3177 /* Commands to show information about the task's ports. */ 3178 add_cmd ("send-rights", class_info, info_send_rights_cmd, 3179 _("Show information about the task's send rights"), 3180 &infolist); 3181 add_cmd ("receive-rights", class_info, info_recv_rights_cmd, 3182 _("Show information about the task's receive rights"), 3183 &infolist); 3184 add_cmd ("port-rights", class_info, info_port_rights_cmd, 3185 _("Show information about the task's port rights"), 3186 &infolist); 3187 add_cmd ("port-sets", class_info, info_port_sets_cmd, 3188 _("Show information about the task's port sets"), 3189 &infolist); 3190 add_cmd ("dead-names", class_info, info_dead_names_cmd, 3191 _("Show information about the task's dead names"), 3192 &infolist); 3193 add_info_alias ("ports", "port-rights", 1); 3194 add_info_alias ("port", "port-rights", 1); 3195 add_info_alias ("psets", "port-sets", 1); 3196} 3197 3198 3199static void 3200set_thread_pause_cmd (char *args, int from_tty) 3201{ 3202 struct proc *thread = cur_thread (); 3203 int old_sc = thread->pause_sc; 3204 thread->pause_sc = parse_bool_arg (args, "set thread pause"); 3205 if (old_sc == 0 && thread->pause_sc != 0 && thread->inf->pause_sc == 0) 3206 /* If the task is currently unsuspended, immediately suspend it, 3207 otherwise wait until the next time it gets control. */ 3208 inf_suspend (thread->inf); 3209} 3210 3211static void 3212show_thread_pause_cmd (char *args, int from_tty) 3213{ 3214 struct proc *thread = cur_thread (); 3215 int sc = thread->pause_sc; 3216 check_empty (args, "show task pause"); 3217 printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n", 3218 proc_string (thread), 3219 sc ? "is" : "isn't", 3220 !sc && thread->inf->pause_sc ? " (but the task is)" : ""); 3221} 3222 3223static void 3224set_thread_run_cmd (char *args, int from_tty) 3225{ 3226 struct proc *thread = cur_thread (); 3227 thread->run_sc = parse_bool_arg (args, "set thread run") ? 0 : 1; 3228} 3229 3230static void 3231show_thread_run_cmd (char *args, int from_tty) 3232{ 3233 struct proc *thread = cur_thread (); 3234 check_empty (args, "show thread run"); 3235 printf_unfiltered ("Thread %s %s allowed to run.", 3236 proc_string (thread), 3237 thread->run_sc == 0 ? "is" : "isn't"); 3238} 3239 3240static void 3241set_thread_detach_sc_cmd (char *args, int from_tty) 3242{ 3243 cur_thread ()->detach_sc = parse_int_arg (args, 3244 "set thread detach-suspend-count"); 3245} 3246 3247static void 3248show_thread_detach_sc_cmd (char *args, int from_tty) 3249{ 3250 struct proc *thread = cur_thread (); 3251 check_empty (args, "show thread detach-suspend-count"); 3252 printf_unfiltered ("Thread %s will be left with a suspend count" 3253 " of %d when detaching.\n", 3254 proc_string (thread), 3255 thread->detach_sc); 3256} 3257 3258static void 3259set_thread_exc_port_cmd (char *args, int from_tty) 3260{ 3261 struct proc *thread = cur_thread (); 3262 if (!args) 3263 error (_("No argument to \"set thread exception-port\" command.")); 3264 steal_exc_port (thread, parse_and_eval_address (args)); 3265} 3266 3267#if 0 3268static void 3269show_thread_cmd (char *args, int from_tty) 3270{ 3271 struct proc *thread = cur_thread (); 3272 check_empty (args, "show thread"); 3273 show_thread_run_cmd (0, from_tty); 3274 show_thread_pause_cmd (0, from_tty); 3275 if (thread->detach_sc != 0) 3276 show_thread_detach_sc_cmd (0, from_tty); 3277} 3278#endif 3279 3280static void 3281thread_takeover_sc_cmd (char *args, int from_tty) 3282{ 3283 struct proc *thread = cur_thread (); 3284 thread_basic_info_data_t _info; 3285 thread_basic_info_t info = &_info; 3286 mach_msg_type_number_t info_len = THREAD_BASIC_INFO_COUNT; 3287 error_t err = 3288 thread_info (thread->port, THREAD_BASIC_INFO, (int *) &info, &info_len); 3289 if (err) 3290 error (("%s."), safe_strerror (err)); 3291 thread->sc = info->suspend_count; 3292 if (from_tty) 3293 printf_unfiltered ("Suspend count was %d.\n", thread->sc); 3294 if (info != &_info) 3295 vm_deallocate (mach_task_self (), (vm_address_t) info, 3296 info_len * sizeof (int)); 3297} 3298 3299 3300static void 3301add_thread_commands (void) 3302{ 3303 add_prefix_cmd ("thread", no_class, set_thread_cmd, 3304 _("Command prefix for setting thread properties."), 3305 &set_thread_cmd_list, "set thread ", 0, &setlist); 3306 add_prefix_cmd ("default", no_class, show_thread_cmd, 3307 _("Command prefix for setting default thread properties."), 3308 &set_thread_default_cmd_list, "set thread default ", 0, 3309 &set_thread_cmd_list); 3310 add_prefix_cmd ("thread", no_class, set_thread_default_cmd, 3311 _("Command prefix for showing thread properties."), 3312 &show_thread_cmd_list, "show thread ", 0, &showlist); 3313 add_prefix_cmd ("default", no_class, show_thread_default_cmd, 3314 _("Command prefix for showing default thread properties."), 3315 &show_thread_default_cmd_list, "show thread default ", 0, 3316 &show_thread_cmd_list); 3317 3318 add_cmd ("pause", class_run, set_thread_pause_cmd, _("\ 3319Set whether the current thread is suspended while gdb has control.\n\ 3320A value of \"on\" takes effect immediately, otherwise nothing happens\n\ 3321until the next time the program is continued. This property normally\n\ 3322has no effect because the whole task is suspended, however, that may\n\ 3323be disabled with \"set task pause off\".\n\ 3324The default value is \"off\"."), 3325 &set_thread_cmd_list); 3326 add_cmd ("pause", no_class, show_thread_pause_cmd, _("\ 3327Show whether the current thread is suspended while gdb has control."), 3328 &show_thread_cmd_list); 3329 3330 add_cmd ("run", class_run, set_thread_run_cmd, 3331 _("Set whether the current thread is allowed to run."), 3332 &set_thread_cmd_list); 3333 add_cmd ("run", no_class, show_thread_run_cmd, 3334 _("Show whether the current thread is allowed to run."), 3335 &show_thread_cmd_list); 3336 3337 add_cmd ("detach-suspend-count", class_run, set_thread_detach_sc_cmd, _("\ 3338Set the suspend count will leave on the thread when detaching.\n\ 3339Note that this is relative to suspend count when gdb noticed the thread;\n\ 3340use the `thread takeover-suspend-count' to force it to an absolute value."), 3341 &set_thread_cmd_list); 3342 add_cmd ("detach-suspend-count", no_class, show_thread_detach_sc_cmd, _("\ 3343Show the suspend count will leave on the thread when detaching.\n\ 3344Note that this is relative to suspend count when gdb noticed the thread;\n\ 3345use the `thread takeover-suspend-count' to force it to an absolute value."), 3346 &show_thread_cmd_list); 3347 3348 add_cmd ("exception-port", no_class, set_thread_exc_port_cmd, _("\ 3349Set the thread exception port to which we forward exceptions.\n\ 3350This overrides the task exception port.\n\ 3351The argument should be the value of the send right in the task."), 3352 &set_thread_cmd_list); 3353 add_alias_cmd ("excp", "exception-port", no_class, 1, &set_thread_cmd_list); 3354 add_alias_cmd ("exc-port", "exception-port", no_class, 1, 3355 &set_thread_cmd_list); 3356 3357 add_cmd ("takeover-suspend-count", no_class, thread_takeover_sc_cmd, _("\ 3358Force the threads absolute suspend-count to be gdb's.\n\ 3359Prior to giving this command, gdb's thread suspend-counts are relative\n\ 3360to the thread's initial suspend-count when gdb notices the threads."), 3361 &thread_cmd_list); 3362} 3363 3364 3365void 3366_initialize_gnu_nat (void) 3367{ 3368 proc_server = getproc (); 3369 3370 init_gnu_ops (); 3371 add_target (&gnu_ops); 3372 3373 add_task_commands (); 3374 add_thread_commands (); 3375 deprecated_add_set_cmd ("gnu-debug", class_maintenance, 3376 var_boolean, (char *) &gnu_debug_flag, 3377 "Set debugging output for the gnu backend.", 3378 &maintenancelist); 3379} 3380 3381#ifdef FLUSH_INFERIOR_CACHE 3382 3383/* When over-writing code on some machines the I-Cache must be flushed 3384 explicitly, because it is not kept coherent by the lazy hardware. 3385 This definitely includes breakpoints, for instance, or else we 3386 end up looping in mysterious Bpt traps */ 3387 3388void 3389flush_inferior_icache (CORE_ADDR pc, int amount) 3390{ 3391 vm_machine_attribute_val_t flush = MATTR_VAL_ICACHE_FLUSH; 3392 error_t ret; 3393 3394 ret = vm_machine_attribute (current_inferior->task->port, 3395 pc, 3396 amount, 3397 MATTR_CACHE, 3398 &flush); 3399 if (ret != KERN_SUCCESS) 3400 warning (_("Error flushing inferior's cache : %s"), safe_strerror (ret)); 3401} 3402#endif /* FLUSH_INFERIOR_CACHE */ 3403