1 /* Interface GDB to the GNU Hurd.
2 Copyright (C) 1992-2014 Free Software Foundation, Inc.
4 This file is part of GDB.
6 Written by Miles Bader <miles@gnu.ai.mit.edu>
8 Some code and ideas from m3-nat.c by Jukka Virtanen <jtv@hut.fi>
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
31 #include <sys/ptrace.h>
34 #include <mach_error.h>
35 #include <mach/exception.h>
36 #include <mach/message.h>
37 #include <mach/notify.h>
38 #include <mach/vm_attributes.h>
41 #include <hurd/interrupt.h>
43 #include <hurd/msg_request.h>
44 #include <hurd/process.h>
45 /* Defined in <hurd/process.h>, but we need forward declarations from
46 <hurd/process_request.h> as well. */
48 #include <hurd/process_request.h>
49 #include <hurd/signal.h>
50 #include <hurd/sigpreempt.h>
62 #include "gdbthread.h"
63 #include "gdb_assert.h"
64 #include "gdb_obstack.h"
67 #include "inf-child.h"
69 #include "exc_request_S.h"
71 #include "process_reply_S.h"
72 #include "msg_reply_S.h"
73 #include "exc_request_U.h"
76 static process_t proc_server = MACH_PORT_NULL;
78 /* If we've sent a proc_wait_request to the proc server, the pid of the
79 process we asked about. We can only ever have one outstanding. */
80 int proc_wait_pid = 0;
82 /* The number of wait requests we've sent, and expect replies from. */
83 int proc_waits_pending = 0;
85 int gnu_debug_flag = 0;
89 static struct inf *make_inf ();
90 void inf_clear_wait (struct inf *inf);
91 void inf_cleanup (struct inf *inf);
92 void inf_startup (struct inf *inf, int pid);
93 int inf_update_suspends (struct inf *inf);
94 void inf_set_pid (struct inf *inf, pid_t pid);
95 void inf_validate_procs (struct inf *inf);
96 void inf_steal_exc_ports (struct inf *inf);
97 void inf_restore_exc_ports (struct inf *inf);
98 void inf_set_threads_resume_sc (struct inf *inf,
99 struct proc *run_thread,
101 int inf_set_threads_resume_sc_for_signal_thread (struct inf *inf);
102 void inf_suspend (struct inf *inf);
103 void inf_resume (struct inf *inf);
104 void inf_set_step_thread (struct inf *inf, struct proc *proc);
105 void inf_detach (struct inf *inf);
106 void inf_attach (struct inf *inf, int pid);
107 void inf_signal (struct inf *inf, enum gdb_signal sig);
108 void inf_continue (struct inf *inf);
110 #define inf_debug(_inf, msg, args...) \
111 do { struct inf *__inf = (_inf); \
112 debug ("{inf %d %s}: " msg, __inf->pid, \
113 host_address_to_string (__inf) , ##args); } while (0)
115 void proc_abort (struct proc *proc, int force);
116 struct proc *make_proc (struct inf *inf, mach_port_t port, int tid);
117 struct proc *_proc_free (struct proc *proc);
118 int proc_update_sc (struct proc *proc);
119 error_t proc_get_exception_port (struct proc *proc, mach_port_t * port);
120 error_t proc_set_exception_port (struct proc *proc, mach_port_t port);
121 static mach_port_t _proc_get_exc_port (struct proc *proc);
122 void proc_steal_exc_port (struct proc *proc, mach_port_t exc_port);
123 void proc_restore_exc_port (struct proc *proc);
124 int proc_trace (struct proc *proc, int set);
126 /* Evaluate RPC_EXPR in a scope with the variables MSGPORT and REFPORT bound
127 to INF's msg port and task port respectively. If it has no msg port,
128 EIEIO is returned. INF must refer to a running process! */
129 #define INF_MSGPORT_RPC(inf, rpc_expr) \
130 HURD_MSGPORT_RPC (proc_getmsgport (proc_server, inf->pid, &msgport), \
131 (refport = inf->task->port, 0), 0, \
132 msgport ? (rpc_expr) : EIEIO)
134 /* Like INF_MSGPORT_RPC, but will also resume the signal thread to ensure
135 there's someone around to deal with the RPC (and resuspend things
136 afterwards). This effects INF's threads' resume_sc count. */
137 #define INF_RESUME_MSGPORT_RPC(inf, rpc_expr) \
138 (inf_set_threads_resume_sc_for_signal_thread (inf) \
141 __e = INF_MSGPORT_RPC (inf, rpc_expr); \
147 /* The state passed by an exception message. */
150 int exception; /* The exception code. */
152 mach_port_t handler; /* The real exception port to handle this. */
153 mach_port_t reply; /* The reply port from the exception call. */
156 /* The results of the last wait an inf did. */
159 struct target_waitstatus status; /* The status returned to gdb. */
160 struct exc_state exc; /* The exception that caused us to return. */
161 struct proc *thread; /* The thread in question. */
162 int suppress; /* Something trivial happened. */
165 /* The state of an inferior. */
168 /* Fields describing the current inferior. */
170 struct proc *task; /* The mach task. */
171 struct proc *threads; /* A linked list of all threads in TASK. */
173 /* True if THREADS needn't be validated by querying the task. We
174 assume that we and the task in question are the only ones
175 frobbing the thread list, so as long as we don't let any code
176 run, we don't have to worry about THREADS changing. */
177 int threads_up_to_date;
179 pid_t pid; /* The real system PID. */
181 struct inf_wait wait; /* What to return from target_wait. */
183 /* One thread proc in INF may be in `single-stepping mode'. This
185 struct proc *step_thread;
187 /* The thread we think is the signal thread. */
188 struct proc *signal_thread;
190 mach_port_t event_port; /* Where we receive various msgs. */
192 /* True if we think at least one thread in the inferior could currently be
194 unsigned int running:1;
196 /* True if the process has stopped (in the proc server sense). Note that
197 since a proc server `stop' leaves the signal thread running, the inf can
198 be RUNNING && STOPPED... */
199 unsigned int stopped:1;
201 /* True if the inferior has no message port. */
202 unsigned int nomsg:1;
204 /* True if the inferior is traced. */
205 unsigned int traced:1;
207 /* True if we shouldn't try waiting for the inferior, usually because we
208 can't for some reason. */
209 unsigned int no_wait:1;
211 /* When starting a new inferior, we don't try to validate threads until all
212 the proper execs have been done, which this flag states we still
214 unsigned int pending_execs:1;
216 /* Fields describing global state. */
218 /* The task suspend count used when gdb has control. This is normally 1 to
219 make things easier for us, but sometimes (like when attaching to vital
220 system servers) it may be desirable to let the task continue to run
221 (pausing individual threads as necessary). */
224 /* The task suspend count left when detaching from a task. */
227 /* The initial values used for the run_sc and pause_sc of newly discovered
228 threads -- see the definition of those fields in struct proc. */
229 int default_thread_run_sc;
230 int default_thread_pause_sc;
231 int default_thread_detach_sc;
233 /* True if the process should be traced when started/attached. Newly
234 started processes *must* be traced at first to exec them properly, but
235 if this is false, tracing is turned off as soon it has done so. */
238 /* True if exceptions from the inferior process should be trapped. This
239 must be on to use breakpoints. */
245 __proc_pid (struct proc *proc)
247 return proc->inf->pid;
251 /* Update PROC's real suspend count to match it's desired one. Returns true
252 if we think PROC is now in a runnable state. */
254 proc_update_sc (struct proc *proc)
258 int delta = proc->sc - proc->cur_sc;
261 proc_debug (proc, "sc: %d --> %d", proc->cur_sc, proc->sc);
263 if (proc->sc == 0 && proc->state_changed)
264 /* Since PROC may start running, we must write back any state changes. */
266 gdb_assert (proc_is_thread (proc));
267 proc_debug (proc, "storing back changed thread state");
268 err = thread_set_state (proc->port, THREAD_STATE_FLAVOR,
269 (thread_state_t) &proc->state, THREAD_STATE_SIZE);
271 proc->state_changed = 0;
276 while (delta-- > 0 && !err)
278 if (proc_is_task (proc))
279 err = task_suspend (proc->port);
281 err = thread_suspend (proc->port);
286 while (delta++ < 0 && !err)
288 if (proc_is_task (proc))
289 err = task_resume (proc->port);
291 err = thread_resume (proc->port);
295 proc->cur_sc = proc->sc;
297 /* If we got an error, then the task/thread has disappeared. */
298 running = !err && proc->sc == 0;
300 proc_debug (proc, "is %s", err ? "dead" : running ? "running" : "suspended");
302 proc_debug (proc, "err = %s", safe_strerror (err));
307 proc->state_valid = proc->state_changed = 0;
308 proc->fetched_regs = 0;
315 /* Thread_abort is called on PROC if needed. PROC must be a thread proc.
316 If PROC is deemed `precious', then nothing is done unless FORCE is true.
317 In particular, a thread is precious if it's running (in which case forcing
318 it includes suspending it first), or if it has an exception pending. */
320 proc_abort (struct proc *proc, int force)
322 gdb_assert (proc_is_thread (proc));
326 struct inf *inf = proc->inf;
327 int running = (proc->cur_sc == 0 && inf->task->cur_sc == 0);
329 if (running && force)
332 inf_update_suspends (proc->inf);
334 warning (_("Stopped %s."), proc_string (proc));
336 else if (proc == inf->wait.thread && inf->wait.exc.reply && !force)
337 /* An exception is pending on PROC, which don't mess with. */
341 /* We only abort the thread if it's not actually running. */
343 thread_abort (proc->port);
344 proc_debug (proc, "aborted");
348 proc_debug (proc, "not aborting");
352 /* Make sure that the state field in PROC is up to date, and return a pointer
353 to it, or 0 if something is wrong. If WILL_MODIFY is true, makes sure
354 that the thread is stopped and aborted first, and sets the state_changed
355 field in PROC to true. */
357 proc_get_state (struct proc *proc, int will_modify)
359 int was_aborted = proc->aborted;
361 proc_debug (proc, "updating state info%s",
362 will_modify ? " (with intention to modify)" : "");
364 proc_abort (proc, will_modify);
366 if (!was_aborted && proc->aborted)
367 /* PROC's state may have changed since we last fetched it. */
368 proc->state_valid = 0;
370 if (!proc->state_valid)
372 mach_msg_type_number_t state_size = THREAD_STATE_SIZE;
374 thread_get_state (proc->port, THREAD_STATE_FLAVOR,
375 (thread_state_t) &proc->state, &state_size);
377 proc_debug (proc, "getting thread state");
378 proc->state_valid = !err;
381 if (proc->state_valid)
384 proc->state_changed = 1;
385 return (thread_state_t) &proc->state;
392 /* Set PORT to PROC's exception port. */
394 proc_get_exception_port (struct proc * proc, mach_port_t * port)
396 if (proc_is_task (proc))
397 return task_get_exception_port (proc->port, port);
399 return thread_get_exception_port (proc->port, port);
402 /* Set PROC's exception port to PORT. */
404 proc_set_exception_port (struct proc * proc, mach_port_t port)
406 proc_debug (proc, "setting exception port: %lu", port);
407 if (proc_is_task (proc))
408 return task_set_exception_port (proc->port, port);
410 return thread_set_exception_port (proc->port, port);
413 /* Get PROC's exception port, cleaning up a bit if proc has died. */
415 _proc_get_exc_port (struct proc *proc)
417 mach_port_t exc_port;
418 error_t err = proc_get_exception_port (proc, &exc_port);
421 /* PROC must be dead. */
424 mach_port_deallocate (mach_task_self (), proc->exc_port);
425 proc->exc_port = MACH_PORT_NULL;
426 if (proc->saved_exc_port)
427 mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
428 proc->saved_exc_port = MACH_PORT_NULL;
434 /* Replace PROC's exception port with EXC_PORT, unless it's already
435 been done. Stash away any existing exception port so we can
438 proc_steal_exc_port (struct proc *proc, mach_port_t exc_port)
440 mach_port_t cur_exc_port = _proc_get_exc_port (proc);
446 proc_debug (proc, "inserting exception port: %lu", exc_port);
448 if (cur_exc_port != exc_port)
449 /* Put in our exception port. */
450 err = proc_set_exception_port (proc, exc_port);
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. */
457 mach_port_deallocate (mach_task_self (), cur_exc_port);
460 /* Keep a copy of PROC's old exception port so it can be restored. */
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;
467 proc_debug (proc, "saved exception port: %lu", proc->saved_exc_port);
470 proc->exc_port = exc_port;
472 warning (_("Error setting exception port for %s: %s"),
473 proc_string (proc), safe_strerror (err));
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. */
481 proc_restore_exc_port (struct proc *proc)
483 mach_port_t cur_exc_port = _proc_get_exc_port (proc);
489 proc_debug (proc, "restoring real exception port");
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);
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;
500 proc->exc_port = MACH_PORT_NULL;
502 warning (_("Error setting exception port for %s: %s"),
503 proc_string (proc), safe_strerror (err));
508 /* Turns hardware tracing in PROC on or off when SET is true or false,
509 respectively. Returns true on success. */
511 proc_trace (struct proc *proc, int set)
513 thread_state_t state = proc_get_state (proc, 1);
516 return 0; /* The thread must be dead. */
518 proc_debug (proc, "tracing %s", set ? "on" : "off");
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);
529 THREAD_STATE_CLEAR_TRACED (state);
535 /* A variable from which to assign new TIDs. */
536 static int next_thread_id = 1;
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. */
541 make_proc (struct inf *inf, mach_port_t port, int tid)
544 mach_port_t prev_port = MACH_PORT_NULL;
545 struct proc *proc = xmalloc (sizeof (struct proc));
551 proc->saved_exc_port = MACH_PORT_NULL;
552 proc->exc_port = MACH_PORT_NULL;
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;
566 proc->state_valid = 0;
567 proc->state_changed = 0;
569 proc_debug (proc, "is new");
571 /* Get notified when things die. */
573 mach_port_request_notification (mach_task_self (), port,
574 MACH_NOTIFY_DEAD_NAME, 1,
576 MACH_MSG_TYPE_MAKE_SEND_ONCE,
579 warning (_("Couldn't request notification for port %lu: %s"),
580 port, safe_strerror (err));
583 proc_debug (proc, "notifications to: %lu", inf->event_port);
584 if (prev_port != MACH_PORT_NULL)
585 mach_port_deallocate (mach_task_self (), prev_port);
588 if (inf->want_exceptions)
590 if (proc_is_task (proc))
591 /* Make the task exception port point to us. */
592 proc_steal_exc_port (proc, inf->event_port);
594 /* Just clear thread exception ports -- they default to the
596 proc_steal_exc_port (proc, MACH_PORT_NULL);
602 /* Frees PROC and any resources it uses, and returns the value of PROC's
605 _proc_free (struct proc *proc)
607 struct inf *inf = proc->inf;
608 struct proc *next = proc->next;
610 proc_debug (proc, "freeing...");
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;
620 if (proc->port != MACH_PORT_NULL)
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. */
629 proc_update_sc (proc);
631 mach_port_deallocate (mach_task_self (), proc->port);
642 struct inf *inf = xmalloc (sizeof (struct inf));
646 inf->threads_up_to_date = 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;
660 inf->pending_execs = 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 */
672 /* Clear INF's target wait status. */
674 inf_clear_wait (struct inf *inf)
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)
682 mach_port_deallocate (mach_task_self (), inf->wait.exc.handler);
683 inf->wait.exc.handler = MACH_PORT_NULL;
685 if (inf->wait.exc.reply != MACH_PORT_NULL)
687 mach_port_deallocate (mach_task_self (), inf->wait.exc.reply);
688 inf->wait.exc.reply = MACH_PORT_NULL;
694 inf_cleanup (struct inf *inf)
696 inf_debug (inf, "cleanup");
698 inf_clear_wait (inf);
700 inf_set_pid (inf, -1);
707 inf->pending_execs = 0;
711 mach_port_destroy (mach_task_self (), inf->event_port);
712 inf->event_port = MACH_PORT_NULL;
717 inf_startup (struct inf *inf, int pid)
721 inf_debug (inf, "startup: pid = %d", pid);
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);
729 error (_("Error allocating event port: %s"), safe_strerror (err));
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);
738 /* Close current process, if any, and attach INF to process PORT. */
740 inf_set_pid (struct inf *inf, pid_t pid)
743 struct proc *task = inf->task;
745 inf_debug (inf, "setting pid: %d", pid);
748 task_port = MACH_PORT_NULL;
751 error_t err = proc_pid2task (proc_server, pid, &task_port);
754 error (_("Error getting task for pid %d: %s"),
755 pid, safe_strerror (err));
758 inf_debug (inf, "setting task: %lu", task_port);
761 task_suspend (task_port);
763 if (task && task->port != task_port)
766 inf_validate_procs (inf); /* Trash all the threads. */
767 _proc_free (task); /* And the task. */
770 if (task_port != MACH_PORT_NULL)
772 inf->task = make_proc (inf, task_port, PROC_TID_TASK);
773 inf->threads_up_to_date = 0;
780 /* Reflect task_suspend above. */
781 inf->task->sc = inf->task->cur_sc = 1;
788 /* Validates INF's stopped, nomsg and traced field from the actual
789 proc server state. Note that the traced field is only updated from
790 the proc server state if we do not have a message port. If we do
791 have a message port we'd better look at the tracemask itself. */
793 inf_validate_procinfo (struct inf *inf)
796 mach_msg_type_number_t noise_len = 0;
798 mach_msg_type_number_t pi_len = 0;
801 proc_getprocinfo (proc_server, inf->pid, &info_flags,
802 (procinfo_t *) &pi, &pi_len, &noise, &noise_len);
806 inf->stopped = !!(pi->state & PI_STOPPED);
807 inf->nomsg = !!(pi->state & PI_NOMSG);
809 inf->traced = !!(pi->state & PI_TRACED);
810 vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len);
812 vm_deallocate (mach_task_self (), (vm_address_t) noise, noise_len);
816 /* Validates INF's task suspend count. If it's higher than we expect,
817 verify with the user before `stealing' the extra count. */
819 inf_validate_task_sc (struct inf *inf)
822 mach_msg_type_number_t noise_len = 0;
824 mach_msg_type_number_t pi_len = 0;
825 int info_flags = PI_FETCH_TASKINFO;
826 int suspend_count = -1;
830 err = proc_getprocinfo (proc_server, inf->pid, &info_flags,
831 (procinfo_t *) &pi, &pi_len, &noise, &noise_len);
834 inf->task->dead = 1; /* oh well */
838 if (inf->task->cur_sc < pi->taskinfo.suspend_count && suspend_count == -1)
840 /* The proc server might have suspended the task while stopping
841 it. This happens when the task is handling a traced signal.
842 Refetch the suspend count. The proc server should be
843 finished stopping the task by now. */
844 suspend_count = pi->taskinfo.suspend_count;
848 suspend_count = pi->taskinfo.suspend_count;
850 vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len);
852 vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len);
854 if (inf->task->cur_sc < suspend_count)
858 target_terminal_ours (); /* Allow I/O. */
859 abort = !query (_("Pid %d has an additional task suspend count of %d;"
860 " clear it? "), inf->pid,
861 suspend_count - inf->task->cur_sc);
862 target_terminal_inferior (); /* Give it back to the child. */
865 error (_("Additional task suspend count left untouched."));
867 inf->task->cur_sc = suspend_count;
871 /* Turns tracing for INF on or off, depending on ON, unless it already
872 is. If INF is running, the resume_sc count of INF's threads will
873 be modified, and the signal thread will briefly be run to change
876 inf_set_traced (struct inf *inf, int on)
878 if (on == inf->traced)
881 if (inf->task && !inf->task->dead)
882 /* Make it take effect immediately. */
884 sigset_t mask = on ? ~(sigset_t) 0 : 0;
886 INF_RESUME_MSGPORT_RPC (inf, msg_set_init_int (msgport, refport,
887 INIT_TRACEMASK, mask));
892 warning (_("Can't modify tracing state for pid %d: %s"),
893 inf->pid, "No signal thread");
897 warning (_("Can't modify tracing state for pid %d: %s"),
898 inf->pid, safe_strerror (err));
907 /* Makes all the real suspend count deltas of all the procs in INF
908 match the desired values. Careful to always do thread/task suspend
909 counts in the safe order. Returns true if at least one thread is
910 thought to be running. */
912 inf_update_suspends (struct inf *inf)
914 struct proc *task = inf->task;
916 /* We don't have to update INF->threads even though we're iterating over it
917 because we'll change a thread only if it already has an existing proc
919 inf_debug (inf, "updating suspend counts");
924 int task_running = (task->sc == 0), thread_running = 0;
926 if (task->sc > task->cur_sc)
927 /* The task is becoming _more_ suspended; do before any threads. */
928 task_running = proc_update_sc (task);
930 if (inf->pending_execs)
931 /* When we're waiting for an exec, things may be happening behind our
932 back, so be conservative. */
935 /* Do all the thread suspend counts. */
936 for (thread = inf->threads; thread; thread = thread->next)
937 thread_running |= proc_update_sc (thread);
939 if (task->sc != task->cur_sc)
940 /* We didn't do the task first, because we wanted to wait for the
941 threads; do it now. */
942 task_running = proc_update_sc (task);
944 inf_debug (inf, "%srunning...",
945 (thread_running && task_running) ? "" : "not ");
947 inf->running = thread_running && task_running;
949 /* Once any thread has executed some code, we can't depend on the
950 threads list any more. */
952 inf->threads_up_to_date = 0;
961 /* Converts a GDB pid to a struct proc. */
963 inf_tid_to_thread (struct inf *inf, int tid)
965 struct proc *thread = inf->threads;
968 if (thread->tid == tid)
971 thread = thread->next;
975 /* Converts a thread port to a struct proc. */
977 inf_port_to_thread (struct inf *inf, mach_port_t port)
979 struct proc *thread = inf->threads;
982 if (thread->port == port)
985 thread = thread->next;
990 /* Make INF's list of threads be consistent with reality of TASK. */
992 inf_validate_procs (struct inf *inf)
994 thread_array_t threads;
995 mach_msg_type_number_t num_threads, i;
996 struct proc *task = inf->task;
998 /* If no threads are currently running, this function will guarantee that
999 things are up to date. The exception is if there are zero threads --
1000 then it is almost certainly in an odd state, and probably some outside
1001 agent will create threads. */
1002 inf->threads_up_to_date = inf->threads ? !inf->running : 0;
1006 error_t err = task_threads (task->port, &threads, &num_threads);
1008 inf_debug (inf, "fetching threads");
1010 /* TASK must be dead. */
1020 inf_debug (inf, "no task");
1024 /* Make things normally linear. */
1025 mach_msg_type_number_t search_start = 0;
1026 /* Which thread in PROCS corresponds to each task thread, & the task. */
1027 struct proc *matched[num_threads + 1];
1028 /* The last thread in INF->threads, so we can add to the end. */
1029 struct proc *last = 0;
1030 /* The current thread we're considering. */
1031 struct proc *thread = inf->threads;
1033 memset (matched, 0, sizeof (matched));
1037 mach_msg_type_number_t left;
1039 for (i = search_start, left = num_threads; left; i++, left--)
1041 if (i >= num_threads)
1042 i -= num_threads; /* I wrapped around. */
1043 if (thread->port == threads[i])
1044 /* We already know about this thread. */
1046 matched[i] = thread;
1048 thread = thread->next;
1056 proc_debug (thread, "died!");
1057 thread->port = MACH_PORT_NULL;
1058 thread = _proc_free (thread); /* THREAD is dead. */
1060 last->next = thread;
1062 inf->threads = thread;
1066 for (i = 0; i < num_threads; i++)
1069 /* Throw away the duplicate send right. */
1070 mach_port_deallocate (mach_task_self (), threads[i]);
1072 /* THREADS[I] is a thread we don't know about yet! */
1076 thread = make_proc (inf, threads[i], next_thread_id++);
1078 last->next = thread;
1080 inf->threads = thread;
1082 proc_debug (thread, "new thread: %lu", threads[i]);
1084 ptid = ptid_build (inf->pid, thread->tid, 0);
1086 /* Tell GDB's generic thread code. */
1088 if (ptid_equal (inferior_ptid, pid_to_ptid (inf->pid)))
1089 /* This is the first time we're hearing about thread
1090 ids, after a fork-child. */
1091 thread_change_ptid (inferior_ptid, ptid);
1092 else if (inf->pending_execs != 0)
1093 /* This is a shell thread. */
1094 add_thread_silent (ptid);
1100 vm_deallocate (mach_task_self (),
1101 (vm_address_t) threads, (num_threads * sizeof (thread_t)));
1106 /* Makes sure that INF's thread list is synced with the actual process. */
1108 inf_update_procs (struct inf *inf)
1112 if (!inf->threads_up_to_date)
1113 inf_validate_procs (inf);
1117 /* Sets the resume_sc of each thread in inf. That of RUN_THREAD is set to 0,
1118 and others are set to their run_sc if RUN_OTHERS is true, and otherwise
1121 inf_set_threads_resume_sc (struct inf *inf,
1122 struct proc *run_thread, int run_others)
1124 struct proc *thread;
1126 inf_update_procs (inf);
1127 for (thread = inf->threads; thread; thread = thread->next)
1128 if (thread == run_thread)
1129 thread->resume_sc = 0;
1130 else if (run_others)
1131 thread->resume_sc = thread->run_sc;
1133 thread->resume_sc = thread->pause_sc;
1137 /* Cause INF to continue execution immediately; individual threads may still
1138 be suspended (but their suspend counts will be updated). */
1140 inf_resume (struct inf *inf)
1142 struct proc *thread;
1144 inf_update_procs (inf);
1146 for (thread = inf->threads; thread; thread = thread->next)
1147 thread->sc = thread->resume_sc;
1151 if (!inf->pending_execs)
1152 /* Try to make sure our task count is correct -- in the case where
1153 we're waiting for an exec though, things are too volatile, so just
1154 assume things will be reasonable (which they usually will be). */
1155 inf_validate_task_sc (inf);
1159 inf_update_suspends (inf);
1162 /* Cause INF to stop execution immediately; individual threads may still
1165 inf_suspend (struct inf *inf)
1167 struct proc *thread;
1169 inf_update_procs (inf);
1171 for (thread = inf->threads; thread; thread = thread->next)
1172 thread->sc = thread->pause_sc;
1175 inf->task->sc = inf->pause_sc;
1177 inf_update_suspends (inf);
1181 /* INF has one thread PROC that is in single-stepping mode. This
1182 function changes it to be PROC, changing any old step_thread to be
1183 a normal one. A PROC of 0 clears any existing value. */
1185 inf_set_step_thread (struct inf *inf, struct proc *thread)
1187 gdb_assert (!thread || proc_is_thread (thread));
1190 inf_debug (inf, "setting step thread: %d/%d", inf->pid, thread->tid);
1192 inf_debug (inf, "clearing step thread");
1194 if (inf->step_thread != thread)
1196 if (inf->step_thread && inf->step_thread->port != MACH_PORT_NULL)
1197 if (!proc_trace (inf->step_thread, 0))
1199 if (thread && proc_trace (thread, 1))
1200 inf->step_thread = thread;
1202 inf->step_thread = 0;
1207 /* Set up the thread resume_sc's so that only the signal thread is running
1208 (plus whatever other thread are set to always run). Returns true if we
1209 did so, or false if we can't find a signal thread. */
1211 inf_set_threads_resume_sc_for_signal_thread (struct inf *inf)
1213 if (inf->signal_thread)
1215 inf_set_threads_resume_sc (inf, inf->signal_thread, 0);
1223 inf_update_signal_thread (struct inf *inf)
1225 /* XXX for now we assume that if there's a msgport, the 2nd thread is
1226 the signal thread. */
1227 inf->signal_thread = inf->threads ? inf->threads->next : 0;
1231 /* Detachs from INF's inferior task, letting it run once again... */
1233 inf_detach (struct inf *inf)
1235 struct proc *task = inf->task;
1237 inf_debug (inf, "detaching...");
1239 inf_clear_wait (inf);
1240 inf_set_step_thread (inf, 0);
1244 struct proc *thread;
1246 inf_validate_procinfo (inf);
1248 inf_set_traced (inf, 0);
1254 inf_signal (inf, GDB_SIGNAL_0);
1257 proc_restore_exc_port (task);
1258 task->sc = inf->detach_sc;
1260 for (thread = inf->threads; thread; thread = thread->next)
1262 proc_restore_exc_port (thread);
1263 thread->sc = thread->detach_sc;
1266 inf_update_suspends (inf);
1272 /* Attaches INF to the process with process id PID, returning it in a
1273 suspended state suitable for debugging. */
1275 inf_attach (struct inf *inf, int pid)
1277 inf_debug (inf, "attaching: %d", pid);
1282 inf_startup (inf, pid);
1286 /* Makes sure that we've got our exception ports entrenched in the process. */
1288 inf_steal_exc_ports (struct inf *inf)
1290 struct proc *thread;
1292 inf_debug (inf, "stealing exception ports");
1294 inf_set_step_thread (inf, 0); /* The step thread is special. */
1296 proc_steal_exc_port (inf->task, inf->event_port);
1297 for (thread = inf->threads; thread; thread = thread->next)
1298 proc_steal_exc_port (thread, MACH_PORT_NULL);
1301 /* Makes sure the process has its own exception ports. */
1303 inf_restore_exc_ports (struct inf *inf)
1305 struct proc *thread;
1307 inf_debug (inf, "restoring exception ports");
1309 inf_set_step_thread (inf, 0); /* The step thread is special. */
1311 proc_restore_exc_port (inf->task);
1312 for (thread = inf->threads; thread; thread = thread->next)
1313 proc_restore_exc_port (thread);
1317 /* Deliver signal SIG to INF. If INF is stopped, delivering a signal, even
1318 signal 0, will continue it. INF is assumed to be in a paused state, and
1319 the resume_sc's of INF's threads may be affected. */
1321 inf_signal (struct inf *inf, enum gdb_signal sig)
1324 int host_sig = gdb_signal_to_host (sig);
1326 #define NAME gdb_signal_to_name (sig)
1328 if (host_sig >= _NSIG)
1329 /* A mach exception. Exceptions are encoded in the signal space by
1330 putting them after _NSIG; this assumes they're positive (and not
1331 extremely large)! */
1333 struct inf_wait *w = &inf->wait;
1335 if (w->status.kind == TARGET_WAITKIND_STOPPED
1336 && w->status.value.sig == sig
1337 && w->thread && !w->thread->aborted)
1338 /* We're passing through the last exception we received. This is
1339 kind of bogus, because exceptions are per-thread whereas gdb
1340 treats signals as per-process. We just forward the exception to
1341 the correct handler, even it's not for the same thread as TID --
1342 i.e., we pretend it's global. */
1344 struct exc_state *e = &w->exc;
1346 inf_debug (inf, "passing through exception:"
1347 " task = %lu, thread = %lu, exc = %d"
1348 ", code = %d, subcode = %d",
1349 w->thread->port, inf->task->port,
1350 e->exception, e->code, e->subcode);
1352 exception_raise_request (e->handler,
1353 e->reply, MACH_MSG_TYPE_MOVE_SEND_ONCE,
1354 w->thread->port, inf->task->port,
1355 e->exception, e->code, e->subcode);
1358 error (_("Can't forward spontaneous exception (%s)."), NAME);
1361 /* A Unix signal. */
1363 /* The process is stopped and expecting a signal. Just send off a
1364 request and let it get handled when we resume everything. */
1366 inf_debug (inf, "sending %s to stopped process", NAME);
1368 INF_MSGPORT_RPC (inf,
1369 msg_sig_post_untraced_request (msgport,
1371 MACH_MSG_TYPE_MAKE_SEND_ONCE,
1375 /* Posting an untraced signal automatically continues it.
1376 We clear this here rather than when we get the reply
1377 because we'd rather assume it's not stopped when it
1378 actually is, than the reverse. */
1382 /* It's not expecting it. We have to let just the signal thread
1383 run, and wait for it to get into a reasonable state before we
1384 can continue the rest of the process. When we finally resume the
1385 process the signal we request will be the very first thing that
1388 inf_debug (inf, "sending %s to unstopped process"
1389 " (so resuming signal thread)", NAME);
1391 INF_RESUME_MSGPORT_RPC (inf,
1392 msg_sig_post_untraced (msgport, host_sig,
1397 /* Can't do too much... */
1398 warning (_("Can't deliver signal %s: No signal thread."), NAME);
1400 warning (_("Delivering signal %s: %s"), NAME, safe_strerror (err));
1406 /* Continue INF without delivering a signal. This is meant to be used
1407 when INF does not have a message port. */
1409 inf_continue (struct inf *inf)
1412 error_t err = proc_pid2proc (proc_server, inf->pid, &proc);
1416 inf_debug (inf, "continuing process");
1418 err = proc_mark_cont (proc);
1421 struct proc *thread;
1423 for (thread = inf->threads; thread; thread = thread->next)
1424 thread_resume (thread->port);
1431 warning (_("Can't continue process: %s"), safe_strerror (err));
1435 /* The inferior used for all gdb target ops. */
1436 struct inf *gnu_current_inf = 0;
1438 /* The inferior being waited for by gnu_wait. Since GDB is decidely not
1439 multi-threaded, we don't bother to lock this. */
1440 struct inf *waiting_inf;
1442 /* Wait for something to happen in the inferior, returning what in STATUS. */
1444 gnu_wait (struct target_ops *ops,
1445 ptid_t ptid, struct target_waitstatus *status, int options)
1449 mach_msg_header_t hdr;
1450 mach_msg_type_t type;
1454 struct proc *thread;
1455 struct inf *inf = gnu_current_inf;
1457 extern int exc_server (mach_msg_header_t *, mach_msg_header_t *);
1458 extern int msg_reply_server (mach_msg_header_t *, mach_msg_header_t *);
1459 extern int notify_server (mach_msg_header_t *, mach_msg_header_t *);
1460 extern int process_reply_server (mach_msg_header_t *, mach_msg_header_t *);
1462 gdb_assert (inf->task);
1464 if (!inf->threads && !inf->pending_execs)
1465 /* No threads! Assume that maybe some outside agency is frobbing our
1466 task, and really look for new threads. If we can't find any, just tell
1467 the user to try again later. */
1469 inf_validate_procs (inf);
1470 if (!inf->threads && !inf->task->dead)
1471 error (_("There are no threads; try again later."));
1476 inf_debug (inf, "waiting for: %s", target_pid_to_str (ptid));
1479 if (proc_wait_pid != inf->pid && !inf->no_wait)
1480 /* Always get information on events from the proc server. */
1482 inf_debug (inf, "requesting wait on pid %d", inf->pid);
1485 /* The proc server is single-threaded, and only allows a single
1486 outstanding wait request, so we have to cancel the previous one. */
1488 inf_debug (inf, "cancelling previous wait on pid %d", proc_wait_pid);
1489 interrupt_operation (proc_server, 0);
1493 proc_wait_request (proc_server, inf->event_port, inf->pid, WUNTRACED);
1495 warning (_("wait request failed: %s"), safe_strerror (err));
1498 inf_debug (inf, "waits pending: %d", proc_waits_pending);
1499 proc_wait_pid = inf->pid;
1500 /* Even if proc_waits_pending was > 0 before, we still won't
1501 get any other replies, because it was either from a
1502 different INF, or a different process attached to INF --
1503 and the event port, which is the wait reply port, changes
1504 when you switch processes. */
1505 proc_waits_pending = 1;
1509 inf_clear_wait (inf);
1511 /* What can happen? (1) Dead name notification; (2) Exceptions arrive;
1512 (3) wait reply from the proc server. */
1514 inf_debug (inf, "waiting for an event...");
1515 err = mach_msg (&msg.hdr, MACH_RCV_MSG | MACH_RCV_INTERRUPT,
1516 0, sizeof (struct msg), inf->event_port,
1517 MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
1519 /* Re-suspend the task. */
1522 if (!inf->task && inf->pending_execs)
1523 /* When doing an exec, it's possible that the old task wasn't reused
1524 (e.g., setuid execs). So if the task seems to have disappeared,
1525 attempt to refetch it, as the pid should still be the same. */
1526 inf_set_pid (inf, inf->pid);
1528 if (err == EMACH_RCV_INTERRUPTED)
1529 inf_debug (inf, "interrupted");
1531 error (_("Couldn't wait for an event: %s"), safe_strerror (err));
1536 mach_msg_header_t hdr;
1537 mach_msg_type_t err_type;
1543 inf_debug (inf, "event: msgid = %d", msg.hdr.msgh_id);
1545 /* Handle what we got. */
1546 if (!notify_server (&msg.hdr, &reply.hdr)
1547 && !exc_server (&msg.hdr, &reply.hdr)
1548 && !process_reply_server (&msg.hdr, &reply.hdr)
1549 && !msg_reply_server (&msg.hdr, &reply.hdr))
1550 /* Whatever it is, it's something strange. */
1551 error (_("Got a strange event, msg id = %d."), msg.hdr.msgh_id);
1554 error (_("Handling event, msgid = %d: %s"),
1555 msg.hdr.msgh_id, safe_strerror (reply.err));
1558 if (inf->pending_execs)
1559 /* We're waiting for the inferior to finish execing. */
1561 struct inf_wait *w = &inf->wait;
1562 enum target_waitkind kind = w->status.kind;
1564 if (kind == TARGET_WAITKIND_SPURIOUS)
1565 /* Since gdb is actually counting the number of times the inferior
1566 stops, expecting one stop per exec, we only return major events
1570 inf_debug (inf, "pending_execs, ignoring minor event");
1572 else if (kind == TARGET_WAITKIND_STOPPED
1573 && w->status.value.sig == GDB_SIGNAL_TRAP)
1574 /* Ah hah! A SIGTRAP from the inferior while starting up probably
1575 means we've succesfully completed an exec! */
1577 inf_debug (inf, "one pending exec completed");
1579 else if (kind == TARGET_WAITKIND_STOPPED)
1580 /* It's possible that this signal is because of a crashed process
1581 being handled by the hurd crash server; in this case, the process
1582 will have an extra task suspend, which we need to know about.
1583 Since the code in inf_resume that normally checks for this is
1584 disabled while INF->pending_execs, we do the check here instead. */
1585 inf_validate_task_sc (inf);
1588 if (inf->wait.suppress)
1589 /* Some totally spurious event happened that we don't consider
1590 worth returning to gdb. Just keep waiting. */
1592 inf_debug (inf, "suppressing return, rewaiting...");
1597 /* Pass back out our results. */
1598 memcpy (status, &inf->wait.status, sizeof (*status));
1600 thread = inf->wait.thread;
1602 ptid = ptid_build (inf->pid, thread->tid, 0);
1603 else if (ptid_equal (ptid, minus_one_ptid))
1604 thread = inf_tid_to_thread (inf, -1);
1606 thread = inf_tid_to_thread (inf, ptid_get_lwp (ptid));
1608 if (!thread || thread->port == MACH_PORT_NULL)
1610 /* TID is dead; try and find a new thread. */
1611 if (inf_update_procs (inf) && inf->threads)
1612 ptid = ptid_build (inf->pid, inf->threads->tid, 0); /* The first
1616 ptid = inferior_ptid; /* let wait_for_inferior handle exit case */
1620 && !ptid_equal (ptid, minus_one_ptid)
1621 && status->kind != TARGET_WAITKIND_SPURIOUS
1622 && inf->pause_sc == 0 && thread->pause_sc == 0)
1623 /* If something actually happened to THREAD, make sure we
1627 inf_update_suspends (inf);
1630 inf_debug (inf, "returning ptid = %s, status = %s (%d)",
1631 target_pid_to_str (ptid),
1632 status->kind == TARGET_WAITKIND_EXITED ? "EXITED"
1633 : status->kind == TARGET_WAITKIND_STOPPED ? "STOPPED"
1634 : status->kind == TARGET_WAITKIND_SIGNALLED ? "SIGNALLED"
1635 : status->kind == TARGET_WAITKIND_LOADED ? "LOADED"
1636 : status->kind == TARGET_WAITKIND_SPURIOUS ? "SPURIOUS"
1638 status->value.integer);
1644 /* The rpc handler called by exc_server. */
1646 S_exception_raise_request (mach_port_t port, mach_port_t reply_port,
1647 thread_t thread_port, task_t task_port,
1648 int exception, int code, int subcode)
1650 struct inf *inf = waiting_inf;
1651 struct proc *thread = inf_port_to_thread (inf, thread_port);
1653 inf_debug (waiting_inf,
1654 "thread = %lu, task = %lu, exc = %d, code = %d, subcode = %d",
1655 thread_port, task_port, exception, code, subcode);
1658 /* We don't know about thread? */
1660 inf_update_procs (inf);
1661 thread = inf_port_to_thread (inf, thread_port);
1663 /* Give up, the generating thread is gone. */
1667 mach_port_deallocate (mach_task_self (), thread_port);
1668 mach_port_deallocate (mach_task_self (), task_port);
1670 if (!thread->aborted)
1671 /* THREAD hasn't been aborted since this exception happened (abortion
1672 clears any exception state), so it must be real. */
1674 /* Store away the details; this will destroy any previous info. */
1675 inf->wait.thread = thread;
1677 inf->wait.status.kind = TARGET_WAITKIND_STOPPED;
1679 if (exception == EXC_BREAKPOINT)
1680 /* GDB likes to get SIGTRAP for breakpoints. */
1682 inf->wait.status.value.sig = GDB_SIGNAL_TRAP;
1683 mach_port_deallocate (mach_task_self (), reply_port);
1686 /* Record the exception so that we can forward it later. */
1688 if (thread->exc_port == port)
1690 inf_debug (waiting_inf, "Handler is thread exception port <%lu>",
1691 thread->saved_exc_port);
1692 inf->wait.exc.handler = thread->saved_exc_port;
1696 inf_debug (waiting_inf, "Handler is task exception port <%lu>",
1697 inf->task->saved_exc_port);
1698 inf->wait.exc.handler = inf->task->saved_exc_port;
1699 gdb_assert (inf->task->exc_port == port);
1701 if (inf->wait.exc.handler != MACH_PORT_NULL)
1702 /* Add a reference to the exception handler. */
1703 mach_port_mod_refs (mach_task_self (),
1704 inf->wait.exc.handler, MACH_PORT_RIGHT_SEND,
1707 inf->wait.exc.exception = exception;
1708 inf->wait.exc.code = code;
1709 inf->wait.exc.subcode = subcode;
1710 inf->wait.exc.reply = reply_port;
1712 /* Exceptions are encoded in the signal space by putting
1713 them after _NSIG; this assumes they're positive (and not
1714 extremely large)! */
1715 inf->wait.status.value.sig =
1716 gdb_signal_from_host (_NSIG + exception);
1720 /* A supppressed exception, which ignore. */
1722 inf->wait.suppress = 1;
1723 mach_port_deallocate (mach_task_self (), reply_port);
1730 /* Fill in INF's wait field after a task has died without giving us more
1731 detailed information. */
1733 inf_task_died_status (struct inf *inf)
1735 warning (_("Pid %d died with unknown exit status, using SIGKILL."),
1737 inf->wait.status.kind = TARGET_WAITKIND_SIGNALLED;
1738 inf->wait.status.value.sig = GDB_SIGNAL_KILL;
1741 /* Notify server routines. The only real one is dead name notification. */
1743 do_mach_notify_dead_name (mach_port_t notify, mach_port_t dead_port)
1745 struct inf *inf = waiting_inf;
1747 inf_debug (waiting_inf, "port = %lu", dead_port);
1749 if (inf->task && inf->task->port == dead_port)
1751 proc_debug (inf->task, "is dead");
1752 inf->task->port = MACH_PORT_NULL;
1753 if (proc_wait_pid == inf->pid)
1754 /* We have a wait outstanding on the process, which will return more
1755 detailed information, so delay until we get that. */
1756 inf->wait.suppress = 1;
1758 /* We never waited for the process (maybe it wasn't a child), so just
1759 pretend it got a SIGKILL. */
1760 inf_task_died_status (inf);
1764 struct proc *thread = inf_port_to_thread (inf, dead_port);
1768 proc_debug (thread, "is dead");
1769 thread->port = MACH_PORT_NULL;
1772 if (inf->task->dead)
1773 /* Since the task is dead, its threads are dying with it. */
1774 inf->wait.suppress = 1;
1777 mach_port_deallocate (mach_task_self (), dead_port);
1778 inf->threads_up_to_date = 0; /* Just in case. */
1784 #define ILL_RPC(fun, ...) \
1785 extern kern_return_t fun (__VA_ARGS__); \
1786 kern_return_t fun (__VA_ARGS__) \
1788 warning (_("illegal rpc: %s"), #fun); \
1792 ILL_RPC (do_mach_notify_no_senders,
1793 mach_port_t notify, mach_port_mscount_t count)
1794 ILL_RPC (do_mach_notify_port_deleted,
1795 mach_port_t notify, mach_port_t name)
1796 ILL_RPC (do_mach_notify_msg_accepted,
1797 mach_port_t notify, mach_port_t name)
1798 ILL_RPC (do_mach_notify_port_destroyed,
1799 mach_port_t notify, mach_port_t name)
1800 ILL_RPC (do_mach_notify_send_once,
1803 /* Process_reply server routines. We only use process_wait_reply. */
1806 S_proc_wait_reply (mach_port_t reply, error_t err,
1807 int status, int sigcode, rusage_t rusage, pid_t pid)
1809 struct inf *inf = waiting_inf;
1811 inf_debug (inf, "err = %s, pid = %d, status = 0x%x, sigcode = %d",
1812 err ? safe_strerror (err) : "0", pid, status, sigcode);
1814 if (err && proc_wait_pid && (!inf->task || !inf->task->port))
1815 /* Ack. The task has died, but the task-died notification code didn't
1816 tell anyone because it thought a more detailed reply from the
1817 procserver was forthcoming. However, we now learn that won't
1818 happen... So we have to act like the task just died, and this time,
1820 inf_task_died_status (inf);
1822 if (--proc_waits_pending == 0)
1823 /* PROC_WAIT_PID represents the most recent wait. We will always get
1824 replies in order because the proc server is single threaded. */
1827 inf_debug (inf, "waits pending now: %d", proc_waits_pending);
1833 warning (_("Can't wait for pid %d: %s"),
1834 inf->pid, safe_strerror (err));
1837 /* Since we can't see the inferior's signals, don't trap them. */
1838 inf_set_traced (inf, 0);
1841 else if (pid == inf->pid)
1843 store_waitstatus (&inf->wait.status, status);
1844 if (inf->wait.status.kind == TARGET_WAITKIND_STOPPED)
1845 /* The process has sent us a signal, and stopped itself in a sane
1846 state pending our actions. */
1848 inf_debug (inf, "process has stopped itself");
1853 inf->wait.suppress = 1; /* Something odd happened. Ignore. */
1858 ILL_RPC (S_proc_setmsgport_reply,
1859 mach_port_t reply_port, kern_return_t return_code,
1860 mach_port_t oldmsgport)
1861 ILL_RPC (S_proc_getmsgport_reply,
1862 mach_port_t reply_port, kern_return_t return_code,
1863 mach_port_t msgports)
1864 ILL_RPC (S_proc_pid2task_reply,
1865 mach_port_t reply_port, kern_return_t return_code, mach_port_t task)
1866 ILL_RPC (S_proc_task2pid_reply,
1867 mach_port_t reply_port, kern_return_t return_code, pid_t pid)
1868 ILL_RPC (S_proc_task2proc_reply,
1869 mach_port_t reply_port, kern_return_t return_code, mach_port_t proc)
1870 ILL_RPC (S_proc_proc2task_reply,
1871 mach_port_t reply_port, kern_return_t return_code, mach_port_t task)
1872 ILL_RPC (S_proc_pid2proc_reply,
1873 mach_port_t reply_port, kern_return_t return_code, mach_port_t proc)
1874 ILL_RPC (S_proc_getprocinfo_reply,
1875 mach_port_t reply_port, kern_return_t return_code,
1876 int flags, procinfo_t procinfo, mach_msg_type_number_t procinfoCnt,
1877 data_t threadwaits, mach_msg_type_number_t threadwaitsCnt)
1878 ILL_RPC (S_proc_getprocargs_reply,
1879 mach_port_t reply_port, kern_return_t return_code,
1880 data_t procargs, mach_msg_type_number_t procargsCnt)
1881 ILL_RPC (S_proc_getprocenv_reply,
1882 mach_port_t reply_port, kern_return_t return_code,
1883 data_t procenv, mach_msg_type_number_t procenvCnt)
1884 ILL_RPC (S_proc_getloginid_reply,
1885 mach_port_t reply_port, kern_return_t return_code, pid_t login_id)
1886 ILL_RPC (S_proc_getloginpids_reply,
1887 mach_port_t reply_port, kern_return_t return_code,
1888 pidarray_t pids, mach_msg_type_number_t pidsCnt)
1889 ILL_RPC (S_proc_getlogin_reply,
1890 mach_port_t reply_port, kern_return_t return_code, string_t logname)
1891 ILL_RPC (S_proc_getsid_reply,
1892 mach_port_t reply_port, kern_return_t return_code, pid_t sid)
1893 ILL_RPC (S_proc_getsessionpgids_reply,
1894 mach_port_t reply_port, kern_return_t return_code,
1895 pidarray_t pgidset, mach_msg_type_number_t pgidsetCnt)
1896 ILL_RPC (S_proc_getsessionpids_reply,
1897 mach_port_t reply_port, kern_return_t return_code,
1898 pidarray_t pidset, mach_msg_type_number_t pidsetCnt)
1899 ILL_RPC (S_proc_getsidport_reply,
1900 mach_port_t reply_port, kern_return_t return_code,
1901 mach_port_t sessport)
1902 ILL_RPC (S_proc_getpgrp_reply,
1903 mach_port_t reply_port, kern_return_t return_code, pid_t pgrp)
1904 ILL_RPC (S_proc_getpgrppids_reply,
1905 mach_port_t reply_port, kern_return_t return_code,
1906 pidarray_t pidset, mach_msg_type_number_t pidsetCnt)
1907 ILL_RPC (S_proc_get_tty_reply,
1908 mach_port_t reply_port, kern_return_t return_code, mach_port_t tty)
1909 ILL_RPC (S_proc_getnports_reply,
1910 mach_port_t reply_port, kern_return_t return_code,
1911 mach_msg_type_number_t nports)
1912 ILL_RPC (S_proc_is_important_reply,
1913 mach_port_t reply_port, kern_return_t return_code,
1914 boolean_t essential)
1915 ILL_RPC (S_proc_get_code_reply,
1916 mach_port_t reply_port, kern_return_t return_code,
1917 vm_address_t start_code, vm_address_t end_code)
1919 /* Msg_reply server routines. We only use msg_sig_post_untraced_reply. */
1922 S_msg_sig_post_untraced_reply (mach_port_t reply, error_t err)
1924 struct inf *inf = waiting_inf;
1927 /* EBUSY is what we get when the crash server has grabbed control of the
1928 process and doesn't like what signal we tried to send it. Just act
1929 like the process stopped (using a signal of 0 should mean that the
1930 *next* time the user continues, it will pass signal 0, which the crash
1931 server should like). */
1933 inf->wait.status.kind = TARGET_WAITKIND_STOPPED;
1934 inf->wait.status.value.sig = GDB_SIGNAL_0;
1937 warning (_("Signal delivery failed: %s"), safe_strerror (err));
1940 /* We only get this reply when we've posted a signal to a process which we
1941 thought was stopped, and which we expected to continue after the signal.
1942 Given that the signal has failed for some reason, it's reasonable to
1943 assume it's still stopped. */
1946 inf->wait.suppress = 1;
1951 ILL_RPC (S_msg_sig_post_reply,
1952 mach_port_t reply, error_t err)
1954 /* Returns the number of messages queued for the receive right PORT. */
1955 static mach_port_msgcount_t
1956 port_msgs_queued (mach_port_t port)
1958 struct mach_port_status status;
1960 mach_port_get_receive_status (mach_task_self (), port, &status);
1965 return status.mps_msgcount;
1969 /* Resume execution of the inferior process.
1971 If STEP is nonzero, single-step it.
1972 If SIGNAL is nonzero, give it that signal.
1975 -1 true Single step the current thread allowing other threads to run.
1976 -1 false Continue the current thread allowing other threads to run.
1977 X true Single step the given thread, don't allow any others to run.
1978 X false Continue the given thread, do not allow any others to run.
1979 (Where X, of course, is anything except -1)
1981 Note that a resume may not `take' if there are pending exceptions/&c
1982 still unprocessed from the last resume we did (any given resume may result
1983 in multiple events returned by wait). */
1986 gnu_resume (struct target_ops *ops,
1987 ptid_t ptid, int step, enum gdb_signal sig)
1989 struct proc *step_thread = 0;
1991 struct inf *inf = gnu_current_inf;
1993 inf_debug (inf, "ptid = %s, step = %d, sig = %d",
1994 target_pid_to_str (ptid), step, sig);
1996 inf_validate_procinfo (inf);
1998 if (sig != GDB_SIGNAL_0 || inf->stopped)
2000 if (sig == GDB_SIGNAL_0 && inf->nomsg)
2003 inf_signal (inf, sig);
2005 else if (inf->wait.exc.reply != MACH_PORT_NULL)
2006 /* We received an exception to which we have chosen not to forward, so
2007 abort the faulting thread, which will perhaps retake it. */
2009 proc_abort (inf->wait.thread, 1);
2010 warning (_("Aborting %s with unforwarded exception %s."),
2011 proc_string (inf->wait.thread),
2012 gdb_signal_to_name (inf->wait.status.value.sig));
2015 if (port_msgs_queued (inf->event_port))
2016 /* If there are still messages in our event queue, don't bother resuming
2017 the process, as we're just going to stop it right away anyway. */
2020 inf_update_procs (inf);
2022 /* A specific PTID means `step only this process id'. */
2023 resume_all = ptid_equal (ptid, minus_one_ptid);
2026 /* Allow all threads to run, except perhaps single-stepping one. */
2028 inf_debug (inf, "running all threads; tid = %d",
2029 ptid_get_pid (inferior_ptid));
2030 ptid = inferior_ptid; /* What to step. */
2031 inf_set_threads_resume_sc (inf, 0, 1);
2034 /* Just allow a single thread to run. */
2036 struct proc *thread = inf_tid_to_thread (inf, ptid_get_lwp (ptid));
2039 error (_("Can't run single thread id %s: no such thread!"),
2040 target_pid_to_str (ptid));
2041 inf_debug (inf, "running one thread: %s", target_pid_to_str (ptid));
2042 inf_set_threads_resume_sc (inf, thread, 0);
2047 step_thread = inf_tid_to_thread (inf, ptid_get_lwp (ptid));
2049 warning (_("Can't step thread id %s: no such thread."),
2050 target_pid_to_str (ptid));
2052 inf_debug (inf, "stepping thread: %s", target_pid_to_str (ptid));
2054 if (step_thread != inf->step_thread)
2055 inf_set_step_thread (inf, step_thread);
2057 inf_debug (inf, "here we go...");
2063 gnu_kill_inferior (struct target_ops *ops)
2065 struct proc *task = gnu_current_inf->task;
2069 proc_debug (task, "terminating...");
2070 task_terminate (task->port);
2071 inf_set_pid (gnu_current_inf, -1);
2073 target_mourn_inferior ();
2076 /* Clean up after the inferior dies. */
2078 gnu_mourn_inferior (struct target_ops *ops)
2080 inf_debug (gnu_current_inf, "rip");
2081 inf_detach (gnu_current_inf);
2082 inf_child_mourn_inferior (ops);
2086 /* Fork an inferior process, and start debugging it. */
2088 /* Set INFERIOR_PID to the first thread available in the child, if any. */
2090 inf_pick_first_thread (void)
2092 if (gnu_current_inf->task && gnu_current_inf->threads)
2093 /* The first thread. */
2094 return gnu_current_inf->threads->tid;
2096 /* What may be the next thread. */
2097 return next_thread_id;
2103 if (!gnu_current_inf)
2104 gnu_current_inf = make_inf ();
2105 return gnu_current_inf;
2109 gnu_create_inferior (struct target_ops *ops,
2110 char *exec_file, char *allargs, char **env,
2113 struct inf *inf = cur_inf ();
2116 void trace_me (void)
2118 /* We're in the child; make this process stop as soon as it execs. */
2119 inf_debug (inf, "tracing self");
2120 if (ptrace (PTRACE_TRACEME) != 0)
2121 error (_("ptrace (PTRACE_TRACEME) failed!"));
2124 inf_debug (inf, "creating inferior");
2126 pid = fork_inferior (exec_file, allargs, env, trace_me,
2127 NULL, NULL, NULL, NULL);
2129 /* Attach to the now stopped child, which is actually a shell... */
2130 inf_debug (inf, "attaching to child: %d", pid);
2132 inf_attach (inf, pid);
2136 inf->pending_execs = 1;
2140 /* Now let the child run again, knowing that it will stop
2141 immediately because of the ptrace. */
2144 /* We now have thread info. */
2145 thread_change_ptid (inferior_ptid,
2146 ptid_build (inf->pid, inf_pick_first_thread (), 0));
2148 startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
2149 inf->pending_execs = 0;
2151 inf_validate_procinfo (inf);
2152 inf_update_signal_thread (inf);
2153 inf_set_traced (inf, inf->want_signals);
2155 /* Execing the process will have trashed our exception ports; steal them
2156 back (or make sure they're restored if the user wants that). */
2157 if (inf->want_exceptions)
2158 inf_steal_exc_ports (inf);
2160 inf_restore_exc_ports (inf);
2164 /* Attach to process PID, then initialize for debugging it
2165 and wait for the trace-trap that results from attaching. */
2167 gnu_attach (struct target_ops *ops, const char *args, int from_tty)
2171 struct inf *inf = cur_inf ();
2172 struct inferior *inferior;
2174 pid = parse_pid_to_attach (args);
2176 if (pid == getpid ()) /* Trying to masturbate? */
2177 error (_("I refuse to debug myself!"));
2181 exec_file = (char *) get_exec_file (0);
2184 printf_unfiltered ("Attaching to program `%s', pid %d\n",
2187 printf_unfiltered ("Attaching to pid %d\n", pid);
2189 gdb_flush (gdb_stdout);
2192 inf_debug (inf, "attaching to pid: %d", pid);
2194 inf_attach (inf, pid);
2198 inferior = current_inferior ();
2199 inferior_appeared (inferior, pid);
2200 inferior->attach_flag = 1;
2202 inf_update_procs (inf);
2204 inferior_ptid = ptid_build (pid, inf_pick_first_thread (), 0);
2206 /* We have to initialize the terminal settings now, since the code
2207 below might try to restore them. */
2208 target_terminal_init ();
2210 /* If the process was stopped before we attached, make it continue the next
2211 time the user does a continue. */
2212 inf_validate_procinfo (inf);
2214 inf_update_signal_thread (inf);
2215 inf_set_traced (inf, inf->want_signals);
2217 #if 0 /* Do we need this? */
2218 renumber_threads (0); /* Give our threads reasonable names. */
2223 /* Take a program previously attached to and detaches it.
2224 The program resumes execution and will no longer stop
2225 on signals, etc. We'd better not have left any breakpoints
2226 in the program or it'll die when it hits one. For this
2227 to work, it may be necessary for the process to have been
2228 previously attached. It *might* work if the program was
2229 started via fork. */
2231 gnu_detach (struct target_ops *ops, const char *args, int from_tty)
2237 char *exec_file = get_exec_file (0);
2240 printf_unfiltered ("Detaching from program `%s' pid %d\n",
2241 exec_file, gnu_current_inf->pid);
2243 printf_unfiltered ("Detaching from pid %d\n", gnu_current_inf->pid);
2244 gdb_flush (gdb_stdout);
2247 pid = gnu_current_inf->pid;
2249 inf_detach (gnu_current_inf);
2251 inferior_ptid = null_ptid;
2252 detach_inferior (pid);
2254 inf_child_maybe_unpush_target (ops);
2258 gnu_terminal_init (struct target_ops *self)
2260 gdb_assert (gnu_current_inf);
2261 child_terminal_init_with_pgrp (gnu_current_inf->pid);
2265 gnu_stop (struct target_ops *self, ptid_t ptid)
2267 error (_("to_stop target function not implemented"));
2271 gnu_thread_alive (struct target_ops *ops, ptid_t ptid)
2273 inf_update_procs (gnu_current_inf);
2274 return !!inf_tid_to_thread (gnu_current_inf,
2275 ptid_get_lwp (ptid));
2279 /* Read inferior task's LEN bytes from ADDR and copy it to MYADDR in
2280 gdb's address space. Return 0 on failure; number of bytes read
2283 gnu_read_inferior (task_t task, CORE_ADDR addr, gdb_byte *myaddr, int length)
2286 vm_address_t low_address = (vm_address_t) trunc_page (addr);
2287 vm_size_t aligned_length =
2288 (vm_size_t) round_page (addr + length) - low_address;
2290 mach_msg_type_number_t copy_count;
2292 /* Get memory from inferior with page aligned addresses. */
2293 err = vm_read (task, low_address, aligned_length, &copied, ©_count);
2297 err = hurd_safe_copyin (myaddr, (void *) (addr - low_address + copied),
2301 warning (_("Read from inferior faulted: %s"), safe_strerror (err));
2305 err = vm_deallocate (mach_task_self (), copied, copy_count);
2307 warning (_("gnu_read_inferior vm_deallocate failed: %s"),
2308 safe_strerror (err));
2313 #define CHK_GOTO_OUT(str,ret) \
2314 do if (ret != KERN_SUCCESS) { errstr = #str; goto out; } while(0)
2316 struct vm_region_list
2318 struct vm_region_list *next;
2319 vm_prot_t protection;
2324 struct obstack region_obstack;
2326 /* Write gdb's LEN bytes from MYADDR and copy it to ADDR in inferior
2327 task's address space. */
2329 gnu_write_inferior (task_t task, CORE_ADDR addr,
2330 const gdb_byte *myaddr, int length)
2333 vm_address_t low_address = (vm_address_t) trunc_page (addr);
2334 vm_size_t aligned_length =
2335 (vm_size_t) round_page (addr + length) - low_address;
2337 mach_msg_type_number_t copy_count;
2340 char *errstr = "Bug in gnu_write_inferior";
2342 struct vm_region_list *region_element;
2343 struct vm_region_list *region_head = (struct vm_region_list *) NULL;
2345 /* Get memory from inferior with page aligned addresses. */
2346 err = vm_read (task,
2351 CHK_GOTO_OUT ("gnu_write_inferior vm_read failed", err);
2355 err = hurd_safe_copyout ((void *) (addr - low_address + copied),
2357 CHK_GOTO_OUT ("Write to inferior faulted", err);
2359 obstack_init (®ion_obstack);
2361 /* Do writes atomically.
2362 First check for holes and unwritable memory. */
2364 vm_size_t remaining_length = aligned_length;
2365 vm_address_t region_address = low_address;
2367 struct vm_region_list *scan;
2369 while (region_address < low_address + aligned_length)
2371 vm_prot_t protection;
2372 vm_prot_t max_protection;
2373 vm_inherit_t inheritance;
2375 mach_port_t object_name;
2377 vm_size_t region_length = remaining_length;
2378 vm_address_t old_address = region_address;
2380 err = vm_region (task,
2389 CHK_GOTO_OUT ("vm_region failed", err);
2391 /* Check for holes in memory. */
2392 if (old_address != region_address)
2394 warning (_("No memory at 0x%lx. Nothing written"),
2401 if (!(max_protection & VM_PROT_WRITE))
2403 warning (_("Memory at address 0x%lx is unwritable. "
2411 /* Chain the regions for later use. */
2413 (struct vm_region_list *)
2414 obstack_alloc (®ion_obstack, sizeof (struct vm_region_list));
2416 region_element->protection = protection;
2417 region_element->start = region_address;
2418 region_element->length = region_length;
2420 /* Chain the regions along with protections. */
2421 region_element->next = region_head;
2422 region_head = region_element;
2424 region_address += region_length;
2425 remaining_length = remaining_length - region_length;
2428 /* If things fail after this, we give up.
2429 Somebody is messing up inferior_task's mappings. */
2431 /* Enable writes to the chained vm regions. */
2432 for (scan = region_head; scan; scan = scan->next)
2434 if (!(scan->protection & VM_PROT_WRITE))
2436 err = vm_protect (task,
2440 scan->protection | VM_PROT_WRITE);
2441 CHK_GOTO_OUT ("vm_protect: enable write failed", err);
2445 err = vm_write (task,
2449 CHK_GOTO_OUT ("vm_write failed", err);
2451 /* Set up the original region protections, if they were changed. */
2452 for (scan = region_head; scan; scan = scan->next)
2454 if (!(scan->protection & VM_PROT_WRITE))
2456 err = vm_protect (task,
2461 CHK_GOTO_OUT ("vm_protect: enable write failed", err);
2469 obstack_free (®ion_obstack, 0);
2471 (void) vm_deallocate (mach_task_self (),
2476 if (err != KERN_SUCCESS)
2478 warning (_("%s: %s"), errstr, mach_error_string (err));
2487 /* Implement the to_xfer_partial target_ops method for
2488 TARGET_OBJECT_MEMORY. */
2490 static enum target_xfer_status
2491 gnu_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
2492 CORE_ADDR memaddr, ULONGEST len, ULONGEST *xfered_len)
2494 task_t task = (gnu_current_inf
2495 ? (gnu_current_inf->task
2496 ? gnu_current_inf->task->port : 0)
2500 if (task == MACH_PORT_NULL)
2501 return TARGET_XFER_E_IO;
2503 if (writebuf != NULL)
2505 inf_debug (gnu_current_inf, "writing %s[%s] <-- %s",
2506 paddress (target_gdbarch (), memaddr), pulongest (len),
2507 host_address_to_string (writebuf));
2508 res = gnu_write_inferior (task, memaddr, writebuf, len);
2512 inf_debug (gnu_current_inf, "reading %s[%s] --> %s",
2513 paddress (target_gdbarch (), memaddr), pulongest (len),
2514 host_address_to_string (readbuf));
2515 res = gnu_read_inferior (task, memaddr, readbuf, len);
2517 gdb_assert (res >= 0);
2519 return TARGET_XFER_E_IO;
2522 *xfered_len = (ULONGEST) res;
2523 return TARGET_XFER_OK;
2527 /* Target to_xfer_partial implementation. */
2529 static enum target_xfer_status
2530 gnu_xfer_partial (struct target_ops *ops, enum target_object object,
2531 const char *annex, gdb_byte *readbuf,
2532 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
2533 ULONGEST *xfered_len)
2537 case TARGET_OBJECT_MEMORY:
2538 return gnu_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
2540 return TARGET_XFER_E_IO;
2544 /* Call FUNC on each memory region in the task. */
2546 gnu_find_memory_regions (struct target_ops *self,
2547 find_memory_region_ftype func, void *data)
2551 vm_address_t region_address, last_region_address, last_region_end;
2552 vm_prot_t last_protection;
2554 if (gnu_current_inf == 0 || gnu_current_inf->task == 0)
2556 task = gnu_current_inf->task->port;
2557 if (task == MACH_PORT_NULL)
2560 region_address = last_region_address = last_region_end = VM_MIN_ADDRESS;
2561 last_protection = VM_PROT_NONE;
2562 while (region_address < VM_MAX_ADDRESS)
2564 vm_prot_t protection;
2565 vm_prot_t max_protection;
2566 vm_inherit_t inheritance;
2568 mach_port_t object_name;
2570 vm_size_t region_length = VM_MAX_ADDRESS - region_address;
2571 vm_address_t old_address = region_address;
2573 err = vm_region (task,
2582 if (err == KERN_NO_SPACE)
2584 if (err != KERN_SUCCESS)
2586 warning (_("vm_region failed: %s"), mach_error_string (err));
2590 if (protection == last_protection && region_address == last_region_end)
2591 /* This region is contiguous with and indistinguishable from
2592 the previous one, so we just extend that one. */
2593 last_region_end = region_address += region_length;
2596 /* This region is distinct from the last one we saw, so report
2597 that previous one. */
2598 if (last_protection != VM_PROT_NONE)
2599 (*func) (last_region_address,
2600 last_region_end - last_region_address,
2601 last_protection & VM_PROT_READ,
2602 last_protection & VM_PROT_WRITE,
2603 last_protection & VM_PROT_EXECUTE,
2604 1, /* MODIFIED is unknown, pass it as true. */
2606 last_region_address = region_address;
2607 last_region_end = region_address += region_length;
2608 last_protection = protection;
2612 /* Report the final region. */
2613 if (last_region_end > last_region_address && last_protection != VM_PROT_NONE)
2614 (*func) (last_region_address, last_region_end - last_region_address,
2615 last_protection & VM_PROT_READ,
2616 last_protection & VM_PROT_WRITE,
2617 last_protection & VM_PROT_EXECUTE,
2618 1, /* MODIFIED is unknown, pass it as true. */
2625 /* Return printable description of proc. */
2627 proc_string (struct proc *proc)
2629 static char tid_str[80];
2631 if (proc_is_task (proc))
2632 xsnprintf (tid_str, sizeof (tid_str), "process %d", proc->inf->pid);
2634 xsnprintf (tid_str, sizeof (tid_str), "Thread %d.%d",
2635 proc->inf->pid, proc->tid);
2640 gnu_pid_to_str (struct target_ops *ops, ptid_t ptid)
2642 struct inf *inf = gnu_current_inf;
2643 int tid = ptid_get_lwp (ptid);
2644 struct proc *thread = inf_tid_to_thread (inf, tid);
2647 return proc_string (thread);
2650 static char tid_str[80];
2652 xsnprintf (tid_str, sizeof (tid_str), "bogus thread id %d", tid);
2658 /* Create a prototype generic GNU/Hurd target. The client can
2659 override it with local methods. */
2664 struct target_ops *t = inf_child_target ();
2666 t->to_attach = gnu_attach;
2667 t->to_attach_no_wait = 1;
2668 t->to_detach = gnu_detach;
2669 t->to_resume = gnu_resume;
2670 t->to_wait = gnu_wait;
2671 t->to_xfer_partial = gnu_xfer_partial;
2672 t->to_find_memory_regions = gnu_find_memory_regions;
2673 t->to_terminal_init = gnu_terminal_init;
2674 t->to_kill = gnu_kill_inferior;
2675 t->to_create_inferior = gnu_create_inferior;
2676 t->to_mourn_inferior = gnu_mourn_inferior;
2677 t->to_thread_alive = gnu_thread_alive;
2678 t->to_pid_to_str = gnu_pid_to_str;
2679 t->to_stop = gnu_stop;
2685 /* User task commands. */
2687 static struct cmd_list_element *set_task_cmd_list = 0;
2688 static struct cmd_list_element *show_task_cmd_list = 0;
2689 /* User thread commands. */
2691 /* Commands with a prefix of `set/show thread'. */
2692 extern struct cmd_list_element *thread_cmd_list;
2693 struct cmd_list_element *set_thread_cmd_list = NULL;
2694 struct cmd_list_element *show_thread_cmd_list = NULL;
2696 /* Commands with a prefix of `set/show thread default'. */
2697 struct cmd_list_element *set_thread_default_cmd_list = NULL;
2698 struct cmd_list_element *show_thread_default_cmd_list = NULL;
2701 set_thread_cmd (char *args, int from_tty)
2703 printf_unfiltered ("\"set thread\" must be followed by the "
2704 "name of a thread property, or \"default\".\n");
2708 show_thread_cmd (char *args, int from_tty)
2710 printf_unfiltered ("\"show thread\" must be followed by the "
2711 "name of a thread property, or \"default\".\n");
2715 set_thread_default_cmd (char *args, int from_tty)
2717 printf_unfiltered ("\"set thread default\" must be followed "
2718 "by the name of a thread property.\n");
2722 show_thread_default_cmd (char *args, int from_tty)
2724 printf_unfiltered ("\"show thread default\" must be followed "
2725 "by the name of a thread property.\n");
2729 parse_int_arg (char *args, char *cmd_prefix)
2734 int val = strtoul (args, &arg_end, 10);
2736 if (*args && *arg_end == '\0')
2739 error (_("Illegal argument for \"%s\" command, should be an integer."),
2744 _parse_bool_arg (char *args, char *t_val, char *f_val, char *cmd_prefix)
2746 if (!args || strcmp (args, t_val) == 0)
2748 else if (strcmp (args, f_val) == 0)
2751 error (_("Illegal argument for \"%s\" command, "
2752 "should be \"%s\" or \"%s\"."),
2753 cmd_prefix, t_val, f_val);
2756 #define parse_bool_arg(args, cmd_prefix) \
2757 _parse_bool_arg (args, "on", "off", cmd_prefix)
2760 check_empty (char *args, char *cmd_prefix)
2763 error (_("Garbage after \"%s\" command: `%s'"), cmd_prefix, args);
2766 /* Returns the alive thread named by INFERIOR_PID, or signals an error. */
2767 static struct proc *
2770 struct inf *inf = cur_inf ();
2771 struct proc *thread = inf_tid_to_thread (inf,
2772 ptid_get_lwp (inferior_ptid));
2774 error (_("No current thread."));
2778 /* Returns the current inferior, but signals an error if it has no task. */
2782 struct inf *inf = cur_inf ();
2785 error (_("No current process."));
2791 set_task_pause_cmd (char *args, int from_tty)
2793 struct inf *inf = cur_inf ();
2794 int old_sc = inf->pause_sc;
2796 inf->pause_sc = parse_bool_arg (args, "set task pause");
2798 if (old_sc == 0 && inf->pause_sc != 0)
2799 /* If the task is currently unsuspended, immediately suspend it,
2800 otherwise wait until the next time it gets control. */
2805 show_task_pause_cmd (char *args, int from_tty)
2807 struct inf *inf = cur_inf ();
2809 check_empty (args, "show task pause");
2810 printf_unfiltered ("The inferior task %s suspended while gdb has control.\n",
2812 ? (inf->pause_sc == 0 ? "isn't" : "is")
2813 : (inf->pause_sc == 0 ? "won't be" : "will be"));
2817 set_task_detach_sc_cmd (char *args, int from_tty)
2819 cur_inf ()->detach_sc = parse_int_arg (args,
2820 "set task detach-suspend-count");
2824 show_task_detach_sc_cmd (char *args, int from_tty)
2826 check_empty (args, "show task detach-suspend-count");
2827 printf_unfiltered ("The inferior task will be left with a "
2828 "suspend count of %d when detaching.\n",
2829 cur_inf ()->detach_sc);
2834 set_thread_default_pause_cmd (char *args, int from_tty)
2836 struct inf *inf = cur_inf ();
2838 inf->default_thread_pause_sc =
2839 parse_bool_arg (args, "set thread default pause") ? 0 : 1;
2843 show_thread_default_pause_cmd (char *args, int from_tty)
2845 struct inf *inf = cur_inf ();
2846 int sc = inf->default_thread_pause_sc;
2848 check_empty (args, "show thread default pause");
2849 printf_unfiltered ("New threads %s suspended while gdb has control%s.\n",
2850 sc ? "are" : "aren't",
2851 !sc && inf->pause_sc ? " (but the task is)" : "");
2855 set_thread_default_run_cmd (char *args, int from_tty)
2857 struct inf *inf = cur_inf ();
2859 inf->default_thread_run_sc =
2860 parse_bool_arg (args, "set thread default run") ? 0 : 1;
2864 show_thread_default_run_cmd (char *args, int from_tty)
2866 struct inf *inf = cur_inf ();
2868 check_empty (args, "show thread default run");
2869 printf_unfiltered ("New threads %s allowed to run.\n",
2870 inf->default_thread_run_sc == 0 ? "are" : "aren't");
2874 set_thread_default_detach_sc_cmd (char *args, int from_tty)
2876 cur_inf ()->default_thread_detach_sc =
2877 parse_int_arg (args, "set thread default detach-suspend-count");
2881 show_thread_default_detach_sc_cmd (char *args, int from_tty)
2883 check_empty (args, "show thread default detach-suspend-count");
2884 printf_unfiltered ("New threads will get a detach-suspend-count of %d.\n",
2885 cur_inf ()->default_thread_detach_sc);
2889 /* Steal a send right called NAME in the inferior task, and make it PROC's
2890 saved exception port. */
2892 steal_exc_port (struct proc *proc, mach_port_t name)
2896 mach_msg_type_name_t port_type;
2898 if (!proc || !proc->inf->task)
2899 error (_("No inferior task."));
2901 err = mach_port_extract_right (proc->inf->task->port,
2902 name, MACH_MSG_TYPE_COPY_SEND,
2905 error (_("Couldn't extract send right %lu from inferior: %s"),
2906 name, safe_strerror (err));
2908 if (proc->saved_exc_port)
2909 /* Get rid of our reference to the old one. */
2910 mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
2912 proc->saved_exc_port = port;
2914 if (!proc->exc_port)
2915 /* If PROC is a thread, we may not have set its exception port
2916 before. We can't use proc_steal_exc_port because it also sets
2919 proc->exc_port = proc->inf->event_port;
2920 err = proc_set_exception_port (proc, proc->exc_port);
2921 error (_("Can't set exception port for %s: %s"),
2922 proc_string (proc), safe_strerror (err));
2927 set_task_exc_port_cmd (char *args, int from_tty)
2929 struct inf *inf = cur_inf ();
2932 error (_("No argument to \"set task exception-port\" command."));
2933 steal_exc_port (inf->task, parse_and_eval_address (args));
2937 set_stopped_cmd (char *args, int from_tty)
2939 cur_inf ()->stopped = _parse_bool_arg (args, "yes", "no", "set stopped");
2943 show_stopped_cmd (char *args, int from_tty)
2945 struct inf *inf = active_inf ();
2947 check_empty (args, "show stopped");
2948 printf_unfiltered ("The inferior process %s stopped.\n",
2949 inf->stopped ? "is" : "isn't");
2953 set_sig_thread_cmd (char *args, int from_tty)
2955 struct inf *inf = cur_inf ();
2957 if (!args || (!isdigit (*args) && strcmp (args, "none") != 0))
2958 error (_("Illegal argument to \"set signal-thread\" command.\n"
2959 "Should be an integer thread ID, or `none'."));
2961 if (strcmp (args, "none") == 0)
2962 inf->signal_thread = 0;
2965 ptid_t ptid = thread_id_to_pid (atoi (args));
2967 if (ptid_equal (ptid, minus_one_ptid))
2968 error (_("Thread ID %s not known. "
2969 "Use the \"info threads\" command to\n"
2970 "see the IDs of currently known threads."), args);
2971 inf->signal_thread = inf_tid_to_thread (inf, ptid_get_lwp (ptid));
2976 show_sig_thread_cmd (char *args, int from_tty)
2978 struct inf *inf = active_inf ();
2980 check_empty (args, "show signal-thread");
2981 if (inf->signal_thread)
2982 printf_unfiltered ("The signal thread is %s.\n",
2983 proc_string (inf->signal_thread));
2985 printf_unfiltered ("There is no signal thread.\n");
2990 set_signals_cmd (char *args, int from_tty)
2992 struct inf *inf = cur_inf ();
2994 inf->want_signals = parse_bool_arg (args, "set signals");
2996 if (inf->task && inf->want_signals != inf->traced)
2997 /* Make this take effect immediately in a running process. */
2998 inf_set_traced (inf, inf->want_signals);
3002 show_signals_cmd (char *args, int from_tty)
3004 struct inf *inf = cur_inf ();
3006 check_empty (args, "show signals");
3007 printf_unfiltered ("The inferior process's signals %s intercepted.\n",
3009 ? (inf->traced ? "are" : "aren't")
3010 : (inf->want_signals ? "will be" : "won't be"));
3014 set_exceptions_cmd (char *args, int from_tty)
3016 struct inf *inf = cur_inf ();
3017 int val = parse_bool_arg (args, "set exceptions");
3019 /* Make this take effect immediately in a running process. */
3022 inf->want_exceptions = val;
3026 show_exceptions_cmd (char *args, int from_tty)
3028 struct inf *inf = cur_inf ();
3030 check_empty (args, "show exceptions");
3031 printf_unfiltered ("Exceptions in the inferior %s trapped.\n",
3033 ? (inf->want_exceptions ? "are" : "aren't")
3034 : (inf->want_exceptions ? "will be" : "won't be"));
3039 set_task_cmd (char *args, int from_tty)
3041 printf_unfiltered ("\"set task\" must be followed by the name"
3042 " of a task property.\n");
3046 show_task_cmd (char *args, int from_tty)
3048 struct inf *inf = cur_inf ();
3050 check_empty (args, "show task");
3052 show_signals_cmd (0, from_tty);
3053 show_exceptions_cmd (0, from_tty);
3054 show_task_pause_cmd (0, from_tty);
3056 if (inf->pause_sc == 0)
3057 show_thread_default_pause_cmd (0, from_tty);
3058 show_thread_default_run_cmd (0, from_tty);
3062 show_stopped_cmd (0, from_tty);
3063 show_sig_thread_cmd (0, from_tty);
3066 if (inf->detach_sc != 0)
3067 show_task_detach_sc_cmd (0, from_tty);
3068 if (inf->default_thread_detach_sc != 0)
3069 show_thread_default_detach_sc_cmd (0, from_tty);
3074 set_noninvasive_cmd (char *args, int from_tty)
3076 /* Invert the sense of the arg for each component. */
3077 char *inv_args = parse_bool_arg (args, "set noninvasive") ? "off" : "on";
3079 set_task_pause_cmd (inv_args, from_tty);
3080 set_signals_cmd (inv_args, from_tty);
3081 set_exceptions_cmd (inv_args, from_tty);
3086 info_port_rights (const char *args, mach_port_type_t only)
3088 struct inf *inf = active_inf ();
3089 struct value *vmark = value_mark ();
3092 /* Explicit list of port rights. */
3096 struct value *val = parse_to_comma_and_eval (&args);
3097 long right = value_as_long (val);
3099 print_port_info (right, 0, inf->task->port, PORTINFO_DETAILS,
3103 error (_("%ld: %s."), right, safe_strerror (err));
3107 /* Print all of them. */
3110 print_task_ports_info (inf->task->port, only, PORTINFO_DETAILS,
3113 error (_("%s."), safe_strerror (err));
3116 value_free_to_mark (vmark);
3120 info_send_rights_cmd (char *args, int from_tty)
3122 info_port_rights (args, MACH_PORT_TYPE_SEND);
3126 info_recv_rights_cmd (char *args, int from_tty)
3128 info_port_rights (args, MACH_PORT_TYPE_RECEIVE);
3132 info_port_sets_cmd (char *args, int from_tty)
3134 info_port_rights (args, MACH_PORT_TYPE_PORT_SET);
3138 info_dead_names_cmd (char *args, int from_tty)
3140 info_port_rights (args, MACH_PORT_TYPE_DEAD_NAME);
3144 info_port_rights_cmd (char *args, int from_tty)
3146 info_port_rights (args, ~0);
3151 add_task_commands (void)
3153 add_cmd ("pause", class_run, set_thread_default_pause_cmd, _("\
3154 Set whether the new threads are suspended while gdb has control.\n\
3155 This property normally has no effect because the whole task is\n\
3156 suspended, however, that may be disabled with \"set task pause off\".\n\
3157 The default value is \"off\"."),
3158 &set_thread_default_cmd_list);
3159 add_cmd ("pause", no_class, show_thread_default_pause_cmd, _("\
3160 Show whether new threads are suspended while gdb has control."),
3161 &show_thread_default_cmd_list);
3163 add_cmd ("run", class_run, set_thread_default_run_cmd, _("\
3164 Set whether new threads are allowed to run (once gdb has noticed them)."),
3165 &set_thread_default_cmd_list);
3166 add_cmd ("run", no_class, show_thread_default_run_cmd, _("\
3167 Show whether new threads are allowed to run (once gdb has noticed them)."),
3168 &show_thread_default_cmd_list);
3170 add_cmd ("detach-suspend-count", class_run, set_thread_default_detach_sc_cmd,
3171 _("Set the default detach-suspend-count value for new threads."),
3172 &set_thread_default_cmd_list);
3173 add_cmd ("detach-suspend-count", no_class, show_thread_default_detach_sc_cmd,
3174 _("Show the default detach-suspend-count value for new threads."),
3175 &show_thread_default_cmd_list);
3177 add_cmd ("signals", class_run, set_signals_cmd, _("\
3178 Set whether the inferior process's signals will be intercepted.\n\
3179 Mach exceptions (such as breakpoint traps) are not affected."),
3181 add_alias_cmd ("sigs", "signals", class_run, 1, &setlist);
3182 add_cmd ("signals", no_class, show_signals_cmd, _("\
3183 Show whether the inferior process's signals will be intercepted."),
3185 add_alias_cmd ("sigs", "signals", no_class, 1, &showlist);
3187 add_cmd ("signal-thread", class_run, set_sig_thread_cmd, _("\
3188 Set the thread that gdb thinks is the libc signal thread.\n\
3189 This thread is run when delivering a signal to a non-stopped process."),
3191 add_alias_cmd ("sigthread", "signal-thread", class_run, 1, &setlist);
3192 add_cmd ("signal-thread", no_class, show_sig_thread_cmd, _("\
3193 Set the thread that gdb thinks is the libc signal thread."),
3195 add_alias_cmd ("sigthread", "signal-thread", no_class, 1, &showlist);
3197 add_cmd ("stopped", class_run, set_stopped_cmd, _("\
3198 Set whether gdb thinks the inferior process is stopped as with SIGSTOP.\n\
3199 Stopped process will be continued by sending them a signal."),
3201 add_cmd ("stopped", no_class, show_stopped_cmd, _("\
3202 Show whether gdb thinks the inferior process is stopped as with SIGSTOP."),
3205 add_cmd ("exceptions", class_run, set_exceptions_cmd, _("\
3206 Set whether exceptions in the inferior process will be trapped.\n\
3207 When exceptions are turned off, neither breakpoints nor single-stepping\n\
3210 /* Allow `set exc' despite conflict with `set exception-port'. */
3211 add_alias_cmd ("exc", "exceptions", class_run, 1, &setlist);
3212 add_cmd ("exceptions", no_class, show_exceptions_cmd, _("\
3213 Show whether exceptions in the inferior process will be trapped."),
3216 add_prefix_cmd ("task", no_class, set_task_cmd,
3217 _("Command prefix for setting task attributes."),
3218 &set_task_cmd_list, "set task ", 0, &setlist);
3219 add_prefix_cmd ("task", no_class, show_task_cmd,
3220 _("Command prefix for showing task attributes."),
3221 &show_task_cmd_list, "show task ", 0, &showlist);
3223 add_cmd ("pause", class_run, set_task_pause_cmd, _("\
3224 Set whether the task is suspended while gdb has control.\n\
3225 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3226 until the next time the program is continued.\n\
3227 When setting this to \"off\", \"set thread default pause on\" can be\n\
3228 used to pause individual threads by default instead."),
3229 &set_task_cmd_list);
3230 add_cmd ("pause", no_class, show_task_pause_cmd,
3231 _("Show whether the task is suspended while gdb has control."),
3232 &show_task_cmd_list);
3234 add_cmd ("detach-suspend-count", class_run, set_task_detach_sc_cmd,
3235 _("Set the suspend count will leave on the thread when detaching."),
3236 &set_task_cmd_list);
3237 add_cmd ("detach-suspend-count", no_class, show_task_detach_sc_cmd,
3238 _("Show the suspend count will leave "
3239 "on the thread when detaching."),
3240 &show_task_cmd_list);
3242 add_cmd ("exception-port", no_class, set_task_exc_port_cmd, _("\
3243 Set the task exception port to which we forward exceptions.\n\
3244 The argument should be the value of the send right in the task."),
3245 &set_task_cmd_list);
3246 add_alias_cmd ("excp", "exception-port", no_class, 1, &set_task_cmd_list);
3247 add_alias_cmd ("exc-port", "exception-port", no_class, 1,
3248 &set_task_cmd_list);
3250 /* A convenient way of turning on all options require to noninvasively
3251 debug running tasks. */
3252 add_cmd ("noninvasive", no_class, set_noninvasive_cmd, _("\
3253 Set task options so that we interfere as little as possible.\n\
3254 This is the same as setting `task pause', `exceptions', and\n\
3255 `signals' to the opposite value."),
3258 /* Commands to show information about the task's ports. */
3259 add_cmd ("send-rights", class_info, info_send_rights_cmd,
3260 _("Show information about the task's send rights"),
3262 add_cmd ("receive-rights", class_info, info_recv_rights_cmd,
3263 _("Show information about the task's receive rights"),
3265 add_cmd ("port-rights", class_info, info_port_rights_cmd,
3266 _("Show information about the task's port rights"),
3268 add_cmd ("port-sets", class_info, info_port_sets_cmd,
3269 _("Show information about the task's port sets"),
3271 add_cmd ("dead-names", class_info, info_dead_names_cmd,
3272 _("Show information about the task's dead names"),
3274 add_info_alias ("ports", "port-rights", 1);
3275 add_info_alias ("port", "port-rights", 1);
3276 add_info_alias ("psets", "port-sets", 1);
3281 set_thread_pause_cmd (char *args, int from_tty)
3283 struct proc *thread = cur_thread ();
3284 int old_sc = thread->pause_sc;
3286 thread->pause_sc = parse_bool_arg (args, "set thread pause");
3287 if (old_sc == 0 && thread->pause_sc != 0 && thread->inf->pause_sc == 0)
3288 /* If the task is currently unsuspended, immediately suspend it,
3289 otherwise wait until the next time it gets control. */
3290 inf_suspend (thread->inf);
3294 show_thread_pause_cmd (char *args, int from_tty)
3296 struct proc *thread = cur_thread ();
3297 int sc = thread->pause_sc;
3299 check_empty (args, "show task pause");
3300 printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n",
3301 proc_string (thread),
3302 sc ? "is" : "isn't",
3303 !sc && thread->inf->pause_sc ? " (but the task is)" : "");
3307 set_thread_run_cmd (char *args, int from_tty)
3309 struct proc *thread = cur_thread ();
3311 thread->run_sc = parse_bool_arg (args, "set thread run") ? 0 : 1;
3315 show_thread_run_cmd (char *args, int from_tty)
3317 struct proc *thread = cur_thread ();
3319 check_empty (args, "show thread run");
3320 printf_unfiltered ("Thread %s %s allowed to run.",
3321 proc_string (thread),
3322 thread->run_sc == 0 ? "is" : "isn't");
3326 set_thread_detach_sc_cmd (char *args, int from_tty)
3328 cur_thread ()->detach_sc = parse_int_arg (args,
3329 "set thread detach-suspend-count");
3333 show_thread_detach_sc_cmd (char *args, int from_tty)
3335 struct proc *thread = cur_thread ();
3337 check_empty (args, "show thread detach-suspend-count");
3338 printf_unfiltered ("Thread %s will be left with a suspend count"
3339 " of %d when detaching.\n",
3340 proc_string (thread),
3345 set_thread_exc_port_cmd (char *args, int from_tty)
3347 struct proc *thread = cur_thread ();
3350 error (_("No argument to \"set thread exception-port\" command."));
3351 steal_exc_port (thread, parse_and_eval_address (args));
3356 show_thread_cmd (char *args, int from_tty)
3358 struct proc *thread = cur_thread ();
3360 check_empty (args, "show thread");
3361 show_thread_run_cmd (0, from_tty);
3362 show_thread_pause_cmd (0, from_tty);
3363 if (thread->detach_sc != 0)
3364 show_thread_detach_sc_cmd (0, from_tty);
3369 thread_takeover_sc_cmd (char *args, int from_tty)
3371 struct proc *thread = cur_thread ();
3373 thread_basic_info_data_t _info;
3374 thread_basic_info_t info = &_info;
3375 mach_msg_type_number_t info_len = THREAD_BASIC_INFO_COUNT;
3377 thread_info (thread->port, THREAD_BASIC_INFO, (int *) &info, &info_len);
3379 error (("%s."), safe_strerror (err));
3380 thread->sc = info->suspend_count;
3382 printf_unfiltered ("Suspend count was %d.\n", thread->sc);
3384 vm_deallocate (mach_task_self (), (vm_address_t) info,
3385 info_len * sizeof (int));
3390 add_thread_commands (void)
3392 add_prefix_cmd ("thread", no_class, set_thread_cmd,
3393 _("Command prefix for setting thread properties."),
3394 &set_thread_cmd_list, "set thread ", 0, &setlist);
3395 add_prefix_cmd ("default", no_class, show_thread_cmd,
3396 _("Command prefix for setting default thread properties."),
3397 &set_thread_default_cmd_list, "set thread default ", 0,
3398 &set_thread_cmd_list);
3399 add_prefix_cmd ("thread", no_class, set_thread_default_cmd,
3400 _("Command prefix for showing thread properties."),
3401 &show_thread_cmd_list, "show thread ", 0, &showlist);
3402 add_prefix_cmd ("default", no_class, show_thread_default_cmd,
3403 _("Command prefix for showing default thread properties."),
3404 &show_thread_default_cmd_list, "show thread default ", 0,
3405 &show_thread_cmd_list);
3407 add_cmd ("pause", class_run, set_thread_pause_cmd, _("\
3408 Set whether the current thread is suspended while gdb has control.\n\
3409 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3410 until the next time the program is continued. This property normally\n\
3411 has no effect because the whole task is suspended, however, that may\n\
3412 be disabled with \"set task pause off\".\n\
3413 The default value is \"off\"."),
3414 &set_thread_cmd_list);
3415 add_cmd ("pause", no_class, show_thread_pause_cmd, _("\
3416 Show whether the current thread is suspended while gdb has control."),
3417 &show_thread_cmd_list);
3419 add_cmd ("run", class_run, set_thread_run_cmd,
3420 _("Set whether the current thread is allowed to run."),
3421 &set_thread_cmd_list);
3422 add_cmd ("run", no_class, show_thread_run_cmd,
3423 _("Show whether the current thread is allowed to run."),
3424 &show_thread_cmd_list);
3426 add_cmd ("detach-suspend-count", class_run, set_thread_detach_sc_cmd, _("\
3427 Set the suspend count will leave on the thread when detaching.\n\
3428 Note that this is relative to suspend count when gdb noticed the thread;\n\
3429 use the `thread takeover-suspend-count' to force it to an absolute value."),
3430 &set_thread_cmd_list);
3431 add_cmd ("detach-suspend-count", no_class, show_thread_detach_sc_cmd, _("\
3432 Show the suspend count will leave on the thread when detaching.\n\
3433 Note that this is relative to suspend count when gdb noticed the thread;\n\
3434 use the `thread takeover-suspend-count' to force it to an absolute value."),
3435 &show_thread_cmd_list);
3437 add_cmd ("exception-port", no_class, set_thread_exc_port_cmd, _("\
3438 Set the thread exception port to which we forward exceptions.\n\
3439 This overrides the task exception port.\n\
3440 The argument should be the value of the send right in the task."),
3441 &set_thread_cmd_list);
3442 add_alias_cmd ("excp", "exception-port", no_class, 1, &set_thread_cmd_list);
3443 add_alias_cmd ("exc-port", "exception-port", no_class, 1,
3444 &set_thread_cmd_list);
3446 add_cmd ("takeover-suspend-count", no_class, thread_takeover_sc_cmd, _("\
3447 Force the threads absolute suspend-count to be gdb's.\n\
3448 Prior to giving this command, gdb's thread suspend-counts are relative\n\
3449 to the thread's initial suspend-count when gdb notices the threads."),
3455 /* -Wmissing-prototypes */
3456 extern initialize_file_ftype _initialize_gnu_nat;
3459 _initialize_gnu_nat (void)
3461 proc_server = getproc ();
3463 add_task_commands ();
3464 add_thread_commands ();
3465 add_setshow_boolean_cmd ("gnu-nat", class_maintenance,
3467 _("Set debugging output for the gnu backend."),
3468 _("Show debugging output for the gnu backend."),
3476 #ifdef FLUSH_INFERIOR_CACHE
3478 /* When over-writing code on some machines the I-Cache must be flushed
3479 explicitly, because it is not kept coherent by the lazy hardware.
3480 This definitely includes breakpoints, for instance, or else we
3481 end up looping in mysterious Bpt traps. */
3484 flush_inferior_icache (CORE_ADDR pc, int amount)
3486 vm_machine_attribute_val_t flush = MATTR_VAL_ICACHE_FLUSH;
3489 ret = vm_machine_attribute (gnu_current_inf->task->port,
3494 if (ret != KERN_SUCCESS)
3495 warning (_("Error flushing inferior's cache : %s"), safe_strerror (ret));
3497 #endif /* FLUSH_INFERIOR_CACHE */