1 /* Interface GDB to the GNU Hurd.
2 Copyright (C) 1992-2017 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/>. */
23 /* Mach/Hurd headers are not yet ready for C++ compilation. */
27 #include <mach_error.h>
28 #include <mach/exception.h>
29 #include <mach/message.h>
30 #include <mach/notify.h>
31 #include <mach/vm_attributes.h>
34 #include <hurd/interrupt.h>
36 #include <hurd/msg_request.h>
37 #include <hurd/process.h>
38 /* Defined in <hurd/process.h>, but we need forward declarations from
39 <hurd/process_request.h> as well. */
41 #include <hurd/process_request.h>
42 #include <hurd/signal.h>
43 #include <hurd/sigpreempt.h>
54 #include <sys/ptrace.h>
64 #include "gdbthread.h"
65 #include "gdb_obstack.h"
66 #include "tid-parse.h"
69 #include "inf-child.h"
71 /* MIG stubs are not yet ready for C++ compilation. */
74 #include "exc_request_S.h"
76 #include "process_reply_S.h"
77 #include "msg_reply_S.h"
78 #include "exc_request_U.h"
82 static process_t proc_server = MACH_PORT_NULL;
84 /* If we've sent a proc_wait_request to the proc server, the pid of the
85 process we asked about. We can only ever have one outstanding. */
86 int proc_wait_pid = 0;
88 /* The number of wait requests we've sent, and expect replies from. */
89 int proc_waits_pending = 0;
91 int gnu_debug_flag = 0;
95 static struct inf *make_inf ();
96 void inf_clear_wait (struct inf *inf);
97 void inf_cleanup (struct inf *inf);
98 void inf_startup (struct inf *inf, int pid);
99 int inf_update_suspends (struct inf *inf);
100 void inf_set_pid (struct inf *inf, pid_t pid);
101 void inf_validate_procs (struct inf *inf);
102 void inf_steal_exc_ports (struct inf *inf);
103 void inf_restore_exc_ports (struct inf *inf);
104 void inf_set_threads_resume_sc (struct inf *inf,
105 struct proc *run_thread,
107 int inf_set_threads_resume_sc_for_signal_thread (struct inf *inf);
108 void inf_suspend (struct inf *inf);
109 void inf_resume (struct inf *inf);
110 void inf_set_step_thread (struct inf *inf, struct proc *proc);
111 void inf_detach (struct inf *inf);
112 void inf_attach (struct inf *inf, int pid);
113 void inf_signal (struct inf *inf, enum gdb_signal sig);
114 void inf_continue (struct inf *inf);
116 #define inf_debug(_inf, msg, args...) \
117 do { struct inf *__inf = (_inf); \
118 debug ("{inf %d %s}: " msg, __inf->pid, \
119 host_address_to_string (__inf) , ##args); } while (0)
121 void proc_abort (struct proc *proc, int force);
122 struct proc *make_proc (struct inf *inf, mach_port_t port, int tid);
123 struct proc *_proc_free (struct proc *proc);
124 int proc_update_sc (struct proc *proc);
125 kern_return_t proc_get_exception_port (struct proc *proc, mach_port_t * port);
126 kern_return_t proc_set_exception_port (struct proc *proc, mach_port_t port);
127 static mach_port_t _proc_get_exc_port (struct proc *proc);
128 void proc_steal_exc_port (struct proc *proc, mach_port_t exc_port);
129 void proc_restore_exc_port (struct proc *proc);
130 int proc_trace (struct proc *proc, int set);
132 /* Evaluate RPC_EXPR in a scope with the variables MSGPORT and REFPORT bound
133 to INF's msg port and task port respectively. If it has no msg port,
134 EIEIO is returned. INF must refer to a running process! */
135 #define INF_MSGPORT_RPC(inf, rpc_expr) \
136 HURD_MSGPORT_RPC (proc_getmsgport (proc_server, inf->pid, &msgport), \
137 (refport = inf->task->port, 0), 0, \
138 msgport ? (rpc_expr) : EIEIO)
140 /* Like INF_MSGPORT_RPC, but will also resume the signal thread to ensure
141 there's someone around to deal with the RPC (and resuspend things
142 afterwards). This effects INF's threads' resume_sc count. */
143 #define INF_RESUME_MSGPORT_RPC(inf, rpc_expr) \
144 (inf_set_threads_resume_sc_for_signal_thread (inf) \
145 ? ({ kern_return_t __e; \
147 __e = INF_MSGPORT_RPC (inf, rpc_expr); \
153 /* The state passed by an exception message. */
156 int exception; /* The exception code. */
158 mach_port_t handler; /* The real exception port to handle this. */
159 mach_port_t reply; /* The reply port from the exception call. */
162 /* The results of the last wait an inf did. */
165 struct target_waitstatus status; /* The status returned to gdb. */
166 struct exc_state exc; /* The exception that caused us to return. */
167 struct proc *thread; /* The thread in question. */
168 int suppress; /* Something trivial happened. */
171 /* The state of an inferior. */
174 /* Fields describing the current inferior. */
176 struct proc *task; /* The mach task. */
177 struct proc *threads; /* A linked list of all threads in TASK. */
179 /* True if THREADS needn't be validated by querying the task. We
180 assume that we and the task in question are the only ones
181 frobbing the thread list, so as long as we don't let any code
182 run, we don't have to worry about THREADS changing. */
183 int threads_up_to_date;
185 pid_t pid; /* The real system PID. */
187 struct inf_wait wait; /* What to return from target_wait. */
189 /* One thread proc in INF may be in `single-stepping mode'. This
191 struct proc *step_thread;
193 /* The thread we think is the signal thread. */
194 struct proc *signal_thread;
196 mach_port_t event_port; /* Where we receive various msgs. */
198 /* True if we think at least one thread in the inferior could currently be
200 unsigned int running:1;
202 /* True if the process has stopped (in the proc server sense). Note that
203 since a proc server `stop' leaves the signal thread running, the inf can
204 be RUNNING && STOPPED... */
205 unsigned int stopped:1;
207 /* True if the inferior has no message port. */
208 unsigned int nomsg:1;
210 /* True if the inferior is traced. */
211 unsigned int traced:1;
213 /* True if we shouldn't try waiting for the inferior, usually because we
214 can't for some reason. */
215 unsigned int no_wait:1;
217 /* When starting a new inferior, we don't try to validate threads until all
218 the proper execs have been done, which this flag states we still
220 unsigned int pending_execs:1;
222 /* Fields describing global state. */
224 /* The task suspend count used when gdb has control. This is normally 1 to
225 make things easier for us, but sometimes (like when attaching to vital
226 system servers) it may be desirable to let the task continue to run
227 (pausing individual threads as necessary). */
230 /* The task suspend count left when detaching from a task. */
233 /* The initial values used for the run_sc and pause_sc of newly discovered
234 threads -- see the definition of those fields in struct proc. */
235 int default_thread_run_sc;
236 int default_thread_pause_sc;
237 int default_thread_detach_sc;
239 /* True if the process should be traced when started/attached. Newly
240 started processes *must* be traced at first to exec them properly, but
241 if this is false, tracing is turned off as soon it has done so. */
244 /* True if exceptions from the inferior process should be trapped. This
245 must be on to use breakpoints. */
251 __proc_pid (struct proc *proc)
253 return proc->inf->pid;
257 /* Update PROC's real suspend count to match it's desired one. Returns true
258 if we think PROC is now in a runnable state. */
260 proc_update_sc (struct proc *proc)
264 int delta = proc->sc - proc->cur_sc;
267 proc_debug (proc, "sc: %d --> %d", proc->cur_sc, proc->sc);
269 if (proc->sc == 0 && proc->state_changed)
270 /* Since PROC may start running, we must write back any state changes. */
272 gdb_assert (proc_is_thread (proc));
273 proc_debug (proc, "storing back changed thread state");
274 err = thread_set_state (proc->port, THREAD_STATE_FLAVOR,
275 (thread_state_t) &proc->state, THREAD_STATE_SIZE);
277 proc->state_changed = 0;
282 while (delta-- > 0 && !err)
284 if (proc_is_task (proc))
285 err = task_suspend (proc->port);
287 err = thread_suspend (proc->port);
292 while (delta++ < 0 && !err)
294 if (proc_is_task (proc))
295 err = task_resume (proc->port);
297 err = thread_resume (proc->port);
301 proc->cur_sc = proc->sc;
303 /* If we got an error, then the task/thread has disappeared. */
304 running = !err && proc->sc == 0;
306 proc_debug (proc, "is %s", err ? "dead" : running ? "running" : "suspended");
308 proc_debug (proc, "err = %s", safe_strerror (err));
313 proc->state_valid = proc->state_changed = 0;
314 proc->fetched_regs = 0;
321 /* Thread_abort is called on PROC if needed. PROC must be a thread proc.
322 If PROC is deemed `precious', then nothing is done unless FORCE is true.
323 In particular, a thread is precious if it's running (in which case forcing
324 it includes suspending it first), or if it has an exception pending. */
326 proc_abort (struct proc *proc, int force)
328 gdb_assert (proc_is_thread (proc));
332 struct inf *inf = proc->inf;
333 int running = (proc->cur_sc == 0 && inf->task->cur_sc == 0);
335 if (running && force)
338 inf_update_suspends (proc->inf);
340 warning (_("Stopped %s."), proc_string (proc));
342 else if (proc == inf->wait.thread && inf->wait.exc.reply && !force)
343 /* An exception is pending on PROC, which don't mess with. */
347 /* We only abort the thread if it's not actually running. */
349 thread_abort (proc->port);
350 proc_debug (proc, "aborted");
354 proc_debug (proc, "not aborting");
358 /* Make sure that the state field in PROC is up to date, and return a pointer
359 to it, or 0 if something is wrong. If WILL_MODIFY is true, makes sure
360 that the thread is stopped and aborted first, and sets the state_changed
361 field in PROC to true. */
363 proc_get_state (struct proc *proc, int will_modify)
365 int was_aborted = proc->aborted;
367 proc_debug (proc, "updating state info%s",
368 will_modify ? " (with intention to modify)" : "");
370 proc_abort (proc, will_modify);
372 if (!was_aborted && proc->aborted)
373 /* PROC's state may have changed since we last fetched it. */
374 proc->state_valid = 0;
376 if (!proc->state_valid)
378 mach_msg_type_number_t state_size = THREAD_STATE_SIZE;
380 thread_get_state (proc->port, THREAD_STATE_FLAVOR,
381 (thread_state_t) &proc->state, &state_size);
383 proc_debug (proc, "getting thread state");
384 proc->state_valid = !err;
387 if (proc->state_valid)
390 proc->state_changed = 1;
391 return (thread_state_t) &proc->state;
398 /* Set PORT to PROC's exception port. */
400 proc_get_exception_port (struct proc * proc, mach_port_t * port)
402 if (proc_is_task (proc))
403 return task_get_exception_port (proc->port, port);
405 return thread_get_exception_port (proc->port, port);
408 /* Set PROC's exception port to PORT. */
410 proc_set_exception_port (struct proc * proc, mach_port_t port)
412 proc_debug (proc, "setting exception port: %lu", port);
413 if (proc_is_task (proc))
414 return task_set_exception_port (proc->port, port);
416 return thread_set_exception_port (proc->port, port);
419 /* Get PROC's exception port, cleaning up a bit if proc has died. */
421 _proc_get_exc_port (struct proc *proc)
423 mach_port_t exc_port;
424 kern_return_t err = proc_get_exception_port (proc, &exc_port);
427 /* PROC must be dead. */
430 mach_port_deallocate (mach_task_self (), proc->exc_port);
431 proc->exc_port = MACH_PORT_NULL;
432 if (proc->saved_exc_port)
433 mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
434 proc->saved_exc_port = MACH_PORT_NULL;
440 /* Replace PROC's exception port with EXC_PORT, unless it's already
441 been done. Stash away any existing exception port so we can
444 proc_steal_exc_port (struct proc *proc, mach_port_t exc_port)
446 mach_port_t cur_exc_port = _proc_get_exc_port (proc);
450 kern_return_t err = 0;
452 proc_debug (proc, "inserting exception port: %lu", exc_port);
454 if (cur_exc_port != exc_port)
455 /* Put in our exception port. */
456 err = proc_set_exception_port (proc, exc_port);
458 if (err || cur_exc_port == proc->exc_port)
459 /* We previously set the exception port, and it's still set. So we
460 just keep the old saved port which is what the proc set. */
463 mach_port_deallocate (mach_task_self (), cur_exc_port);
466 /* Keep a copy of PROC's old exception port so it can be restored. */
468 if (proc->saved_exc_port)
469 mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
470 proc->saved_exc_port = cur_exc_port;
473 proc_debug (proc, "saved exception port: %lu", proc->saved_exc_port);
476 proc->exc_port = exc_port;
478 warning (_("Error setting exception port for %s: %s"),
479 proc_string (proc), safe_strerror (err));
483 /* If we previously replaced PROC's exception port, put back what we
484 found there at the time, unless *our* exception port has since been
485 overwritten, in which case who knows what's going on. */
487 proc_restore_exc_port (struct proc *proc)
489 mach_port_t cur_exc_port = _proc_get_exc_port (proc);
493 kern_return_t err = 0;
495 proc_debug (proc, "restoring real exception port");
497 if (proc->exc_port == cur_exc_port)
498 /* Our's is still there. */
499 err = proc_set_exception_port (proc, proc->saved_exc_port);
501 if (proc->saved_exc_port)
502 mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
503 proc->saved_exc_port = MACH_PORT_NULL;
506 proc->exc_port = MACH_PORT_NULL;
508 warning (_("Error setting exception port for %s: %s"),
509 proc_string (proc), safe_strerror (err));
514 /* Turns hardware tracing in PROC on or off when SET is true or false,
515 respectively. Returns true on success. */
517 proc_trace (struct proc *proc, int set)
519 thread_state_t state = proc_get_state (proc, 1);
522 return 0; /* The thread must be dead. */
524 proc_debug (proc, "tracing %s", set ? "on" : "off");
528 /* XXX We don't get the exception unless the thread has its own
529 exception port???? */
530 if (proc->exc_port == MACH_PORT_NULL)
531 proc_steal_exc_port (proc, proc->inf->event_port);
532 THREAD_STATE_SET_TRACED (state);
535 THREAD_STATE_CLEAR_TRACED (state);
541 /* A variable from which to assign new TIDs. */
542 static int next_thread_id = 1;
544 /* Returns a new proc structure with the given fields. Also adds a
545 notification for PORT becoming dead to be sent to INF's notify port. */
547 make_proc (struct inf *inf, mach_port_t port, int tid)
550 mach_port_t prev_port = MACH_PORT_NULL;
551 struct proc *proc = XNEW (struct proc);
557 proc->saved_exc_port = MACH_PORT_NULL;
558 proc->exc_port = MACH_PORT_NULL;
563 /* Note that these are all the values for threads; the task simply uses the
564 corresponding field in INF directly. */
565 proc->run_sc = inf->default_thread_run_sc;
566 proc->pause_sc = inf->default_thread_pause_sc;
567 proc->detach_sc = inf->default_thread_detach_sc;
568 proc->resume_sc = proc->run_sc;
572 proc->state_valid = 0;
573 proc->state_changed = 0;
575 proc_debug (proc, "is new");
577 /* Get notified when things die. */
579 mach_port_request_notification (mach_task_self (), port,
580 MACH_NOTIFY_DEAD_NAME, 1,
582 MACH_MSG_TYPE_MAKE_SEND_ONCE,
585 warning (_("Couldn't request notification for port %lu: %s"),
586 port, safe_strerror (err));
589 proc_debug (proc, "notifications to: %lu", inf->event_port);
590 if (prev_port != MACH_PORT_NULL)
591 mach_port_deallocate (mach_task_self (), prev_port);
594 if (inf->want_exceptions)
596 if (proc_is_task (proc))
597 /* Make the task exception port point to us. */
598 proc_steal_exc_port (proc, inf->event_port);
600 /* Just clear thread exception ports -- they default to the
602 proc_steal_exc_port (proc, MACH_PORT_NULL);
608 /* Frees PROC and any resources it uses, and returns the value of PROC's
611 _proc_free (struct proc *proc)
613 struct inf *inf = proc->inf;
614 struct proc *next = proc->next;
616 proc_debug (proc, "freeing...");
618 if (proc == inf->step_thread)
619 /* Turn off single stepping. */
620 inf_set_step_thread (inf, 0);
621 if (proc == inf->wait.thread)
622 inf_clear_wait (inf);
623 if (proc == inf->signal_thread)
624 inf->signal_thread = 0;
626 if (proc->port != MACH_PORT_NULL)
628 if (proc->exc_port != MACH_PORT_NULL)
629 /* Restore the original exception port. */
630 proc_restore_exc_port (proc);
631 if (proc->cur_sc != 0)
632 /* Resume the thread/task. */
635 proc_update_sc (proc);
637 mach_port_deallocate (mach_task_self (), proc->port);
648 struct inf *inf = XNEW (struct inf);
652 inf->threads_up_to_date = 0;
654 inf->wait.status.kind = TARGET_WAITKIND_SPURIOUS;
655 inf->wait.thread = 0;
656 inf->wait.exc.handler = MACH_PORT_NULL;
657 inf->wait.exc.reply = MACH_PORT_NULL;
658 inf->step_thread = 0;
659 inf->signal_thread = 0;
660 inf->event_port = MACH_PORT_NULL;
666 inf->pending_execs = 0;
669 inf->default_thread_run_sc = 0;
670 inf->default_thread_pause_sc = 0;
671 inf->default_thread_detach_sc = 0;
672 inf->want_signals = 1; /* By default */
673 inf->want_exceptions = 1; /* By default */
678 /* Clear INF's target wait status. */
680 inf_clear_wait (struct inf *inf)
682 inf_debug (inf, "clearing wait");
683 inf->wait.status.kind = TARGET_WAITKIND_SPURIOUS;
684 inf->wait.thread = 0;
685 inf->wait.suppress = 0;
686 if (inf->wait.exc.handler != MACH_PORT_NULL)
688 mach_port_deallocate (mach_task_self (), inf->wait.exc.handler);
689 inf->wait.exc.handler = MACH_PORT_NULL;
691 if (inf->wait.exc.reply != MACH_PORT_NULL)
693 mach_port_deallocate (mach_task_self (), inf->wait.exc.reply);
694 inf->wait.exc.reply = MACH_PORT_NULL;
700 inf_cleanup (struct inf *inf)
702 inf_debug (inf, "cleanup");
704 inf_clear_wait (inf);
706 inf_set_pid (inf, -1);
713 inf->pending_execs = 0;
717 mach_port_destroy (mach_task_self (), inf->event_port);
718 inf->event_port = MACH_PORT_NULL;
723 inf_startup (struct inf *inf, int pid)
727 inf_debug (inf, "startup: pid = %d", pid);
731 /* Make the port on which we receive all events. */
732 err = mach_port_allocate (mach_task_self (),
733 MACH_PORT_RIGHT_RECEIVE, &inf->event_port);
735 error (_("Error allocating event port: %s"), safe_strerror (err));
737 /* Make a send right for it, so we can easily copy it for other people. */
738 mach_port_insert_right (mach_task_self (), inf->event_port,
739 inf->event_port, MACH_MSG_TYPE_MAKE_SEND);
740 inf_set_pid (inf, pid);
744 /* Close current process, if any, and attach INF to process PORT. */
746 inf_set_pid (struct inf *inf, pid_t pid)
749 struct proc *task = inf->task;
751 inf_debug (inf, "setting pid: %d", pid);
754 task_port = MACH_PORT_NULL;
757 kern_return_t err = proc_pid2task (proc_server, pid, &task_port);
760 error (_("Error getting task for pid %d: %s"),
761 pid, safe_strerror (err));
764 inf_debug (inf, "setting task: %lu", task_port);
767 task_suspend (task_port);
769 if (task && task->port != task_port)
772 inf_validate_procs (inf); /* Trash all the threads. */
773 _proc_free (task); /* And the task. */
776 if (task_port != MACH_PORT_NULL)
778 inf->task = make_proc (inf, task_port, PROC_TID_TASK);
779 inf->threads_up_to_date = 0;
786 /* Reflect task_suspend above. */
787 inf->task->sc = inf->task->cur_sc = 1;
794 /* Validates INF's stopped, nomsg and traced field from the actual
795 proc server state. Note that the traced field is only updated from
796 the proc server state if we do not have a message port. If we do
797 have a message port we'd better look at the tracemask itself. */
799 inf_validate_procinfo (struct inf *inf)
802 mach_msg_type_number_t noise_len = 0;
804 mach_msg_type_number_t pi_len = 0;
807 proc_getprocinfo (proc_server, inf->pid, &info_flags,
808 (procinfo_t *) &pi, &pi_len, &noise, &noise_len);
812 inf->stopped = !!(pi->state & PI_STOPPED);
813 inf->nomsg = !!(pi->state & PI_NOMSG);
815 inf->traced = !!(pi->state & PI_TRACED);
816 vm_deallocate (mach_task_self (), (vm_address_t) pi,
817 pi_len * sizeof (*(procinfo_t) 0));
819 vm_deallocate (mach_task_self (), (vm_address_t) noise, noise_len);
823 /* Validates INF's task suspend count. If it's higher than we expect,
824 verify with the user before `stealing' the extra count. */
826 inf_validate_task_sc (struct inf *inf)
829 mach_msg_type_number_t noise_len = 0;
831 mach_msg_type_number_t pi_len = 0;
832 int info_flags = PI_FETCH_TASKINFO;
833 int suspend_count = -1;
837 err = proc_getprocinfo (proc_server, inf->pid, &info_flags,
838 (procinfo_t *) &pi, &pi_len, &noise, &noise_len);
841 inf->task->dead = 1; /* oh well */
845 if (inf->task->cur_sc < pi->taskinfo.suspend_count && suspend_count == -1)
847 /* The proc server might have suspended the task while stopping
848 it. This happens when the task is handling a traced signal.
849 Refetch the suspend count. The proc server should be
850 finished stopping the task by now. */
851 suspend_count = pi->taskinfo.suspend_count;
855 suspend_count = pi->taskinfo.suspend_count;
857 vm_deallocate (mach_task_self (), (vm_address_t) pi,
858 pi_len * sizeof (*(procinfo_t) 0));
860 vm_deallocate (mach_task_self (), (vm_address_t) noise, noise_len);
862 if (inf->task->cur_sc < suspend_count)
864 if (!query (_("Pid %d has an additional task suspend count of %d;"
865 " clear it? "), inf->pid,
866 suspend_count - inf->task->cur_sc))
867 error (_("Additional task suspend count left untouched."));
869 inf->task->cur_sc = suspend_count;
873 /* Turns tracing for INF on or off, depending on ON, unless it already
874 is. If INF is running, the resume_sc count of INF's threads will
875 be modified, and the signal thread will briefly be run to change
878 inf_set_traced (struct inf *inf, int on)
880 if (on == inf->traced)
883 if (inf->task && !inf->task->dead)
884 /* Make it take effect immediately. */
886 sigset_t mask = on ? ~(sigset_t) 0 : 0;
888 INF_RESUME_MSGPORT_RPC (inf, msg_set_init_int (msgport, refport,
889 INIT_TRACEMASK, mask));
894 warning (_("Can't modify tracing state for pid %d: %s"),
895 inf->pid, "No signal thread");
899 warning (_("Can't modify tracing state for pid %d: %s"),
900 inf->pid, safe_strerror (err));
909 /* Makes all the real suspend count deltas of all the procs in INF
910 match the desired values. Careful to always do thread/task suspend
911 counts in the safe order. Returns true if at least one thread is
912 thought to be running. */
914 inf_update_suspends (struct inf *inf)
916 struct proc *task = inf->task;
918 /* We don't have to update INF->threads even though we're iterating over it
919 because we'll change a thread only if it already has an existing proc
921 inf_debug (inf, "updating suspend counts");
926 int task_running = (task->sc == 0), thread_running = 0;
928 if (task->sc > task->cur_sc)
929 /* The task is becoming _more_ suspended; do before any threads. */
930 task_running = proc_update_sc (task);
932 if (inf->pending_execs)
933 /* When we're waiting for an exec, things may be happening behind our
934 back, so be conservative. */
937 /* Do all the thread suspend counts. */
938 for (thread = inf->threads; thread; thread = thread->next)
939 thread_running |= proc_update_sc (thread);
941 if (task->sc != task->cur_sc)
942 /* We didn't do the task first, because we wanted to wait for the
943 threads; do it now. */
944 task_running = proc_update_sc (task);
946 inf_debug (inf, "%srunning...",
947 (thread_running && task_running) ? "" : "not ");
949 inf->running = thread_running && task_running;
951 /* Once any thread has executed some code, we can't depend on the
952 threads list any more. */
954 inf->threads_up_to_date = 0;
963 /* Converts a GDB pid to a struct proc. */
965 inf_tid_to_thread (struct inf *inf, int tid)
967 struct proc *thread = inf->threads;
970 if (thread->tid == tid)
973 thread = thread->next;
977 /* Converts a thread port to a struct proc. */
979 inf_port_to_thread (struct inf *inf, mach_port_t port)
981 struct proc *thread = inf->threads;
984 if (thread->port == port)
987 thread = thread->next;
994 inf_threads (struct inf *inf, inf_threads_ftype *f, void *arg)
998 for (thread = inf->threads; thread; thread = thread->next)
1003 /* Make INF's list of threads be consistent with reality of TASK. */
1005 inf_validate_procs (struct inf *inf)
1007 thread_array_t threads;
1008 mach_msg_type_number_t num_threads, i;
1009 struct proc *task = inf->task;
1011 /* If no threads are currently running, this function will guarantee that
1012 things are up to date. The exception is if there are zero threads --
1013 then it is almost certainly in an odd state, and probably some outside
1014 agent will create threads. */
1015 inf->threads_up_to_date = inf->threads ? !inf->running : 0;
1019 kern_return_t err = task_threads (task->port, &threads, &num_threads);
1021 inf_debug (inf, "fetching threads");
1023 /* TASK must be dead. */
1033 inf_debug (inf, "no task");
1037 /* Make things normally linear. */
1038 mach_msg_type_number_t search_start = 0;
1039 /* Which thread in PROCS corresponds to each task thread, & the task. */
1040 struct proc *matched[num_threads + 1];
1041 /* The last thread in INF->threads, so we can add to the end. */
1042 struct proc *last = 0;
1043 /* The current thread we're considering. */
1044 struct proc *thread = inf->threads;
1046 memset (matched, 0, sizeof (matched));
1050 mach_msg_type_number_t left;
1052 for (i = search_start, left = num_threads; left; i++, left--)
1054 if (i >= num_threads)
1055 i -= num_threads; /* I wrapped around. */
1056 if (thread->port == threads[i])
1057 /* We already know about this thread. */
1059 matched[i] = thread;
1061 thread = thread->next;
1069 proc_debug (thread, "died!");
1070 thread->port = MACH_PORT_NULL;
1071 thread = _proc_free (thread); /* THREAD is dead. */
1073 last->next = thread;
1075 inf->threads = thread;
1079 for (i = 0; i < num_threads; i++)
1082 /* Throw away the duplicate send right. */
1083 mach_port_deallocate (mach_task_self (), threads[i]);
1085 /* THREADS[I] is a thread we don't know about yet! */
1089 thread = make_proc (inf, threads[i], next_thread_id++);
1091 last->next = thread;
1093 inf->threads = thread;
1095 proc_debug (thread, "new thread: %lu", threads[i]);
1097 ptid = ptid_build (inf->pid, thread->tid, 0);
1099 /* Tell GDB's generic thread code. */
1101 if (ptid_equal (inferior_ptid, pid_to_ptid (inf->pid)))
1102 /* This is the first time we're hearing about thread
1103 ids, after a fork-child. */
1104 thread_change_ptid (inferior_ptid, ptid);
1105 else if (inf->pending_execs != 0)
1106 /* This is a shell thread. */
1107 add_thread_silent (ptid);
1113 vm_deallocate (mach_task_self (),
1114 (vm_address_t) threads, (num_threads * sizeof (thread_t)));
1119 /* Makes sure that INF's thread list is synced with the actual process. */
1121 inf_update_procs (struct inf *inf)
1125 if (!inf->threads_up_to_date)
1126 inf_validate_procs (inf);
1130 /* Sets the resume_sc of each thread in inf. That of RUN_THREAD is set to 0,
1131 and others are set to their run_sc if RUN_OTHERS is true, and otherwise
1134 inf_set_threads_resume_sc (struct inf *inf,
1135 struct proc *run_thread, int run_others)
1137 struct proc *thread;
1139 inf_update_procs (inf);
1140 for (thread = inf->threads; thread; thread = thread->next)
1141 if (thread == run_thread)
1142 thread->resume_sc = 0;
1143 else if (run_others)
1144 thread->resume_sc = thread->run_sc;
1146 thread->resume_sc = thread->pause_sc;
1150 /* Cause INF to continue execution immediately; individual threads may still
1151 be suspended (but their suspend counts will be updated). */
1153 inf_resume (struct inf *inf)
1155 struct proc *thread;
1157 inf_update_procs (inf);
1159 for (thread = inf->threads; thread; thread = thread->next)
1160 thread->sc = thread->resume_sc;
1164 if (!inf->pending_execs)
1165 /* Try to make sure our task count is correct -- in the case where
1166 we're waiting for an exec though, things are too volatile, so just
1167 assume things will be reasonable (which they usually will be). */
1168 inf_validate_task_sc (inf);
1172 inf_update_suspends (inf);
1175 /* Cause INF to stop execution immediately; individual threads may still
1178 inf_suspend (struct inf *inf)
1180 struct proc *thread;
1182 inf_update_procs (inf);
1184 for (thread = inf->threads; thread; thread = thread->next)
1185 thread->sc = thread->pause_sc;
1188 inf->task->sc = inf->pause_sc;
1190 inf_update_suspends (inf);
1194 /* INF has one thread PROC that is in single-stepping mode. This
1195 function changes it to be PROC, changing any old step_thread to be
1196 a normal one. A PROC of 0 clears any existing value. */
1198 inf_set_step_thread (struct inf *inf, struct proc *thread)
1200 gdb_assert (!thread || proc_is_thread (thread));
1203 inf_debug (inf, "setting step thread: %d/%d", inf->pid, thread->tid);
1205 inf_debug (inf, "clearing step thread");
1207 if (inf->step_thread != thread)
1209 if (inf->step_thread && inf->step_thread->port != MACH_PORT_NULL)
1210 if (!proc_trace (inf->step_thread, 0))
1212 if (thread && proc_trace (thread, 1))
1213 inf->step_thread = thread;
1215 inf->step_thread = 0;
1220 /* Set up the thread resume_sc's so that only the signal thread is running
1221 (plus whatever other thread are set to always run). Returns true if we
1222 did so, or false if we can't find a signal thread. */
1224 inf_set_threads_resume_sc_for_signal_thread (struct inf *inf)
1226 if (inf->signal_thread)
1228 inf_set_threads_resume_sc (inf, inf->signal_thread, 0);
1236 inf_update_signal_thread (struct inf *inf)
1238 /* XXX for now we assume that if there's a msgport, the 2nd thread is
1239 the signal thread. */
1240 inf->signal_thread = inf->threads ? inf->threads->next : 0;
1244 /* Detachs from INF's inferior task, letting it run once again... */
1246 inf_detach (struct inf *inf)
1248 struct proc *task = inf->task;
1250 inf_debug (inf, "detaching...");
1252 inf_clear_wait (inf);
1253 inf_set_step_thread (inf, 0);
1257 struct proc *thread;
1259 inf_validate_procinfo (inf);
1261 inf_set_traced (inf, 0);
1267 inf_signal (inf, GDB_SIGNAL_0);
1270 proc_restore_exc_port (task);
1271 task->sc = inf->detach_sc;
1273 for (thread = inf->threads; thread; thread = thread->next)
1275 proc_restore_exc_port (thread);
1276 thread->sc = thread->detach_sc;
1279 inf_update_suspends (inf);
1285 /* Attaches INF to the process with process id PID, returning it in a
1286 suspended state suitable for debugging. */
1288 inf_attach (struct inf *inf, int pid)
1290 inf_debug (inf, "attaching: %d", pid);
1295 inf_startup (inf, pid);
1299 /* Makes sure that we've got our exception ports entrenched in the process. */
1301 inf_steal_exc_ports (struct inf *inf)
1303 struct proc *thread;
1305 inf_debug (inf, "stealing exception ports");
1307 inf_set_step_thread (inf, 0); /* The step thread is special. */
1309 proc_steal_exc_port (inf->task, inf->event_port);
1310 for (thread = inf->threads; thread; thread = thread->next)
1311 proc_steal_exc_port (thread, MACH_PORT_NULL);
1314 /* Makes sure the process has its own exception ports. */
1316 inf_restore_exc_ports (struct inf *inf)
1318 struct proc *thread;
1320 inf_debug (inf, "restoring exception ports");
1322 inf_set_step_thread (inf, 0); /* The step thread is special. */
1324 proc_restore_exc_port (inf->task);
1325 for (thread = inf->threads; thread; thread = thread->next)
1326 proc_restore_exc_port (thread);
1330 /* Deliver signal SIG to INF. If INF is stopped, delivering a signal, even
1331 signal 0, will continue it. INF is assumed to be in a paused state, and
1332 the resume_sc's of INF's threads may be affected. */
1334 inf_signal (struct inf *inf, enum gdb_signal sig)
1336 kern_return_t err = 0;
1337 int host_sig = gdb_signal_to_host (sig);
1339 #define NAME gdb_signal_to_name (sig)
1341 if (host_sig >= _NSIG)
1342 /* A mach exception. Exceptions are encoded in the signal space by
1343 putting them after _NSIG; this assumes they're positive (and not
1344 extremely large)! */
1346 struct inf_wait *w = &inf->wait;
1348 if (w->status.kind == TARGET_WAITKIND_STOPPED
1349 && w->status.value.sig == sig
1350 && w->thread && !w->thread->aborted)
1351 /* We're passing through the last exception we received. This is
1352 kind of bogus, because exceptions are per-thread whereas gdb
1353 treats signals as per-process. We just forward the exception to
1354 the correct handler, even it's not for the same thread as TID --
1355 i.e., we pretend it's global. */
1357 struct exc_state *e = &w->exc;
1359 inf_debug (inf, "passing through exception:"
1360 " task = %lu, thread = %lu, exc = %d"
1361 ", code = %d, subcode = %d",
1362 w->thread->port, inf->task->port,
1363 e->exception, e->code, e->subcode);
1365 exception_raise_request (e->handler,
1366 e->reply, MACH_MSG_TYPE_MOVE_SEND_ONCE,
1367 w->thread->port, inf->task->port,
1368 e->exception, e->code, e->subcode);
1371 error (_("Can't forward spontaneous exception (%s)."), NAME);
1374 /* A Unix signal. */
1376 /* The process is stopped and expecting a signal. Just send off a
1377 request and let it get handled when we resume everything. */
1379 inf_debug (inf, "sending %s to stopped process", NAME);
1381 INF_MSGPORT_RPC (inf,
1382 msg_sig_post_untraced_request (msgport,
1384 MACH_MSG_TYPE_MAKE_SEND_ONCE,
1388 /* Posting an untraced signal automatically continues it.
1389 We clear this here rather than when we get the reply
1390 because we'd rather assume it's not stopped when it
1391 actually is, than the reverse. */
1395 /* It's not expecting it. We have to let just the signal thread
1396 run, and wait for it to get into a reasonable state before we
1397 can continue the rest of the process. When we finally resume the
1398 process the signal we request will be the very first thing that
1401 inf_debug (inf, "sending %s to unstopped process"
1402 " (so resuming signal thread)", NAME);
1404 INF_RESUME_MSGPORT_RPC (inf,
1405 msg_sig_post_untraced (msgport, host_sig,
1410 /* Can't do too much... */
1411 warning (_("Can't deliver signal %s: No signal thread."), NAME);
1413 warning (_("Delivering signal %s: %s"), NAME, safe_strerror (err));
1419 /* Continue INF without delivering a signal. This is meant to be used
1420 when INF does not have a message port. */
1422 inf_continue (struct inf *inf)
1425 kern_return_t err = proc_pid2proc (proc_server, inf->pid, &proc);
1429 inf_debug (inf, "continuing process");
1431 err = proc_mark_cont (proc);
1434 struct proc *thread;
1436 for (thread = inf->threads; thread; thread = thread->next)
1437 thread_resume (thread->port);
1444 warning (_("Can't continue process: %s"), safe_strerror (err));
1448 /* The inferior used for all gdb target ops. */
1449 struct inf *gnu_current_inf = 0;
1451 /* The inferior being waited for by gnu_wait. Since GDB is decidely not
1452 multi-threaded, we don't bother to lock this. */
1453 struct inf *waiting_inf;
1455 /* MIG stubs are not yet ready for C++ compilation. */
1456 extern "C" int exc_server (mach_msg_header_t *, mach_msg_header_t *);
1457 extern "C" int msg_reply_server (mach_msg_header_t *, mach_msg_header_t *);
1458 extern "C" int notify_server (mach_msg_header_t *, mach_msg_header_t *);
1459 extern "C" int process_reply_server (mach_msg_header_t *, mach_msg_header_t *);
1461 /* Wait for something to happen in the inferior, returning what in STATUS. */
1463 gnu_wait (struct target_ops *ops,
1464 ptid_t ptid, struct target_waitstatus *status, int options)
1468 mach_msg_header_t hdr;
1469 mach_msg_type_t type;
1473 struct proc *thread;
1474 struct inf *inf = gnu_current_inf;
1476 gdb_assert (inf->task);
1478 if (!inf->threads && !inf->pending_execs)
1479 /* No threads! Assume that maybe some outside agency is frobbing our
1480 task, and really look for new threads. If we can't find any, just tell
1481 the user to try again later. */
1483 inf_validate_procs (inf);
1484 if (!inf->threads && !inf->task->dead)
1485 error (_("There are no threads; try again later."));
1490 inf_debug (inf, "waiting for: %s", target_pid_to_str (ptid));
1493 if (proc_wait_pid != inf->pid && !inf->no_wait)
1494 /* Always get information on events from the proc server. */
1496 inf_debug (inf, "requesting wait on pid %d", inf->pid);
1499 /* The proc server is single-threaded, and only allows a single
1500 outstanding wait request, so we have to cancel the previous one. */
1502 inf_debug (inf, "cancelling previous wait on pid %d", proc_wait_pid);
1503 interrupt_operation (proc_server, 0);
1507 proc_wait_request (proc_server, inf->event_port, inf->pid, WUNTRACED);
1509 warning (_("wait request failed: %s"), safe_strerror (err));
1512 inf_debug (inf, "waits pending: %d", proc_waits_pending);
1513 proc_wait_pid = inf->pid;
1514 /* Even if proc_waits_pending was > 0 before, we still won't
1515 get any other replies, because it was either from a
1516 different INF, or a different process attached to INF --
1517 and the event port, which is the wait reply port, changes
1518 when you switch processes. */
1519 proc_waits_pending = 1;
1523 inf_clear_wait (inf);
1525 /* What can happen? (1) Dead name notification; (2) Exceptions arrive;
1526 (3) wait reply from the proc server. */
1528 inf_debug (inf, "waiting for an event...");
1529 err = mach_msg (&msg.hdr, MACH_RCV_MSG | MACH_RCV_INTERRUPT,
1530 0, sizeof (struct msg), inf->event_port,
1531 MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
1533 /* Re-suspend the task. */
1536 if (!inf->task && inf->pending_execs)
1537 /* When doing an exec, it's possible that the old task wasn't reused
1538 (e.g., setuid execs). So if the task seems to have disappeared,
1539 attempt to refetch it, as the pid should still be the same. */
1540 inf_set_pid (inf, inf->pid);
1542 if (err == EMACH_RCV_INTERRUPTED)
1543 inf_debug (inf, "interrupted");
1545 error (_("Couldn't wait for an event: %s"), safe_strerror (err));
1550 mach_msg_header_t hdr;
1551 mach_msg_type_t err_type;
1557 inf_debug (inf, "event: msgid = %d", msg.hdr.msgh_id);
1559 /* Handle what we got. */
1560 if (!notify_server (&msg.hdr, &reply.hdr)
1561 && !exc_server (&msg.hdr, &reply.hdr)
1562 && !process_reply_server (&msg.hdr, &reply.hdr)
1563 && !msg_reply_server (&msg.hdr, &reply.hdr))
1564 /* Whatever it is, it's something strange. */
1565 error (_("Got a strange event, msg id = %d."), msg.hdr.msgh_id);
1568 error (_("Handling event, msgid = %d: %s"),
1569 msg.hdr.msgh_id, safe_strerror (reply.err));
1572 if (inf->pending_execs)
1573 /* We're waiting for the inferior to finish execing. */
1575 struct inf_wait *w = &inf->wait;
1576 enum target_waitkind kind = w->status.kind;
1578 if (kind == TARGET_WAITKIND_SPURIOUS)
1579 /* Since gdb is actually counting the number of times the inferior
1580 stops, expecting one stop per exec, we only return major events
1584 inf_debug (inf, "pending_execs, ignoring minor event");
1586 else if (kind == TARGET_WAITKIND_STOPPED
1587 && w->status.value.sig == GDB_SIGNAL_TRAP)
1588 /* Ah hah! A SIGTRAP from the inferior while starting up probably
1589 means we've succesfully completed an exec! */
1591 inf_debug (inf, "one pending exec completed");
1593 else if (kind == TARGET_WAITKIND_STOPPED)
1594 /* It's possible that this signal is because of a crashed process
1595 being handled by the hurd crash server; in this case, the process
1596 will have an extra task suspend, which we need to know about.
1597 Since the code in inf_resume that normally checks for this is
1598 disabled while INF->pending_execs, we do the check here instead. */
1599 inf_validate_task_sc (inf);
1602 if (inf->wait.suppress)
1603 /* Some totally spurious event happened that we don't consider
1604 worth returning to gdb. Just keep waiting. */
1606 inf_debug (inf, "suppressing return, rewaiting...");
1611 /* Pass back out our results. */
1612 memcpy (status, &inf->wait.status, sizeof (*status));
1614 thread = inf->wait.thread;
1616 ptid = ptid_build (inf->pid, thread->tid, 0);
1617 else if (ptid_equal (ptid, minus_one_ptid))
1618 thread = inf_tid_to_thread (inf, -1);
1620 thread = inf_tid_to_thread (inf, ptid_get_lwp (ptid));
1622 if (!thread || thread->port == MACH_PORT_NULL)
1624 /* TID is dead; try and find a new thread. */
1625 if (inf_update_procs (inf) && inf->threads)
1626 ptid = ptid_build (inf->pid, inf->threads->tid, 0); /* The first
1630 ptid = inferior_ptid; /* let wait_for_inferior handle exit case */
1634 && !ptid_equal (ptid, minus_one_ptid)
1635 && status->kind != TARGET_WAITKIND_SPURIOUS
1636 && inf->pause_sc == 0 && thread->pause_sc == 0)
1637 /* If something actually happened to THREAD, make sure we
1641 inf_update_suspends (inf);
1644 inf_debug (inf, "returning ptid = %s, status = %s (%d)",
1645 target_pid_to_str (ptid),
1646 status->kind == TARGET_WAITKIND_EXITED ? "EXITED"
1647 : status->kind == TARGET_WAITKIND_STOPPED ? "STOPPED"
1648 : status->kind == TARGET_WAITKIND_SIGNALLED ? "SIGNALLED"
1649 : status->kind == TARGET_WAITKIND_LOADED ? "LOADED"
1650 : status->kind == TARGET_WAITKIND_SPURIOUS ? "SPURIOUS"
1652 status->value.integer);
1658 /* The rpc handler called by exc_server. */
1660 S_exception_raise_request (mach_port_t port, mach_port_t reply_port,
1661 thread_t thread_port, task_t task_port,
1662 int exception, int code, int subcode)
1664 struct inf *inf = waiting_inf;
1665 struct proc *thread = inf_port_to_thread (inf, thread_port);
1667 inf_debug (waiting_inf,
1668 "thread = %lu, task = %lu, exc = %d, code = %d, subcode = %d",
1669 thread_port, task_port, exception, code, subcode);
1672 /* We don't know about thread? */
1674 inf_update_procs (inf);
1675 thread = inf_port_to_thread (inf, thread_port);
1677 /* Give up, the generating thread is gone. */
1681 mach_port_deallocate (mach_task_self (), thread_port);
1682 mach_port_deallocate (mach_task_self (), task_port);
1684 if (!thread->aborted)
1685 /* THREAD hasn't been aborted since this exception happened (abortion
1686 clears any exception state), so it must be real. */
1688 /* Store away the details; this will destroy any previous info. */
1689 inf->wait.thread = thread;
1691 inf->wait.status.kind = TARGET_WAITKIND_STOPPED;
1693 if (exception == EXC_BREAKPOINT)
1694 /* GDB likes to get SIGTRAP for breakpoints. */
1696 inf->wait.status.value.sig = GDB_SIGNAL_TRAP;
1697 mach_port_deallocate (mach_task_self (), reply_port);
1700 /* Record the exception so that we can forward it later. */
1702 if (thread->exc_port == port)
1704 inf_debug (waiting_inf, "Handler is thread exception port <%lu>",
1705 thread->saved_exc_port);
1706 inf->wait.exc.handler = thread->saved_exc_port;
1710 inf_debug (waiting_inf, "Handler is task exception port <%lu>",
1711 inf->task->saved_exc_port);
1712 inf->wait.exc.handler = inf->task->saved_exc_port;
1713 gdb_assert (inf->task->exc_port == port);
1715 if (inf->wait.exc.handler != MACH_PORT_NULL)
1716 /* Add a reference to the exception handler. */
1717 mach_port_mod_refs (mach_task_self (),
1718 inf->wait.exc.handler, MACH_PORT_RIGHT_SEND,
1721 inf->wait.exc.exception = exception;
1722 inf->wait.exc.code = code;
1723 inf->wait.exc.subcode = subcode;
1724 inf->wait.exc.reply = reply_port;
1726 /* Exceptions are encoded in the signal space by putting
1727 them after _NSIG; this assumes they're positive (and not
1728 extremely large)! */
1729 inf->wait.status.value.sig =
1730 gdb_signal_from_host (_NSIG + exception);
1734 /* A supppressed exception, which ignore. */
1736 inf->wait.suppress = 1;
1737 mach_port_deallocate (mach_task_self (), reply_port);
1744 /* Fill in INF's wait field after a task has died without giving us more
1745 detailed information. */
1747 inf_task_died_status (struct inf *inf)
1749 warning (_("Pid %d died with unknown exit status, using SIGKILL."),
1751 inf->wait.status.kind = TARGET_WAITKIND_SIGNALLED;
1752 inf->wait.status.value.sig = GDB_SIGNAL_KILL;
1755 /* Notify server routines. The only real one is dead name notification. */
1757 do_mach_notify_dead_name (mach_port_t notify, mach_port_t dead_port)
1759 struct inf *inf = waiting_inf;
1761 inf_debug (waiting_inf, "port = %lu", dead_port);
1763 if (inf->task && inf->task->port == dead_port)
1765 proc_debug (inf->task, "is dead");
1766 inf->task->port = MACH_PORT_NULL;
1767 if (proc_wait_pid == inf->pid)
1768 /* We have a wait outstanding on the process, which will return more
1769 detailed information, so delay until we get that. */
1770 inf->wait.suppress = 1;
1772 /* We never waited for the process (maybe it wasn't a child), so just
1773 pretend it got a SIGKILL. */
1774 inf_task_died_status (inf);
1778 struct proc *thread = inf_port_to_thread (inf, dead_port);
1782 proc_debug (thread, "is dead");
1783 thread->port = MACH_PORT_NULL;
1786 if (inf->task->dead)
1787 /* Since the task is dead, its threads are dying with it. */
1788 inf->wait.suppress = 1;
1791 mach_port_deallocate (mach_task_self (), dead_port);
1792 inf->threads_up_to_date = 0; /* Just in case. */
1798 #define ILL_RPC(fun, ...) \
1799 extern kern_return_t fun (__VA_ARGS__); \
1800 kern_return_t fun (__VA_ARGS__) \
1802 warning (_("illegal rpc: %s"), #fun); \
1806 ILL_RPC (do_mach_notify_no_senders,
1807 mach_port_t notify, mach_port_mscount_t count)
1808 ILL_RPC (do_mach_notify_port_deleted,
1809 mach_port_t notify, mach_port_t name)
1810 ILL_RPC (do_mach_notify_msg_accepted,
1811 mach_port_t notify, mach_port_t name)
1812 ILL_RPC (do_mach_notify_port_destroyed,
1813 mach_port_t notify, mach_port_t name)
1814 ILL_RPC (do_mach_notify_send_once,
1817 /* Process_reply server routines. We only use process_wait_reply. */
1820 S_proc_wait_reply (mach_port_t reply, kern_return_t err,
1821 int status, int sigcode, rusage_t rusage, pid_t pid)
1823 struct inf *inf = waiting_inf;
1825 inf_debug (inf, "err = %s, pid = %d, status = 0x%x, sigcode = %d",
1826 err ? safe_strerror (err) : "0", pid, status, sigcode);
1828 if (err && proc_wait_pid && (!inf->task || !inf->task->port))
1829 /* Ack. The task has died, but the task-died notification code didn't
1830 tell anyone because it thought a more detailed reply from the
1831 procserver was forthcoming. However, we now learn that won't
1832 happen... So we have to act like the task just died, and this time,
1834 inf_task_died_status (inf);
1836 if (--proc_waits_pending == 0)
1837 /* PROC_WAIT_PID represents the most recent wait. We will always get
1838 replies in order because the proc server is single threaded. */
1841 inf_debug (inf, "waits pending now: %d", proc_waits_pending);
1847 warning (_("Can't wait for pid %d: %s"),
1848 inf->pid, safe_strerror (err));
1851 /* Since we can't see the inferior's signals, don't trap them. */
1852 inf_set_traced (inf, 0);
1855 else if (pid == inf->pid)
1857 store_waitstatus (&inf->wait.status, status);
1858 if (inf->wait.status.kind == TARGET_WAITKIND_STOPPED)
1859 /* The process has sent us a signal, and stopped itself in a sane
1860 state pending our actions. */
1862 inf_debug (inf, "process has stopped itself");
1867 inf->wait.suppress = 1; /* Something odd happened. Ignore. */
1872 ILL_RPC (S_proc_setmsgport_reply,
1873 mach_port_t reply_port, kern_return_t return_code,
1874 mach_port_t oldmsgport)
1875 ILL_RPC (S_proc_getmsgport_reply,
1876 mach_port_t reply_port, kern_return_t return_code,
1877 mach_port_t msgports)
1878 ILL_RPC (S_proc_pid2task_reply,
1879 mach_port_t reply_port, kern_return_t return_code, mach_port_t task)
1880 ILL_RPC (S_proc_task2pid_reply,
1881 mach_port_t reply_port, kern_return_t return_code, pid_t pid)
1882 ILL_RPC (S_proc_task2proc_reply,
1883 mach_port_t reply_port, kern_return_t return_code, mach_port_t proc)
1884 ILL_RPC (S_proc_proc2task_reply,
1885 mach_port_t reply_port, kern_return_t return_code, mach_port_t task)
1886 ILL_RPC (S_proc_pid2proc_reply,
1887 mach_port_t reply_port, kern_return_t return_code, mach_port_t proc)
1888 ILL_RPC (S_proc_getprocinfo_reply,
1889 mach_port_t reply_port, kern_return_t return_code,
1890 int flags, procinfo_t procinfo, mach_msg_type_number_t procinfoCnt,
1891 data_t threadwaits, mach_msg_type_number_t threadwaitsCnt)
1892 ILL_RPC (S_proc_getprocargs_reply,
1893 mach_port_t reply_port, kern_return_t return_code,
1894 data_t procargs, mach_msg_type_number_t procargsCnt)
1895 ILL_RPC (S_proc_getprocenv_reply,
1896 mach_port_t reply_port, kern_return_t return_code,
1897 data_t procenv, mach_msg_type_number_t procenvCnt)
1898 ILL_RPC (S_proc_getloginid_reply,
1899 mach_port_t reply_port, kern_return_t return_code, pid_t login_id)
1900 ILL_RPC (S_proc_getloginpids_reply,
1901 mach_port_t reply_port, kern_return_t return_code,
1902 pidarray_t pids, mach_msg_type_number_t pidsCnt)
1903 ILL_RPC (S_proc_getlogin_reply,
1904 mach_port_t reply_port, kern_return_t return_code, string_t logname)
1905 ILL_RPC (S_proc_getsid_reply,
1906 mach_port_t reply_port, kern_return_t return_code, pid_t sid)
1907 ILL_RPC (S_proc_getsessionpgids_reply,
1908 mach_port_t reply_port, kern_return_t return_code,
1909 pidarray_t pgidset, mach_msg_type_number_t pgidsetCnt)
1910 ILL_RPC (S_proc_getsessionpids_reply,
1911 mach_port_t reply_port, kern_return_t return_code,
1912 pidarray_t pidset, mach_msg_type_number_t pidsetCnt)
1913 ILL_RPC (S_proc_getsidport_reply,
1914 mach_port_t reply_port, kern_return_t return_code,
1915 mach_port_t sessport)
1916 ILL_RPC (S_proc_getpgrp_reply,
1917 mach_port_t reply_port, kern_return_t return_code, pid_t pgrp)
1918 ILL_RPC (S_proc_getpgrppids_reply,
1919 mach_port_t reply_port, kern_return_t return_code,
1920 pidarray_t pidset, mach_msg_type_number_t pidsetCnt)
1921 ILL_RPC (S_proc_get_tty_reply,
1922 mach_port_t reply_port, kern_return_t return_code, mach_port_t tty)
1923 ILL_RPC (S_proc_getnports_reply,
1924 mach_port_t reply_port, kern_return_t return_code,
1925 mach_msg_type_number_t nports)
1926 ILL_RPC (S_proc_is_important_reply,
1927 mach_port_t reply_port, kern_return_t return_code,
1928 boolean_t essential)
1929 ILL_RPC (S_proc_get_code_reply,
1930 mach_port_t reply_port, kern_return_t return_code,
1931 vm_address_t start_code, vm_address_t end_code)
1933 /* Msg_reply server routines. We only use msg_sig_post_untraced_reply. */
1936 S_msg_sig_post_untraced_reply (mach_port_t reply, kern_return_t err)
1938 struct inf *inf = waiting_inf;
1941 /* EBUSY is what we get when the crash server has grabbed control of the
1942 process and doesn't like what signal we tried to send it. Just act
1943 like the process stopped (using a signal of 0 should mean that the
1944 *next* time the user continues, it will pass signal 0, which the crash
1945 server should like). */
1947 inf->wait.status.kind = TARGET_WAITKIND_STOPPED;
1948 inf->wait.status.value.sig = GDB_SIGNAL_0;
1951 warning (_("Signal delivery failed: %s"), safe_strerror (err));
1954 /* We only get this reply when we've posted a signal to a process which we
1955 thought was stopped, and which we expected to continue after the signal.
1956 Given that the signal has failed for some reason, it's reasonable to
1957 assume it's still stopped. */
1960 inf->wait.suppress = 1;
1965 ILL_RPC (S_msg_sig_post_reply,
1966 mach_port_t reply, kern_return_t err)
1968 /* Returns the number of messages queued for the receive right PORT. */
1969 static mach_port_msgcount_t
1970 port_msgs_queued (mach_port_t port)
1972 struct mach_port_status status;
1974 mach_port_get_receive_status (mach_task_self (), port, &status);
1979 return status.mps_msgcount;
1983 /* Resume execution of the inferior process.
1985 If STEP is nonzero, single-step it.
1986 If SIGNAL is nonzero, give it that signal.
1989 -1 true Single step the current thread allowing other threads to run.
1990 -1 false Continue the current thread allowing other threads to run.
1991 X true Single step the given thread, don't allow any others to run.
1992 X false Continue the given thread, do not allow any others to run.
1993 (Where X, of course, is anything except -1)
1995 Note that a resume may not `take' if there are pending exceptions/&c
1996 still unprocessed from the last resume we did (any given resume may result
1997 in multiple events returned by wait). */
2000 gnu_resume (struct target_ops *ops,
2001 ptid_t ptid, int step, enum gdb_signal sig)
2003 struct proc *step_thread = 0;
2005 struct inf *inf = gnu_current_inf;
2007 inf_debug (inf, "ptid = %s, step = %d, sig = %d",
2008 target_pid_to_str (ptid), step, sig);
2010 inf_validate_procinfo (inf);
2012 if (sig != GDB_SIGNAL_0 || inf->stopped)
2014 if (sig == GDB_SIGNAL_0 && inf->nomsg)
2017 inf_signal (inf, sig);
2019 else if (inf->wait.exc.reply != MACH_PORT_NULL)
2020 /* We received an exception to which we have chosen not to forward, so
2021 abort the faulting thread, which will perhaps retake it. */
2023 proc_abort (inf->wait.thread, 1);
2024 warning (_("Aborting %s with unforwarded exception %s."),
2025 proc_string (inf->wait.thread),
2026 gdb_signal_to_name (inf->wait.status.value.sig));
2029 if (port_msgs_queued (inf->event_port))
2030 /* If there are still messages in our event queue, don't bother resuming
2031 the process, as we're just going to stop it right away anyway. */
2034 inf_update_procs (inf);
2036 /* A specific PTID means `step only this process id'. */
2037 resume_all = ptid_equal (ptid, minus_one_ptid);
2040 /* Allow all threads to run, except perhaps single-stepping one. */
2042 inf_debug (inf, "running all threads; tid = %d",
2043 ptid_get_pid (inferior_ptid));
2044 ptid = inferior_ptid; /* What to step. */
2045 inf_set_threads_resume_sc (inf, 0, 1);
2048 /* Just allow a single thread to run. */
2050 struct proc *thread = inf_tid_to_thread (inf, ptid_get_lwp (ptid));
2053 error (_("Can't run single thread id %s: no such thread!"),
2054 target_pid_to_str (ptid));
2055 inf_debug (inf, "running one thread: %s", target_pid_to_str (ptid));
2056 inf_set_threads_resume_sc (inf, thread, 0);
2061 step_thread = inf_tid_to_thread (inf, ptid_get_lwp (ptid));
2063 warning (_("Can't step thread id %s: no such thread."),
2064 target_pid_to_str (ptid));
2066 inf_debug (inf, "stepping thread: %s", target_pid_to_str (ptid));
2068 if (step_thread != inf->step_thread)
2069 inf_set_step_thread (inf, step_thread);
2071 inf_debug (inf, "here we go...");
2077 gnu_kill_inferior (struct target_ops *ops)
2079 struct proc *task = gnu_current_inf->task;
2083 proc_debug (task, "terminating...");
2084 task_terminate (task->port);
2085 inf_set_pid (gnu_current_inf, -1);
2087 target_mourn_inferior (inferior_ptid);
2090 /* Clean up after the inferior dies. */
2092 gnu_mourn_inferior (struct target_ops *ops)
2094 inf_debug (gnu_current_inf, "rip");
2095 inf_detach (gnu_current_inf);
2096 inf_child_mourn_inferior (ops);
2100 /* Fork an inferior process, and start debugging it. */
2102 /* Set INFERIOR_PID to the first thread available in the child, if any. */
2104 inf_pick_first_thread (void)
2106 if (gnu_current_inf->task && gnu_current_inf->threads)
2107 /* The first thread. */
2108 return gnu_current_inf->threads->tid;
2110 /* What may be the next thread. */
2111 return next_thread_id;
2117 if (!gnu_current_inf)
2118 gnu_current_inf = make_inf ();
2119 return gnu_current_inf;
2123 gnu_ptrace_me (void)
2125 /* We're in the child; make this process stop as soon as it execs. */
2126 struct inf *inf = cur_inf ();
2127 inf_debug (inf, "tracing self");
2128 if (ptrace (PTRACE_TRACEME) != 0)
2129 trace_start_error_with_name ("ptrace");
2133 gnu_create_inferior (struct target_ops *ops,
2134 const char *exec_file, const std::string &allargs,
2138 struct inf *inf = cur_inf ();
2141 inf_debug (inf, "creating inferior");
2143 pid = fork_inferior (exec_file, allargs, env, gnu_ptrace_me,
2144 NULL, NULL, NULL, NULL);
2146 /* Attach to the now stopped child, which is actually a shell... */
2147 inf_debug (inf, "attaching to child: %d", pid);
2149 inf_attach (inf, pid);
2153 inf->pending_execs = 1;
2157 /* Now let the child run again, knowing that it will stop
2158 immediately because of the ptrace. */
2161 /* We now have thread info. */
2162 thread_change_ptid (inferior_ptid,
2163 ptid_build (inf->pid, inf_pick_first_thread (), 0));
2165 startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
2166 inf->pending_execs = 0;
2167 /* Get rid of the old shell threads. */
2170 inf_validate_procinfo (inf);
2171 inf_update_signal_thread (inf);
2172 inf_set_traced (inf, inf->want_signals);
2174 /* Execing the process will have trashed our exception ports; steal them
2175 back (or make sure they're restored if the user wants that). */
2176 if (inf->want_exceptions)
2177 inf_steal_exc_ports (inf);
2179 inf_restore_exc_ports (inf);
2183 /* Attach to process PID, then initialize for debugging it
2184 and wait for the trace-trap that results from attaching. */
2186 gnu_attach (struct target_ops *ops, const char *args, int from_tty)
2190 struct inf *inf = cur_inf ();
2191 struct inferior *inferior;
2193 pid = parse_pid_to_attach (args);
2195 if (pid == getpid ()) /* Trying to masturbate? */
2196 error (_("I refuse to debug myself!"));
2200 exec_file = (char *) get_exec_file (0);
2203 printf_unfiltered ("Attaching to program `%s', pid %d\n",
2206 printf_unfiltered ("Attaching to pid %d\n", pid);
2208 gdb_flush (gdb_stdout);
2211 inf_debug (inf, "attaching to pid: %d", pid);
2213 inf_attach (inf, pid);
2217 inferior = current_inferior ();
2218 inferior_appeared (inferior, pid);
2219 inferior->attach_flag = 1;
2221 inf_update_procs (inf);
2223 inferior_ptid = ptid_build (pid, inf_pick_first_thread (), 0);
2225 /* We have to initialize the terminal settings now, since the code
2226 below might try to restore them. */
2227 target_terminal_init ();
2229 /* If the process was stopped before we attached, make it continue the next
2230 time the user does a continue. */
2231 inf_validate_procinfo (inf);
2233 inf_update_signal_thread (inf);
2234 inf_set_traced (inf, inf->want_signals);
2236 #if 0 /* Do we need this? */
2237 renumber_threads (0); /* Give our threads reasonable names. */
2242 /* Take a program previously attached to and detaches it.
2243 The program resumes execution and will no longer stop
2244 on signals, etc. We'd better not have left any breakpoints
2245 in the program or it'll die when it hits one. For this
2246 to work, it may be necessary for the process to have been
2247 previously attached. It *might* work if the program was
2248 started via fork. */
2250 gnu_detach (struct target_ops *ops, const char *args, int from_tty)
2256 char *exec_file = get_exec_file (0);
2259 printf_unfiltered ("Detaching from program `%s' pid %d\n",
2260 exec_file, gnu_current_inf->pid);
2262 printf_unfiltered ("Detaching from pid %d\n", gnu_current_inf->pid);
2263 gdb_flush (gdb_stdout);
2266 pid = gnu_current_inf->pid;
2268 inf_detach (gnu_current_inf);
2270 inferior_ptid = null_ptid;
2271 detach_inferior (pid);
2273 inf_child_maybe_unpush_target (ops);
2277 gnu_terminal_init (struct target_ops *self)
2279 gdb_assert (gnu_current_inf);
2280 child_terminal_init_with_pgrp (gnu_current_inf->pid);
2284 gnu_stop (struct target_ops *self, ptid_t ptid)
2286 error (_("to_stop target function not implemented"));
2290 gnu_thread_alive (struct target_ops *ops, ptid_t ptid)
2292 inf_update_procs (gnu_current_inf);
2293 return !!inf_tid_to_thread (gnu_current_inf,
2294 ptid_get_lwp (ptid));
2298 /* Read inferior task's LEN bytes from ADDR and copy it to MYADDR in
2299 gdb's address space. Return 0 on failure; number of bytes read
2302 gnu_read_inferior (task_t task, CORE_ADDR addr, gdb_byte *myaddr, int length)
2305 vm_address_t low_address = (vm_address_t) trunc_page (addr);
2306 vm_size_t aligned_length =
2307 (vm_size_t) round_page (addr + length) - low_address;
2309 mach_msg_type_number_t copy_count;
2311 /* Get memory from inferior with page aligned addresses. */
2312 err = vm_read (task, low_address, aligned_length, &copied, ©_count);
2316 err = hurd_safe_copyin (myaddr, (void *) (addr - low_address + copied),
2320 warning (_("Read from inferior faulted: %s"), safe_strerror (err));
2324 err = vm_deallocate (mach_task_self (), copied, copy_count);
2326 warning (_("gnu_read_inferior vm_deallocate failed: %s"),
2327 safe_strerror (err));
2332 #define CHK_GOTO_OUT(str,ret) \
2333 do if (ret != KERN_SUCCESS) { errstr = #str; goto out; } while(0)
2335 struct vm_region_list
2337 struct vm_region_list *next;
2338 vm_prot_t protection;
2343 struct obstack region_obstack;
2345 /* Write gdb's LEN bytes from MYADDR and copy it to ADDR in inferior
2346 task's address space. */
2348 gnu_write_inferior (task_t task, CORE_ADDR addr,
2349 const gdb_byte *myaddr, int length)
2352 vm_address_t low_address = (vm_address_t) trunc_page (addr);
2353 vm_size_t aligned_length =
2354 (vm_size_t) round_page (addr + length) - low_address;
2356 mach_msg_type_number_t copy_count;
2359 char *errstr = "Bug in gnu_write_inferior";
2361 struct vm_region_list *region_element;
2362 struct vm_region_list *region_head = NULL;
2364 /* Get memory from inferior with page aligned addresses. */
2365 err = vm_read (task,
2370 CHK_GOTO_OUT ("gnu_write_inferior vm_read failed", err);
2374 err = hurd_safe_copyout ((void *) (addr - low_address + copied),
2376 CHK_GOTO_OUT ("Write to inferior faulted", err);
2378 obstack_init (®ion_obstack);
2380 /* Do writes atomically.
2381 First check for holes and unwritable memory. */
2383 vm_size_t remaining_length = aligned_length;
2384 vm_address_t region_address = low_address;
2386 struct vm_region_list *scan;
2388 while (region_address < low_address + aligned_length)
2390 vm_prot_t protection;
2391 vm_prot_t max_protection;
2392 vm_inherit_t inheritance;
2394 mach_port_t object_name;
2396 vm_size_t region_length = remaining_length;
2397 vm_address_t old_address = region_address;
2399 err = vm_region (task,
2408 CHK_GOTO_OUT ("vm_region failed", err);
2410 /* Check for holes in memory. */
2411 if (old_address != region_address)
2413 warning (_("No memory at 0x%lx. Nothing written"),
2420 if (!(max_protection & VM_PROT_WRITE))
2422 warning (_("Memory at address 0x%lx is unwritable. "
2430 /* Chain the regions for later use. */
2431 region_element = XOBNEW (®ion_obstack, struct vm_region_list);
2433 region_element->protection = protection;
2434 region_element->start = region_address;
2435 region_element->length = region_length;
2437 /* Chain the regions along with protections. */
2438 region_element->next = region_head;
2439 region_head = region_element;
2441 region_address += region_length;
2442 remaining_length = remaining_length - region_length;
2445 /* If things fail after this, we give up.
2446 Somebody is messing up inferior_task's mappings. */
2448 /* Enable writes to the chained vm regions. */
2449 for (scan = region_head; scan; scan = scan->next)
2451 if (!(scan->protection & VM_PROT_WRITE))
2453 err = vm_protect (task,
2457 scan->protection | VM_PROT_WRITE);
2458 CHK_GOTO_OUT ("vm_protect: enable write failed", err);
2462 err = vm_write (task,
2466 CHK_GOTO_OUT ("vm_write failed", err);
2468 /* Set up the original region protections, if they were changed. */
2469 for (scan = region_head; scan; scan = scan->next)
2471 if (!(scan->protection & VM_PROT_WRITE))
2473 err = vm_protect (task,
2478 CHK_GOTO_OUT ("vm_protect: enable write failed", err);
2486 obstack_free (®ion_obstack, 0);
2488 (void) vm_deallocate (mach_task_self (),
2493 if (err != KERN_SUCCESS)
2495 warning (_("%s: %s"), errstr, mach_error_string (err));
2504 /* Implement the to_xfer_partial target_ops method for
2505 TARGET_OBJECT_MEMORY. */
2507 static enum target_xfer_status
2508 gnu_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
2509 CORE_ADDR memaddr, ULONGEST len, ULONGEST *xfered_len)
2511 task_t task = (gnu_current_inf
2512 ? (gnu_current_inf->task
2513 ? gnu_current_inf->task->port : 0)
2517 if (task == MACH_PORT_NULL)
2518 return TARGET_XFER_E_IO;
2520 if (writebuf != NULL)
2522 inf_debug (gnu_current_inf, "writing %s[%s] <-- %s",
2523 paddress (target_gdbarch (), memaddr), pulongest (len),
2524 host_address_to_string (writebuf));
2525 res = gnu_write_inferior (task, memaddr, writebuf, len);
2529 inf_debug (gnu_current_inf, "reading %s[%s] --> %s",
2530 paddress (target_gdbarch (), memaddr), pulongest (len),
2531 host_address_to_string (readbuf));
2532 res = gnu_read_inferior (task, memaddr, readbuf, len);
2534 gdb_assert (res >= 0);
2536 return TARGET_XFER_E_IO;
2539 *xfered_len = (ULONGEST) res;
2540 return TARGET_XFER_OK;
2544 /* Target to_xfer_partial implementation. */
2546 static enum target_xfer_status
2547 gnu_xfer_partial (struct target_ops *ops, enum target_object object,
2548 const char *annex, gdb_byte *readbuf,
2549 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
2550 ULONGEST *xfered_len)
2554 case TARGET_OBJECT_MEMORY:
2555 return gnu_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
2557 return TARGET_XFER_E_IO;
2561 /* Call FUNC on each memory region in the task. */
2563 gnu_find_memory_regions (struct target_ops *self,
2564 find_memory_region_ftype func, void *data)
2568 vm_address_t region_address, last_region_address, last_region_end;
2569 vm_prot_t last_protection;
2571 if (gnu_current_inf == 0 || gnu_current_inf->task == 0)
2573 task = gnu_current_inf->task->port;
2574 if (task == MACH_PORT_NULL)
2577 region_address = last_region_address = last_region_end = VM_MIN_ADDRESS;
2578 last_protection = VM_PROT_NONE;
2579 while (region_address < VM_MAX_ADDRESS)
2581 vm_prot_t protection;
2582 vm_prot_t max_protection;
2583 vm_inherit_t inheritance;
2585 mach_port_t object_name;
2587 vm_size_t region_length = VM_MAX_ADDRESS - region_address;
2588 vm_address_t old_address = region_address;
2590 err = vm_region (task,
2599 if (err == KERN_NO_SPACE)
2601 if (err != KERN_SUCCESS)
2603 warning (_("vm_region failed: %s"), mach_error_string (err));
2607 if (protection == last_protection && region_address == last_region_end)
2608 /* This region is contiguous with and indistinguishable from
2609 the previous one, so we just extend that one. */
2610 last_region_end = region_address += region_length;
2613 /* This region is distinct from the last one we saw, so report
2614 that previous one. */
2615 if (last_protection != VM_PROT_NONE)
2616 (*func) (last_region_address,
2617 last_region_end - last_region_address,
2618 last_protection & VM_PROT_READ,
2619 last_protection & VM_PROT_WRITE,
2620 last_protection & VM_PROT_EXECUTE,
2621 1, /* MODIFIED is unknown, pass it as true. */
2623 last_region_address = region_address;
2624 last_region_end = region_address += region_length;
2625 last_protection = protection;
2629 /* Report the final region. */
2630 if (last_region_end > last_region_address && last_protection != VM_PROT_NONE)
2631 (*func) (last_region_address, last_region_end - last_region_address,
2632 last_protection & VM_PROT_READ,
2633 last_protection & VM_PROT_WRITE,
2634 last_protection & VM_PROT_EXECUTE,
2635 1, /* MODIFIED is unknown, pass it as true. */
2642 /* Return printable description of proc. */
2644 proc_string (struct proc *proc)
2646 static char tid_str[80];
2648 if (proc_is_task (proc))
2649 xsnprintf (tid_str, sizeof (tid_str), "process %d", proc->inf->pid);
2651 xsnprintf (tid_str, sizeof (tid_str), "Thread %d.%d",
2652 proc->inf->pid, proc->tid);
2657 gnu_pid_to_str (struct target_ops *ops, ptid_t ptid)
2659 struct inf *inf = gnu_current_inf;
2660 int tid = ptid_get_lwp (ptid);
2661 struct proc *thread = inf_tid_to_thread (inf, tid);
2664 return proc_string (thread);
2667 static char tid_str[80];
2669 xsnprintf (tid_str, sizeof (tid_str), "bogus thread id %d", tid);
2675 /* Create a prototype generic GNU/Hurd target. The client can
2676 override it with local methods. */
2681 struct target_ops *t = inf_child_target ();
2683 t->to_attach = gnu_attach;
2684 t->to_attach_no_wait = 1;
2685 t->to_detach = gnu_detach;
2686 t->to_resume = gnu_resume;
2687 t->to_wait = gnu_wait;
2688 t->to_xfer_partial = gnu_xfer_partial;
2689 t->to_find_memory_regions = gnu_find_memory_regions;
2690 t->to_terminal_init = gnu_terminal_init;
2691 t->to_kill = gnu_kill_inferior;
2692 t->to_create_inferior = gnu_create_inferior;
2693 t->to_mourn_inferior = gnu_mourn_inferior;
2694 t->to_thread_alive = gnu_thread_alive;
2695 t->to_pid_to_str = gnu_pid_to_str;
2696 t->to_stop = gnu_stop;
2702 /* User task commands. */
2704 static struct cmd_list_element *set_task_cmd_list = 0;
2705 static struct cmd_list_element *show_task_cmd_list = 0;
2706 /* User thread commands. */
2708 /* Commands with a prefix of `set/show thread'. */
2709 extern struct cmd_list_element *thread_cmd_list;
2710 struct cmd_list_element *set_thread_cmd_list = NULL;
2711 struct cmd_list_element *show_thread_cmd_list = NULL;
2713 /* Commands with a prefix of `set/show thread default'. */
2714 struct cmd_list_element *set_thread_default_cmd_list = NULL;
2715 struct cmd_list_element *show_thread_default_cmd_list = NULL;
2718 set_thread_cmd (char *args, int from_tty)
2720 printf_unfiltered ("\"set thread\" must be followed by the "
2721 "name of a thread property, or \"default\".\n");
2725 show_thread_cmd (char *args, int from_tty)
2727 printf_unfiltered ("\"show thread\" must be followed by the "
2728 "name of a thread property, or \"default\".\n");
2732 set_thread_default_cmd (char *args, int from_tty)
2734 printf_unfiltered ("\"set thread default\" must be followed "
2735 "by the name of a thread property.\n");
2739 show_thread_default_cmd (char *args, int from_tty)
2741 printf_unfiltered ("\"show thread default\" must be followed "
2742 "by the name of a thread property.\n");
2746 parse_int_arg (char *args, char *cmd_prefix)
2751 int val = strtoul (args, &arg_end, 10);
2753 if (*args && *arg_end == '\0')
2756 error (_("Illegal argument for \"%s\" command, should be an integer."),
2761 _parse_bool_arg (char *args, char *t_val, char *f_val, char *cmd_prefix)
2763 if (!args || strcmp (args, t_val) == 0)
2765 else if (strcmp (args, f_val) == 0)
2768 error (_("Illegal argument for \"%s\" command, "
2769 "should be \"%s\" or \"%s\"."),
2770 cmd_prefix, t_val, f_val);
2773 #define parse_bool_arg(args, cmd_prefix) \
2774 _parse_bool_arg (args, "on", "off", cmd_prefix)
2777 check_empty (char *args, char *cmd_prefix)
2780 error (_("Garbage after \"%s\" command: `%s'"), cmd_prefix, args);
2783 /* Returns the alive thread named by INFERIOR_PID, or signals an error. */
2784 static struct proc *
2787 struct inf *inf = cur_inf ();
2788 struct proc *thread = inf_tid_to_thread (inf,
2789 ptid_get_lwp (inferior_ptid));
2791 error (_("No current thread."));
2795 /* Returns the current inferior, but signals an error if it has no task. */
2799 struct inf *inf = cur_inf ();
2802 error (_("No current process."));
2808 set_task_pause_cmd (int arg, int from_tty)
2810 struct inf *inf = cur_inf ();
2811 int old_sc = inf->pause_sc;
2813 inf->pause_sc = arg;
2815 if (old_sc == 0 && inf->pause_sc != 0)
2816 /* If the task is currently unsuspended, immediately suspend it,
2817 otherwise wait until the next time it gets control. */
2822 set_task_pause_cmd (char *args, int from_tty)
2824 set_task_pause_cmd (parse_bool_arg (args, "set task pause"), from_tty);
2828 show_task_pause_cmd (char *args, int from_tty)
2830 struct inf *inf = cur_inf ();
2832 check_empty (args, "show task pause");
2833 printf_unfiltered ("The inferior task %s suspended while gdb has control.\n",
2835 ? (inf->pause_sc == 0 ? "isn't" : "is")
2836 : (inf->pause_sc == 0 ? "won't be" : "will be"));
2840 set_task_detach_sc_cmd (char *args, int from_tty)
2842 cur_inf ()->detach_sc = parse_int_arg (args,
2843 "set task detach-suspend-count");
2847 show_task_detach_sc_cmd (char *args, int from_tty)
2849 check_empty (args, "show task detach-suspend-count");
2850 printf_unfiltered ("The inferior task will be left with a "
2851 "suspend count of %d when detaching.\n",
2852 cur_inf ()->detach_sc);
2857 set_thread_default_pause_cmd (char *args, int from_tty)
2859 struct inf *inf = cur_inf ();
2861 inf->default_thread_pause_sc =
2862 parse_bool_arg (args, "set thread default pause") ? 0 : 1;
2866 show_thread_default_pause_cmd (char *args, int from_tty)
2868 struct inf *inf = cur_inf ();
2869 int sc = inf->default_thread_pause_sc;
2871 check_empty (args, "show thread default pause");
2872 printf_unfiltered ("New threads %s suspended while gdb has control%s.\n",
2873 sc ? "are" : "aren't",
2874 !sc && inf->pause_sc ? " (but the task is)" : "");
2878 set_thread_default_run_cmd (char *args, int from_tty)
2880 struct inf *inf = cur_inf ();
2882 inf->default_thread_run_sc =
2883 parse_bool_arg (args, "set thread default run") ? 0 : 1;
2887 show_thread_default_run_cmd (char *args, int from_tty)
2889 struct inf *inf = cur_inf ();
2891 check_empty (args, "show thread default run");
2892 printf_unfiltered ("New threads %s allowed to run.\n",
2893 inf->default_thread_run_sc == 0 ? "are" : "aren't");
2897 set_thread_default_detach_sc_cmd (char *args, int from_tty)
2899 cur_inf ()->default_thread_detach_sc =
2900 parse_int_arg (args, "set thread default detach-suspend-count");
2904 show_thread_default_detach_sc_cmd (char *args, int from_tty)
2906 check_empty (args, "show thread default detach-suspend-count");
2907 printf_unfiltered ("New threads will get a detach-suspend-count of %d.\n",
2908 cur_inf ()->default_thread_detach_sc);
2912 /* Steal a send right called NAME in the inferior task, and make it PROC's
2913 saved exception port. */
2915 steal_exc_port (struct proc *proc, mach_port_t name)
2919 mach_msg_type_name_t port_type;
2921 if (!proc || !proc->inf->task)
2922 error (_("No inferior task."));
2924 err = mach_port_extract_right (proc->inf->task->port,
2925 name, MACH_MSG_TYPE_COPY_SEND,
2928 error (_("Couldn't extract send right %lu from inferior: %s"),
2929 name, safe_strerror (err));
2931 if (proc->saved_exc_port)
2932 /* Get rid of our reference to the old one. */
2933 mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
2935 proc->saved_exc_port = port;
2937 if (!proc->exc_port)
2938 /* If PROC is a thread, we may not have set its exception port
2939 before. We can't use proc_steal_exc_port because it also sets
2942 proc->exc_port = proc->inf->event_port;
2943 err = proc_set_exception_port (proc, proc->exc_port);
2944 error (_("Can't set exception port for %s: %s"),
2945 proc_string (proc), safe_strerror (err));
2950 set_task_exc_port_cmd (char *args, int from_tty)
2952 struct inf *inf = cur_inf ();
2955 error (_("No argument to \"set task exception-port\" command."));
2956 steal_exc_port (inf->task, parse_and_eval_address (args));
2960 set_stopped_cmd (char *args, int from_tty)
2962 cur_inf ()->stopped = _parse_bool_arg (args, "yes", "no", "set stopped");
2966 show_stopped_cmd (char *args, int from_tty)
2968 struct inf *inf = active_inf ();
2970 check_empty (args, "show stopped");
2971 printf_unfiltered ("The inferior process %s stopped.\n",
2972 inf->stopped ? "is" : "isn't");
2976 set_sig_thread_cmd (char *args, int from_tty)
2978 struct inf *inf = cur_inf ();
2980 if (!args || (!isdigit (*args) && strcmp (args, "none") != 0))
2981 error (_("Illegal argument to \"set signal-thread\" command.\n"
2982 "Should be a thread ID, or \"none\"."));
2984 if (strcmp (args, "none") == 0)
2985 inf->signal_thread = 0;
2988 struct thread_info *tp = parse_thread_id (args, NULL);
2989 inf->signal_thread = inf_tid_to_thread (inf, ptid_get_lwp (tp->ptid));
2994 show_sig_thread_cmd (char *args, int from_tty)
2996 struct inf *inf = active_inf ();
2998 check_empty (args, "show signal-thread");
2999 if (inf->signal_thread)
3000 printf_unfiltered ("The signal thread is %s.\n",
3001 proc_string (inf->signal_thread));
3003 printf_unfiltered ("There is no signal thread.\n");
3008 set_signals_cmd (int arg, int from_tty)
3010 struct inf *inf = cur_inf ();
3012 inf->want_signals = arg;
3014 if (inf->task && inf->want_signals != inf->traced)
3015 /* Make this take effect immediately in a running process. */
3016 inf_set_traced (inf, inf->want_signals);
3020 set_signals_cmd (char *args, int from_tty)
3022 set_signals_cmd(parse_bool_arg (args, "set signals"), from_tty);
3026 show_signals_cmd (char *args, int from_tty)
3028 struct inf *inf = cur_inf ();
3030 check_empty (args, "show signals");
3031 printf_unfiltered ("The inferior process's signals %s intercepted.\n",
3033 ? (inf->traced ? "are" : "aren't")
3034 : (inf->want_signals ? "will be" : "won't be"));
3038 set_exceptions_cmd (int arg, int from_tty)
3040 struct inf *inf = cur_inf ();
3042 /* Make this take effect immediately in a running process. */
3045 inf->want_exceptions = arg;
3049 set_exceptions_cmd (char *args, int from_tty)
3051 set_exceptions_cmd (parse_bool_arg (args, "set exceptions"), from_tty);
3055 show_exceptions_cmd (char *args, int from_tty)
3057 struct inf *inf = cur_inf ();
3059 check_empty (args, "show exceptions");
3060 printf_unfiltered ("Exceptions in the inferior %s trapped.\n",
3062 ? (inf->want_exceptions ? "are" : "aren't")
3063 : (inf->want_exceptions ? "will be" : "won't be"));
3068 set_task_cmd (char *args, int from_tty)
3070 printf_unfiltered ("\"set task\" must be followed by the name"
3071 " of a task property.\n");
3075 show_task_cmd (char *args, int from_tty)
3077 struct inf *inf = cur_inf ();
3079 check_empty (args, "show task");
3081 show_signals_cmd (0, from_tty);
3082 show_exceptions_cmd (0, from_tty);
3083 show_task_pause_cmd (0, from_tty);
3085 if (inf->pause_sc == 0)
3086 show_thread_default_pause_cmd (0, from_tty);
3087 show_thread_default_run_cmd (0, from_tty);
3091 show_stopped_cmd (0, from_tty);
3092 show_sig_thread_cmd (0, from_tty);
3095 if (inf->detach_sc != 0)
3096 show_task_detach_sc_cmd (0, from_tty);
3097 if (inf->default_thread_detach_sc != 0)
3098 show_thread_default_detach_sc_cmd (0, from_tty);
3103 set_noninvasive_cmd (char *args, int from_tty)
3105 /* Invert the sense of the arg for each component. */
3106 int inv_arg = parse_bool_arg (args, "set noninvasive") ? 0 : 1;
3108 set_task_pause_cmd (inv_arg, from_tty);
3109 set_signals_cmd (inv_arg, from_tty);
3110 set_exceptions_cmd (inv_arg, from_tty);
3115 info_port_rights (const char *args, mach_port_type_t only)
3117 struct inf *inf = active_inf ();
3118 struct value *vmark = value_mark ();
3121 /* Explicit list of port rights. */
3125 struct value *val = parse_to_comma_and_eval (&args);
3126 long right = value_as_long (val);
3128 print_port_info (right, 0, inf->task->port, PORTINFO_DETAILS,
3132 error (_("%ld: %s."), right, safe_strerror (err));
3136 /* Print all of them. */
3139 print_task_ports_info (inf->task->port, only, PORTINFO_DETAILS,
3142 error (_("%s."), safe_strerror (err));
3145 value_free_to_mark (vmark);
3149 info_send_rights_cmd (char *args, int from_tty)
3151 info_port_rights (args, MACH_PORT_TYPE_SEND);
3155 info_recv_rights_cmd (char *args, int from_tty)
3157 info_port_rights (args, MACH_PORT_TYPE_RECEIVE);
3161 info_port_sets_cmd (char *args, int from_tty)
3163 info_port_rights (args, MACH_PORT_TYPE_PORT_SET);
3167 info_dead_names_cmd (char *args, int from_tty)
3169 info_port_rights (args, MACH_PORT_TYPE_DEAD_NAME);
3173 info_port_rights_cmd (char *args, int from_tty)
3175 info_port_rights (args, ~0);
3180 add_task_commands (void)
3182 add_cmd ("pause", class_run, set_thread_default_pause_cmd, _("\
3183 Set whether the new threads are suspended while gdb has control.\n\
3184 This property normally has no effect because the whole task is\n\
3185 suspended, however, that may be disabled with \"set task pause off\".\n\
3186 The default value is \"off\"."),
3187 &set_thread_default_cmd_list);
3188 add_cmd ("pause", no_class, show_thread_default_pause_cmd, _("\
3189 Show whether new threads are suspended while gdb has control."),
3190 &show_thread_default_cmd_list);
3192 add_cmd ("run", class_run, set_thread_default_run_cmd, _("\
3193 Set whether new threads are allowed to run (once gdb has noticed them)."),
3194 &set_thread_default_cmd_list);
3195 add_cmd ("run", no_class, show_thread_default_run_cmd, _("\
3196 Show whether new threads are allowed to run (once gdb has noticed them)."),
3197 &show_thread_default_cmd_list);
3199 add_cmd ("detach-suspend-count", class_run, set_thread_default_detach_sc_cmd,
3200 _("Set the default detach-suspend-count value for new threads."),
3201 &set_thread_default_cmd_list);
3202 add_cmd ("detach-suspend-count", no_class, show_thread_default_detach_sc_cmd,
3203 _("Show the default detach-suspend-count value for new threads."),
3204 &show_thread_default_cmd_list);
3206 add_cmd ("signals", class_run, set_signals_cmd, _("\
3207 Set whether the inferior process's signals will be intercepted.\n\
3208 Mach exceptions (such as breakpoint traps) are not affected."),
3210 add_alias_cmd ("sigs", "signals", class_run, 1, &setlist);
3211 add_cmd ("signals", no_class, show_signals_cmd, _("\
3212 Show whether the inferior process's signals will be intercepted."),
3214 add_alias_cmd ("sigs", "signals", no_class, 1, &showlist);
3216 add_cmd ("signal-thread", class_run, set_sig_thread_cmd, _("\
3217 Set the thread that gdb thinks is the libc signal thread.\n\
3218 This thread is run when delivering a signal to a non-stopped process."),
3220 add_alias_cmd ("sigthread", "signal-thread", class_run, 1, &setlist);
3221 add_cmd ("signal-thread", no_class, show_sig_thread_cmd, _("\
3222 Set the thread that gdb thinks is the libc signal thread."),
3224 add_alias_cmd ("sigthread", "signal-thread", no_class, 1, &showlist);
3226 add_cmd ("stopped", class_run, set_stopped_cmd, _("\
3227 Set whether gdb thinks the inferior process is stopped as with SIGSTOP.\n\
3228 Stopped process will be continued by sending them a signal."),
3230 add_cmd ("stopped", no_class, show_stopped_cmd, _("\
3231 Show whether gdb thinks the inferior process is stopped as with SIGSTOP."),
3234 add_cmd ("exceptions", class_run, set_exceptions_cmd, _("\
3235 Set whether exceptions in the inferior process will be trapped.\n\
3236 When exceptions are turned off, neither breakpoints nor single-stepping\n\
3239 /* Allow `set exc' despite conflict with `set exception-port'. */
3240 add_alias_cmd ("exc", "exceptions", class_run, 1, &setlist);
3241 add_cmd ("exceptions", no_class, show_exceptions_cmd, _("\
3242 Show whether exceptions in the inferior process will be trapped."),
3245 add_prefix_cmd ("task", no_class, set_task_cmd,
3246 _("Command prefix for setting task attributes."),
3247 &set_task_cmd_list, "set task ", 0, &setlist);
3248 add_prefix_cmd ("task", no_class, show_task_cmd,
3249 _("Command prefix for showing task attributes."),
3250 &show_task_cmd_list, "show task ", 0, &showlist);
3252 add_cmd ("pause", class_run, set_task_pause_cmd, _("\
3253 Set whether the task is suspended while gdb has control.\n\
3254 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3255 until the next time the program is continued.\n\
3256 When setting this to \"off\", \"set thread default pause on\" can be\n\
3257 used to pause individual threads by default instead."),
3258 &set_task_cmd_list);
3259 add_cmd ("pause", no_class, show_task_pause_cmd,
3260 _("Show whether the task is suspended while gdb has control."),
3261 &show_task_cmd_list);
3263 add_cmd ("detach-suspend-count", class_run, set_task_detach_sc_cmd,
3264 _("Set the suspend count will leave on the thread when detaching."),
3265 &set_task_cmd_list);
3266 add_cmd ("detach-suspend-count", no_class, show_task_detach_sc_cmd,
3267 _("Show the suspend count will leave "
3268 "on the thread when detaching."),
3269 &show_task_cmd_list);
3271 add_cmd ("exception-port", no_class, set_task_exc_port_cmd, _("\
3272 Set the task exception port to which we forward exceptions.\n\
3273 The argument should be the value of the send right in the task."),
3274 &set_task_cmd_list);
3275 add_alias_cmd ("excp", "exception-port", no_class, 1, &set_task_cmd_list);
3276 add_alias_cmd ("exc-port", "exception-port", no_class, 1,
3277 &set_task_cmd_list);
3279 /* A convenient way of turning on all options require to noninvasively
3280 debug running tasks. */
3281 add_cmd ("noninvasive", no_class, set_noninvasive_cmd, _("\
3282 Set task options so that we interfere as little as possible.\n\
3283 This is the same as setting `task pause', `exceptions', and\n\
3284 `signals' to the opposite value."),
3287 /* Commands to show information about the task's ports. */
3288 add_info ("send-rights", info_send_rights_cmd,
3289 _("Show information about the task's send rights"));
3290 add_info ("receive-rights", info_recv_rights_cmd,
3291 _("Show information about the task's receive rights"));
3292 add_info ("port-rights", info_port_rights_cmd,
3293 _("Show information about the task's port rights"));
3294 add_info ("port-sets", info_port_sets_cmd,
3295 _("Show information about the task's port sets"));
3296 add_info ("dead-names", info_dead_names_cmd,
3297 _("Show information about the task's dead names"));
3298 add_info_alias ("ports", "port-rights", 1);
3299 add_info_alias ("port", "port-rights", 1);
3300 add_info_alias ("psets", "port-sets", 1);
3305 set_thread_pause_cmd (char *args, int from_tty)
3307 struct proc *thread = cur_thread ();
3308 int old_sc = thread->pause_sc;
3310 thread->pause_sc = parse_bool_arg (args, "set thread pause");
3311 if (old_sc == 0 && thread->pause_sc != 0 && thread->inf->pause_sc == 0)
3312 /* If the task is currently unsuspended, immediately suspend it,
3313 otherwise wait until the next time it gets control. */
3314 inf_suspend (thread->inf);
3318 show_thread_pause_cmd (char *args, int from_tty)
3320 struct proc *thread = cur_thread ();
3321 int sc = thread->pause_sc;
3323 check_empty (args, "show task pause");
3324 printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n",
3325 proc_string (thread),
3326 sc ? "is" : "isn't",
3327 !sc && thread->inf->pause_sc ? " (but the task is)" : "");
3331 set_thread_run_cmd (char *args, int from_tty)
3333 struct proc *thread = cur_thread ();
3335 thread->run_sc = parse_bool_arg (args, "set thread run") ? 0 : 1;
3339 show_thread_run_cmd (char *args, int from_tty)
3341 struct proc *thread = cur_thread ();
3343 check_empty (args, "show thread run");
3344 printf_unfiltered ("Thread %s %s allowed to run.",
3345 proc_string (thread),
3346 thread->run_sc == 0 ? "is" : "isn't");
3350 set_thread_detach_sc_cmd (char *args, int from_tty)
3352 cur_thread ()->detach_sc = parse_int_arg (args,
3353 "set thread detach-suspend-count");
3357 show_thread_detach_sc_cmd (char *args, int from_tty)
3359 struct proc *thread = cur_thread ();
3361 check_empty (args, "show thread detach-suspend-count");
3362 printf_unfiltered ("Thread %s will be left with a suspend count"
3363 " of %d when detaching.\n",
3364 proc_string (thread),
3369 set_thread_exc_port_cmd (char *args, int from_tty)
3371 struct proc *thread = cur_thread ();
3374 error (_("No argument to \"set thread exception-port\" command."));
3375 steal_exc_port (thread, parse_and_eval_address (args));
3380 show_thread_cmd (char *args, int from_tty)
3382 struct proc *thread = cur_thread ();
3384 check_empty (args, "show thread");
3385 show_thread_run_cmd (0, from_tty);
3386 show_thread_pause_cmd (0, from_tty);
3387 if (thread->detach_sc != 0)
3388 show_thread_detach_sc_cmd (0, from_tty);
3393 thread_takeover_sc_cmd (char *args, int from_tty)
3395 struct proc *thread = cur_thread ();
3397 thread_basic_info_data_t _info;
3398 thread_basic_info_t info = &_info;
3399 mach_msg_type_number_t info_len = THREAD_BASIC_INFO_COUNT;
3401 thread_info (thread->port, THREAD_BASIC_INFO, (int *) &info, &info_len);
3403 error (("%s."), safe_strerror (err));
3404 thread->sc = info->suspend_count;
3406 printf_unfiltered ("Suspend count was %d.\n", thread->sc);
3408 vm_deallocate (mach_task_self (), (vm_address_t) info,
3409 info_len * sizeof (int));
3414 add_thread_commands (void)
3416 add_prefix_cmd ("thread", no_class, set_thread_cmd,
3417 _("Command prefix for setting thread properties."),
3418 &set_thread_cmd_list, "set thread ", 0, &setlist);
3419 add_prefix_cmd ("default", no_class, show_thread_cmd,
3420 _("Command prefix for setting default thread properties."),
3421 &set_thread_default_cmd_list, "set thread default ", 0,
3422 &set_thread_cmd_list);
3423 add_prefix_cmd ("thread", no_class, set_thread_default_cmd,
3424 _("Command prefix for showing thread properties."),
3425 &show_thread_cmd_list, "show thread ", 0, &showlist);
3426 add_prefix_cmd ("default", no_class, show_thread_default_cmd,
3427 _("Command prefix for showing default thread properties."),
3428 &show_thread_default_cmd_list, "show thread default ", 0,
3429 &show_thread_cmd_list);
3431 add_cmd ("pause", class_run, set_thread_pause_cmd, _("\
3432 Set whether the current thread is suspended while gdb has control.\n\
3433 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3434 until the next time the program is continued. This property normally\n\
3435 has no effect because the whole task is suspended, however, that may\n\
3436 be disabled with \"set task pause off\".\n\
3437 The default value is \"off\"."),
3438 &set_thread_cmd_list);
3439 add_cmd ("pause", no_class, show_thread_pause_cmd, _("\
3440 Show whether the current thread is suspended while gdb has control."),
3441 &show_thread_cmd_list);
3443 add_cmd ("run", class_run, set_thread_run_cmd,
3444 _("Set whether the current thread is allowed to run."),
3445 &set_thread_cmd_list);
3446 add_cmd ("run", no_class, show_thread_run_cmd,
3447 _("Show whether the current thread is allowed to run."),
3448 &show_thread_cmd_list);
3450 add_cmd ("detach-suspend-count", class_run, set_thread_detach_sc_cmd, _("\
3451 Set the suspend count will leave on the thread when detaching.\n\
3452 Note that this is relative to suspend count when gdb noticed the thread;\n\
3453 use the `thread takeover-suspend-count' to force it to an absolute value."),
3454 &set_thread_cmd_list);
3455 add_cmd ("detach-suspend-count", no_class, show_thread_detach_sc_cmd, _("\
3456 Show the suspend count will leave on the thread when detaching.\n\
3457 Note that this is relative to suspend count when gdb noticed the thread;\n\
3458 use the `thread takeover-suspend-count' to force it to an absolute value."),
3459 &show_thread_cmd_list);
3461 add_cmd ("exception-port", no_class, set_thread_exc_port_cmd, _("\
3462 Set the thread exception port to which we forward exceptions.\n\
3463 This overrides the task exception port.\n\
3464 The argument should be the value of the send right in the task."),
3465 &set_thread_cmd_list);
3466 add_alias_cmd ("excp", "exception-port", no_class, 1, &set_thread_cmd_list);
3467 add_alias_cmd ("exc-port", "exception-port", no_class, 1,
3468 &set_thread_cmd_list);
3470 add_cmd ("takeover-suspend-count", no_class, thread_takeover_sc_cmd, _("\
3471 Force the threads absolute suspend-count to be gdb's.\n\
3472 Prior to giving this command, gdb's thread suspend-counts are relative\n\
3473 to the thread's initial suspend-count when gdb notices the threads."),
3479 /* -Wmissing-prototypes */
3480 extern initialize_file_ftype _initialize_gnu_nat;
3483 _initialize_gnu_nat (void)
3485 proc_server = getproc ();
3487 add_task_commands ();
3488 add_thread_commands ();
3489 add_setshow_boolean_cmd ("gnu-nat", class_maintenance,
3491 _("Set debugging output for the gnu backend."),
3492 _("Show debugging output for the gnu backend."),
3500 #ifdef FLUSH_INFERIOR_CACHE
3502 /* When over-writing code on some machines the I-Cache must be flushed
3503 explicitly, because it is not kept coherent by the lazy hardware.
3504 This definitely includes breakpoints, for instance, or else we
3505 end up looping in mysterious Bpt traps. */
3508 flush_inferior_icache (CORE_ADDR pc, int amount)
3510 vm_machine_attribute_val_t flush = MATTR_VAL_ICACHE_FLUSH;
3513 ret = vm_machine_attribute (gnu_current_inf->task->port,
3518 if (ret != KERN_SUCCESS)
3519 warning (_("Error flushing inferior's cache : %s"), safe_strerror (ret));
3521 #endif /* FLUSH_INFERIOR_CACHE */