1 /* Interface GDB to the GNU Hurd.
2 Copyright (C) 1992-2019 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 /* Include this first, to pick up the <mach.h> 'thread_info' diversion. */
26 /* Mach/Hurd headers are not yet ready for C++ compilation. */
30 #include <mach_error.h>
31 #include <mach/exception.h>
32 #include <mach/message.h>
33 #include <mach/notify.h>
34 #include <mach/vm_attributes.h>
37 #include <hurd/interrupt.h>
39 #include <hurd/msg_request.h>
40 #include <hurd/process.h>
41 /* Defined in <hurd/process.h>, but we need forward declarations from
42 <hurd/process_request.h> as well. */
44 #include <hurd/process_request.h>
45 #include <hurd/signal.h>
46 #include <hurd/sigpreempt.h>
57 #include <sys/ptrace.h>
66 #include "common/gdb_wait.h"
69 #include "gdbthread.h"
70 #include "gdb_obstack.h"
71 #include "tid-parse.h"
73 #include "inf-child.h"
75 /* MIG stubs are not yet ready for C++ compilation. */
78 #include "exc_request_S.h"
80 #include "process_reply_S.h"
81 #include "msg_reply_S.h"
82 #include "exc_request_U.h"
86 static process_t proc_server = MACH_PORT_NULL;
88 /* If we've sent a proc_wait_request to the proc server, the pid of the
89 process we asked about. We can only ever have one outstanding. */
90 int proc_wait_pid = 0;
92 /* The number of wait requests we've sent, and expect replies from. */
93 int proc_waits_pending = 0;
95 int gnu_debug_flag = 0;
99 static struct inf *make_inf ();
100 void inf_clear_wait (struct inf *inf);
101 void inf_cleanup (struct inf *inf);
102 void inf_startup (struct inf *inf, int pid);
103 int inf_update_suspends (struct inf *inf);
104 void inf_set_pid (struct inf *inf, pid_t pid);
105 void inf_validate_procs (struct inf *inf);
106 void inf_steal_exc_ports (struct inf *inf);
107 void inf_restore_exc_ports (struct inf *inf);
108 void inf_set_threads_resume_sc (struct inf *inf,
109 struct proc *run_thread,
111 int inf_set_threads_resume_sc_for_signal_thread (struct inf *inf);
112 void inf_suspend (struct inf *inf);
113 void inf_resume (struct inf *inf);
114 void inf_set_step_thread (struct inf *inf, struct proc *proc);
115 void inf_detach (struct inf *inf);
116 void inf_attach (struct inf *inf, int pid);
117 void inf_signal (struct inf *inf, enum gdb_signal sig);
118 void inf_continue (struct inf *inf);
120 #define inf_debug(_inf, msg, args...) \
121 do { struct inf *__inf = (_inf); \
122 debug ("{inf %d %s}: " msg, __inf->pid, \
123 host_address_to_string (__inf) , ##args); } while (0)
125 void proc_abort (struct proc *proc, int force);
126 struct proc *make_proc (struct inf *inf, mach_port_t port, int tid);
127 struct proc *_proc_free (struct proc *proc);
128 int proc_update_sc (struct proc *proc);
129 kern_return_t proc_get_exception_port (struct proc *proc, mach_port_t * port);
130 kern_return_t proc_set_exception_port (struct proc *proc, mach_port_t port);
131 static mach_port_t _proc_get_exc_port (struct proc *proc);
132 void proc_steal_exc_port (struct proc *proc, mach_port_t exc_port);
133 void proc_restore_exc_port (struct proc *proc);
134 int proc_trace (struct proc *proc, int set);
136 /* Evaluate RPC_EXPR in a scope with the variables MSGPORT and REFPORT bound
137 to INF's msg port and task port respectively. If it has no msg port,
138 EIEIO is returned. INF must refer to a running process! */
139 #define INF_MSGPORT_RPC(inf, rpc_expr) \
140 HURD_MSGPORT_RPC (proc_getmsgport (proc_server, inf->pid, &msgport), \
141 (refport = inf->task->port, 0), 0, \
142 msgport ? (rpc_expr) : EIEIO)
144 /* Like INF_MSGPORT_RPC, but will also resume the signal thread to ensure
145 there's someone around to deal with the RPC (and resuspend things
146 afterwards). This effects INF's threads' resume_sc count. */
147 #define INF_RESUME_MSGPORT_RPC(inf, rpc_expr) \
148 (inf_set_threads_resume_sc_for_signal_thread (inf) \
149 ? ({ kern_return_t __e; \
151 __e = INF_MSGPORT_RPC (inf, rpc_expr); \
157 /* The state passed by an exception message. */
160 int exception; /* The exception code. */
162 mach_port_t handler; /* The real exception port to handle this. */
163 mach_port_t reply; /* The reply port from the exception call. */
166 /* The results of the last wait an inf did. */
169 struct target_waitstatus status; /* The status returned to gdb. */
170 struct exc_state exc; /* The exception that caused us to return. */
171 struct proc *thread; /* The thread in question. */
172 int suppress; /* Something trivial happened. */
175 /* The state of an inferior. */
178 /* Fields describing the current inferior. */
180 struct proc *task; /* The mach task. */
181 struct proc *threads; /* A linked list of all threads in TASK. */
183 /* True if THREADS needn't be validated by querying the task. We
184 assume that we and the task in question are the only ones
185 frobbing the thread list, so as long as we don't let any code
186 run, we don't have to worry about THREADS changing. */
187 int threads_up_to_date;
189 pid_t pid; /* The real system PID. */
191 struct inf_wait wait; /* What to return from target_wait. */
193 /* One thread proc in INF may be in `single-stepping mode'. This
195 struct proc *step_thread;
197 /* The thread we think is the signal thread. */
198 struct proc *signal_thread;
200 mach_port_t event_port; /* Where we receive various msgs. */
202 /* True if we think at least one thread in the inferior could currently be
204 unsigned int running:1;
206 /* True if the process has stopped (in the proc server sense). Note that
207 since a proc server `stop' leaves the signal thread running, the inf can
208 be RUNNING && STOPPED... */
209 unsigned int stopped:1;
211 /* True if the inferior has no message port. */
212 unsigned int nomsg:1;
214 /* True if the inferior is traced. */
215 unsigned int traced:1;
217 /* True if we shouldn't try waiting for the inferior, usually because we
218 can't for some reason. */
219 unsigned int no_wait:1;
221 /* When starting a new inferior, we don't try to validate threads until all
222 the proper execs have been done, which this flag states we still
224 unsigned int pending_execs:1;
226 /* Fields describing global state. */
228 /* The task suspend count used when gdb has control. This is normally 1 to
229 make things easier for us, but sometimes (like when attaching to vital
230 system servers) it may be desirable to let the task continue to run
231 (pausing individual threads as necessary). */
234 /* The task suspend count left when detaching from a task. */
237 /* The initial values used for the run_sc and pause_sc of newly discovered
238 threads -- see the definition of those fields in struct proc. */
239 int default_thread_run_sc;
240 int default_thread_pause_sc;
241 int default_thread_detach_sc;
243 /* True if the process should be traced when started/attached. Newly
244 started processes *must* be traced at first to exec them properly, but
245 if this is false, tracing is turned off as soon it has done so. */
248 /* True if exceptions from the inferior process should be trapped. This
249 must be on to use breakpoints. */
255 __proc_pid (struct proc *proc)
257 return proc->inf->pid;
261 /* Update PROC's real suspend count to match it's desired one. Returns true
262 if we think PROC is now in a runnable state. */
264 proc_update_sc (struct proc *proc)
268 int delta = proc->sc - proc->cur_sc;
271 proc_debug (proc, "sc: %d --> %d", proc->cur_sc, proc->sc);
273 if (proc->sc == 0 && proc->state_changed)
274 /* Since PROC may start running, we must write back any state changes. */
276 gdb_assert (proc_is_thread (proc));
277 proc_debug (proc, "storing back changed thread state");
278 err = thread_set_state (proc->port, THREAD_STATE_FLAVOR,
279 (thread_state_t) &proc->state, THREAD_STATE_SIZE);
281 proc->state_changed = 0;
286 while (delta-- > 0 && !err)
288 if (proc_is_task (proc))
289 err = task_suspend (proc->port);
291 err = thread_suspend (proc->port);
296 while (delta++ < 0 && !err)
298 if (proc_is_task (proc))
299 err = task_resume (proc->port);
301 err = thread_resume (proc->port);
305 proc->cur_sc = proc->sc;
307 /* If we got an error, then the task/thread has disappeared. */
308 running = !err && proc->sc == 0;
310 proc_debug (proc, "is %s", err ? "dead" : running ? "running" : "suspended");
312 proc_debug (proc, "err = %s", safe_strerror (err));
317 proc->state_valid = proc->state_changed = 0;
318 proc->fetched_regs = 0;
325 /* Thread_abort is called on PROC if needed. PROC must be a thread proc.
326 If PROC is deemed `precious', then nothing is done unless FORCE is true.
327 In particular, a thread is precious if it's running (in which case forcing
328 it includes suspending it first), or if it has an exception pending. */
330 proc_abort (struct proc *proc, int force)
332 gdb_assert (proc_is_thread (proc));
336 struct inf *inf = proc->inf;
337 int running = (proc->cur_sc == 0 && inf->task->cur_sc == 0);
339 if (running && force)
342 inf_update_suspends (proc->inf);
344 warning (_("Stopped %s."), proc_string (proc));
346 else if (proc == inf->wait.thread && inf->wait.exc.reply && !force)
347 /* An exception is pending on PROC, which don't mess with. */
351 /* We only abort the thread if it's not actually running. */
353 thread_abort (proc->port);
354 proc_debug (proc, "aborted");
358 proc_debug (proc, "not aborting");
362 /* Make sure that the state field in PROC is up to date, and return a pointer
363 to it, or 0 if something is wrong. If WILL_MODIFY is true, makes sure
364 that the thread is stopped and aborted first, and sets the state_changed
365 field in PROC to true. */
367 proc_get_state (struct proc *proc, int will_modify)
369 int was_aborted = proc->aborted;
371 proc_debug (proc, "updating state info%s",
372 will_modify ? " (with intention to modify)" : "");
374 proc_abort (proc, will_modify);
376 if (!was_aborted && proc->aborted)
377 /* PROC's state may have changed since we last fetched it. */
378 proc->state_valid = 0;
380 if (!proc->state_valid)
382 mach_msg_type_number_t state_size = THREAD_STATE_SIZE;
384 thread_get_state (proc->port, THREAD_STATE_FLAVOR,
385 (thread_state_t) &proc->state, &state_size);
387 proc_debug (proc, "getting thread state");
388 proc->state_valid = !err;
391 if (proc->state_valid)
394 proc->state_changed = 1;
395 return (thread_state_t) &proc->state;
402 /* Set PORT to PROC's exception port. */
404 proc_get_exception_port (struct proc * proc, mach_port_t * port)
406 if (proc_is_task (proc))
407 return task_get_exception_port (proc->port, port);
409 return thread_get_exception_port (proc->port, port);
412 /* Set PROC's exception port to PORT. */
414 proc_set_exception_port (struct proc * proc, mach_port_t port)
416 proc_debug (proc, "setting exception port: %lu", port);
417 if (proc_is_task (proc))
418 return task_set_exception_port (proc->port, port);
420 return thread_set_exception_port (proc->port, port);
423 /* Get PROC's exception port, cleaning up a bit if proc has died. */
425 _proc_get_exc_port (struct proc *proc)
427 mach_port_t exc_port;
428 kern_return_t err = proc_get_exception_port (proc, &exc_port);
431 /* PROC must be dead. */
434 mach_port_deallocate (mach_task_self (), proc->exc_port);
435 proc->exc_port = MACH_PORT_NULL;
436 if (proc->saved_exc_port)
437 mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
438 proc->saved_exc_port = MACH_PORT_NULL;
444 /* Replace PROC's exception port with EXC_PORT, unless it's already
445 been done. Stash away any existing exception port so we can
448 proc_steal_exc_port (struct proc *proc, mach_port_t exc_port)
450 mach_port_t cur_exc_port = _proc_get_exc_port (proc);
454 kern_return_t err = 0;
456 proc_debug (proc, "inserting exception port: %lu", exc_port);
458 if (cur_exc_port != exc_port)
459 /* Put in our exception port. */
460 err = proc_set_exception_port (proc, exc_port);
462 if (err || cur_exc_port == proc->exc_port)
463 /* We previously set the exception port, and it's still set. So we
464 just keep the old saved port which is what the proc set. */
467 mach_port_deallocate (mach_task_self (), cur_exc_port);
470 /* Keep a copy of PROC's old exception port so it can be restored. */
472 if (proc->saved_exc_port)
473 mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
474 proc->saved_exc_port = cur_exc_port;
477 proc_debug (proc, "saved exception port: %lu", proc->saved_exc_port);
480 proc->exc_port = exc_port;
482 warning (_("Error setting exception port for %s: %s"),
483 proc_string (proc), safe_strerror (err));
487 /* If we previously replaced PROC's exception port, put back what we
488 found there at the time, unless *our* exception port has since been
489 overwritten, in which case who knows what's going on. */
491 proc_restore_exc_port (struct proc *proc)
493 mach_port_t cur_exc_port = _proc_get_exc_port (proc);
497 kern_return_t err = 0;
499 proc_debug (proc, "restoring real exception port");
501 if (proc->exc_port == cur_exc_port)
502 /* Our's is still there. */
503 err = proc_set_exception_port (proc, proc->saved_exc_port);
505 if (proc->saved_exc_port)
506 mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
507 proc->saved_exc_port = MACH_PORT_NULL;
510 proc->exc_port = MACH_PORT_NULL;
512 warning (_("Error setting exception port for %s: %s"),
513 proc_string (proc), safe_strerror (err));
518 /* Turns hardware tracing in PROC on or off when SET is true or false,
519 respectively. Returns true on success. */
521 proc_trace (struct proc *proc, int set)
523 thread_state_t state = proc_get_state (proc, 1);
526 return 0; /* The thread must be dead. */
528 proc_debug (proc, "tracing %s", set ? "on" : "off");
532 /* XXX We don't get the exception unless the thread has its own
533 exception port???? */
534 if (proc->exc_port == MACH_PORT_NULL)
535 proc_steal_exc_port (proc, proc->inf->event_port);
536 THREAD_STATE_SET_TRACED (state);
539 THREAD_STATE_CLEAR_TRACED (state);
545 /* A variable from which to assign new TIDs. */
546 static int next_thread_id = 1;
548 /* Returns a new proc structure with the given fields. Also adds a
549 notification for PORT becoming dead to be sent to INF's notify port. */
551 make_proc (struct inf *inf, mach_port_t port, int tid)
554 mach_port_t prev_port = MACH_PORT_NULL;
555 struct proc *proc = XNEW (struct proc);
561 proc->saved_exc_port = MACH_PORT_NULL;
562 proc->exc_port = MACH_PORT_NULL;
567 /* Note that these are all the values for threads; the task simply uses the
568 corresponding field in INF directly. */
569 proc->run_sc = inf->default_thread_run_sc;
570 proc->pause_sc = inf->default_thread_pause_sc;
571 proc->detach_sc = inf->default_thread_detach_sc;
572 proc->resume_sc = proc->run_sc;
576 proc->state_valid = 0;
577 proc->state_changed = 0;
579 proc_debug (proc, "is new");
581 /* Get notified when things die. */
583 mach_port_request_notification (mach_task_self (), port,
584 MACH_NOTIFY_DEAD_NAME, 1,
586 MACH_MSG_TYPE_MAKE_SEND_ONCE,
589 warning (_("Couldn't request notification for port %lu: %s"),
590 port, safe_strerror (err));
593 proc_debug (proc, "notifications to: %lu", inf->event_port);
594 if (prev_port != MACH_PORT_NULL)
595 mach_port_deallocate (mach_task_self (), prev_port);
598 if (inf->want_exceptions)
600 if (proc_is_task (proc))
601 /* Make the task exception port point to us. */
602 proc_steal_exc_port (proc, inf->event_port);
604 /* Just clear thread exception ports -- they default to the
606 proc_steal_exc_port (proc, MACH_PORT_NULL);
612 /* Frees PROC and any resources it uses, and returns the value of PROC's
615 _proc_free (struct proc *proc)
617 struct inf *inf = proc->inf;
618 struct proc *next = proc->next;
620 proc_debug (proc, "freeing...");
622 if (proc == inf->step_thread)
623 /* Turn off single stepping. */
624 inf_set_step_thread (inf, 0);
625 if (proc == inf->wait.thread)
626 inf_clear_wait (inf);
627 if (proc == inf->signal_thread)
628 inf->signal_thread = 0;
630 if (proc->port != MACH_PORT_NULL)
632 if (proc->exc_port != MACH_PORT_NULL)
633 /* Restore the original exception port. */
634 proc_restore_exc_port (proc);
635 if (proc->cur_sc != 0)
636 /* Resume the thread/task. */
639 proc_update_sc (proc);
641 mach_port_deallocate (mach_task_self (), proc->port);
652 struct inf *inf = XNEW (struct inf);
656 inf->threads_up_to_date = 0;
658 inf->wait.status.kind = TARGET_WAITKIND_SPURIOUS;
659 inf->wait.thread = 0;
660 inf->wait.exc.handler = MACH_PORT_NULL;
661 inf->wait.exc.reply = MACH_PORT_NULL;
662 inf->step_thread = 0;
663 inf->signal_thread = 0;
664 inf->event_port = MACH_PORT_NULL;
670 inf->pending_execs = 0;
673 inf->default_thread_run_sc = 0;
674 inf->default_thread_pause_sc = 0;
675 inf->default_thread_detach_sc = 0;
676 inf->want_signals = 1; /* By default */
677 inf->want_exceptions = 1; /* By default */
682 /* Clear INF's target wait status. */
684 inf_clear_wait (struct inf *inf)
686 inf_debug (inf, "clearing wait");
687 inf->wait.status.kind = TARGET_WAITKIND_SPURIOUS;
688 inf->wait.thread = 0;
689 inf->wait.suppress = 0;
690 if (inf->wait.exc.handler != MACH_PORT_NULL)
692 mach_port_deallocate (mach_task_self (), inf->wait.exc.handler);
693 inf->wait.exc.handler = MACH_PORT_NULL;
695 if (inf->wait.exc.reply != MACH_PORT_NULL)
697 mach_port_deallocate (mach_task_self (), inf->wait.exc.reply);
698 inf->wait.exc.reply = MACH_PORT_NULL;
704 inf_cleanup (struct inf *inf)
706 inf_debug (inf, "cleanup");
708 inf_clear_wait (inf);
710 inf_set_pid (inf, -1);
717 inf->pending_execs = 0;
721 mach_port_destroy (mach_task_self (), inf->event_port);
722 inf->event_port = MACH_PORT_NULL;
727 inf_startup (struct inf *inf, int pid)
731 inf_debug (inf, "startup: pid = %d", pid);
735 /* Make the port on which we receive all events. */
736 err = mach_port_allocate (mach_task_self (),
737 MACH_PORT_RIGHT_RECEIVE, &inf->event_port);
739 error (_("Error allocating event port: %s"), safe_strerror (err));
741 /* Make a send right for it, so we can easily copy it for other people. */
742 mach_port_insert_right (mach_task_self (), inf->event_port,
743 inf->event_port, MACH_MSG_TYPE_MAKE_SEND);
744 inf_set_pid (inf, pid);
748 /* Close current process, if any, and attach INF to process PORT. */
750 inf_set_pid (struct inf *inf, pid_t pid)
753 struct proc *task = inf->task;
755 inf_debug (inf, "setting pid: %d", pid);
758 task_port = MACH_PORT_NULL;
761 kern_return_t err = proc_pid2task (proc_server, pid, &task_port);
764 error (_("Error getting task for pid %d: %s"),
765 pid, safe_strerror (err));
768 inf_debug (inf, "setting task: %lu", task_port);
771 task_suspend (task_port);
773 if (task && task->port != task_port)
776 inf_validate_procs (inf); /* Trash all the threads. */
777 _proc_free (task); /* And the task. */
780 if (task_port != MACH_PORT_NULL)
782 inf->task = make_proc (inf, task_port, PROC_TID_TASK);
783 inf->threads_up_to_date = 0;
790 /* Reflect task_suspend above. */
791 inf->task->sc = inf->task->cur_sc = 1;
798 /* Validates INF's stopped, nomsg and traced field from the actual
799 proc server state. Note that the traced field is only updated from
800 the proc server state if we do not have a message port. If we do
801 have a message port we'd better look at the tracemask itself. */
803 inf_validate_procinfo (struct inf *inf)
806 mach_msg_type_number_t noise_len = 0;
808 mach_msg_type_number_t pi_len = 0;
811 proc_getprocinfo (proc_server, inf->pid, &info_flags,
812 (procinfo_t *) &pi, &pi_len, &noise, &noise_len);
816 inf->stopped = !!(pi->state & PI_STOPPED);
817 inf->nomsg = !!(pi->state & PI_NOMSG);
819 inf->traced = !!(pi->state & PI_TRACED);
820 vm_deallocate (mach_task_self (), (vm_address_t) pi,
821 pi_len * sizeof (*(procinfo_t) 0));
823 vm_deallocate (mach_task_self (), (vm_address_t) noise, noise_len);
827 /* Validates INF's task suspend count. If it's higher than we expect,
828 verify with the user before `stealing' the extra count. */
830 inf_validate_task_sc (struct inf *inf)
833 mach_msg_type_number_t noise_len = 0;
835 mach_msg_type_number_t pi_len = 0;
836 int info_flags = PI_FETCH_TASKINFO;
837 int suspend_count = -1;
841 err = proc_getprocinfo (proc_server, inf->pid, &info_flags,
842 (procinfo_t *) &pi, &pi_len, &noise, &noise_len);
845 inf->task->dead = 1; /* oh well */
849 if (inf->task->cur_sc < pi->taskinfo.suspend_count && suspend_count == -1)
851 /* The proc server might have suspended the task while stopping
852 it. This happens when the task is handling a traced signal.
853 Refetch the suspend count. The proc server should be
854 finished stopping the task by now. */
855 suspend_count = pi->taskinfo.suspend_count;
859 suspend_count = pi->taskinfo.suspend_count;
861 vm_deallocate (mach_task_self (), (vm_address_t) pi,
862 pi_len * sizeof (*(procinfo_t) 0));
864 vm_deallocate (mach_task_self (), (vm_address_t) noise, noise_len);
866 if (inf->task->cur_sc < suspend_count)
868 if (!query (_("Pid %d has an additional task suspend count of %d;"
869 " clear it? "), inf->pid,
870 suspend_count - inf->task->cur_sc))
871 error (_("Additional task suspend count left untouched."));
873 inf->task->cur_sc = suspend_count;
877 /* Turns tracing for INF on or off, depending on ON, unless it already
878 is. If INF is running, the resume_sc count of INF's threads will
879 be modified, and the signal thread will briefly be run to change
882 inf_set_traced (struct inf *inf, int on)
884 if (on == inf->traced)
887 if (inf->task && !inf->task->dead)
888 /* Make it take effect immediately. */
890 sigset_t mask = on ? ~(sigset_t) 0 : 0;
892 INF_RESUME_MSGPORT_RPC (inf, msg_set_init_int (msgport, refport,
893 INIT_TRACEMASK, mask));
898 warning (_("Can't modify tracing state for pid %d: %s"),
899 inf->pid, "No signal thread");
903 warning (_("Can't modify tracing state for pid %d: %s"),
904 inf->pid, safe_strerror (err));
913 /* Makes all the real suspend count deltas of all the procs in INF
914 match the desired values. Careful to always do thread/task suspend
915 counts in the safe order. Returns true if at least one thread is
916 thought to be running. */
918 inf_update_suspends (struct inf *inf)
920 struct proc *task = inf->task;
922 /* We don't have to update INF->threads even though we're iterating over it
923 because we'll change a thread only if it already has an existing proc
925 inf_debug (inf, "updating suspend counts");
930 int task_running = (task->sc == 0), thread_running = 0;
932 if (task->sc > task->cur_sc)
933 /* The task is becoming _more_ suspended; do before any threads. */
934 task_running = proc_update_sc (task);
936 if (inf->pending_execs)
937 /* When we're waiting for an exec, things may be happening behind our
938 back, so be conservative. */
941 /* Do all the thread suspend counts. */
942 for (thread = inf->threads; thread; thread = thread->next)
943 thread_running |= proc_update_sc (thread);
945 if (task->sc != task->cur_sc)
946 /* We didn't do the task first, because we wanted to wait for the
947 threads; do it now. */
948 task_running = proc_update_sc (task);
950 inf_debug (inf, "%srunning...",
951 (thread_running && task_running) ? "" : "not ");
953 inf->running = thread_running && task_running;
955 /* Once any thread has executed some code, we can't depend on the
956 threads list any more. */
958 inf->threads_up_to_date = 0;
967 /* Converts a GDB pid to a struct proc. */
969 inf_tid_to_thread (struct inf *inf, int tid)
971 struct proc *thread = inf->threads;
974 if (thread->tid == tid)
977 thread = thread->next;
981 /* Converts a thread port to a struct proc. */
983 inf_port_to_thread (struct inf *inf, mach_port_t port)
985 struct proc *thread = inf->threads;
988 if (thread->port == port)
991 thread = thread->next;
998 inf_threads (struct inf *inf, inf_threads_ftype *f, void *arg)
1000 struct proc *thread;
1002 for (thread = inf->threads; thread; thread = thread->next)
1007 /* Make INF's list of threads be consistent with reality of TASK. */
1009 inf_validate_procs (struct inf *inf)
1011 thread_array_t threads;
1012 mach_msg_type_number_t num_threads, i;
1013 struct proc *task = inf->task;
1015 /* If no threads are currently running, this function will guarantee that
1016 things are up to date. The exception is if there are zero threads --
1017 then it is almost certainly in an odd state, and probably some outside
1018 agent will create threads. */
1019 inf->threads_up_to_date = inf->threads ? !inf->running : 0;
1023 kern_return_t err = task_threads (task->port, &threads, &num_threads);
1025 inf_debug (inf, "fetching threads");
1027 /* TASK must be dead. */
1037 inf_debug (inf, "no task");
1041 /* Make things normally linear. */
1042 mach_msg_type_number_t search_start = 0;
1043 /* Which thread in PROCS corresponds to each task thread, & the task. */
1044 struct proc *matched[num_threads + 1];
1045 /* The last thread in INF->threads, so we can add to the end. */
1046 struct proc *last = 0;
1047 /* The current thread we're considering. */
1048 struct proc *thread = inf->threads;
1050 memset (matched, 0, sizeof (matched));
1054 mach_msg_type_number_t left;
1056 for (i = search_start, left = num_threads; left; i++, left--)
1058 if (i >= num_threads)
1059 i -= num_threads; /* I wrapped around. */
1060 if (thread->port == threads[i])
1061 /* We already know about this thread. */
1063 matched[i] = thread;
1065 thread = thread->next;
1073 proc_debug (thread, "died!");
1074 thread->port = MACH_PORT_NULL;
1075 thread = _proc_free (thread); /* THREAD is dead. */
1077 last->next = thread;
1079 inf->threads = thread;
1083 for (i = 0; i < num_threads; i++)
1086 /* Throw away the duplicate send right. */
1087 mach_port_deallocate (mach_task_self (), threads[i]);
1089 /* THREADS[I] is a thread we don't know about yet! */
1093 thread = make_proc (inf, threads[i], next_thread_id++);
1095 last->next = thread;
1097 inf->threads = thread;
1099 proc_debug (thread, "new thread: %lu", threads[i]);
1101 ptid = ptid_t (inf->pid, thread->tid, 0);
1103 /* Tell GDB's generic thread code. */
1105 if (inferior_ptid == ptid_t (inf->pid))
1106 /* This is the first time we're hearing about thread
1107 ids, after a fork-child. */
1108 thread_change_ptid (inferior_ptid, ptid);
1109 else if (inf->pending_execs != 0)
1110 /* This is a shell thread. */
1111 add_thread_silent (ptid);
1117 vm_deallocate (mach_task_self (),
1118 (vm_address_t) threads, (num_threads * sizeof (thread_t)));
1123 /* Makes sure that INF's thread list is synced with the actual process. */
1125 inf_update_procs (struct inf *inf)
1129 if (!inf->threads_up_to_date)
1130 inf_validate_procs (inf);
1134 /* Sets the resume_sc of each thread in inf. That of RUN_THREAD is set to 0,
1135 and others are set to their run_sc if RUN_OTHERS is true, and otherwise
1138 inf_set_threads_resume_sc (struct inf *inf,
1139 struct proc *run_thread, int run_others)
1141 struct proc *thread;
1143 inf_update_procs (inf);
1144 for (thread = inf->threads; thread; thread = thread->next)
1145 if (thread == run_thread)
1146 thread->resume_sc = 0;
1147 else if (run_others)
1148 thread->resume_sc = thread->run_sc;
1150 thread->resume_sc = thread->pause_sc;
1154 /* Cause INF to continue execution immediately; individual threads may still
1155 be suspended (but their suspend counts will be updated). */
1157 inf_resume (struct inf *inf)
1159 struct proc *thread;
1161 inf_update_procs (inf);
1163 for (thread = inf->threads; thread; thread = thread->next)
1164 thread->sc = thread->resume_sc;
1168 if (!inf->pending_execs)
1169 /* Try to make sure our task count is correct -- in the case where
1170 we're waiting for an exec though, things are too volatile, so just
1171 assume things will be reasonable (which they usually will be). */
1172 inf_validate_task_sc (inf);
1176 inf_update_suspends (inf);
1179 /* Cause INF to stop execution immediately; individual threads may still
1182 inf_suspend (struct inf *inf)
1184 struct proc *thread;
1186 inf_update_procs (inf);
1188 for (thread = inf->threads; thread; thread = thread->next)
1189 thread->sc = thread->pause_sc;
1192 inf->task->sc = inf->pause_sc;
1194 inf_update_suspends (inf);
1198 /* INF has one thread PROC that is in single-stepping mode. This
1199 function changes it to be PROC, changing any old step_thread to be
1200 a normal one. A PROC of 0 clears any existing value. */
1202 inf_set_step_thread (struct inf *inf, struct proc *thread)
1204 gdb_assert (!thread || proc_is_thread (thread));
1207 inf_debug (inf, "setting step thread: %d/%d", inf->pid, thread->tid);
1209 inf_debug (inf, "clearing step thread");
1211 if (inf->step_thread != thread)
1213 if (inf->step_thread && inf->step_thread->port != MACH_PORT_NULL)
1214 if (!proc_trace (inf->step_thread, 0))
1216 if (thread && proc_trace (thread, 1))
1217 inf->step_thread = thread;
1219 inf->step_thread = 0;
1224 /* Set up the thread resume_sc's so that only the signal thread is running
1225 (plus whatever other thread are set to always run). Returns true if we
1226 did so, or false if we can't find a signal thread. */
1228 inf_set_threads_resume_sc_for_signal_thread (struct inf *inf)
1230 if (inf->signal_thread)
1232 inf_set_threads_resume_sc (inf, inf->signal_thread, 0);
1240 inf_update_signal_thread (struct inf *inf)
1242 /* XXX for now we assume that if there's a msgport, the 2nd thread is
1243 the signal thread. */
1244 inf->signal_thread = inf->threads ? inf->threads->next : 0;
1248 /* Detachs from INF's inferior task, letting it run once again... */
1250 inf_detach (struct inf *inf)
1252 struct proc *task = inf->task;
1254 inf_debug (inf, "detaching...");
1256 inf_clear_wait (inf);
1257 inf_set_step_thread (inf, 0);
1261 struct proc *thread;
1263 inf_validate_procinfo (inf);
1265 inf_set_traced (inf, 0);
1271 inf_signal (inf, GDB_SIGNAL_0);
1274 proc_restore_exc_port (task);
1275 task->sc = inf->detach_sc;
1277 for (thread = inf->threads; thread; thread = thread->next)
1279 proc_restore_exc_port (thread);
1280 thread->sc = thread->detach_sc;
1283 inf_update_suspends (inf);
1289 /* Attaches INF to the process with process id PID, returning it in a
1290 suspended state suitable for debugging. */
1292 inf_attach (struct inf *inf, int pid)
1294 inf_debug (inf, "attaching: %d", pid);
1299 inf_startup (inf, pid);
1303 /* Makes sure that we've got our exception ports entrenched in the process. */
1305 inf_steal_exc_ports (struct inf *inf)
1307 struct proc *thread;
1309 inf_debug (inf, "stealing exception ports");
1311 inf_set_step_thread (inf, 0); /* The step thread is special. */
1313 proc_steal_exc_port (inf->task, inf->event_port);
1314 for (thread = inf->threads; thread; thread = thread->next)
1315 proc_steal_exc_port (thread, MACH_PORT_NULL);
1318 /* Makes sure the process has its own exception ports. */
1320 inf_restore_exc_ports (struct inf *inf)
1322 struct proc *thread;
1324 inf_debug (inf, "restoring exception ports");
1326 inf_set_step_thread (inf, 0); /* The step thread is special. */
1328 proc_restore_exc_port (inf->task);
1329 for (thread = inf->threads; thread; thread = thread->next)
1330 proc_restore_exc_port (thread);
1334 /* Deliver signal SIG to INF. If INF is stopped, delivering a signal, even
1335 signal 0, will continue it. INF is assumed to be in a paused state, and
1336 the resume_sc's of INF's threads may be affected. */
1338 inf_signal (struct inf *inf, enum gdb_signal sig)
1340 kern_return_t err = 0;
1341 int host_sig = gdb_signal_to_host (sig);
1343 #define NAME gdb_signal_to_name (sig)
1345 if (host_sig >= _NSIG)
1346 /* A mach exception. Exceptions are encoded in the signal space by
1347 putting them after _NSIG; this assumes they're positive (and not
1348 extremely large)! */
1350 struct inf_wait *w = &inf->wait;
1352 if (w->status.kind == TARGET_WAITKIND_STOPPED
1353 && w->status.value.sig == sig
1354 && w->thread && !w->thread->aborted)
1355 /* We're passing through the last exception we received. This is
1356 kind of bogus, because exceptions are per-thread whereas gdb
1357 treats signals as per-process. We just forward the exception to
1358 the correct handler, even it's not for the same thread as TID --
1359 i.e., we pretend it's global. */
1361 struct exc_state *e = &w->exc;
1363 inf_debug (inf, "passing through exception:"
1364 " task = %lu, thread = %lu, exc = %d"
1365 ", code = %d, subcode = %d",
1366 w->thread->port, inf->task->port,
1367 e->exception, e->code, e->subcode);
1369 exception_raise_request (e->handler,
1370 e->reply, MACH_MSG_TYPE_MOVE_SEND_ONCE,
1371 w->thread->port, inf->task->port,
1372 e->exception, e->code, e->subcode);
1375 error (_("Can't forward spontaneous exception (%s)."), NAME);
1378 /* A Unix signal. */
1380 /* The process is stopped and expecting a signal. Just send off a
1381 request and let it get handled when we resume everything. */
1383 inf_debug (inf, "sending %s to stopped process", NAME);
1385 INF_MSGPORT_RPC (inf,
1386 msg_sig_post_untraced_request (msgport,
1388 MACH_MSG_TYPE_MAKE_SEND_ONCE,
1392 /* Posting an untraced signal automatically continues it.
1393 We clear this here rather than when we get the reply
1394 because we'd rather assume it's not stopped when it
1395 actually is, than the reverse. */
1399 /* It's not expecting it. We have to let just the signal thread
1400 run, and wait for it to get into a reasonable state before we
1401 can continue the rest of the process. When we finally resume the
1402 process the signal we request will be the very first thing that
1405 inf_debug (inf, "sending %s to unstopped process"
1406 " (so resuming signal thread)", NAME);
1408 INF_RESUME_MSGPORT_RPC (inf,
1409 msg_sig_post_untraced (msgport, host_sig,
1414 /* Can't do too much... */
1415 warning (_("Can't deliver signal %s: No signal thread."), NAME);
1417 warning (_("Delivering signal %s: %s"), NAME, safe_strerror (err));
1423 /* Continue INF without delivering a signal. This is meant to be used
1424 when INF does not have a message port. */
1426 inf_continue (struct inf *inf)
1429 kern_return_t err = proc_pid2proc (proc_server, inf->pid, &proc);
1433 inf_debug (inf, "continuing process");
1435 err = proc_mark_cont (proc);
1438 struct proc *thread;
1440 for (thread = inf->threads; thread; thread = thread->next)
1441 thread_resume (thread->port);
1448 warning (_("Can't continue process: %s"), safe_strerror (err));
1452 /* The inferior used for all gdb target ops. */
1453 struct inf *gnu_current_inf = 0;
1455 /* The inferior being waited for by gnu_wait. Since GDB is decidely not
1456 multi-threaded, we don't bother to lock this. */
1457 struct inf *waiting_inf;
1459 /* MIG stubs are not yet ready for C++ compilation. */
1460 extern "C" int exc_server (mach_msg_header_t *, mach_msg_header_t *);
1461 extern "C" int msg_reply_server (mach_msg_header_t *, mach_msg_header_t *);
1462 extern "C" int notify_server (mach_msg_header_t *, mach_msg_header_t *);
1463 extern "C" int process_reply_server (mach_msg_header_t *, mach_msg_header_t *);
1465 /* Wait for something to happen in the inferior, returning what in STATUS. */
1468 gnu_nat_target::wait (ptid_t ptid, struct target_waitstatus *status,
1473 mach_msg_header_t hdr;
1474 mach_msg_type_t type;
1478 struct proc *thread;
1479 struct inf *inf = gnu_current_inf;
1481 gdb_assert (inf->task);
1483 if (!inf->threads && !inf->pending_execs)
1484 /* No threads! Assume that maybe some outside agency is frobbing our
1485 task, and really look for new threads. If we can't find any, just tell
1486 the user to try again later. */
1488 inf_validate_procs (inf);
1489 if (!inf->threads && !inf->task->dead)
1490 error (_("There are no threads; try again later."));
1495 inf_debug (inf, "waiting for: %s", target_pid_to_str (ptid));
1498 if (proc_wait_pid != inf->pid && !inf->no_wait)
1499 /* Always get information on events from the proc server. */
1501 inf_debug (inf, "requesting wait on pid %d", inf->pid);
1504 /* The proc server is single-threaded, and only allows a single
1505 outstanding wait request, so we have to cancel the previous one. */
1507 inf_debug (inf, "cancelling previous wait on pid %d", proc_wait_pid);
1508 interrupt_operation (proc_server, 0);
1512 proc_wait_request (proc_server, inf->event_port, inf->pid, WUNTRACED);
1514 warning (_("wait request failed: %s"), safe_strerror (err));
1517 inf_debug (inf, "waits pending: %d", proc_waits_pending);
1518 proc_wait_pid = inf->pid;
1519 /* Even if proc_waits_pending was > 0 before, we still won't
1520 get any other replies, because it was either from a
1521 different INF, or a different process attached to INF --
1522 and the event port, which is the wait reply port, changes
1523 when you switch processes. */
1524 proc_waits_pending = 1;
1528 inf_clear_wait (inf);
1530 /* What can happen? (1) Dead name notification; (2) Exceptions arrive;
1531 (3) wait reply from the proc server. */
1533 inf_debug (inf, "waiting for an event...");
1534 err = mach_msg (&msg.hdr, MACH_RCV_MSG | MACH_RCV_INTERRUPT,
1535 0, sizeof (struct msg), inf->event_port,
1536 MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
1538 /* Re-suspend the task. */
1541 if (!inf->task && inf->pending_execs)
1542 /* When doing an exec, it's possible that the old task wasn't reused
1543 (e.g., setuid execs). So if the task seems to have disappeared,
1544 attempt to refetch it, as the pid should still be the same. */
1545 inf_set_pid (inf, inf->pid);
1547 if (err == EMACH_RCV_INTERRUPTED)
1548 inf_debug (inf, "interrupted");
1550 error (_("Couldn't wait for an event: %s"), safe_strerror (err));
1555 mach_msg_header_t hdr;
1556 mach_msg_type_t err_type;
1562 inf_debug (inf, "event: msgid = %d", msg.hdr.msgh_id);
1564 /* Handle what we got. */
1565 if (!notify_server (&msg.hdr, &reply.hdr)
1566 && !exc_server (&msg.hdr, &reply.hdr)
1567 && !process_reply_server (&msg.hdr, &reply.hdr)
1568 && !msg_reply_server (&msg.hdr, &reply.hdr))
1569 /* Whatever it is, it's something strange. */
1570 error (_("Got a strange event, msg id = %d."), msg.hdr.msgh_id);
1573 error (_("Handling event, msgid = %d: %s"),
1574 msg.hdr.msgh_id, safe_strerror (reply.err));
1577 if (inf->pending_execs)
1578 /* We're waiting for the inferior to finish execing. */
1580 struct inf_wait *w = &inf->wait;
1581 enum target_waitkind kind = w->status.kind;
1583 if (kind == TARGET_WAITKIND_SPURIOUS)
1584 /* Since gdb is actually counting the number of times the inferior
1585 stops, expecting one stop per exec, we only return major events
1589 inf_debug (inf, "pending_execs, ignoring minor event");
1591 else if (kind == TARGET_WAITKIND_STOPPED
1592 && w->status.value.sig == GDB_SIGNAL_TRAP)
1593 /* Ah hah! A SIGTRAP from the inferior while starting up probably
1594 means we've succesfully completed an exec! */
1596 inf_debug (inf, "one pending exec completed");
1598 else if (kind == TARGET_WAITKIND_STOPPED)
1599 /* It's possible that this signal is because of a crashed process
1600 being handled by the hurd crash server; in this case, the process
1601 will have an extra task suspend, which we need to know about.
1602 Since the code in inf_resume that normally checks for this is
1603 disabled while INF->pending_execs, we do the check here instead. */
1604 inf_validate_task_sc (inf);
1607 if (inf->wait.suppress)
1608 /* Some totally spurious event happened that we don't consider
1609 worth returning to gdb. Just keep waiting. */
1611 inf_debug (inf, "suppressing return, rewaiting...");
1616 /* Pass back out our results. */
1617 memcpy (status, &inf->wait.status, sizeof (*status));
1619 thread = inf->wait.thread;
1621 ptid = ptid_t (inf->pid, thread->tid, 0);
1622 else if (ptid == minus_one_ptid)
1623 thread = inf_tid_to_thread (inf, -1);
1625 thread = inf_tid_to_thread (inf, ptid.lwp ());
1627 if (!thread || thread->port == MACH_PORT_NULL)
1629 /* TID is dead; try and find a new thread. */
1630 if (inf_update_procs (inf) && inf->threads)
1631 ptid = ptid_t (inf->pid, inf->threads->tid, 0); /* The first
1635 ptid = inferior_ptid; /* let wait_for_inferior handle exit case */
1639 && ptid != minus_one_ptid
1640 && status->kind != TARGET_WAITKIND_SPURIOUS
1641 && inf->pause_sc == 0 && thread->pause_sc == 0)
1642 /* If something actually happened to THREAD, make sure we
1646 inf_update_suspends (inf);
1649 inf_debug (inf, "returning ptid = %s, status = %s (%d)",
1650 target_pid_to_str (ptid),
1651 status->kind == TARGET_WAITKIND_EXITED ? "EXITED"
1652 : status->kind == TARGET_WAITKIND_STOPPED ? "STOPPED"
1653 : status->kind == TARGET_WAITKIND_SIGNALLED ? "SIGNALLED"
1654 : status->kind == TARGET_WAITKIND_LOADED ? "LOADED"
1655 : status->kind == TARGET_WAITKIND_SPURIOUS ? "SPURIOUS"
1657 status->value.integer);
1663 /* The rpc handler called by exc_server. */
1665 S_exception_raise_request (mach_port_t port, mach_port_t reply_port,
1666 thread_t thread_port, task_t task_port,
1667 int exception, int code, int subcode)
1669 struct inf *inf = waiting_inf;
1670 struct proc *thread = inf_port_to_thread (inf, thread_port);
1672 inf_debug (waiting_inf,
1673 "thread = %lu, task = %lu, exc = %d, code = %d, subcode = %d",
1674 thread_port, task_port, exception, code, subcode);
1677 /* We don't know about thread? */
1679 inf_update_procs (inf);
1680 thread = inf_port_to_thread (inf, thread_port);
1682 /* Give up, the generating thread is gone. */
1686 mach_port_deallocate (mach_task_self (), thread_port);
1687 mach_port_deallocate (mach_task_self (), task_port);
1689 if (!thread->aborted)
1690 /* THREAD hasn't been aborted since this exception happened (abortion
1691 clears any exception state), so it must be real. */
1693 /* Store away the details; this will destroy any previous info. */
1694 inf->wait.thread = thread;
1696 inf->wait.status.kind = TARGET_WAITKIND_STOPPED;
1698 if (exception == EXC_BREAKPOINT)
1699 /* GDB likes to get SIGTRAP for breakpoints. */
1701 inf->wait.status.value.sig = GDB_SIGNAL_TRAP;
1702 mach_port_deallocate (mach_task_self (), reply_port);
1705 /* Record the exception so that we can forward it later. */
1707 if (thread->exc_port == port)
1709 inf_debug (waiting_inf, "Handler is thread exception port <%lu>",
1710 thread->saved_exc_port);
1711 inf->wait.exc.handler = thread->saved_exc_port;
1715 inf_debug (waiting_inf, "Handler is task exception port <%lu>",
1716 inf->task->saved_exc_port);
1717 inf->wait.exc.handler = inf->task->saved_exc_port;
1718 gdb_assert (inf->task->exc_port == port);
1720 if (inf->wait.exc.handler != MACH_PORT_NULL)
1721 /* Add a reference to the exception handler. */
1722 mach_port_mod_refs (mach_task_self (),
1723 inf->wait.exc.handler, MACH_PORT_RIGHT_SEND,
1726 inf->wait.exc.exception = exception;
1727 inf->wait.exc.code = code;
1728 inf->wait.exc.subcode = subcode;
1729 inf->wait.exc.reply = reply_port;
1731 /* Exceptions are encoded in the signal space by putting
1732 them after _NSIG; this assumes they're positive (and not
1733 extremely large)! */
1734 inf->wait.status.value.sig =
1735 gdb_signal_from_host (_NSIG + exception);
1739 /* A supppressed exception, which ignore. */
1741 inf->wait.suppress = 1;
1742 mach_port_deallocate (mach_task_self (), reply_port);
1749 /* Fill in INF's wait field after a task has died without giving us more
1750 detailed information. */
1752 inf_task_died_status (struct inf *inf)
1754 warning (_("Pid %d died with unknown exit status, using SIGKILL."),
1756 inf->wait.status.kind = TARGET_WAITKIND_SIGNALLED;
1757 inf->wait.status.value.sig = GDB_SIGNAL_KILL;
1760 /* Notify server routines. The only real one is dead name notification. */
1762 do_mach_notify_dead_name (mach_port_t notify, mach_port_t dead_port)
1764 struct inf *inf = waiting_inf;
1766 inf_debug (waiting_inf, "port = %lu", dead_port);
1768 if (inf->task && inf->task->port == dead_port)
1770 proc_debug (inf->task, "is dead");
1771 inf->task->port = MACH_PORT_NULL;
1772 if (proc_wait_pid == inf->pid)
1773 /* We have a wait outstanding on the process, which will return more
1774 detailed information, so delay until we get that. */
1775 inf->wait.suppress = 1;
1777 /* We never waited for the process (maybe it wasn't a child), so just
1778 pretend it got a SIGKILL. */
1779 inf_task_died_status (inf);
1783 struct proc *thread = inf_port_to_thread (inf, dead_port);
1787 proc_debug (thread, "is dead");
1788 thread->port = MACH_PORT_NULL;
1791 if (inf->task->dead)
1792 /* Since the task is dead, its threads are dying with it. */
1793 inf->wait.suppress = 1;
1796 mach_port_deallocate (mach_task_self (), dead_port);
1797 inf->threads_up_to_date = 0; /* Just in case. */
1803 #define ILL_RPC(fun, ...) \
1804 extern kern_return_t fun (__VA_ARGS__); \
1805 kern_return_t fun (__VA_ARGS__) \
1807 warning (_("illegal rpc: %s"), #fun); \
1811 ILL_RPC (do_mach_notify_no_senders,
1812 mach_port_t notify, mach_port_mscount_t count)
1813 ILL_RPC (do_mach_notify_port_deleted,
1814 mach_port_t notify, mach_port_t name)
1815 ILL_RPC (do_mach_notify_msg_accepted,
1816 mach_port_t notify, mach_port_t name)
1817 ILL_RPC (do_mach_notify_port_destroyed,
1818 mach_port_t notify, mach_port_t name)
1819 ILL_RPC (do_mach_notify_send_once,
1822 /* Process_reply server routines. We only use process_wait_reply. */
1825 S_proc_wait_reply (mach_port_t reply, kern_return_t err,
1826 int status, int sigcode, rusage_t rusage, pid_t pid)
1828 struct inf *inf = waiting_inf;
1830 inf_debug (inf, "err = %s, pid = %d, status = 0x%x, sigcode = %d",
1831 err ? safe_strerror (err) : "0", pid, status, sigcode);
1833 if (err && proc_wait_pid && (!inf->task || !inf->task->port))
1834 /* Ack. The task has died, but the task-died notification code didn't
1835 tell anyone because it thought a more detailed reply from the
1836 procserver was forthcoming. However, we now learn that won't
1837 happen... So we have to act like the task just died, and this time,
1839 inf_task_died_status (inf);
1841 if (--proc_waits_pending == 0)
1842 /* PROC_WAIT_PID represents the most recent wait. We will always get
1843 replies in order because the proc server is single threaded. */
1846 inf_debug (inf, "waits pending now: %d", proc_waits_pending);
1852 warning (_("Can't wait for pid %d: %s"),
1853 inf->pid, safe_strerror (err));
1856 /* Since we can't see the inferior's signals, don't trap them. */
1857 inf_set_traced (inf, 0);
1860 else if (pid == inf->pid)
1862 store_waitstatus (&inf->wait.status, status);
1863 if (inf->wait.status.kind == TARGET_WAITKIND_STOPPED)
1864 /* The process has sent us a signal, and stopped itself in a sane
1865 state pending our actions. */
1867 inf_debug (inf, "process has stopped itself");
1872 inf->wait.suppress = 1; /* Something odd happened. Ignore. */
1877 ILL_RPC (S_proc_setmsgport_reply,
1878 mach_port_t reply_port, kern_return_t return_code,
1879 mach_port_t oldmsgport)
1880 ILL_RPC (S_proc_getmsgport_reply,
1881 mach_port_t reply_port, kern_return_t return_code,
1882 mach_port_t msgports)
1883 ILL_RPC (S_proc_pid2task_reply,
1884 mach_port_t reply_port, kern_return_t return_code, mach_port_t task)
1885 ILL_RPC (S_proc_task2pid_reply,
1886 mach_port_t reply_port, kern_return_t return_code, pid_t pid)
1887 ILL_RPC (S_proc_task2proc_reply,
1888 mach_port_t reply_port, kern_return_t return_code, mach_port_t proc)
1889 ILL_RPC (S_proc_proc2task_reply,
1890 mach_port_t reply_port, kern_return_t return_code, mach_port_t task)
1891 ILL_RPC (S_proc_pid2proc_reply,
1892 mach_port_t reply_port, kern_return_t return_code, mach_port_t proc)
1893 ILL_RPC (S_proc_getprocinfo_reply,
1894 mach_port_t reply_port, kern_return_t return_code,
1895 int flags, procinfo_t procinfo, mach_msg_type_number_t procinfoCnt,
1896 data_t threadwaits, mach_msg_type_number_t threadwaitsCnt)
1897 ILL_RPC (S_proc_getprocargs_reply,
1898 mach_port_t reply_port, kern_return_t return_code,
1899 data_t procargs, mach_msg_type_number_t procargsCnt)
1900 ILL_RPC (S_proc_getprocenv_reply,
1901 mach_port_t reply_port, kern_return_t return_code,
1902 data_t procenv, mach_msg_type_number_t procenvCnt)
1903 ILL_RPC (S_proc_getloginid_reply,
1904 mach_port_t reply_port, kern_return_t return_code, pid_t login_id)
1905 ILL_RPC (S_proc_getloginpids_reply,
1906 mach_port_t reply_port, kern_return_t return_code,
1907 pidarray_t pids, mach_msg_type_number_t pidsCnt)
1908 ILL_RPC (S_proc_getlogin_reply,
1909 mach_port_t reply_port, kern_return_t return_code, string_t logname)
1910 ILL_RPC (S_proc_getsid_reply,
1911 mach_port_t reply_port, kern_return_t return_code, pid_t sid)
1912 ILL_RPC (S_proc_getsessionpgids_reply,
1913 mach_port_t reply_port, kern_return_t return_code,
1914 pidarray_t pgidset, mach_msg_type_number_t pgidsetCnt)
1915 ILL_RPC (S_proc_getsessionpids_reply,
1916 mach_port_t reply_port, kern_return_t return_code,
1917 pidarray_t pidset, mach_msg_type_number_t pidsetCnt)
1918 ILL_RPC (S_proc_getsidport_reply,
1919 mach_port_t reply_port, kern_return_t return_code,
1920 mach_port_t sessport)
1921 ILL_RPC (S_proc_getpgrp_reply,
1922 mach_port_t reply_port, kern_return_t return_code, pid_t pgrp)
1923 ILL_RPC (S_proc_getpgrppids_reply,
1924 mach_port_t reply_port, kern_return_t return_code,
1925 pidarray_t pidset, mach_msg_type_number_t pidsetCnt)
1926 ILL_RPC (S_proc_get_tty_reply,
1927 mach_port_t reply_port, kern_return_t return_code, mach_port_t tty)
1928 ILL_RPC (S_proc_getnports_reply,
1929 mach_port_t reply_port, kern_return_t return_code,
1930 mach_msg_type_number_t nports)
1931 ILL_RPC (S_proc_is_important_reply,
1932 mach_port_t reply_port, kern_return_t return_code,
1933 boolean_t essential)
1934 ILL_RPC (S_proc_get_code_reply,
1935 mach_port_t reply_port, kern_return_t return_code,
1936 vm_address_t start_code, vm_address_t end_code)
1938 /* Msg_reply server routines. We only use msg_sig_post_untraced_reply. */
1941 S_msg_sig_post_untraced_reply (mach_port_t reply, kern_return_t err)
1943 struct inf *inf = waiting_inf;
1946 /* EBUSY is what we get when the crash server has grabbed control of the
1947 process and doesn't like what signal we tried to send it. Just act
1948 like the process stopped (using a signal of 0 should mean that the
1949 *next* time the user continues, it will pass signal 0, which the crash
1950 server should like). */
1952 inf->wait.status.kind = TARGET_WAITKIND_STOPPED;
1953 inf->wait.status.value.sig = GDB_SIGNAL_0;
1956 warning (_("Signal delivery failed: %s"), safe_strerror (err));
1959 /* We only get this reply when we've posted a signal to a process which we
1960 thought was stopped, and which we expected to continue after the signal.
1961 Given that the signal has failed for some reason, it's reasonable to
1962 assume it's still stopped. */
1965 inf->wait.suppress = 1;
1970 ILL_RPC (S_msg_sig_post_reply,
1971 mach_port_t reply, kern_return_t err)
1973 /* Returns the number of messages queued for the receive right PORT. */
1974 static mach_port_msgcount_t
1975 port_msgs_queued (mach_port_t port)
1977 struct mach_port_status status;
1979 mach_port_get_receive_status (mach_task_self (), port, &status);
1984 return status.mps_msgcount;
1988 /* Resume execution of the inferior process.
1990 If STEP is nonzero, single-step it.
1991 If SIGNAL is nonzero, give it that signal.
1994 -1 true Single step the current thread allowing other threads to run.
1995 -1 false Continue the current thread allowing other threads to run.
1996 X true Single step the given thread, don't allow any others to run.
1997 X false Continue the given thread, do not allow any others to run.
1998 (Where X, of course, is anything except -1)
2000 Note that a resume may not `take' if there are pending exceptions/&c
2001 still unprocessed from the last resume we did (any given resume may result
2002 in multiple events returned by wait). */
2005 gnu_nat_target::resume (ptid_t ptid, int step, enum gdb_signal sig)
2007 struct proc *step_thread = 0;
2009 struct inf *inf = gnu_current_inf;
2011 inf_debug (inf, "ptid = %s, step = %d, sig = %d",
2012 target_pid_to_str (ptid), step, sig);
2014 inf_validate_procinfo (inf);
2016 if (sig != GDB_SIGNAL_0 || inf->stopped)
2018 if (sig == GDB_SIGNAL_0 && inf->nomsg)
2021 inf_signal (inf, sig);
2023 else if (inf->wait.exc.reply != MACH_PORT_NULL)
2024 /* We received an exception to which we have chosen not to forward, so
2025 abort the faulting thread, which will perhaps retake it. */
2027 proc_abort (inf->wait.thread, 1);
2028 warning (_("Aborting %s with unforwarded exception %s."),
2029 proc_string (inf->wait.thread),
2030 gdb_signal_to_name (inf->wait.status.value.sig));
2033 if (port_msgs_queued (inf->event_port))
2034 /* If there are still messages in our event queue, don't bother resuming
2035 the process, as we're just going to stop it right away anyway. */
2038 inf_update_procs (inf);
2040 /* A specific PTID means `step only this process id'. */
2041 resume_all = ptid == minus_one_ptid;
2044 /* Allow all threads to run, except perhaps single-stepping one. */
2046 inf_debug (inf, "running all threads; tid = %d",
2047 inferior_ptid.pid ());
2048 ptid = inferior_ptid; /* What to step. */
2049 inf_set_threads_resume_sc (inf, 0, 1);
2052 /* Just allow a single thread to run. */
2054 struct proc *thread = inf_tid_to_thread (inf, ptid.lwp ());
2057 error (_("Can't run single thread id %s: no such thread!"),
2058 target_pid_to_str (ptid));
2059 inf_debug (inf, "running one thread: %s", target_pid_to_str (ptid));
2060 inf_set_threads_resume_sc (inf, thread, 0);
2065 step_thread = inf_tid_to_thread (inf, ptid.lwp ());
2067 warning (_("Can't step thread id %s: no such thread."),
2068 target_pid_to_str (ptid));
2070 inf_debug (inf, "stepping thread: %s", target_pid_to_str (ptid));
2072 if (step_thread != inf->step_thread)
2073 inf_set_step_thread (inf, step_thread);
2075 inf_debug (inf, "here we go...");
2081 gnu_nat_target::kill ()
2083 struct proc *task = gnu_current_inf->task;
2087 proc_debug (task, "terminating...");
2088 task_terminate (task->port);
2089 inf_set_pid (gnu_current_inf, -1);
2091 target_mourn_inferior (inferior_ptid);
2094 /* Clean up after the inferior dies. */
2096 gnu_nat_target::mourn_inferior ()
2098 inf_debug (gnu_current_inf, "rip");
2099 inf_detach (gnu_current_inf);
2100 inf_child_target::mourn_inferior ();
2104 /* Fork an inferior process, and start debugging it. */
2106 /* Set INFERIOR_PID to the first thread available in the child, if any. */
2108 inf_pick_first_thread (void)
2110 if (gnu_current_inf->task && gnu_current_inf->threads)
2111 /* The first thread. */
2112 return gnu_current_inf->threads->tid;
2114 /* What may be the next thread. */
2115 return next_thread_id;
2121 if (!gnu_current_inf)
2122 gnu_current_inf = make_inf ();
2123 return gnu_current_inf;
2127 gnu_ptrace_me (void)
2129 /* We're in the child; make this process stop as soon as it execs. */
2130 struct inf *inf = cur_inf ();
2131 inf_debug (inf, "tracing self");
2132 if (ptrace (PTRACE_TRACEME) != 0)
2133 trace_start_error_with_name ("ptrace");
2137 gnu_nat_target::create_inferior (const char *exec_file,
2138 const std::string &allargs,
2142 struct inf *inf = cur_inf ();
2145 inf_debug (inf, "creating inferior");
2147 pid = fork_inferior (exec_file, allargs, env, gnu_ptrace_me,
2148 NULL, NULL, NULL, NULL);
2150 /* We have something that executes now. We'll be running through
2151 the shell at this point (if startup-with-shell is true), but the
2152 pid shouldn't change. */
2153 add_thread_silent (ptid_t (pid));
2155 /* Attach to the now stopped child, which is actually a shell... */
2156 inf_debug (inf, "attaching to child: %d", pid);
2158 inf_attach (inf, pid);
2162 inf->pending_execs = 1;
2166 /* Now let the child run again, knowing that it will stop
2167 immediately because of the ptrace. */
2170 /* We now have thread info. */
2171 thread_change_ptid (inferior_ptid,
2172 ptid_t (inf->pid, inf_pick_first_thread (), 0));
2174 gdb_startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED);
2176 inf->pending_execs = 0;
2177 /* Get rid of the old shell threads. */
2180 inf_validate_procinfo (inf);
2181 inf_update_signal_thread (inf);
2182 inf_set_traced (inf, inf->want_signals);
2184 /* Execing the process will have trashed our exception ports; steal them
2185 back (or make sure they're restored if the user wants that). */
2186 if (inf->want_exceptions)
2187 inf_steal_exc_ports (inf);
2189 inf_restore_exc_ports (inf);
2193 /* Attach to process PID, then initialize for debugging it
2194 and wait for the trace-trap that results from attaching. */
2196 gnu_nat_target::attach (const char *args, int from_tty)
2200 struct inf *inf = cur_inf ();
2201 struct inferior *inferior;
2203 pid = parse_pid_to_attach (args);
2205 if (pid == getpid ()) /* Trying to masturbate? */
2206 error (_("I refuse to debug myself!"));
2210 exec_file = (char *) get_exec_file (0);
2213 printf_unfiltered ("Attaching to program `%s', pid %d\n",
2216 printf_unfiltered ("Attaching to pid %d\n", pid);
2218 gdb_flush (gdb_stdout);
2221 inf_debug (inf, "attaching to pid: %d", pid);
2223 inf_attach (inf, pid);
2227 inferior = current_inferior ();
2228 inferior_appeared (inferior, pid);
2229 inferior->attach_flag = 1;
2231 inf_update_procs (inf);
2233 inferior_ptid = ptid_t (pid, inf_pick_first_thread (), 0);
2235 /* We have to initialize the terminal settings now, since the code
2236 below might try to restore them. */
2237 target_terminal::init ();
2239 /* If the process was stopped before we attached, make it continue the next
2240 time the user does a continue. */
2241 inf_validate_procinfo (inf);
2243 inf_update_signal_thread (inf);
2244 inf_set_traced (inf, inf->want_signals);
2246 #if 0 /* Do we need this? */
2247 renumber_threads (0); /* Give our threads reasonable names. */
2252 /* Take a program previously attached to and detaches it.
2253 The program resumes execution and will no longer stop
2254 on signals, etc. We'd better not have left any breakpoints
2255 in the program or it'll die when it hits one. For this
2256 to work, it may be necessary for the process to have been
2257 previously attached. It *might* work if the program was
2258 started via fork. */
2260 gnu_nat_target::detach (inferior *inf, int from_tty)
2266 char *exec_file = get_exec_file (0);
2269 printf_unfiltered ("Detaching from program `%s' pid %d\n",
2270 exec_file, gnu_current_inf->pid);
2272 printf_unfiltered ("Detaching from pid %d\n", gnu_current_inf->pid);
2273 gdb_flush (gdb_stdout);
2276 pid = gnu_current_inf->pid;
2278 inf_detach (gnu_current_inf);
2280 inferior_ptid = null_ptid;
2281 detach_inferior (pid);
2283 maybe_unpush_target ();
2288 gnu_nat_target::stop (ptid_t ptid)
2290 error (_("stop target function not implemented"));
2294 gnu_nat_target::thread_alive (ptid_t ptid)
2296 inf_update_procs (gnu_current_inf);
2297 return !!inf_tid_to_thread (gnu_current_inf,
2302 /* Read inferior task's LEN bytes from ADDR and copy it to MYADDR in
2303 gdb's address space. Return 0 on failure; number of bytes read
2306 gnu_read_inferior (task_t task, CORE_ADDR addr, gdb_byte *myaddr, int length)
2309 vm_address_t low_address = (vm_address_t) trunc_page (addr);
2310 vm_size_t aligned_length =
2311 (vm_size_t) round_page (addr + length) - low_address;
2313 mach_msg_type_number_t copy_count;
2315 /* Get memory from inferior with page aligned addresses. */
2316 err = vm_read (task, low_address, aligned_length, &copied, ©_count);
2320 err = hurd_safe_copyin (myaddr, (void *) (addr - low_address + copied),
2324 warning (_("Read from inferior faulted: %s"), safe_strerror (err));
2328 err = vm_deallocate (mach_task_self (), copied, copy_count);
2330 warning (_("gnu_read_inferior vm_deallocate failed: %s"),
2331 safe_strerror (err));
2336 #define CHK_GOTO_OUT(str,ret) \
2337 do if (ret != KERN_SUCCESS) { errstr = #str; goto out; } while(0)
2339 struct vm_region_list
2341 struct vm_region_list *next;
2342 vm_prot_t protection;
2347 struct obstack region_obstack;
2349 /* Write gdb's LEN bytes from MYADDR and copy it to ADDR in inferior
2350 task's address space. */
2352 gnu_write_inferior (task_t task, CORE_ADDR addr,
2353 const gdb_byte *myaddr, int length)
2356 vm_address_t low_address = (vm_address_t) trunc_page (addr);
2357 vm_size_t aligned_length =
2358 (vm_size_t) round_page (addr + length) - low_address;
2360 mach_msg_type_number_t copy_count;
2363 char *errstr = "Bug in gnu_write_inferior";
2365 struct vm_region_list *region_element;
2366 struct vm_region_list *region_head = NULL;
2368 /* Get memory from inferior with page aligned addresses. */
2369 err = vm_read (task,
2374 CHK_GOTO_OUT ("gnu_write_inferior vm_read failed", err);
2378 err = hurd_safe_copyout ((void *) (addr - low_address + copied),
2380 CHK_GOTO_OUT ("Write to inferior faulted", err);
2382 obstack_init (®ion_obstack);
2384 /* Do writes atomically.
2385 First check for holes and unwritable memory. */
2387 vm_size_t remaining_length = aligned_length;
2388 vm_address_t region_address = low_address;
2390 struct vm_region_list *scan;
2392 while (region_address < low_address + aligned_length)
2394 vm_prot_t protection;
2395 vm_prot_t max_protection;
2396 vm_inherit_t inheritance;
2398 mach_port_t object_name;
2400 vm_size_t region_length = remaining_length;
2401 vm_address_t old_address = region_address;
2403 err = vm_region (task,
2412 CHK_GOTO_OUT ("vm_region failed", err);
2414 /* Check for holes in memory. */
2415 if (old_address != region_address)
2417 warning (_("No memory at 0x%lx. Nothing written"),
2424 if (!(max_protection & VM_PROT_WRITE))
2426 warning (_("Memory at address 0x%lx is unwritable. "
2434 /* Chain the regions for later use. */
2435 region_element = XOBNEW (®ion_obstack, struct vm_region_list);
2437 region_element->protection = protection;
2438 region_element->start = region_address;
2439 region_element->length = region_length;
2441 /* Chain the regions along with protections. */
2442 region_element->next = region_head;
2443 region_head = region_element;
2445 region_address += region_length;
2446 remaining_length = remaining_length - region_length;
2449 /* If things fail after this, we give up.
2450 Somebody is messing up inferior_task's mappings. */
2452 /* Enable writes to the chained vm regions. */
2453 for (scan = region_head; scan; scan = scan->next)
2455 if (!(scan->protection & VM_PROT_WRITE))
2457 err = vm_protect (task,
2461 scan->protection | VM_PROT_WRITE);
2462 CHK_GOTO_OUT ("vm_protect: enable write failed", err);
2466 err = vm_write (task,
2470 CHK_GOTO_OUT ("vm_write failed", err);
2472 /* Set up the original region protections, if they were changed. */
2473 for (scan = region_head; scan; scan = scan->next)
2475 if (!(scan->protection & VM_PROT_WRITE))
2477 err = vm_protect (task,
2482 CHK_GOTO_OUT ("vm_protect: enable write failed", err);
2490 obstack_free (®ion_obstack, 0);
2492 (void) vm_deallocate (mach_task_self (),
2497 if (err != KERN_SUCCESS)
2499 warning (_("%s: %s"), errstr, mach_error_string (err));
2508 /* Implement the to_xfer_partial target_ops method for
2509 TARGET_OBJECT_MEMORY. */
2511 static enum target_xfer_status
2512 gnu_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
2513 CORE_ADDR memaddr, ULONGEST len, ULONGEST *xfered_len)
2515 task_t task = (gnu_current_inf
2516 ? (gnu_current_inf->task
2517 ? gnu_current_inf->task->port : 0)
2521 if (task == MACH_PORT_NULL)
2522 return TARGET_XFER_E_IO;
2524 if (writebuf != NULL)
2526 inf_debug (gnu_current_inf, "writing %s[%s] <-- %s",
2527 paddress (target_gdbarch (), memaddr), pulongest (len),
2528 host_address_to_string (writebuf));
2529 res = gnu_write_inferior (task, memaddr, writebuf, len);
2533 inf_debug (gnu_current_inf, "reading %s[%s] --> %s",
2534 paddress (target_gdbarch (), memaddr), pulongest (len),
2535 host_address_to_string (readbuf));
2536 res = gnu_read_inferior (task, memaddr, readbuf, len);
2538 gdb_assert (res >= 0);
2540 return TARGET_XFER_E_IO;
2543 *xfered_len = (ULONGEST) res;
2544 return TARGET_XFER_OK;
2548 /* GNU does not have auxv, but we can at least fake the AT_ENTRY entry for PIE
2550 static enum target_xfer_status
2551 gnu_xfer_auxv (gdb_byte *readbuf, const gdb_byte *writebuf,
2552 CORE_ADDR memaddr, ULONGEST len, ULONGEST *xfered_len)
2554 task_t task = (gnu_current_inf
2555 ? (gnu_current_inf->task
2556 ? gnu_current_inf->task->port : 0)
2562 ElfW(auxv_t) auxv[2];
2564 if (task == MACH_PORT_NULL)
2565 return TARGET_XFER_E_IO;
2566 if (writebuf != NULL)
2567 return TARGET_XFER_E_IO;
2569 if (memaddr == sizeof (auxv))
2570 return TARGET_XFER_EOF;
2571 if (memaddr > sizeof (auxv))
2572 return TARGET_XFER_E_IO;
2574 err = proc_task2proc (proc_server, task, &proc);
2576 return TARGET_XFER_E_IO;
2578 /* Get entry from proc server. */
2579 err = proc_get_entry (proc, &entry);
2581 return TARGET_XFER_E_IO;
2583 /* Fake auxv entry. */
2584 auxv[0].a_type = AT_ENTRY;
2585 auxv[0].a_un.a_val = entry;
2586 auxv[1].a_type = AT_NULL;
2587 auxv[1].a_un.a_val = 0;
2589 inf_debug (gnu_current_inf, "reading auxv %s[%s] --> %s",
2590 paddress (target_gdbarch (), memaddr), pulongest (len),
2591 host_address_to_string (readbuf));
2593 if (memaddr + len > sizeof (auxv))
2594 len = sizeof (auxv) - memaddr;
2596 memcpy (readbuf, (gdb_byte *) &auxv + memaddr, len);
2599 return TARGET_XFER_OK;
2602 /* Target to_xfer_partial implementation. */
2604 enum target_xfer_status
2605 gnu_nat_target::xfer_partial (enum target_object object,
2606 const char *annex, gdb_byte *readbuf,
2607 const gdb_byte *writebuf, ULONGEST offset,
2608 ULONGEST len, ULONGEST *xfered_len)
2612 case TARGET_OBJECT_MEMORY:
2613 return gnu_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
2614 case TARGET_OBJECT_AUXV:
2615 return gnu_xfer_auxv (readbuf, writebuf, offset, len, xfered_len);
2617 return TARGET_XFER_E_IO;
2621 /* Call FUNC on each memory region in the task. */
2624 gnu_nat_target::find_memory_regions (find_memory_region_ftype func,
2629 vm_address_t region_address, last_region_address, last_region_end;
2630 vm_prot_t last_protection;
2632 if (gnu_current_inf == 0 || gnu_current_inf->task == 0)
2634 task = gnu_current_inf->task->port;
2635 if (task == MACH_PORT_NULL)
2638 region_address = last_region_address = last_region_end = VM_MIN_ADDRESS;
2639 last_protection = VM_PROT_NONE;
2640 while (region_address < VM_MAX_ADDRESS)
2642 vm_prot_t protection;
2643 vm_prot_t max_protection;
2644 vm_inherit_t inheritance;
2646 mach_port_t object_name;
2648 vm_size_t region_length = VM_MAX_ADDRESS - region_address;
2649 vm_address_t old_address = region_address;
2651 err = vm_region (task,
2660 if (err == KERN_NO_SPACE)
2662 if (err != KERN_SUCCESS)
2664 warning (_("vm_region failed: %s"), mach_error_string (err));
2668 if (protection == last_protection && region_address == last_region_end)
2669 /* This region is contiguous with and indistinguishable from
2670 the previous one, so we just extend that one. */
2671 last_region_end = region_address += region_length;
2674 /* This region is distinct from the last one we saw, so report
2675 that previous one. */
2676 if (last_protection != VM_PROT_NONE)
2677 (*func) (last_region_address,
2678 last_region_end - last_region_address,
2679 last_protection & VM_PROT_READ,
2680 last_protection & VM_PROT_WRITE,
2681 last_protection & VM_PROT_EXECUTE,
2682 1, /* MODIFIED is unknown, pass it as true. */
2684 last_region_address = region_address;
2685 last_region_end = region_address += region_length;
2686 last_protection = protection;
2690 /* Report the final region. */
2691 if (last_region_end > last_region_address && last_protection != VM_PROT_NONE)
2692 (*func) (last_region_address, last_region_end - last_region_address,
2693 last_protection & VM_PROT_READ,
2694 last_protection & VM_PROT_WRITE,
2695 last_protection & VM_PROT_EXECUTE,
2696 1, /* MODIFIED is unknown, pass it as true. */
2703 /* Return printable description of proc. */
2705 proc_string (struct proc *proc)
2707 static char tid_str[80];
2709 if (proc_is_task (proc))
2710 xsnprintf (tid_str, sizeof (tid_str), "process %d", proc->inf->pid);
2712 xsnprintf (tid_str, sizeof (tid_str), "Thread %d.%d",
2713 proc->inf->pid, proc->tid);
2718 gnu_nat_target::pid_to_str (ptid_t ptid)
2720 struct inf *inf = gnu_current_inf;
2721 int tid = ptid.lwp ();
2722 struct proc *thread = inf_tid_to_thread (inf, tid);
2725 return proc_string (thread);
2728 static char tid_str[80];
2730 xsnprintf (tid_str, sizeof (tid_str), "bogus thread id %d", tid);
2736 /* User task commands. */
2738 static struct cmd_list_element *set_task_cmd_list = 0;
2739 static struct cmd_list_element *show_task_cmd_list = 0;
2740 /* User thread commands. */
2742 /* Commands with a prefix of `set/show thread'. */
2743 extern struct cmd_list_element *thread_cmd_list;
2744 struct cmd_list_element *set_thread_cmd_list = NULL;
2745 struct cmd_list_element *show_thread_cmd_list = NULL;
2747 /* Commands with a prefix of `set/show thread default'. */
2748 struct cmd_list_element *set_thread_default_cmd_list = NULL;
2749 struct cmd_list_element *show_thread_default_cmd_list = NULL;
2752 set_thread_cmd (const char *args, int from_tty)
2754 printf_unfiltered ("\"set thread\" must be followed by the "
2755 "name of a thread property, or \"default\".\n");
2759 show_thread_cmd (const char *args, int from_tty)
2761 printf_unfiltered ("\"show thread\" must be followed by the "
2762 "name of a thread property, or \"default\".\n");
2766 set_thread_default_cmd (const char *args, int from_tty)
2768 printf_unfiltered ("\"set thread default\" must be followed "
2769 "by the name of a thread property.\n");
2773 show_thread_default_cmd (const char *args, int from_tty)
2775 printf_unfiltered ("\"show thread default\" must be followed "
2776 "by the name of a thread property.\n");
2780 parse_int_arg (const char *args, char *cmd_prefix)
2785 int val = strtoul (args, &arg_end, 10);
2787 if (*args && *arg_end == '\0')
2790 error (_("Illegal argument for \"%s\" command, should be an integer."),
2795 _parse_bool_arg (const char *args, char *t_val, char *f_val, char *cmd_prefix)
2797 if (!args || strcmp (args, t_val) == 0)
2799 else if (strcmp (args, f_val) == 0)
2802 error (_("Illegal argument for \"%s\" command, "
2803 "should be \"%s\" or \"%s\"."),
2804 cmd_prefix, t_val, f_val);
2807 #define parse_bool_arg(args, cmd_prefix) \
2808 _parse_bool_arg (args, "on", "off", cmd_prefix)
2811 check_empty (const char *args, char *cmd_prefix)
2814 error (_("Garbage after \"%s\" command: `%s'"), cmd_prefix, args);
2817 /* Returns the alive thread named by INFERIOR_PID, or signals an error. */
2818 static struct proc *
2821 struct inf *inf = cur_inf ();
2822 struct proc *thread = inf_tid_to_thread (inf,
2823 inferior_ptid.lwp ());
2825 error (_("No current thread."));
2829 /* Returns the current inferior, but signals an error if it has no task. */
2833 struct inf *inf = cur_inf ();
2836 error (_("No current process."));
2842 set_task_pause_cmd (int arg, int from_tty)
2844 struct inf *inf = cur_inf ();
2845 int old_sc = inf->pause_sc;
2847 inf->pause_sc = arg;
2849 if (old_sc == 0 && inf->pause_sc != 0)
2850 /* If the task is currently unsuspended, immediately suspend it,
2851 otherwise wait until the next time it gets control. */
2856 set_task_pause_cmd (const char *args, int from_tty)
2858 set_task_pause_cmd (parse_bool_arg (args, "set task pause"), from_tty);
2862 show_task_pause_cmd (const char *args, int from_tty)
2864 struct inf *inf = cur_inf ();
2866 check_empty (args, "show task pause");
2867 printf_unfiltered ("The inferior task %s suspended while gdb has control.\n",
2869 ? (inf->pause_sc == 0 ? "isn't" : "is")
2870 : (inf->pause_sc == 0 ? "won't be" : "will be"));
2874 set_task_detach_sc_cmd (const char *args, int from_tty)
2876 cur_inf ()->detach_sc = parse_int_arg (args,
2877 "set task detach-suspend-count");
2881 show_task_detach_sc_cmd (const char *args, int from_tty)
2883 check_empty (args, "show task detach-suspend-count");
2884 printf_unfiltered ("The inferior task will be left with a "
2885 "suspend count of %d when detaching.\n",
2886 cur_inf ()->detach_sc);
2891 set_thread_default_pause_cmd (const char *args, int from_tty)
2893 struct inf *inf = cur_inf ();
2895 inf->default_thread_pause_sc =
2896 parse_bool_arg (args, "set thread default pause") ? 0 : 1;
2900 show_thread_default_pause_cmd (const char *args, int from_tty)
2902 struct inf *inf = cur_inf ();
2903 int sc = inf->default_thread_pause_sc;
2905 check_empty (args, "show thread default pause");
2906 printf_unfiltered ("New threads %s suspended while gdb has control%s.\n",
2907 sc ? "are" : "aren't",
2908 !sc && inf->pause_sc ? " (but the task is)" : "");
2912 set_thread_default_run_cmd (const char *args, int from_tty)
2914 struct inf *inf = cur_inf ();
2916 inf->default_thread_run_sc =
2917 parse_bool_arg (args, "set thread default run") ? 0 : 1;
2921 show_thread_default_run_cmd (const char *args, int from_tty)
2923 struct inf *inf = cur_inf ();
2925 check_empty (args, "show thread default run");
2926 printf_unfiltered ("New threads %s allowed to run.\n",
2927 inf->default_thread_run_sc == 0 ? "are" : "aren't");
2931 set_thread_default_detach_sc_cmd (const char *args, int from_tty)
2933 cur_inf ()->default_thread_detach_sc =
2934 parse_int_arg (args, "set thread default detach-suspend-count");
2938 show_thread_default_detach_sc_cmd (const char *args, int from_tty)
2940 check_empty (args, "show thread default detach-suspend-count");
2941 printf_unfiltered ("New threads will get a detach-suspend-count of %d.\n",
2942 cur_inf ()->default_thread_detach_sc);
2946 /* Steal a send right called NAME in the inferior task, and make it PROC's
2947 saved exception port. */
2949 steal_exc_port (struct proc *proc, mach_port_t name)
2953 mach_msg_type_name_t port_type;
2955 if (!proc || !proc->inf->task)
2956 error (_("No inferior task."));
2958 err = mach_port_extract_right (proc->inf->task->port,
2959 name, MACH_MSG_TYPE_COPY_SEND,
2962 error (_("Couldn't extract send right %lu from inferior: %s"),
2963 name, safe_strerror (err));
2965 if (proc->saved_exc_port)
2966 /* Get rid of our reference to the old one. */
2967 mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
2969 proc->saved_exc_port = port;
2971 if (!proc->exc_port)
2972 /* If PROC is a thread, we may not have set its exception port
2973 before. We can't use proc_steal_exc_port because it also sets
2976 proc->exc_port = proc->inf->event_port;
2977 err = proc_set_exception_port (proc, proc->exc_port);
2978 error (_("Can't set exception port for %s: %s"),
2979 proc_string (proc), safe_strerror (err));
2984 set_task_exc_port_cmd (const char *args, int from_tty)
2986 struct inf *inf = cur_inf ();
2989 error (_("No argument to \"set task exception-port\" command."));
2990 steal_exc_port (inf->task, parse_and_eval_address (args));
2994 set_stopped_cmd (const char *args, int from_tty)
2996 cur_inf ()->stopped = _parse_bool_arg (args, "yes", "no", "set stopped");
3000 show_stopped_cmd (const char *args, int from_tty)
3002 struct inf *inf = active_inf ();
3004 check_empty (args, "show stopped");
3005 printf_unfiltered ("The inferior process %s stopped.\n",
3006 inf->stopped ? "is" : "isn't");
3010 set_sig_thread_cmd (const char *args, int from_tty)
3012 struct inf *inf = cur_inf ();
3014 if (!args || (!isdigit (*args) && strcmp (args, "none") != 0))
3015 error (_("Illegal argument to \"set signal-thread\" command.\n"
3016 "Should be a thread ID, or \"none\"."));
3018 if (strcmp (args, "none") == 0)
3019 inf->signal_thread = 0;
3022 struct thread_info *tp = parse_thread_id (args, NULL);
3023 inf->signal_thread = inf_tid_to_thread (inf, tp->ptid.lwp ());
3028 show_sig_thread_cmd (const char *args, int from_tty)
3030 struct inf *inf = active_inf ();
3032 check_empty (args, "show signal-thread");
3033 if (inf->signal_thread)
3034 printf_unfiltered ("The signal thread is %s.\n",
3035 proc_string (inf->signal_thread));
3037 printf_unfiltered ("There is no signal thread.\n");
3042 set_signals_cmd (int arg, int from_tty)
3044 struct inf *inf = cur_inf ();
3046 inf->want_signals = arg;
3048 if (inf->task && inf->want_signals != inf->traced)
3049 /* Make this take effect immediately in a running process. */
3050 inf_set_traced (inf, inf->want_signals);
3054 set_signals_cmd (const char *args, int from_tty)
3056 set_signals_cmd(parse_bool_arg (args, "set signals"), from_tty);
3060 show_signals_cmd (const char *args, int from_tty)
3062 struct inf *inf = cur_inf ();
3064 check_empty (args, "show signals");
3065 printf_unfiltered ("The inferior process's signals %s intercepted.\n",
3067 ? (inf->traced ? "are" : "aren't")
3068 : (inf->want_signals ? "will be" : "won't be"));
3072 set_exceptions_cmd (int arg, int from_tty)
3074 struct inf *inf = cur_inf ();
3076 /* Make this take effect immediately in a running process. */
3079 inf->want_exceptions = arg;
3083 set_exceptions_cmd (const char *args, int from_tty)
3085 set_exceptions_cmd (parse_bool_arg (args, "set exceptions"), from_tty);
3089 show_exceptions_cmd (const char *args, int from_tty)
3091 struct inf *inf = cur_inf ();
3093 check_empty (args, "show exceptions");
3094 printf_unfiltered ("Exceptions in the inferior %s trapped.\n",
3096 ? (inf->want_exceptions ? "are" : "aren't")
3097 : (inf->want_exceptions ? "will be" : "won't be"));
3102 set_task_cmd (const char *args, int from_tty)
3104 printf_unfiltered ("\"set task\" must be followed by the name"
3105 " of a task property.\n");
3109 show_task_cmd (const char *args, int from_tty)
3111 struct inf *inf = cur_inf ();
3113 check_empty (args, "show task");
3115 show_signals_cmd (0, from_tty);
3116 show_exceptions_cmd (0, from_tty);
3117 show_task_pause_cmd (0, from_tty);
3119 if (inf->pause_sc == 0)
3120 show_thread_default_pause_cmd (0, from_tty);
3121 show_thread_default_run_cmd (0, from_tty);
3125 show_stopped_cmd (0, from_tty);
3126 show_sig_thread_cmd (0, from_tty);
3129 if (inf->detach_sc != 0)
3130 show_task_detach_sc_cmd (0, from_tty);
3131 if (inf->default_thread_detach_sc != 0)
3132 show_thread_default_detach_sc_cmd (0, from_tty);
3137 set_noninvasive_cmd (const char *args, int from_tty)
3139 /* Invert the sense of the arg for each component. */
3140 int inv_arg = parse_bool_arg (args, "set noninvasive") ? 0 : 1;
3142 set_task_pause_cmd (inv_arg, from_tty);
3143 set_signals_cmd (inv_arg, from_tty);
3144 set_exceptions_cmd (inv_arg, from_tty);
3149 info_port_rights (const char *args, mach_port_type_t only)
3151 struct inf *inf = active_inf ();
3152 struct value *vmark = value_mark ();
3155 /* Explicit list of port rights. */
3159 struct value *val = parse_to_comma_and_eval (&args);
3160 long right = value_as_long (val);
3162 print_port_info (right, 0, inf->task->port, PORTINFO_DETAILS,
3166 error (_("%ld: %s."), right, safe_strerror (err));
3170 /* Print all of them. */
3173 print_task_ports_info (inf->task->port, only, PORTINFO_DETAILS,
3176 error (_("%s."), safe_strerror (err));
3179 value_free_to_mark (vmark);
3183 info_send_rights_cmd (const char *args, int from_tty)
3185 info_port_rights (args, MACH_PORT_TYPE_SEND);
3189 info_recv_rights_cmd (const char *args, int from_tty)
3191 info_port_rights (args, MACH_PORT_TYPE_RECEIVE);
3195 info_port_sets_cmd (const char *args, int from_tty)
3197 info_port_rights (args, MACH_PORT_TYPE_PORT_SET);
3201 info_dead_names_cmd (const char *args, int from_tty)
3203 info_port_rights (args, MACH_PORT_TYPE_DEAD_NAME);
3207 info_port_rights_cmd (const char *args, int from_tty)
3209 info_port_rights (args, ~0);
3214 add_task_commands (void)
3216 add_cmd ("pause", class_run, set_thread_default_pause_cmd, _("\
3217 Set whether the new threads are suspended while gdb has control.\n\
3218 This property normally has no effect because the whole task is\n\
3219 suspended, however, that may be disabled with \"set task pause off\".\n\
3220 The default value is \"off\"."),
3221 &set_thread_default_cmd_list);
3222 add_cmd ("pause", no_class, show_thread_default_pause_cmd, _("\
3223 Show whether new threads are suspended while gdb has control."),
3224 &show_thread_default_cmd_list);
3226 add_cmd ("run", class_run, set_thread_default_run_cmd, _("\
3227 Set whether new threads are allowed to run (once gdb has noticed them)."),
3228 &set_thread_default_cmd_list);
3229 add_cmd ("run", no_class, show_thread_default_run_cmd, _("\
3230 Show whether new threads are allowed to run (once gdb has noticed them)."),
3231 &show_thread_default_cmd_list);
3233 add_cmd ("detach-suspend-count", class_run, set_thread_default_detach_sc_cmd,
3234 _("Set the default detach-suspend-count value for new threads."),
3235 &set_thread_default_cmd_list);
3236 add_cmd ("detach-suspend-count", no_class, show_thread_default_detach_sc_cmd,
3237 _("Show the default detach-suspend-count value for new threads."),
3238 &show_thread_default_cmd_list);
3240 add_cmd ("signals", class_run, set_signals_cmd, _("\
3241 Set whether the inferior process's signals will be intercepted.\n\
3242 Mach exceptions (such as breakpoint traps) are not affected."),
3244 add_alias_cmd ("sigs", "signals", class_run, 1, &setlist);
3245 add_cmd ("signals", no_class, show_signals_cmd, _("\
3246 Show whether the inferior process's signals will be intercepted."),
3248 add_alias_cmd ("sigs", "signals", no_class, 1, &showlist);
3250 add_cmd ("signal-thread", class_run, set_sig_thread_cmd, _("\
3251 Set the thread that gdb thinks is the libc signal thread.\n\
3252 This thread is run when delivering a signal to a non-stopped process."),
3254 add_alias_cmd ("sigthread", "signal-thread", class_run, 1, &setlist);
3255 add_cmd ("signal-thread", no_class, show_sig_thread_cmd, _("\
3256 Set the thread that gdb thinks is the libc signal thread."),
3258 add_alias_cmd ("sigthread", "signal-thread", no_class, 1, &showlist);
3260 add_cmd ("stopped", class_run, set_stopped_cmd, _("\
3261 Set whether gdb thinks the inferior process is stopped as with SIGSTOP.\n\
3262 Stopped process will be continued by sending them a signal."),
3264 add_cmd ("stopped", no_class, show_stopped_cmd, _("\
3265 Show whether gdb thinks the inferior process is stopped as with SIGSTOP."),
3268 add_cmd ("exceptions", class_run, set_exceptions_cmd, _("\
3269 Set whether exceptions in the inferior process will be trapped.\n\
3270 When exceptions are turned off, neither breakpoints nor single-stepping\n\
3273 /* Allow `set exc' despite conflict with `set exception-port'. */
3274 add_alias_cmd ("exc", "exceptions", class_run, 1, &setlist);
3275 add_cmd ("exceptions", no_class, show_exceptions_cmd, _("\
3276 Show whether exceptions in the inferior process will be trapped."),
3279 add_prefix_cmd ("task", no_class, set_task_cmd,
3280 _("Command prefix for setting task attributes."),
3281 &set_task_cmd_list, "set task ", 0, &setlist);
3282 add_prefix_cmd ("task", no_class, show_task_cmd,
3283 _("Command prefix for showing task attributes."),
3284 &show_task_cmd_list, "show task ", 0, &showlist);
3286 add_cmd ("pause", class_run, set_task_pause_cmd, _("\
3287 Set whether the task is suspended while gdb has control.\n\
3288 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3289 until the next time the program is continued.\n\
3290 When setting this to \"off\", \"set thread default pause on\" can be\n\
3291 used to pause individual threads by default instead."),
3292 &set_task_cmd_list);
3293 add_cmd ("pause", no_class, show_task_pause_cmd,
3294 _("Show whether the task is suspended while gdb has control."),
3295 &show_task_cmd_list);
3297 add_cmd ("detach-suspend-count", class_run, set_task_detach_sc_cmd,
3298 _("Set the suspend count will leave on the thread when detaching."),
3299 &set_task_cmd_list);
3300 add_cmd ("detach-suspend-count", no_class, show_task_detach_sc_cmd,
3301 _("Show the suspend count will leave "
3302 "on the thread when detaching."),
3303 &show_task_cmd_list);
3305 add_cmd ("exception-port", no_class, set_task_exc_port_cmd, _("\
3306 Set the task exception port to which we forward exceptions.\n\
3307 The argument should be the value of the send right in the task."),
3308 &set_task_cmd_list);
3309 add_alias_cmd ("excp", "exception-port", no_class, 1, &set_task_cmd_list);
3310 add_alias_cmd ("exc-port", "exception-port", no_class, 1,
3311 &set_task_cmd_list);
3313 /* A convenient way of turning on all options require to noninvasively
3314 debug running tasks. */
3315 add_cmd ("noninvasive", no_class, set_noninvasive_cmd, _("\
3316 Set task options so that we interfere as little as possible.\n\
3317 This is the same as setting `task pause', `exceptions', and\n\
3318 `signals' to the opposite value."),
3321 /* Commands to show information about the task's ports. */
3322 add_info ("send-rights", info_send_rights_cmd,
3323 _("Show information about the task's send rights"));
3324 add_info ("receive-rights", info_recv_rights_cmd,
3325 _("Show information about the task's receive rights"));
3326 add_info ("port-rights", info_port_rights_cmd,
3327 _("Show information about the task's port rights"));
3328 add_info ("port-sets", info_port_sets_cmd,
3329 _("Show information about the task's port sets"));
3330 add_info ("dead-names", info_dead_names_cmd,
3331 _("Show information about the task's dead names"));
3332 add_info_alias ("ports", "port-rights", 1);
3333 add_info_alias ("port", "port-rights", 1);
3334 add_info_alias ("psets", "port-sets", 1);
3339 set_thread_pause_cmd (const char *args, int from_tty)
3341 struct proc *thread = cur_thread ();
3342 int old_sc = thread->pause_sc;
3344 thread->pause_sc = parse_bool_arg (args, "set thread pause");
3345 if (old_sc == 0 && thread->pause_sc != 0 && thread->inf->pause_sc == 0)
3346 /* If the task is currently unsuspended, immediately suspend it,
3347 otherwise wait until the next time it gets control. */
3348 inf_suspend (thread->inf);
3352 show_thread_pause_cmd (const char *args, int from_tty)
3354 struct proc *thread = cur_thread ();
3355 int sc = thread->pause_sc;
3357 check_empty (args, "show task pause");
3358 printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n",
3359 proc_string (thread),
3360 sc ? "is" : "isn't",
3361 !sc && thread->inf->pause_sc ? " (but the task is)" : "");
3365 set_thread_run_cmd (const char *args, int from_tty)
3367 struct proc *thread = cur_thread ();
3369 thread->run_sc = parse_bool_arg (args, "set thread run") ? 0 : 1;
3373 show_thread_run_cmd (const char *args, int from_tty)
3375 struct proc *thread = cur_thread ();
3377 check_empty (args, "show thread run");
3378 printf_unfiltered ("Thread %s %s allowed to run.",
3379 proc_string (thread),
3380 thread->run_sc == 0 ? "is" : "isn't");
3384 set_thread_detach_sc_cmd (const char *args, int from_tty)
3386 cur_thread ()->detach_sc = parse_int_arg (args,
3387 "set thread detach-suspend-count");
3391 show_thread_detach_sc_cmd (const char *args, int from_tty)
3393 struct proc *thread = cur_thread ();
3395 check_empty (args, "show thread detach-suspend-count");
3396 printf_unfiltered ("Thread %s will be left with a suspend count"
3397 " of %d when detaching.\n",
3398 proc_string (thread),
3403 set_thread_exc_port_cmd (const char *args, int from_tty)
3405 struct proc *thread = cur_thread ();
3408 error (_("No argument to \"set thread exception-port\" command."));
3409 steal_exc_port (thread, parse_and_eval_address (args));
3414 show_thread_cmd (char *args, int from_tty)
3416 struct proc *thread = cur_thread ();
3418 check_empty (args, "show thread");
3419 show_thread_run_cmd (0, from_tty);
3420 show_thread_pause_cmd (0, from_tty);
3421 if (thread->detach_sc != 0)
3422 show_thread_detach_sc_cmd (0, from_tty);
3427 thread_takeover_sc_cmd (const char *args, int from_tty)
3429 struct proc *thread = cur_thread ();
3431 thread_basic_info_data_t _info;
3432 thread_basic_info_t info = &_info;
3433 mach_msg_type_number_t info_len = THREAD_BASIC_INFO_COUNT;
3435 = mach_thread_info (thread->port, THREAD_BASIC_INFO,
3436 (int *) &info, &info_len);
3438 error (("%s."), safe_strerror (err));
3439 thread->sc = info->suspend_count;
3441 printf_unfiltered ("Suspend count was %d.\n", thread->sc);
3443 vm_deallocate (mach_task_self (), (vm_address_t) info,
3444 info_len * sizeof (int));
3449 add_thread_commands (void)
3451 add_prefix_cmd ("thread", no_class, set_thread_cmd,
3452 _("Command prefix for setting thread properties."),
3453 &set_thread_cmd_list, "set thread ", 0, &setlist);
3454 add_prefix_cmd ("default", no_class, show_thread_cmd,
3455 _("Command prefix for setting default thread properties."),
3456 &set_thread_default_cmd_list, "set thread default ", 0,
3457 &set_thread_cmd_list);
3458 add_prefix_cmd ("thread", no_class, set_thread_default_cmd,
3459 _("Command prefix for showing thread properties."),
3460 &show_thread_cmd_list, "show thread ", 0, &showlist);
3461 add_prefix_cmd ("default", no_class, show_thread_default_cmd,
3462 _("Command prefix for showing default thread properties."),
3463 &show_thread_default_cmd_list, "show thread default ", 0,
3464 &show_thread_cmd_list);
3466 add_cmd ("pause", class_run, set_thread_pause_cmd, _("\
3467 Set whether the current thread is suspended while gdb has control.\n\
3468 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3469 until the next time the program is continued. This property normally\n\
3470 has no effect because the whole task is suspended, however, that may\n\
3471 be disabled with \"set task pause off\".\n\
3472 The default value is \"off\"."),
3473 &set_thread_cmd_list);
3474 add_cmd ("pause", no_class, show_thread_pause_cmd, _("\
3475 Show whether the current thread is suspended while gdb has control."),
3476 &show_thread_cmd_list);
3478 add_cmd ("run", class_run, set_thread_run_cmd,
3479 _("Set whether the current thread is allowed to run."),
3480 &set_thread_cmd_list);
3481 add_cmd ("run", no_class, show_thread_run_cmd,
3482 _("Show whether the current thread is allowed to run."),
3483 &show_thread_cmd_list);
3485 add_cmd ("detach-suspend-count", class_run, set_thread_detach_sc_cmd, _("\
3486 Set the suspend count will leave on the thread when detaching.\n\
3487 Note that this is relative to suspend count when gdb noticed the thread;\n\
3488 use the `thread takeover-suspend-count' to force it to an absolute value."),
3489 &set_thread_cmd_list);
3490 add_cmd ("detach-suspend-count", no_class, show_thread_detach_sc_cmd, _("\
3491 Show the suspend count will leave on the thread when detaching.\n\
3492 Note that this is relative to suspend count when gdb noticed the thread;\n\
3493 use the `thread takeover-suspend-count' to force it to an absolute value."),
3494 &show_thread_cmd_list);
3496 add_cmd ("exception-port", no_class, set_thread_exc_port_cmd, _("\
3497 Set the thread exception port to which we forward exceptions.\n\
3498 This overrides the task exception port.\n\
3499 The argument should be the value of the send right in the task."),
3500 &set_thread_cmd_list);
3501 add_alias_cmd ("excp", "exception-port", no_class, 1, &set_thread_cmd_list);
3502 add_alias_cmd ("exc-port", "exception-port", no_class, 1,
3503 &set_thread_cmd_list);
3505 add_cmd ("takeover-suspend-count", no_class, thread_takeover_sc_cmd, _("\
3506 Force the threads absolute suspend-count to be gdb's.\n\
3507 Prior to giving this command, gdb's thread suspend-counts are relative\n\
3508 to the thread's initial suspend-count when gdb notices the threads."),
3513 _initialize_gnu_nat (void)
3515 proc_server = getproc ();
3517 add_task_commands ();
3518 add_thread_commands ();
3519 add_setshow_boolean_cmd ("gnu-nat", class_maintenance,
3521 _("Set debugging output for the gnu backend."),
3522 _("Show debugging output for the gnu backend."),
3530 #ifdef FLUSH_INFERIOR_CACHE
3532 /* When over-writing code on some machines the I-Cache must be flushed
3533 explicitly, because it is not kept coherent by the lazy hardware.
3534 This definitely includes breakpoints, for instance, or else we
3535 end up looping in mysterious Bpt traps. */
3538 flush_inferior_icache (CORE_ADDR pc, int amount)
3540 vm_machine_attribute_val_t flush = MATTR_VAL_ICACHE_FLUSH;
3543 ret = vm_machine_attribute (gnu_current_inf->task->port,
3548 if (ret != KERN_SUCCESS)
3549 warning (_("Error flushing inferior's cache : %s"), safe_strerror (ret));
3551 #endif /* FLUSH_INFERIOR_CACHE */