1 /* Interface GDB to the GNU Hurd.
2 Copyright (C) 1992-2013 Free Software Foundation, Inc.
4 This file is part of GDB.
6 Written by Miles Bader <miles@gnu.ai.mit.edu>
8 Some code and ideas from m3-nat.c by Jukka Virtanen <jtv@hut.fi>
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
31 #include "gdb_string.h"
32 #include <sys/ptrace.h>
35 #include <mach_error.h>
36 #include <mach/exception.h>
37 #include <mach/message.h>
38 #include <mach/notify.h>
39 #include <mach/vm_attributes.h>
42 #include <hurd/interrupt.h>
44 #include <hurd/msg_request.h>
45 #include <hurd/process.h>
46 /* Defined in <hurd/process.h>, but we need forward declarations from
47 <hurd/process_request.h> as well. */
49 #include <hurd/process_request.h>
50 #include <hurd/signal.h>
51 #include <hurd/sigpreempt.h>
63 #include "gdbthread.h"
64 #include "gdb_assert.h"
65 #include "gdb_obstack.h"
68 #include "inf-child.h"
70 #include "exc_request_S.h"
72 #include "process_reply_S.h"
73 #include "msg_reply_S.h"
74 #include "exc_request_U.h"
77 static process_t proc_server = MACH_PORT_NULL;
79 /* If we've sent a proc_wait_request to the proc server, the pid of the
80 process we asked about. We can only ever have one outstanding. */
81 int proc_wait_pid = 0;
83 /* The number of wait requests we've sent, and expect replies from. */
84 int proc_waits_pending = 0;
86 int gnu_debug_flag = 0;
90 struct inf *make_inf ();
91 void inf_clear_wait (struct inf *inf);
92 void inf_cleanup (struct inf *inf);
93 void inf_startup (struct inf *inf, int pid);
94 int inf_update_suspends (struct inf *inf);
95 void inf_set_pid (struct inf *inf, pid_t pid);
96 void inf_validate_procs (struct inf *inf);
97 void inf_steal_exc_ports (struct inf *inf);
98 void inf_restore_exc_ports (struct inf *inf);
99 struct proc *inf_tid_to_proc (struct inf *inf, int tid);
100 void inf_set_threads_resume_sc (struct inf *inf,
101 struct proc *run_thread,
103 int inf_set_threads_resume_sc_for_signal_thread (struct inf *inf);
104 void inf_suspend (struct inf *inf);
105 void inf_resume (struct inf *inf);
106 void inf_set_step_thread (struct inf *inf, struct proc *proc);
107 void inf_detach (struct inf *inf);
108 void inf_attach (struct inf *inf, int pid);
109 void inf_signal (struct inf *inf, enum gdb_signal sig);
110 void inf_continue (struct inf *inf);
112 #define inf_debug(_inf, msg, args...) \
113 do { struct inf *__inf = (_inf); \
114 debug ("{inf %d %s}: " msg, __inf->pid, \
115 host_address_to_string (__inf) , ##args); } while (0)
117 void proc_abort (struct proc *proc, int force);
118 struct proc *make_proc (struct inf *inf, mach_port_t port, int tid);
119 struct proc *_proc_free (struct proc *proc);
120 int proc_update_sc (struct proc *proc);
121 error_t proc_get_exception_port (struct proc *proc, mach_port_t * port);
122 error_t proc_set_exception_port (struct proc *proc, mach_port_t port);
123 static mach_port_t _proc_get_exc_port (struct proc *proc);
124 void proc_steal_exc_port (struct proc *proc, mach_port_t exc_port);
125 void proc_restore_exc_port (struct proc *proc);
126 int proc_trace (struct proc *proc, int set);
128 /* Evaluate RPC_EXPR in a scope with the variables MSGPORT and REFPORT bound
129 to INF's msg port and task port respectively. If it has no msg port,
130 EIEIO is returned. INF must refer to a running process! */
131 #define INF_MSGPORT_RPC(inf, rpc_expr) \
132 HURD_MSGPORT_RPC (proc_getmsgport (proc_server, inf->pid, &msgport), \
133 (refport = inf->task->port, 0), 0, \
134 msgport ? (rpc_expr) : EIEIO)
136 /* Like INF_MSGPORT_RPC, but will also resume the signal thread to ensure
137 there's someone around to deal with the RPC (and resuspend things
138 afterwards). This effects INF's threads' resume_sc count. */
139 #define INF_RESUME_MSGPORT_RPC(inf, rpc_expr) \
140 (inf_set_threads_resume_sc_for_signal_thread (inf) \
143 __e = INF_MSGPORT_RPC (inf, rpc_expr); \
149 /* The state passed by an exception message. */
152 int exception; /* The exception code. */
154 mach_port_t handler; /* The real exception port to handle this. */
155 mach_port_t reply; /* The reply port from the exception call. */
158 /* The results of the last wait an inf did. */
161 struct target_waitstatus status; /* The status returned to gdb. */
162 struct exc_state exc; /* The exception that caused us to return. */
163 struct proc *thread; /* The thread in question. */
164 int suppress; /* Something trivial happened. */
167 /* The state of an inferior. */
170 /* Fields describing the current inferior. */
172 struct proc *task; /* The mach task. */
173 struct proc *threads; /* A linked list of all threads in TASK. */
175 /* True if THREADS needn't be validated by querying the task. We
176 assume that we and the task in question are the only ones
177 frobbing the thread list, so as long as we don't let any code
178 run, we don't have to worry about THREADS changing. */
179 int threads_up_to_date;
181 pid_t pid; /* The real system PID. */
183 struct inf_wait wait; /* What to return from target_wait. */
185 /* One thread proc in INF may be in `single-stepping mode'. This
187 struct proc *step_thread;
189 /* The thread we think is the signal thread. */
190 struct proc *signal_thread;
192 mach_port_t event_port; /* Where we receive various msgs. */
194 /* True if we think at least one thread in the inferior could currently be
196 unsigned int running:1;
198 /* True if the process has stopped (in the proc server sense). Note that
199 since a proc server `stop' leaves the signal thread running, the inf can
200 be RUNNING && STOPPED... */
201 unsigned int stopped:1;
203 /* True if the inferior has no message port. */
204 unsigned int nomsg:1;
206 /* True if the inferior is traced. */
207 unsigned int traced:1;
209 /* True if we shouldn't try waiting for the inferior, usually because we
210 can't for some reason. */
211 unsigned int no_wait:1;
213 /* When starting a new inferior, we don't try to validate threads until all
214 the proper execs have been done. This is a count of how many execs we
216 unsigned pending_execs;
218 /* Fields describing global state. */
220 /* The task suspend count used when gdb has control. This is normally 1 to
221 make things easier for us, but sometimes (like when attaching to vital
222 system servers) it may be desirable to let the task continue to run
223 (pausing individual threads as necessary). */
226 /* The task suspend count left when detaching from a task. */
229 /* The initial values used for the run_sc and pause_sc of newly discovered
230 threads -- see the definition of those fields in struct proc. */
231 int default_thread_run_sc;
232 int default_thread_pause_sc;
233 int default_thread_detach_sc;
235 /* True if the process should be traced when started/attached. Newly
236 started processes *must* be traced at first to exec them properly, but
237 if this is false, tracing is turned off as soon it has done so. */
240 /* True if exceptions from the inferior process should be trapped. This
241 must be on to use breakpoints. */
247 __proc_pid (struct proc *proc)
249 return proc->inf->pid;
253 /* Update PROC's real suspend count to match it's desired one. Returns true
254 if we think PROC is now in a runnable state. */
256 proc_update_sc (struct proc *proc)
260 int delta = proc->sc - proc->cur_sc;
263 proc_debug (proc, "sc: %d --> %d", proc->cur_sc, proc->sc);
265 if (proc->sc == 0 && proc->state_changed)
266 /* Since PROC may start running, we must write back any state changes. */
268 gdb_assert (proc_is_thread (proc));
269 proc_debug (proc, "storing back changed thread state");
270 err = thread_set_state (proc->port, THREAD_STATE_FLAVOR,
271 (thread_state_t) &proc->state, THREAD_STATE_SIZE);
273 proc->state_changed = 0;
278 while (delta-- > 0 && !err)
280 if (proc_is_task (proc))
281 err = task_suspend (proc->port);
283 err = thread_suspend (proc->port);
288 while (delta++ < 0 && !err)
290 if (proc_is_task (proc))
291 err = task_resume (proc->port);
293 err = thread_resume (proc->port);
297 proc->cur_sc = proc->sc;
299 /* If we got an error, then the task/thread has disappeared. */
300 running = !err && proc->sc == 0;
302 proc_debug (proc, "is %s", err ? "dead" : running ? "running" : "suspended");
304 proc_debug (proc, "err = %s", safe_strerror (err));
309 proc->state_valid = proc->state_changed = 0;
310 proc->fetched_regs = 0;
317 /* Thread_abort is called on PROC if needed. PROC must be a thread proc.
318 If PROC is deemed `precious', then nothing is done unless FORCE is true.
319 In particular, a thread is precious if it's running (in which case forcing
320 it includes suspending it first), or if it has an exception pending. */
322 proc_abort (struct proc *proc, int force)
324 gdb_assert (proc_is_thread (proc));
328 struct inf *inf = proc->inf;
329 int running = (proc->cur_sc == 0 && inf->task->cur_sc == 0);
331 if (running && force)
334 inf_update_suspends (proc->inf);
336 warning (_("Stopped %s."), proc_string (proc));
338 else if (proc == inf->wait.thread && inf->wait.exc.reply && !force)
339 /* An exception is pending on PROC, which don't mess with. */
343 /* We only abort the thread if it's not actually running. */
345 thread_abort (proc->port);
346 proc_debug (proc, "aborted");
350 proc_debug (proc, "not aborting");
354 /* Make sure that the state field in PROC is up to date, and return a pointer
355 to it, or 0 if something is wrong. If WILL_MODIFY is true, makes sure
356 that the thread is stopped and aborted first, and sets the state_changed
357 field in PROC to true. */
359 proc_get_state (struct proc *proc, int will_modify)
361 int was_aborted = proc->aborted;
363 proc_debug (proc, "updating state info%s",
364 will_modify ? " (with intention to modify)" : "");
366 proc_abort (proc, will_modify);
368 if (!was_aborted && proc->aborted)
369 /* PROC's state may have changed since we last fetched it. */
370 proc->state_valid = 0;
372 if (!proc->state_valid)
374 mach_msg_type_number_t state_size = THREAD_STATE_SIZE;
376 thread_get_state (proc->port, THREAD_STATE_FLAVOR,
377 (thread_state_t) &proc->state, &state_size);
379 proc_debug (proc, "getting thread state");
380 proc->state_valid = !err;
383 if (proc->state_valid)
386 proc->state_changed = 1;
387 return (thread_state_t) &proc->state;
394 /* Set PORT to PROC's exception port. */
396 proc_get_exception_port (struct proc * proc, mach_port_t * port)
398 if (proc_is_task (proc))
399 return task_get_exception_port (proc->port, port);
401 return thread_get_exception_port (proc->port, port);
404 /* Set PROC's exception port to PORT. */
406 proc_set_exception_port (struct proc * proc, mach_port_t port)
408 proc_debug (proc, "setting exception port: %d", port);
409 if (proc_is_task (proc))
410 return task_set_exception_port (proc->port, port);
412 return thread_set_exception_port (proc->port, port);
415 /* Get PROC's exception port, cleaning up a bit if proc has died. */
417 _proc_get_exc_port (struct proc *proc)
419 mach_port_t exc_port;
420 error_t err = proc_get_exception_port (proc, &exc_port);
423 /* PROC must be dead. */
426 mach_port_deallocate (mach_task_self (), proc->exc_port);
427 proc->exc_port = MACH_PORT_NULL;
428 if (proc->saved_exc_port)
429 mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
430 proc->saved_exc_port = MACH_PORT_NULL;
436 /* Replace PROC's exception port with EXC_PORT, unless it's already
437 been done. Stash away any existing exception port so we can
440 proc_steal_exc_port (struct proc *proc, mach_port_t exc_port)
442 mach_port_t cur_exc_port = _proc_get_exc_port (proc);
448 proc_debug (proc, "inserting exception port: %d", exc_port);
450 if (cur_exc_port != exc_port)
451 /* Put in our exception port. */
452 err = proc_set_exception_port (proc, exc_port);
454 if (err || cur_exc_port == proc->exc_port)
455 /* We previously set the exception port, and it's still set. So we
456 just keep the old saved port which is what the proc set. */
459 mach_port_deallocate (mach_task_self (), cur_exc_port);
462 /* Keep a copy of PROC's old exception port so it can be restored. */
464 if (proc->saved_exc_port)
465 mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
466 proc->saved_exc_port = cur_exc_port;
469 proc_debug (proc, "saved exception port: %d", proc->saved_exc_port);
472 proc->exc_port = exc_port;
474 warning (_("Error setting exception port for %s: %s"),
475 proc_string (proc), safe_strerror (err));
479 /* If we previously replaced PROC's exception port, put back what we
480 found there at the time, unless *our* exception port has since been
481 overwritten, in which case who knows what's going on. */
483 proc_restore_exc_port (struct proc *proc)
485 mach_port_t cur_exc_port = _proc_get_exc_port (proc);
491 proc_debug (proc, "restoring real exception port");
493 if (proc->exc_port == cur_exc_port)
494 /* Our's is still there. */
495 err = proc_set_exception_port (proc, proc->saved_exc_port);
497 if (proc->saved_exc_port)
498 mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
499 proc->saved_exc_port = MACH_PORT_NULL;
502 proc->exc_port = MACH_PORT_NULL;
504 warning (_("Error setting exception port for %s: %s"),
505 proc_string (proc), safe_strerror (err));
510 /* Turns hardware tracing in PROC on or off when SET is true or false,
511 respectively. Returns true on success. */
513 proc_trace (struct proc *proc, int set)
515 thread_state_t state = proc_get_state (proc, 1);
518 return 0; /* The thread must be dead. */
520 proc_debug (proc, "tracing %s", set ? "on" : "off");
524 /* XXX We don't get the exception unless the thread has its own
525 exception port???? */
526 if (proc->exc_port == MACH_PORT_NULL)
527 proc_steal_exc_port (proc, proc->inf->event_port);
528 THREAD_STATE_SET_TRACED (state);
531 THREAD_STATE_CLEAR_TRACED (state);
537 /* A variable from which to assign new TIDs. */
538 static int next_thread_id = 1;
540 /* Returns a new proc structure with the given fields. Also adds a
541 notification for PORT becoming dead to be sent to INF's notify port. */
543 make_proc (struct inf *inf, mach_port_t port, int tid)
546 mach_port_t prev_port = MACH_PORT_NULL;
547 struct proc *proc = xmalloc (sizeof (struct proc));
553 proc->saved_exc_port = MACH_PORT_NULL;
554 proc->exc_port = MACH_PORT_NULL;
559 /* Note that these are all the values for threads; the task simply uses the
560 corresponding field in INF directly. */
561 proc->run_sc = inf->default_thread_run_sc;
562 proc->pause_sc = inf->default_thread_pause_sc;
563 proc->detach_sc = inf->default_thread_detach_sc;
564 proc->resume_sc = proc->run_sc;
568 proc->state_valid = 0;
569 proc->state_changed = 0;
571 proc_debug (proc, "is new");
573 /* Get notified when things die. */
575 mach_port_request_notification (mach_task_self (), port,
576 MACH_NOTIFY_DEAD_NAME, 1,
578 MACH_MSG_TYPE_MAKE_SEND_ONCE,
581 warning (_("Couldn't request notification for port %d: %s"),
582 port, safe_strerror (err));
585 proc_debug (proc, "notifications to: %d", inf->event_port);
586 if (prev_port != MACH_PORT_NULL)
587 mach_port_deallocate (mach_task_self (), prev_port);
590 if (inf->want_exceptions)
592 if (proc_is_task (proc))
593 /* Make the task exception port point to us. */
594 proc_steal_exc_port (proc, inf->event_port);
596 /* Just clear thread exception ports -- they default to the
598 proc_steal_exc_port (proc, MACH_PORT_NULL);
604 /* Frees PROC and any resources it uses, and returns the value of PROC's
607 _proc_free (struct proc *proc)
609 struct inf *inf = proc->inf;
610 struct proc *next = proc->next;
612 proc_debug (proc, "freeing...");
614 if (proc == inf->step_thread)
615 /* Turn off single stepping. */
616 inf_set_step_thread (inf, 0);
617 if (proc == inf->wait.thread)
618 inf_clear_wait (inf);
619 if (proc == inf->signal_thread)
620 inf->signal_thread = 0;
622 if (proc->port != MACH_PORT_NULL)
624 if (proc->exc_port != MACH_PORT_NULL)
625 /* Restore the original exception port. */
626 proc_restore_exc_port (proc);
627 if (proc->cur_sc != 0)
628 /* Resume the thread/task. */
631 proc_update_sc (proc);
633 mach_port_deallocate (mach_task_self (), proc->port);
644 struct inf *inf = xmalloc (sizeof (struct inf));
648 inf->threads_up_to_date = 0;
650 inf->wait.status.kind = TARGET_WAITKIND_SPURIOUS;
651 inf->wait.thread = 0;
652 inf->wait.exc.handler = MACH_PORT_NULL;
653 inf->wait.exc.reply = MACH_PORT_NULL;
654 inf->step_thread = 0;
655 inf->signal_thread = 0;
656 inf->event_port = MACH_PORT_NULL;
662 inf->pending_execs = 0;
665 inf->default_thread_run_sc = 0;
666 inf->default_thread_pause_sc = 0;
667 inf->default_thread_detach_sc = 0;
668 inf->want_signals = 1; /* By default */
669 inf->want_exceptions = 1; /* By default */
674 /* Clear INF's target wait status. */
676 inf_clear_wait (struct inf *inf)
678 inf_debug (inf, "clearing wait");
679 inf->wait.status.kind = TARGET_WAITKIND_SPURIOUS;
680 inf->wait.thread = 0;
681 inf->wait.suppress = 0;
682 if (inf->wait.exc.handler != MACH_PORT_NULL)
684 mach_port_deallocate (mach_task_self (), inf->wait.exc.handler);
685 inf->wait.exc.handler = MACH_PORT_NULL;
687 if (inf->wait.exc.reply != MACH_PORT_NULL)
689 mach_port_deallocate (mach_task_self (), inf->wait.exc.reply);
690 inf->wait.exc.reply = MACH_PORT_NULL;
696 inf_cleanup (struct inf *inf)
698 inf_debug (inf, "cleanup");
700 inf_clear_wait (inf);
702 inf_set_pid (inf, -1);
709 inf->pending_execs = 0;
713 mach_port_destroy (mach_task_self (), inf->event_port);
714 inf->event_port = MACH_PORT_NULL;
719 inf_startup (struct inf *inf, int pid)
723 inf_debug (inf, "startup: pid = %d", pid);
727 /* Make the port on which we receive all events. */
728 err = mach_port_allocate (mach_task_self (),
729 MACH_PORT_RIGHT_RECEIVE, &inf->event_port);
731 error (_("Error allocating event port: %s"), safe_strerror (err));
733 /* Make a send right for it, so we can easily copy it for other people. */
734 mach_port_insert_right (mach_task_self (), inf->event_port,
735 inf->event_port, MACH_MSG_TYPE_MAKE_SEND);
736 inf_set_pid (inf, pid);
740 /* Close current process, if any, and attach INF to process PORT. */
742 inf_set_pid (struct inf *inf, pid_t pid)
745 struct proc *task = inf->task;
747 inf_debug (inf, "setting pid: %d", pid);
750 task_port = MACH_PORT_NULL;
753 error_t err = proc_pid2task (proc_server, pid, &task_port);
756 error (_("Error getting task for pid %d: %s"),
757 pid, safe_strerror (err));
760 inf_debug (inf, "setting task: %d", task_port);
763 task_suspend (task_port);
765 if (task && task->port != task_port)
768 inf_validate_procs (inf); /* Trash all the threads. */
769 _proc_free (task); /* And the task. */
772 if (task_port != MACH_PORT_NULL)
774 inf->task = make_proc (inf, task_port, PROC_TID_TASK);
775 inf->threads_up_to_date = 0;
782 /* Reflect task_suspend above. */
783 inf->task->sc = inf->task->cur_sc = 1;
790 /* Validates INF's stopped, nomsg and traced field from the actual
791 proc server state. Note that the traced field is only updated from
792 the proc server state if we do not have a message port. If we do
793 have a message port we'd better look at the tracemask itself. */
795 inf_validate_procinfo (struct inf *inf)
798 mach_msg_type_number_t noise_len = 0;
800 mach_msg_type_number_t pi_len = 0;
803 proc_getprocinfo (proc_server, inf->pid, &info_flags,
804 (procinfo_t *) &pi, &pi_len, &noise, &noise_len);
808 inf->stopped = !!(pi->state & PI_STOPPED);
809 inf->nomsg = !!(pi->state & PI_NOMSG);
811 inf->traced = !!(pi->state & PI_TRACED);
812 vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len);
814 vm_deallocate (mach_task_self (), (vm_address_t) noise, noise_len);
818 /* Validates INF's task suspend count. If it's higher than we expect,
819 verify with the user before `stealing' the extra count. */
821 inf_validate_task_sc (struct inf *inf)
824 mach_msg_type_number_t noise_len = 0;
826 mach_msg_type_number_t pi_len = 0;
827 int info_flags = PI_FETCH_TASKINFO;
828 int suspend_count = -1;
832 err = proc_getprocinfo (proc_server, inf->pid, &info_flags,
833 (procinfo_t *) &pi, &pi_len, &noise, &noise_len);
836 inf->task->dead = 1; /* oh well */
840 if (inf->task->cur_sc < pi->taskinfo.suspend_count && suspend_count == -1)
842 /* The proc server might have suspended the task while stopping
843 it. This happens when the task is handling a traced signal.
844 Refetch the suspend count. The proc server should be
845 finished stopping the task by now. */
846 suspend_count = pi->taskinfo.suspend_count;
850 suspend_count = pi->taskinfo.suspend_count;
852 vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len);
854 vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len);
856 if (inf->task->cur_sc < suspend_count)
860 target_terminal_ours (); /* Allow I/O. */
861 abort = !query (_("Pid %d has an additional task suspend count of %d;"
862 " clear it? "), inf->pid,
863 suspend_count - inf->task->cur_sc);
864 target_terminal_inferior (); /* Give it back to the child. */
867 error (_("Additional task suspend count left untouched."));
869 inf->task->cur_sc = suspend_count;
873 /* Turns tracing for INF on or off, depending on ON, unless it already
874 is. If INF is running, the resume_sc count of INF's threads will
875 be modified, and the signal thread will briefly be run to change
878 inf_set_traced (struct inf *inf, int on)
880 if (on == inf->traced)
883 if (inf->task && !inf->task->dead)
884 /* Make it take effect immediately. */
886 sigset_t mask = on ? ~(sigset_t) 0 : 0;
888 INF_RESUME_MSGPORT_RPC (inf, msg_set_init_int (msgport, refport,
889 INIT_TRACEMASK, mask));
894 warning (_("Can't modify tracing state for pid %d: %s"),
895 inf->pid, "No signal thread");
899 warning (_("Can't modify tracing state for pid %d: %s"),
900 inf->pid, safe_strerror (err));
909 /* Makes all the real suspend count deltas of all the procs in INF
910 match the desired values. Careful to always do thread/task suspend
911 counts in the safe order. Returns true if at least one thread is
912 thought to be running. */
914 inf_update_suspends (struct inf *inf)
916 struct proc *task = inf->task;
918 /* We don't have to update INF->threads even though we're iterating over it
919 because we'll change a thread only if it already has an existing proc
921 inf_debug (inf, "updating suspend counts");
926 int task_running = (task->sc == 0), thread_running = 0;
928 if (task->sc > task->cur_sc)
929 /* The task is becoming _more_ suspended; do before any threads. */
930 task_running = proc_update_sc (task);
932 if (inf->pending_execs)
933 /* When we're waiting for an exec, things may be happening behind our
934 back, so be conservative. */
937 /* Do all the thread suspend counts. */
938 for (thread = inf->threads; thread; thread = thread->next)
939 thread_running |= proc_update_sc (thread);
941 if (task->sc != task->cur_sc)
942 /* We didn't do the task first, because we wanted to wait for the
943 threads; do it now. */
944 task_running = proc_update_sc (task);
946 inf_debug (inf, "%srunning...",
947 (thread_running && task_running) ? "" : "not ");
949 inf->running = thread_running && task_running;
951 /* Once any thread has executed some code, we can't depend on the
952 threads list any more. */
954 inf->threads_up_to_date = 0;
963 /* Converts a GDB pid to a struct proc. */
965 inf_tid_to_thread (struct inf *inf, int tid)
967 struct proc *thread = inf->threads;
970 if (thread->tid == tid)
973 thread = thread->next;
977 /* Converts a thread port to a struct proc. */
979 inf_port_to_thread (struct inf *inf, mach_port_t port)
981 struct proc *thread = inf->threads;
984 if (thread->port == port)
987 thread = thread->next;
992 /* Make INF's list of threads be consistent with reality of TASK. */
994 inf_validate_procs (struct inf *inf)
996 thread_array_t threads;
997 mach_msg_type_number_t num_threads, i;
998 struct proc *task = inf->task;
1000 /* If no threads are currently running, this function will guarantee that
1001 things are up to date. The exception is if there are zero threads --
1002 then it is almost certainly in an odd state, and probably some outside
1003 agent will create threads. */
1004 inf->threads_up_to_date = inf->threads ? !inf->running : 0;
1008 error_t err = task_threads (task->port, &threads, &num_threads);
1010 inf_debug (inf, "fetching threads");
1012 /* TASK must be dead. */
1022 inf_debug (inf, "no task");
1026 /* Make things normally linear. */
1027 mach_msg_type_number_t search_start = 0;
1028 /* Which thread in PROCS corresponds to each task thread, & the task. */
1029 struct proc *matched[num_threads + 1];
1030 /* The last thread in INF->threads, so we can add to the end. */
1031 struct proc *last = 0;
1032 /* The current thread we're considering. */
1033 struct proc *thread = inf->threads;
1035 memset (matched, 0, sizeof (matched));
1039 mach_msg_type_number_t left;
1041 for (i = search_start, left = num_threads; left; i++, left--)
1043 if (i >= num_threads)
1044 i -= num_threads; /* I wrapped around. */
1045 if (thread->port == threads[i])
1046 /* We already know about this thread. */
1048 matched[i] = thread;
1050 thread = thread->next;
1058 proc_debug (thread, "died!");
1059 thread->port = MACH_PORT_NULL;
1060 thread = _proc_free (thread); /* THREAD is dead. */
1062 last->next = thread;
1064 inf->threads = thread;
1068 for (i = 0; i < num_threads; i++)
1071 /* Throw away the duplicate send right. */
1072 mach_port_deallocate (mach_task_self (), threads[i]);
1074 /* THREADS[I] is a thread we don't know about yet! */
1078 thread = make_proc (inf, threads[i], next_thread_id++);
1080 last->next = thread;
1082 inf->threads = thread;
1084 proc_debug (thread, "new thread: %d", threads[i]);
1086 ptid = ptid_build (inf->pid, thread->tid, 0);
1088 /* Tell GDB's generic thread code. */
1090 if (ptid_equal (inferior_ptid, pid_to_ptid (inf->pid)))
1091 /* This is the first time we're hearing about thread
1092 ids, after a fork-child. */
1093 thread_change_ptid (inferior_ptid, ptid);
1094 else if (inf->pending_execs != 0)
1095 /* This is a shell thread. */
1096 add_thread_silent (ptid);
1102 vm_deallocate (mach_task_self (),
1103 (vm_address_t) threads, (num_threads * sizeof (thread_t)));
1108 /* Makes sure that INF's thread list is synced with the actual process. */
1110 inf_update_procs (struct inf *inf)
1114 if (!inf->threads_up_to_date)
1115 inf_validate_procs (inf);
1119 /* Sets the resume_sc of each thread in inf. That of RUN_THREAD is set to 0,
1120 and others are set to their run_sc if RUN_OTHERS is true, and otherwise
1123 inf_set_threads_resume_sc (struct inf *inf,
1124 struct proc *run_thread, int run_others)
1126 struct proc *thread;
1128 inf_update_procs (inf);
1129 for (thread = inf->threads; thread; thread = thread->next)
1130 if (thread == run_thread)
1131 thread->resume_sc = 0;
1132 else if (run_others)
1133 thread->resume_sc = thread->run_sc;
1135 thread->resume_sc = thread->pause_sc;
1139 /* Cause INF to continue execution immediately; individual threads may still
1140 be suspended (but their suspend counts will be updated). */
1142 inf_resume (struct inf *inf)
1144 struct proc *thread;
1146 inf_update_procs (inf);
1148 for (thread = inf->threads; thread; thread = thread->next)
1149 thread->sc = thread->resume_sc;
1153 if (!inf->pending_execs)
1154 /* Try to make sure our task count is correct -- in the case where
1155 we're waiting for an exec though, things are too volatile, so just
1156 assume things will be reasonable (which they usually will be). */
1157 inf_validate_task_sc (inf);
1161 inf_update_suspends (inf);
1164 /* Cause INF to stop execution immediately; individual threads may still
1167 inf_suspend (struct inf *inf)
1169 struct proc *thread;
1171 inf_update_procs (inf);
1173 for (thread = inf->threads; thread; thread = thread->next)
1174 thread->sc = thread->pause_sc;
1177 inf->task->sc = inf->pause_sc;
1179 inf_update_suspends (inf);
1183 /* INF has one thread PROC that is in single-stepping mode. This
1184 function changes it to be PROC, changing any old step_thread to be
1185 a normal one. A PROC of 0 clears any existing value. */
1187 inf_set_step_thread (struct inf *inf, struct proc *thread)
1189 gdb_assert (!thread || proc_is_thread (thread));
1192 inf_debug (inf, "setting step thread: %d/%d", inf->pid, thread->tid);
1194 inf_debug (inf, "clearing step thread");
1196 if (inf->step_thread != thread)
1198 if (inf->step_thread && inf->step_thread->port != MACH_PORT_NULL)
1199 if (!proc_trace (inf->step_thread, 0))
1201 if (thread && proc_trace (thread, 1))
1202 inf->step_thread = thread;
1204 inf->step_thread = 0;
1209 /* Set up the thread resume_sc's so that only the signal thread is running
1210 (plus whatever other thread are set to always run). Returns true if we
1211 did so, or false if we can't find a signal thread. */
1213 inf_set_threads_resume_sc_for_signal_thread (struct inf *inf)
1215 if (inf->signal_thread)
1217 inf_set_threads_resume_sc (inf, inf->signal_thread, 0);
1225 inf_update_signal_thread (struct inf *inf)
1227 /* XXX for now we assume that if there's a msgport, the 2nd thread is
1228 the signal thread. */
1229 inf->signal_thread = inf->threads ? inf->threads->next : 0;
1233 /* Detachs from INF's inferior task, letting it run once again... */
1235 inf_detach (struct inf *inf)
1237 struct proc *task = inf->task;
1239 inf_debug (inf, "detaching...");
1241 inf_clear_wait (inf);
1242 inf_set_step_thread (inf, 0);
1246 struct proc *thread;
1248 inf_validate_procinfo (inf);
1250 inf_set_traced (inf, 0);
1256 inf_signal (inf, GDB_SIGNAL_0);
1259 proc_restore_exc_port (task);
1260 task->sc = inf->detach_sc;
1262 for (thread = inf->threads; thread; thread = thread->next)
1264 proc_restore_exc_port (thread);
1265 thread->sc = thread->detach_sc;
1268 inf_update_suspends (inf);
1274 /* Attaches INF to the process with process id PID, returning it in a
1275 suspended state suitable for debugging. */
1277 inf_attach (struct inf *inf, int pid)
1279 inf_debug (inf, "attaching: %d", pid);
1284 inf_startup (inf, pid);
1288 /* Makes sure that we've got our exception ports entrenched in the process. */
1290 inf_steal_exc_ports (struct inf *inf)
1292 struct proc *thread;
1294 inf_debug (inf, "stealing exception ports");
1296 inf_set_step_thread (inf, 0); /* The step thread is special. */
1298 proc_steal_exc_port (inf->task, inf->event_port);
1299 for (thread = inf->threads; thread; thread = thread->next)
1300 proc_steal_exc_port (thread, MACH_PORT_NULL);
1303 /* Makes sure the process has its own exception ports. */
1305 inf_restore_exc_ports (struct inf *inf)
1307 struct proc *thread;
1309 inf_debug (inf, "restoring exception ports");
1311 inf_set_step_thread (inf, 0); /* The step thread is special. */
1313 proc_restore_exc_port (inf->task);
1314 for (thread = inf->threads; thread; thread = thread->next)
1315 proc_restore_exc_port (thread);
1319 /* Deliver signal SIG to INF. If INF is stopped, delivering a signal, even
1320 signal 0, will continue it. INF is assumed to be in a paused state, and
1321 the resume_sc's of INF's threads may be affected. */
1323 inf_signal (struct inf *inf, enum gdb_signal sig)
1326 int host_sig = gdb_signal_to_host (sig);
1328 #define NAME gdb_signal_to_name (sig)
1330 if (host_sig >= _NSIG)
1331 /* A mach exception. Exceptions are encoded in the signal space by
1332 putting them after _NSIG; this assumes they're positive (and not
1333 extremely large)! */
1335 struct inf_wait *w = &inf->wait;
1337 if (w->status.kind == TARGET_WAITKIND_STOPPED
1338 && w->status.value.sig == sig
1339 && w->thread && !w->thread->aborted)
1340 /* We're passing through the last exception we received. This is
1341 kind of bogus, because exceptions are per-thread whereas gdb
1342 treats signals as per-process. We just forward the exception to
1343 the correct handler, even it's not for the same thread as TID --
1344 i.e., we pretend it's global. */
1346 struct exc_state *e = &w->exc;
1348 inf_debug (inf, "passing through exception:"
1349 " task = %d, thread = %d, exc = %d"
1350 ", code = %d, subcode = %d",
1351 w->thread->port, inf->task->port,
1352 e->exception, e->code, e->subcode);
1354 exception_raise_request (e->handler,
1355 e->reply, MACH_MSG_TYPE_MOVE_SEND_ONCE,
1356 w->thread->port, inf->task->port,
1357 e->exception, e->code, e->subcode);
1360 error (_("Can't forward spontaneous exception (%s)."), NAME);
1363 /* A Unix signal. */
1365 /* The process is stopped and expecting a signal. Just send off a
1366 request and let it get handled when we resume everything. */
1368 inf_debug (inf, "sending %s to stopped process", NAME);
1370 INF_MSGPORT_RPC (inf,
1371 msg_sig_post_untraced_request (msgport,
1373 MACH_MSG_TYPE_MAKE_SEND_ONCE,
1377 /* Posting an untraced signal automatically continues it.
1378 We clear this here rather than when we get the reply
1379 because we'd rather assume it's not stopped when it
1380 actually is, than the reverse. */
1384 /* It's not expecting it. We have to let just the signal thread
1385 run, and wait for it to get into a reasonable state before we
1386 can continue the rest of the process. When we finally resume the
1387 process the signal we request will be the very first thing that
1390 inf_debug (inf, "sending %s to unstopped process"
1391 " (so resuming signal thread)", NAME);
1393 INF_RESUME_MSGPORT_RPC (inf,
1394 msg_sig_post_untraced (msgport, host_sig,
1399 /* Can't do too much... */
1400 warning (_("Can't deliver signal %s: No signal thread."), NAME);
1402 warning (_("Delivering signal %s: %s"), NAME, safe_strerror (err));
1408 /* Continue INF without delivering a signal. This is meant to be used
1409 when INF does not have a message port. */
1411 inf_continue (struct inf *inf)
1414 error_t err = proc_pid2proc (proc_server, inf->pid, &proc);
1418 inf_debug (inf, "continuing process");
1420 err = proc_mark_cont (proc);
1423 struct proc *thread;
1425 for (thread = inf->threads; thread; thread = thread->next)
1426 thread_resume (thread->port);
1433 warning (_("Can't continue process: %s"), safe_strerror (err));
1437 /* The inferior used for all gdb target ops. */
1438 struct inf *gnu_current_inf = 0;
1440 /* The inferior being waited for by gnu_wait. Since GDB is decidely not
1441 multi-threaded, we don't bother to lock this. */
1442 struct inf *waiting_inf;
1444 /* Wait for something to happen in the inferior, returning what in STATUS. */
1446 gnu_wait (struct target_ops *ops,
1447 ptid_t ptid, struct target_waitstatus *status, int options)
1451 mach_msg_header_t hdr;
1452 mach_msg_type_t type;
1456 struct proc *thread;
1457 struct inf *inf = gnu_current_inf;
1459 extern int exc_server (mach_msg_header_t *, mach_msg_header_t *);
1460 extern int msg_reply_server (mach_msg_header_t *, mach_msg_header_t *);
1461 extern int notify_server (mach_msg_header_t *, mach_msg_header_t *);
1462 extern int process_reply_server (mach_msg_header_t *, mach_msg_header_t *);
1464 gdb_assert (inf->task);
1466 if (!inf->threads && !inf->pending_execs)
1467 /* No threads! Assume that maybe some outside agency is frobbing our
1468 task, and really look for new threads. If we can't find any, just tell
1469 the user to try again later. */
1471 inf_validate_procs (inf);
1472 if (!inf->threads && !inf->task->dead)
1473 error (_("There are no threads; try again later."));
1478 inf_debug (inf, "waiting for: %s", target_pid_to_str (ptid));
1481 if (proc_wait_pid != inf->pid && !inf->no_wait)
1482 /* Always get information on events from the proc server. */
1484 inf_debug (inf, "requesting wait on pid %d", inf->pid);
1487 /* The proc server is single-threaded, and only allows a single
1488 outstanding wait request, so we have to cancel the previous one. */
1490 inf_debug (inf, "cancelling previous wait on pid %d", proc_wait_pid);
1491 interrupt_operation (proc_server, 0);
1495 proc_wait_request (proc_server, inf->event_port, inf->pid, WUNTRACED);
1497 warning (_("wait request failed: %s"), safe_strerror (err));
1500 inf_debug (inf, "waits pending: %d", proc_waits_pending);
1501 proc_wait_pid = inf->pid;
1502 /* Even if proc_waits_pending was > 0 before, we still won't
1503 get any other replies, because it was either from a
1504 different INF, or a different process attached to INF --
1505 and the event port, which is the wait reply port, changes
1506 when you switch processes. */
1507 proc_waits_pending = 1;
1511 inf_clear_wait (inf);
1513 /* What can happen? (1) Dead name notification; (2) Exceptions arrive;
1514 (3) wait reply from the proc server. */
1516 inf_debug (inf, "waiting for an event...");
1517 err = mach_msg (&msg.hdr, MACH_RCV_MSG | MACH_RCV_INTERRUPT,
1518 0, sizeof (struct msg), inf->event_port,
1519 MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
1521 /* Re-suspend the task. */
1524 if (!inf->task && inf->pending_execs)
1525 /* When doing an exec, it's possible that the old task wasn't reused
1526 (e.g., setuid execs). So if the task seems to have disappeared,
1527 attempt to refetch it, as the pid should still be the same. */
1528 inf_set_pid (inf, inf->pid);
1530 if (err == EMACH_RCV_INTERRUPTED)
1531 inf_debug (inf, "interrupted");
1533 error (_("Couldn't wait for an event: %s"), safe_strerror (err));
1538 mach_msg_header_t hdr;
1539 mach_msg_type_t err_type;
1545 inf_debug (inf, "event: msgid = %d", msg.hdr.msgh_id);
1547 /* Handle what we got. */
1548 if (!notify_server (&msg.hdr, &reply.hdr)
1549 && !exc_server (&msg.hdr, &reply.hdr)
1550 && !process_reply_server (&msg.hdr, &reply.hdr)
1551 && !msg_reply_server (&msg.hdr, &reply.hdr))
1552 /* Whatever it is, it's something strange. */
1553 error (_("Got a strange event, msg id = %d."), msg.hdr.msgh_id);
1556 error (_("Handling event, msgid = %d: %s"),
1557 msg.hdr.msgh_id, safe_strerror (reply.err));
1560 if (inf->pending_execs)
1561 /* We're waiting for the inferior to finish execing. */
1563 struct inf_wait *w = &inf->wait;
1564 enum target_waitkind kind = w->status.kind;
1566 if (kind == TARGET_WAITKIND_SPURIOUS)
1567 /* Since gdb is actually counting the number of times the inferior
1568 stops, expecting one stop per exec, we only return major events
1572 inf_debug (inf, "pending_execs = %d, ignoring minor event",
1573 inf->pending_execs);
1575 else if (kind == TARGET_WAITKIND_STOPPED
1576 && w->status.value.sig == GDB_SIGNAL_TRAP)
1577 /* Ah hah! A SIGTRAP from the inferior while starting up probably
1578 means we've succesfully completed an exec! */
1580 if (--inf->pending_execs == 0)
1583 #if 0 /* do we need this? */
1584 prune_threads (1); /* Get rid of the old shell
1586 renumber_threads (0); /* Give our threads reasonable
1590 inf_debug (inf, "pending exec completed, pending_execs => %d",
1591 inf->pending_execs);
1593 else if (kind == TARGET_WAITKIND_STOPPED)
1594 /* It's possible that this signal is because of a crashed process
1595 being handled by the hurd crash server; in this case, the process
1596 will have an extra task suspend, which we need to know about.
1597 Since the code in inf_resume that normally checks for this is
1598 disabled while INF->pending_execs, we do the check here instead. */
1599 inf_validate_task_sc (inf);
1602 if (inf->wait.suppress)
1603 /* Some totally spurious event happened that we don't consider
1604 worth returning to gdb. Just keep waiting. */
1606 inf_debug (inf, "suppressing return, rewaiting...");
1611 /* Pass back out our results. */
1612 memcpy (status, &inf->wait.status, sizeof (*status));
1614 thread = inf->wait.thread;
1616 ptid = ptid_build (inf->pid, thread->tid, 0);
1617 else if (ptid_equal (ptid, minus_one_ptid))
1618 thread = inf_tid_to_thread (inf, -1);
1620 thread = inf_tid_to_thread (inf, ptid_get_lwp (ptid));
1622 if (!thread || thread->port == MACH_PORT_NULL)
1624 /* TID is dead; try and find a new thread. */
1625 if (inf_update_procs (inf) && inf->threads)
1626 ptid = ptid_build (inf->pid, inf->threads->tid, 0); /* The first
1630 ptid = inferior_ptid; /* let wait_for_inferior handle exit case */
1634 && !ptid_equal (ptid, minus_one_ptid)
1635 && status->kind != TARGET_WAITKIND_SPURIOUS
1636 && inf->pause_sc == 0 && thread->pause_sc == 0)
1637 /* If something actually happened to THREAD, make sure we
1641 inf_update_suspends (inf);
1644 inf_debug (inf, "returning ptid = %s, status = %s (%d)",
1645 target_pid_to_str (ptid),
1646 status->kind == TARGET_WAITKIND_EXITED ? "EXITED"
1647 : status->kind == TARGET_WAITKIND_STOPPED ? "STOPPED"
1648 : status->kind == TARGET_WAITKIND_SIGNALLED ? "SIGNALLED"
1649 : status->kind == TARGET_WAITKIND_LOADED ? "LOADED"
1650 : status->kind == TARGET_WAITKIND_SPURIOUS ? "SPURIOUS"
1652 status->value.integer);
1658 /* The rpc handler called by exc_server. */
1660 S_exception_raise_request (mach_port_t port, mach_port_t reply_port,
1661 thread_t thread_port, task_t task_port,
1662 int exception, int code, int subcode)
1664 struct inf *inf = waiting_inf;
1665 struct proc *thread = inf_port_to_thread (inf, thread_port);
1667 inf_debug (waiting_inf,
1668 "thread = %d, task = %d, exc = %d, code = %d, subcode = %d",
1669 thread_port, task_port, exception, code, subcode);
1672 /* We don't know about thread? */
1674 inf_update_procs (inf);
1675 thread = inf_port_to_thread (inf, thread_port);
1677 /* Give up, the generating thread is gone. */
1681 mach_port_deallocate (mach_task_self (), thread_port);
1682 mach_port_deallocate (mach_task_self (), task_port);
1684 if (!thread->aborted)
1685 /* THREAD hasn't been aborted since this exception happened (abortion
1686 clears any exception state), so it must be real. */
1688 /* Store away the details; this will destroy any previous info. */
1689 inf->wait.thread = thread;
1691 inf->wait.status.kind = TARGET_WAITKIND_STOPPED;
1693 if (exception == EXC_BREAKPOINT)
1694 /* GDB likes to get SIGTRAP for breakpoints. */
1696 inf->wait.status.value.sig = GDB_SIGNAL_TRAP;
1697 mach_port_deallocate (mach_task_self (), reply_port);
1700 /* Record the exception so that we can forward it later. */
1702 if (thread->exc_port == port)
1704 inf_debug (waiting_inf, "Handler is thread exception port <%d>",
1705 thread->saved_exc_port);
1706 inf->wait.exc.handler = thread->saved_exc_port;
1710 inf_debug (waiting_inf, "Handler is task exception port <%d>",
1711 inf->task->saved_exc_port);
1712 inf->wait.exc.handler = inf->task->saved_exc_port;
1713 gdb_assert (inf->task->exc_port == port);
1715 if (inf->wait.exc.handler != MACH_PORT_NULL)
1716 /* Add a reference to the exception handler. */
1717 mach_port_mod_refs (mach_task_self (),
1718 inf->wait.exc.handler, MACH_PORT_RIGHT_SEND,
1721 inf->wait.exc.exception = exception;
1722 inf->wait.exc.code = code;
1723 inf->wait.exc.subcode = subcode;
1724 inf->wait.exc.reply = reply_port;
1726 /* Exceptions are encoded in the signal space by putting
1727 them after _NSIG; this assumes they're positive (and not
1728 extremely large)! */
1729 inf->wait.status.value.sig =
1730 gdb_signal_from_host (_NSIG + exception);
1734 /* A supppressed exception, which ignore. */
1736 inf->wait.suppress = 1;
1737 mach_port_deallocate (mach_task_self (), reply_port);
1744 /* Fill in INF's wait field after a task has died without giving us more
1745 detailed information. */
1747 inf_task_died_status (struct inf *inf)
1749 warning (_("Pid %d died with unknown exit status, using SIGKILL."),
1751 inf->wait.status.kind = TARGET_WAITKIND_SIGNALLED;
1752 inf->wait.status.value.sig = GDB_SIGNAL_KILL;
1755 /* Notify server routines. The only real one is dead name notification. */
1757 do_mach_notify_dead_name (mach_port_t notify, mach_port_t dead_port)
1759 struct inf *inf = waiting_inf;
1761 inf_debug (waiting_inf, "port = %d", dead_port);
1763 if (inf->task && inf->task->port == dead_port)
1765 proc_debug (inf->task, "is dead");
1766 inf->task->port = MACH_PORT_NULL;
1767 if (proc_wait_pid == inf->pid)
1768 /* We have a wait outstanding on the process, which will return more
1769 detailed information, so delay until we get that. */
1770 inf->wait.suppress = 1;
1772 /* We never waited for the process (maybe it wasn't a child), so just
1773 pretend it got a SIGKILL. */
1774 inf_task_died_status (inf);
1778 struct proc *thread = inf_port_to_thread (inf, dead_port);
1782 proc_debug (thread, "is dead");
1783 thread->port = MACH_PORT_NULL;
1786 if (inf->task->dead)
1787 /* Since the task is dead, its threads are dying with it. */
1788 inf->wait.suppress = 1;
1791 mach_port_deallocate (mach_task_self (), dead_port);
1792 inf->threads_up_to_date = 0; /* Just in case. */
1801 warning (_("illegal rpc: %s"), fun);
1806 do_mach_notify_no_senders (mach_port_t notify, mach_port_mscount_t count)
1808 return ill_rpc ("do_mach_notify_no_senders");
1812 do_mach_notify_port_deleted (mach_port_t notify, mach_port_t name)
1814 return ill_rpc ("do_mach_notify_port_deleted");
1818 do_mach_notify_msg_accepted (mach_port_t notify, mach_port_t name)
1820 return ill_rpc ("do_mach_notify_msg_accepted");
1824 do_mach_notify_port_destroyed (mach_port_t notify, mach_port_t name)
1826 return ill_rpc ("do_mach_notify_port_destroyed");
1830 do_mach_notify_send_once (mach_port_t notify)
1832 return ill_rpc ("do_mach_notify_send_once");
1836 /* Process_reply server routines. We only use process_wait_reply. */
1839 S_proc_wait_reply (mach_port_t reply, error_t err,
1840 int status, int sigcode, rusage_t rusage, pid_t pid)
1842 struct inf *inf = waiting_inf;
1844 inf_debug (inf, "err = %s, pid = %d, status = 0x%x, sigcode = %d",
1845 err ? safe_strerror (err) : "0", pid, status, sigcode);
1847 if (err && proc_wait_pid && (!inf->task || !inf->task->port))
1848 /* Ack. The task has died, but the task-died notification code didn't
1849 tell anyone because it thought a more detailed reply from the
1850 procserver was forthcoming. However, we now learn that won't
1851 happen... So we have to act like the task just died, and this time,
1853 inf_task_died_status (inf);
1855 if (--proc_waits_pending == 0)
1856 /* PROC_WAIT_PID represents the most recent wait. We will always get
1857 replies in order because the proc server is single threaded. */
1860 inf_debug (inf, "waits pending now: %d", proc_waits_pending);
1866 warning (_("Can't wait for pid %d: %s"),
1867 inf->pid, safe_strerror (err));
1870 /* Since we can't see the inferior's signals, don't trap them. */
1871 inf_set_traced (inf, 0);
1874 else if (pid == inf->pid)
1876 store_waitstatus (&inf->wait.status, status);
1877 if (inf->wait.status.kind == TARGET_WAITKIND_STOPPED)
1878 /* The process has sent us a signal, and stopped itself in a sane
1879 state pending our actions. */
1881 inf_debug (inf, "process has stopped itself");
1886 inf->wait.suppress = 1; /* Something odd happened. Ignore. */
1892 S_proc_setmsgport_reply (mach_port_t reply, error_t err,
1893 mach_port_t old_msg_port)
1895 return ill_rpc ("S_proc_setmsgport_reply");
1899 S_proc_getmsgport_reply (mach_port_t reply, error_t err, mach_port_t msg_port)
1901 return ill_rpc ("S_proc_getmsgport_reply");
1905 /* Msg_reply server routines. We only use msg_sig_post_untraced_reply. */
1908 S_msg_sig_post_untraced_reply (mach_port_t reply, error_t err)
1910 struct inf *inf = waiting_inf;
1913 /* EBUSY is what we get when the crash server has grabbed control of the
1914 process and doesn't like what signal we tried to send it. Just act
1915 like the process stopped (using a signal of 0 should mean that the
1916 *next* time the user continues, it will pass signal 0, which the crash
1917 server should like). */
1919 inf->wait.status.kind = TARGET_WAITKIND_STOPPED;
1920 inf->wait.status.value.sig = GDB_SIGNAL_0;
1923 warning (_("Signal delivery failed: %s"), safe_strerror (err));
1926 /* We only get this reply when we've posted a signal to a process which we
1927 thought was stopped, and which we expected to continue after the signal.
1928 Given that the signal has failed for some reason, it's reasonable to
1929 assume it's still stopped. */
1932 inf->wait.suppress = 1;
1938 S_msg_sig_post_reply (mach_port_t reply, error_t err)
1940 return ill_rpc ("S_msg_sig_post_reply");
1944 /* Returns the number of messages queued for the receive right PORT. */
1945 static mach_port_msgcount_t
1946 port_msgs_queued (mach_port_t port)
1948 struct mach_port_status status;
1950 mach_port_get_receive_status (mach_task_self (), port, &status);
1955 return status.mps_msgcount;
1959 /* Resume execution of the inferior process.
1961 If STEP is nonzero, single-step it.
1962 If SIGNAL is nonzero, give it that signal.
1965 -1 true Single step the current thread allowing other threads to run.
1966 -1 false Continue the current thread allowing other threads to run.
1967 X true Single step the given thread, don't allow any others to run.
1968 X false Continue the given thread, do not allow any others to run.
1969 (Where X, of course, is anything except -1)
1971 Note that a resume may not `take' if there are pending exceptions/&c
1972 still unprocessed from the last resume we did (any given resume may result
1973 in multiple events returned by wait). */
1976 gnu_resume (struct target_ops *ops,
1977 ptid_t ptid, int step, enum gdb_signal sig)
1979 struct proc *step_thread = 0;
1981 struct inf *inf = gnu_current_inf;
1983 inf_debug (inf, "ptid = %s, step = %d, sig = %d",
1984 target_pid_to_str (ptid), step, sig);
1986 inf_validate_procinfo (inf);
1988 if (sig != GDB_SIGNAL_0 || inf->stopped)
1990 if (sig == GDB_SIGNAL_0 && inf->nomsg)
1993 inf_signal (inf, sig);
1995 else if (inf->wait.exc.reply != MACH_PORT_NULL)
1996 /* We received an exception to which we have chosen not to forward, so
1997 abort the faulting thread, which will perhaps retake it. */
1999 proc_abort (inf->wait.thread, 1);
2000 warning (_("Aborting %s with unforwarded exception %s."),
2001 proc_string (inf->wait.thread),
2002 gdb_signal_to_name (inf->wait.status.value.sig));
2005 if (port_msgs_queued (inf->event_port))
2006 /* If there are still messages in our event queue, don't bother resuming
2007 the process, as we're just going to stop it right away anyway. */
2010 inf_update_procs (inf);
2012 /* A specific PTID means `step only this process id'. */
2013 resume_all = ptid_equal (ptid, minus_one_ptid);
2016 /* Allow all threads to run, except perhaps single-stepping one. */
2018 inf_debug (inf, "running all threads; tid = %d", PIDGET (inferior_ptid));
2019 ptid = inferior_ptid; /* What to step. */
2020 inf_set_threads_resume_sc (inf, 0, 1);
2023 /* Just allow a single thread to run. */
2025 struct proc *thread = inf_tid_to_thread (inf, ptid_get_lwp (ptid));
2028 error (_("Can't run single thread id %s: no such thread!"),
2029 target_pid_to_str (ptid));
2030 inf_debug (inf, "running one thread: %s", target_pid_to_str (ptid));
2031 inf_set_threads_resume_sc (inf, thread, 0);
2036 step_thread = inf_tid_to_thread (inf, ptid_get_lwp (ptid));
2038 warning (_("Can't step thread id %s: no such thread."),
2039 target_pid_to_str (ptid));
2041 inf_debug (inf, "stepping thread: %s", target_pid_to_str (ptid));
2043 if (step_thread != inf->step_thread)
2044 inf_set_step_thread (inf, step_thread);
2046 inf_debug (inf, "here we go...");
2052 gnu_kill_inferior (struct target_ops *ops)
2054 struct proc *task = gnu_current_inf->task;
2058 proc_debug (task, "terminating...");
2059 task_terminate (task->port);
2060 inf_set_pid (gnu_current_inf, -1);
2062 target_mourn_inferior ();
2065 /* Clean up after the inferior dies. */
2067 gnu_mourn_inferior (struct target_ops *ops)
2069 inf_debug (gnu_current_inf, "rip");
2070 inf_detach (gnu_current_inf);
2071 unpush_target (ops);
2072 generic_mourn_inferior ();
2076 /* Fork an inferior process, and start debugging it. */
2078 /* Set INFERIOR_PID to the first thread available in the child, if any. */
2080 inf_pick_first_thread (void)
2082 if (gnu_current_inf->task && gnu_current_inf->threads)
2083 /* The first thread. */
2084 return gnu_current_inf->threads->tid;
2086 /* What may be the next thread. */
2087 return next_thread_id;
2093 if (!gnu_current_inf)
2094 gnu_current_inf = make_inf ();
2095 return gnu_current_inf;
2099 gnu_create_inferior (struct target_ops *ops,
2100 char *exec_file, char *allargs, char **env,
2103 struct inf *inf = cur_inf ();
2108 /* We're in the child; make this process stop as soon as it execs. */
2109 inf_debug (inf, "tracing self");
2110 if (ptrace (PTRACE_TRACEME) != 0)
2111 error (_("ptrace (PTRACE_TRACEME) failed!"));
2114 inf_debug (inf, "creating inferior");
2116 pid = fork_inferior (exec_file, allargs, env, trace_me,
2117 NULL, NULL, NULL, NULL);
2119 /* Attach to the now stopped child, which is actually a shell... */
2120 inf_debug (inf, "attaching to child: %d", pid);
2122 inf_attach (inf, pid);
2126 inf->pending_execs = 2;
2130 /* Now let the child run again, knowing that it will stop
2131 immediately because of the ptrace. */
2134 /* We now have thread info. */
2135 thread_change_ptid (inferior_ptid,
2136 ptid_build (inf->pid, inf_pick_first_thread (), 0));
2138 startup_inferior (inf->pending_execs);
2140 inf_validate_procinfo (inf);
2141 inf_update_signal_thread (inf);
2142 inf_set_traced (inf, inf->want_signals);
2144 /* Execing the process will have trashed our exception ports; steal them
2145 back (or make sure they're restored if the user wants that). */
2146 if (inf->want_exceptions)
2147 inf_steal_exc_ports (inf);
2149 inf_restore_exc_ports (inf);
2153 /* Attach to process PID, then initialize for debugging it
2154 and wait for the trace-trap that results from attaching. */
2156 gnu_attach (struct target_ops *ops, char *args, int from_tty)
2160 struct inf *inf = cur_inf ();
2161 struct inferior *inferior;
2163 pid = parse_pid_to_attach (args);
2165 if (pid == getpid ()) /* Trying to masturbate? */
2166 error (_("I refuse to debug myself!"));
2170 exec_file = (char *) get_exec_file (0);
2173 printf_unfiltered ("Attaching to program `%s', pid %d\n",
2176 printf_unfiltered ("Attaching to pid %d\n", pid);
2178 gdb_flush (gdb_stdout);
2181 inf_debug (inf, "attaching to pid: %d", pid);
2183 inf_attach (inf, pid);
2187 inferior = current_inferior ();
2188 inferior_appeared (inferior, pid);
2189 inferior->attach_flag = 1;
2191 inf_update_procs (inf);
2193 inferior_ptid = ptid_build (pid, inf_pick_first_thread (), 0);
2195 /* We have to initialize the terminal settings now, since the code
2196 below might try to restore them. */
2197 target_terminal_init ();
2199 /* If the process was stopped before we attached, make it continue the next
2200 time the user does a continue. */
2201 inf_validate_procinfo (inf);
2203 inf_update_signal_thread (inf);
2204 inf_set_traced (inf, inf->want_signals);
2206 #if 0 /* Do we need this? */
2207 renumber_threads (0); /* Give our threads reasonable names. */
2212 /* Take a program previously attached to and detaches it.
2213 The program resumes execution and will no longer stop
2214 on signals, etc. We'd better not have left any breakpoints
2215 in the program or it'll die when it hits one. For this
2216 to work, it may be necessary for the process to have been
2217 previously attached. It *might* work if the program was
2218 started via fork. */
2220 gnu_detach (struct target_ops *ops, char *args, int from_tty)
2226 char *exec_file = get_exec_file (0);
2229 printf_unfiltered ("Detaching from program `%s' pid %d\n",
2230 exec_file, gnu_current_inf->pid);
2232 printf_unfiltered ("Detaching from pid %d\n", gnu_current_inf->pid);
2233 gdb_flush (gdb_stdout);
2236 pid = gnu_current_inf->pid;
2238 inf_detach (gnu_current_inf);
2240 inferior_ptid = null_ptid;
2241 detach_inferior (pid);
2243 unpush_target (ops); /* Pop out of handling an inferior. */
2247 gnu_terminal_init_inferior (void)
2249 gdb_assert (gnu_current_inf);
2250 terminal_init_inferior_with_pgrp (gnu_current_inf->pid);
2254 gnu_stop (ptid_t ptid)
2256 error (_("to_stop target function not implemented"));
2260 gnu_thread_alive (struct target_ops *ops, ptid_t ptid)
2262 inf_update_procs (gnu_current_inf);
2263 return !!inf_tid_to_thread (gnu_current_inf,
2264 ptid_get_lwp (ptid));
2268 /* Read inferior task's LEN bytes from ADDR and copy it to MYADDR in
2269 gdb's address space. Return 0 on failure; number of bytes read
2272 gnu_read_inferior (task_t task, CORE_ADDR addr, char *myaddr, int length)
2275 vm_address_t low_address = (vm_address_t) trunc_page (addr);
2276 vm_size_t aligned_length =
2277 (vm_size_t) round_page (addr + length) - low_address;
2281 /* Get memory from inferior with page aligned addresses. */
2282 err = vm_read (task, low_address, aligned_length, &copied, ©_count);
2286 err = hurd_safe_copyin (myaddr, (void *) (addr - low_address + copied),
2290 warning (_("Read from inferior faulted: %s"), safe_strerror (err));
2294 err = vm_deallocate (mach_task_self (), copied, copy_count);
2296 warning (_("gnu_read_inferior vm_deallocate failed: %s"),
2297 safe_strerror (err));
2302 #define CHK_GOTO_OUT(str,ret) \
2303 do if (ret != KERN_SUCCESS) { errstr = #str; goto out; } while(0)
2305 struct vm_region_list
2307 struct vm_region_list *next;
2308 vm_prot_t protection;
2313 struct obstack region_obstack;
2315 /* Write gdb's LEN bytes from MYADDR and copy it to ADDR in inferior
2316 task's address space. */
2318 gnu_write_inferior (task_t task, CORE_ADDR addr, char *myaddr, int length)
2321 vm_address_t low_address = (vm_address_t) trunc_page (addr);
2322 vm_size_t aligned_length =
2323 (vm_size_t) round_page (addr + length) - low_address;
2328 char *errstr = "Bug in gnu_write_inferior";
2330 struct vm_region_list *region_element;
2331 struct vm_region_list *region_head = (struct vm_region_list *) NULL;
2333 /* Get memory from inferior with page aligned addresses. */
2334 err = vm_read (task,
2339 CHK_GOTO_OUT ("gnu_write_inferior vm_read failed", err);
2343 err = hurd_safe_copyout ((void *) (addr - low_address + copied),
2345 CHK_GOTO_OUT ("Write to inferior faulted", err);
2347 obstack_init (®ion_obstack);
2349 /* Do writes atomically.
2350 First check for holes and unwritable memory. */
2352 vm_size_t remaining_length = aligned_length;
2353 vm_address_t region_address = low_address;
2355 struct vm_region_list *scan;
2357 while (region_address < low_address + aligned_length)
2359 vm_prot_t protection;
2360 vm_prot_t max_protection;
2361 vm_inherit_t inheritance;
2363 mach_port_t object_name;
2365 vm_size_t region_length = remaining_length;
2366 vm_address_t old_address = region_address;
2368 err = vm_region (task,
2377 CHK_GOTO_OUT ("vm_region failed", err);
2379 /* Check for holes in memory. */
2380 if (old_address != region_address)
2382 warning (_("No memory at 0x%x. Nothing written"),
2389 if (!(max_protection & VM_PROT_WRITE))
2391 warning (_("Memory at address 0x%x is unwritable. "
2399 /* Chain the regions for later use. */
2401 (struct vm_region_list *)
2402 obstack_alloc (®ion_obstack, sizeof (struct vm_region_list));
2404 region_element->protection = protection;
2405 region_element->start = region_address;
2406 region_element->length = region_length;
2408 /* Chain the regions along with protections. */
2409 region_element->next = region_head;
2410 region_head = region_element;
2412 region_address += region_length;
2413 remaining_length = remaining_length - region_length;
2416 /* If things fail after this, we give up.
2417 Somebody is messing up inferior_task's mappings. */
2419 /* Enable writes to the chained vm regions. */
2420 for (scan = region_head; scan; scan = scan->next)
2422 if (!(scan->protection & VM_PROT_WRITE))
2424 err = vm_protect (task,
2428 scan->protection | VM_PROT_WRITE);
2429 CHK_GOTO_OUT ("vm_protect: enable write failed", err);
2433 err = vm_write (task,
2437 CHK_GOTO_OUT ("vm_write failed", err);
2439 /* Set up the original region protections, if they were changed. */
2440 for (scan = region_head; scan; scan = scan->next)
2442 if (!(scan->protection & VM_PROT_WRITE))
2444 err = vm_protect (task,
2449 CHK_GOTO_OUT ("vm_protect: enable write failed", err);
2457 obstack_free (®ion_obstack, 0);
2459 (void) vm_deallocate (mach_task_self (),
2464 if (err != KERN_SUCCESS)
2466 warning (_("%s: %s"), errstr, mach_error_string (err));
2474 /* Return 0 on failure, number of bytes handled otherwise. TARGET
2477 gnu_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
2478 struct mem_attrib *attrib,
2479 struct target_ops *target)
2481 task_t task = (gnu_current_inf
2482 ? (gnu_current_inf->task
2483 ? gnu_current_inf->task->port : 0)
2486 if (task == MACH_PORT_NULL)
2490 inf_debug (gnu_current_inf, "%s %s[%d] %s %s",
2491 write ? "writing" : "reading",
2492 paddress (target_gdbarch (), memaddr), len,
2493 write ? "<--" : "-->", host_address_to_string (myaddr));
2495 return gnu_write_inferior (task, memaddr, myaddr, len);
2497 return gnu_read_inferior (task, memaddr, myaddr, len);
2501 /* Call FUNC on each memory region in the task. */
2503 gnu_find_memory_regions (find_memory_region_ftype func, void *data)
2507 vm_address_t region_address, last_region_address, last_region_end;
2508 vm_prot_t last_protection;
2510 if (gnu_current_inf == 0 || gnu_current_inf->task == 0)
2512 task = gnu_current_inf->task->port;
2513 if (task == MACH_PORT_NULL)
2516 region_address = last_region_address = last_region_end = VM_MIN_ADDRESS;
2517 last_protection = VM_PROT_NONE;
2518 while (region_address < VM_MAX_ADDRESS)
2520 vm_prot_t protection;
2521 vm_prot_t max_protection;
2522 vm_inherit_t inheritance;
2524 mach_port_t object_name;
2526 vm_size_t region_length = VM_MAX_ADDRESS - region_address;
2527 vm_address_t old_address = region_address;
2529 err = vm_region (task,
2538 if (err == KERN_NO_SPACE)
2540 if (err != KERN_SUCCESS)
2542 warning (_("vm_region failed: %s"), mach_error_string (err));
2546 if (protection == last_protection && region_address == last_region_end)
2547 /* This region is contiguous with and indistinguishable from
2548 the previous one, so we just extend that one. */
2549 last_region_end = region_address += region_length;
2552 /* This region is distinct from the last one we saw, so report
2553 that previous one. */
2554 if (last_protection != VM_PROT_NONE)
2555 (*func) (last_region_address,
2556 last_region_end - last_region_address,
2557 last_protection & VM_PROT_READ,
2558 last_protection & VM_PROT_WRITE,
2559 last_protection & VM_PROT_EXECUTE,
2560 1, /* MODIFIED is unknown, pass it as true. */
2562 last_region_address = region_address;
2563 last_region_end = region_address += region_length;
2564 last_protection = protection;
2568 /* Report the final region. */
2569 if (last_region_end > last_region_address && last_protection != VM_PROT_NONE)
2570 (*func) (last_region_address, last_region_end - last_region_address,
2571 last_protection & VM_PROT_READ,
2572 last_protection & VM_PROT_WRITE,
2573 last_protection & VM_PROT_EXECUTE,
2574 1, /* MODIFIED is unknown, pass it as true. */
2581 /* Return printable description of proc. */
2583 proc_string (struct proc *proc)
2585 static char tid_str[80];
2587 if (proc_is_task (proc))
2588 xsnprintf (tid_str, sizeof (tid_str), "process %d", proc->inf->pid);
2590 xsnprintf (tid_str, sizeof (tid_str), "Thread %d.%d",
2591 proc->inf->pid, proc->tid);
2596 gnu_pid_to_str (struct target_ops *ops, ptid_t ptid)
2598 struct inf *inf = gnu_current_inf;
2599 int tid = ptid_get_lwp (ptid);
2600 struct proc *thread = inf_tid_to_thread (inf, tid);
2603 return proc_string (thread);
2606 static char tid_str[80];
2608 xsnprintf (tid_str, sizeof (tid_str), "bogus thread id %d", tid);
2614 /* Create a prototype generic GNU/Hurd target. The client can
2615 override it with local methods. */
2620 struct target_ops *t = inf_child_target ();
2622 t->to_shortname = "GNU";
2623 t->to_longname = "GNU Hurd process";
2624 t->to_doc = "GNU Hurd process";
2626 t->to_attach = gnu_attach;
2627 t->to_attach_no_wait = 1;
2628 t->to_detach = gnu_detach;
2629 t->to_resume = gnu_resume;
2630 t->to_wait = gnu_wait;
2631 t->deprecated_xfer_memory = gnu_xfer_memory;
2632 t->to_find_memory_regions = gnu_find_memory_regions;
2633 t->to_terminal_init = gnu_terminal_init_inferior;
2634 t->to_kill = gnu_kill_inferior;
2635 t->to_create_inferior = gnu_create_inferior;
2636 t->to_mourn_inferior = gnu_mourn_inferior;
2637 t->to_thread_alive = gnu_thread_alive;
2638 t->to_pid_to_str = gnu_pid_to_str;
2639 t->to_stop = gnu_stop;
2645 /* User task commands. */
2647 static struct cmd_list_element *set_task_cmd_list = 0;
2648 static struct cmd_list_element *show_task_cmd_list = 0;
2649 /* User thread commands. */
2651 /* Commands with a prefix of `set/show thread'. */
2652 extern struct cmd_list_element *thread_cmd_list;
2653 struct cmd_list_element *set_thread_cmd_list = NULL;
2654 struct cmd_list_element *show_thread_cmd_list = NULL;
2656 /* Commands with a prefix of `set/show thread default'. */
2657 struct cmd_list_element *set_thread_default_cmd_list = NULL;
2658 struct cmd_list_element *show_thread_default_cmd_list = NULL;
2661 set_thread_cmd (char *args, int from_tty)
2663 printf_unfiltered ("\"set thread\" must be followed by the "
2664 "name of a thread property, or \"default\".\n");
2668 show_thread_cmd (char *args, int from_tty)
2670 printf_unfiltered ("\"show thread\" must be followed by the "
2671 "name of a thread property, or \"default\".\n");
2675 set_thread_default_cmd (char *args, int from_tty)
2677 printf_unfiltered ("\"set thread default\" must be followed "
2678 "by the name of a thread property.\n");
2682 show_thread_default_cmd (char *args, int from_tty)
2684 printf_unfiltered ("\"show thread default\" must be followed "
2685 "by the name of a thread property.\n");
2689 parse_int_arg (char *args, char *cmd_prefix)
2694 int val = strtoul (args, &arg_end, 10);
2696 if (*args && *arg_end == '\0')
2699 error (_("Illegal argument for \"%s\" command, should be an integer."),
2704 _parse_bool_arg (char *args, char *t_val, char *f_val, char *cmd_prefix)
2706 if (!args || strcmp (args, t_val) == 0)
2708 else if (strcmp (args, f_val) == 0)
2711 error (_("Illegal argument for \"%s\" command, "
2712 "should be \"%s\" or \"%s\"."),
2713 cmd_prefix, t_val, f_val);
2716 #define parse_bool_arg(args, cmd_prefix) \
2717 _parse_bool_arg (args, "on", "off", cmd_prefix)
2720 check_empty (char *args, char *cmd_prefix)
2723 error (_("Garbage after \"%s\" command: `%s'"), cmd_prefix, args);
2726 /* Returns the alive thread named by INFERIOR_PID, or signals an error. */
2727 static struct proc *
2730 struct inf *inf = cur_inf ();
2731 struct proc *thread = inf_tid_to_thread (inf,
2732 ptid_get_lwp (inferior_ptid));
2734 error (_("No current thread."));
2738 /* Returns the current inferior, but signals an error if it has no task. */
2742 struct inf *inf = cur_inf ();
2745 error (_("No current process."));
2751 set_task_pause_cmd (char *args, int from_tty)
2753 struct inf *inf = cur_inf ();
2754 int old_sc = inf->pause_sc;
2756 inf->pause_sc = parse_bool_arg (args, "set task pause");
2758 if (old_sc == 0 && inf->pause_sc != 0)
2759 /* If the task is currently unsuspended, immediately suspend it,
2760 otherwise wait until the next time it gets control. */
2765 show_task_pause_cmd (char *args, int from_tty)
2767 struct inf *inf = cur_inf ();
2769 check_empty (args, "show task pause");
2770 printf_unfiltered ("The inferior task %s suspended while gdb has control.\n",
2772 ? (inf->pause_sc == 0 ? "isn't" : "is")
2773 : (inf->pause_sc == 0 ? "won't be" : "will be"));
2777 set_task_detach_sc_cmd (char *args, int from_tty)
2779 cur_inf ()->detach_sc = parse_int_arg (args,
2780 "set task detach-suspend-count");
2784 show_task_detach_sc_cmd (char *args, int from_tty)
2786 check_empty (args, "show task detach-suspend-count");
2787 printf_unfiltered ("The inferior task will be left with a "
2788 "suspend count of %d when detaching.\n",
2789 cur_inf ()->detach_sc);
2794 set_thread_default_pause_cmd (char *args, int from_tty)
2796 struct inf *inf = cur_inf ();
2798 inf->default_thread_pause_sc =
2799 parse_bool_arg (args, "set thread default pause") ? 0 : 1;
2803 show_thread_default_pause_cmd (char *args, int from_tty)
2805 struct inf *inf = cur_inf ();
2806 int sc = inf->default_thread_pause_sc;
2808 check_empty (args, "show thread default pause");
2809 printf_unfiltered ("New threads %s suspended while gdb has control%s.\n",
2810 sc ? "are" : "aren't",
2811 !sc && inf->pause_sc ? " (but the task is)" : "");
2815 set_thread_default_run_cmd (char *args, int from_tty)
2817 struct inf *inf = cur_inf ();
2819 inf->default_thread_run_sc =
2820 parse_bool_arg (args, "set thread default run") ? 0 : 1;
2824 show_thread_default_run_cmd (char *args, int from_tty)
2826 struct inf *inf = cur_inf ();
2828 check_empty (args, "show thread default run");
2829 printf_unfiltered ("New threads %s allowed to run.\n",
2830 inf->default_thread_run_sc == 0 ? "are" : "aren't");
2834 set_thread_default_detach_sc_cmd (char *args, int from_tty)
2836 cur_inf ()->default_thread_detach_sc =
2837 parse_int_arg (args, "set thread default detach-suspend-count");
2841 show_thread_default_detach_sc_cmd (char *args, int from_tty)
2843 check_empty (args, "show thread default detach-suspend-count");
2844 printf_unfiltered ("New threads will get a detach-suspend-count of %d.\n",
2845 cur_inf ()->default_thread_detach_sc);
2849 /* Steal a send right called NAME in the inferior task, and make it PROC's
2850 saved exception port. */
2852 steal_exc_port (struct proc *proc, mach_port_t name)
2856 mach_msg_type_name_t port_type;
2858 if (!proc || !proc->inf->task)
2859 error (_("No inferior task."));
2861 err = mach_port_extract_right (proc->inf->task->port,
2862 name, MACH_MSG_TYPE_COPY_SEND,
2865 error (_("Couldn't extract send right %d from inferior: %s"),
2866 name, safe_strerror (err));
2868 if (proc->saved_exc_port)
2869 /* Get rid of our reference to the old one. */
2870 mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
2872 proc->saved_exc_port = port;
2874 if (!proc->exc_port)
2875 /* If PROC is a thread, we may not have set its exception port
2876 before. We can't use proc_steal_exc_port because it also sets
2879 proc->exc_port = proc->inf->event_port;
2880 err = proc_set_exception_port (proc, proc->exc_port);
2881 error (_("Can't set exception port for %s: %s"),
2882 proc_string (proc), safe_strerror (err));
2887 set_task_exc_port_cmd (char *args, int from_tty)
2889 struct inf *inf = cur_inf ();
2892 error (_("No argument to \"set task exception-port\" command."));
2893 steal_exc_port (inf->task, parse_and_eval_address (args));
2897 set_stopped_cmd (char *args, int from_tty)
2899 cur_inf ()->stopped = _parse_bool_arg (args, "yes", "no", "set stopped");
2903 show_stopped_cmd (char *args, int from_tty)
2905 struct inf *inf = active_inf ();
2907 check_empty (args, "show stopped");
2908 printf_unfiltered ("The inferior process %s stopped.\n",
2909 inf->stopped ? "is" : "isn't");
2913 set_sig_thread_cmd (char *args, int from_tty)
2915 struct inf *inf = cur_inf ();
2917 if (!args || (!isdigit (*args) && strcmp (args, "none") != 0))
2918 error (_("Illegal argument to \"set signal-thread\" command.\n"
2919 "Should be an integer thread ID, or `none'."));
2921 if (strcmp (args, "none") == 0)
2922 inf->signal_thread = 0;
2925 ptid_t ptid = thread_id_to_pid (atoi (args));
2927 if (ptid_equal (ptid, minus_one_ptid))
2928 error (_("Thread ID %s not known. "
2929 "Use the \"info threads\" command to\n"
2930 "see the IDs of currently known threads."), args);
2931 inf->signal_thread = inf_tid_to_thread (inf, ptid_get_lwp (ptid));
2936 show_sig_thread_cmd (char *args, int from_tty)
2938 struct inf *inf = active_inf ();
2940 check_empty (args, "show signal-thread");
2941 if (inf->signal_thread)
2942 printf_unfiltered ("The signal thread is %s.\n",
2943 proc_string (inf->signal_thread));
2945 printf_unfiltered ("There is no signal thread.\n");
2950 set_signals_cmd (char *args, int from_tty)
2952 struct inf *inf = cur_inf ();
2954 inf->want_signals = parse_bool_arg (args, "set signals");
2956 if (inf->task && inf->want_signals != inf->traced)
2957 /* Make this take effect immediately in a running process. */
2958 inf_set_traced (inf, inf->want_signals);
2962 show_signals_cmd (char *args, int from_tty)
2964 struct inf *inf = cur_inf ();
2966 check_empty (args, "show signals");
2967 printf_unfiltered ("The inferior process's signals %s intercepted.\n",
2969 ? (inf->traced ? "are" : "aren't")
2970 : (inf->want_signals ? "will be" : "won't be"));
2974 set_exceptions_cmd (char *args, int from_tty)
2976 struct inf *inf = cur_inf ();
2977 int val = parse_bool_arg (args, "set exceptions");
2979 if (inf->task && inf->want_exceptions != val)
2980 /* Make this take effect immediately in a running process. */
2983 inf->want_exceptions = val;
2987 show_exceptions_cmd (char *args, int from_tty)
2989 struct inf *inf = cur_inf ();
2991 check_empty (args, "show exceptions");
2992 printf_unfiltered ("Exceptions in the inferior %s trapped.\n",
2994 ? (inf->want_exceptions ? "are" : "aren't")
2995 : (inf->want_exceptions ? "will be" : "won't be"));
3000 set_task_cmd (char *args, int from_tty)
3002 printf_unfiltered ("\"set task\" must be followed by the name"
3003 " of a task property.\n");
3007 show_task_cmd (char *args, int from_tty)
3009 struct inf *inf = cur_inf ();
3011 check_empty (args, "show task");
3013 show_signals_cmd (0, from_tty);
3014 show_exceptions_cmd (0, from_tty);
3015 show_task_pause_cmd (0, from_tty);
3017 if (inf->pause_sc == 0)
3018 show_thread_default_pause_cmd (0, from_tty);
3019 show_thread_default_run_cmd (0, from_tty);
3023 show_stopped_cmd (0, from_tty);
3024 show_sig_thread_cmd (0, from_tty);
3027 if (inf->detach_sc != 0)
3028 show_task_detach_sc_cmd (0, from_tty);
3029 if (inf->default_thread_detach_sc != 0)
3030 show_thread_default_detach_sc_cmd (0, from_tty);
3035 set_noninvasive_cmd (char *args, int from_tty)
3037 /* Invert the sense of the arg for each component. */
3038 char *inv_args = parse_bool_arg (args, "set noninvasive") ? "off" : "on";
3040 set_task_pause_cmd (inv_args, from_tty);
3041 set_signals_cmd (inv_args, from_tty);
3042 set_exceptions_cmd (inv_args, from_tty);
3047 info_port_rights (char *args, mach_port_type_t only)
3049 struct inf *inf = active_inf ();
3050 struct value *vmark = value_mark ();
3053 /* Explicit list of port rights. */
3057 struct value *val = parse_to_comma_and_eval (&args);
3058 long right = value_as_long (val);
3060 print_port_info (right, 0, inf->task->port, PORTINFO_DETAILS,
3064 error (_("%ld: %s."), right, safe_strerror (err));
3068 /* Print all of them. */
3071 print_task_ports_info (inf->task->port, only, PORTINFO_DETAILS,
3074 error (_("%s."), safe_strerror (err));
3077 value_free_to_mark (vmark);
3081 info_send_rights_cmd (char *args, int from_tty)
3083 info_port_rights (args, MACH_PORT_TYPE_SEND);
3087 info_recv_rights_cmd (char *args, int from_tty)
3089 info_port_rights (args, MACH_PORT_TYPE_RECEIVE);
3093 info_port_sets_cmd (char *args, int from_tty)
3095 info_port_rights (args, MACH_PORT_TYPE_PORT_SET);
3099 info_dead_names_cmd (char *args, int from_tty)
3101 info_port_rights (args, MACH_PORT_TYPE_DEAD_NAME);
3105 info_port_rights_cmd (char *args, int from_tty)
3107 info_port_rights (args, ~0);
3112 add_task_commands (void)
3114 add_cmd ("pause", class_run, set_thread_default_pause_cmd, _("\
3115 Set whether the new threads are suspended while gdb has control.\n\
3116 This property normally has no effect because the whole task is\n\
3117 suspended, however, that may be disabled with \"set task pause off\".\n\
3118 The default value is \"off\"."),
3119 &set_thread_default_cmd_list);
3120 add_cmd ("pause", no_class, show_thread_default_pause_cmd, _("\
3121 Show whether new threads are suspended while gdb has control."),
3122 &show_thread_default_cmd_list);
3124 add_cmd ("run", class_run, set_thread_default_run_cmd, _("\
3125 Set whether new threads are allowed to run (once gdb has noticed them)."),
3126 &set_thread_default_cmd_list);
3127 add_cmd ("run", no_class, show_thread_default_run_cmd, _("\
3128 Show whether new threads are allowed to run (once gdb has noticed them)."),
3129 &show_thread_default_cmd_list);
3131 add_cmd ("detach-suspend-count", class_run, set_thread_default_detach_sc_cmd,
3132 _("Set the default detach-suspend-count value for new threads."),
3133 &set_thread_default_cmd_list);
3134 add_cmd ("detach-suspend-count", no_class, show_thread_default_detach_sc_cmd,
3135 _("Show the default detach-suspend-count value for new threads."),
3136 &show_thread_default_cmd_list);
3138 add_cmd ("signals", class_run, set_signals_cmd, _("\
3139 Set whether the inferior process's signals will be intercepted.\n\
3140 Mach exceptions (such as breakpoint traps) are not affected."),
3142 add_alias_cmd ("sigs", "signals", class_run, 1, &setlist);
3143 add_cmd ("signals", no_class, show_signals_cmd, _("\
3144 Show whether the inferior process's signals will be intercepted."),
3146 add_alias_cmd ("sigs", "signals", no_class, 1, &showlist);
3148 add_cmd ("signal-thread", class_run, set_sig_thread_cmd, _("\
3149 Set the thread that gdb thinks is the libc signal thread.\n\
3150 This thread is run when delivering a signal to a non-stopped process."),
3152 add_alias_cmd ("sigthread", "signal-thread", class_run, 1, &setlist);
3153 add_cmd ("signal-thread", no_class, show_sig_thread_cmd, _("\
3154 Set the thread that gdb thinks is the libc signal thread."),
3156 add_alias_cmd ("sigthread", "signal-thread", no_class, 1, &showlist);
3158 add_cmd ("stopped", class_run, set_stopped_cmd, _("\
3159 Set whether gdb thinks the inferior process is stopped as with SIGSTOP.\n\
3160 Stopped process will be continued by sending them a signal."),
3162 add_cmd ("stopped", no_class, show_stopped_cmd, _("\
3163 Show whether gdb thinks the inferior process is stopped as with SIGSTOP."),
3166 add_cmd ("exceptions", class_run, set_exceptions_cmd, _("\
3167 Set whether exceptions in the inferior process will be trapped.\n\
3168 When exceptions are turned off, neither breakpoints nor single-stepping\n\
3171 /* Allow `set exc' despite conflict with `set exception-port'. */
3172 add_alias_cmd ("exc", "exceptions", class_run, 1, &setlist);
3173 add_cmd ("exceptions", no_class, show_exceptions_cmd, _("\
3174 Show whether exceptions in the inferior process will be trapped."),
3177 add_prefix_cmd ("task", no_class, set_task_cmd,
3178 _("Command prefix for setting task attributes."),
3179 &set_task_cmd_list, "set task ", 0, &setlist);
3180 add_prefix_cmd ("task", no_class, show_task_cmd,
3181 _("Command prefix for showing task attributes."),
3182 &show_task_cmd_list, "show task ", 0, &showlist);
3184 add_cmd ("pause", class_run, set_task_pause_cmd, _("\
3185 Set whether the task is suspended while gdb has control.\n\
3186 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3187 until the next time the program is continued.\n\
3188 When setting this to \"off\", \"set thread default pause on\" can be\n\
3189 used to pause individual threads by default instead."),
3190 &set_task_cmd_list);
3191 add_cmd ("pause", no_class, show_task_pause_cmd,
3192 _("Show whether the task is suspended while gdb has control."),
3193 &show_task_cmd_list);
3195 add_cmd ("detach-suspend-count", class_run, set_task_detach_sc_cmd,
3196 _("Set the suspend count will leave on the thread when detaching."),
3197 &set_task_cmd_list);
3198 add_cmd ("detach-suspend-count", no_class, show_task_detach_sc_cmd,
3199 _("Show the suspend count will leave "
3200 "on the thread when detaching."),
3201 &show_task_cmd_list);
3203 add_cmd ("exception-port", no_class, set_task_exc_port_cmd, _("\
3204 Set the task exception port to which we forward exceptions.\n\
3205 The argument should be the value of the send right in the task."),
3206 &set_task_cmd_list);
3207 add_alias_cmd ("excp", "exception-port", no_class, 1, &set_task_cmd_list);
3208 add_alias_cmd ("exc-port", "exception-port", no_class, 1,
3209 &set_task_cmd_list);
3211 /* A convenient way of turning on all options require to noninvasively
3212 debug running tasks. */
3213 add_cmd ("noninvasive", no_class, set_noninvasive_cmd, _("\
3214 Set task options so that we interfere as little as possible.\n\
3215 This is the same as setting `task pause', `exceptions', and\n\
3216 `signals' to the opposite value."),
3219 /* Commands to show information about the task's ports. */
3220 add_cmd ("send-rights", class_info, info_send_rights_cmd,
3221 _("Show information about the task's send rights"),
3223 add_cmd ("receive-rights", class_info, info_recv_rights_cmd,
3224 _("Show information about the task's receive rights"),
3226 add_cmd ("port-rights", class_info, info_port_rights_cmd,
3227 _("Show information about the task's port rights"),
3229 add_cmd ("port-sets", class_info, info_port_sets_cmd,
3230 _("Show information about the task's port sets"),
3232 add_cmd ("dead-names", class_info, info_dead_names_cmd,
3233 _("Show information about the task's dead names"),
3235 add_info_alias ("ports", "port-rights", 1);
3236 add_info_alias ("port", "port-rights", 1);
3237 add_info_alias ("psets", "port-sets", 1);
3242 set_thread_pause_cmd (char *args, int from_tty)
3244 struct proc *thread = cur_thread ();
3245 int old_sc = thread->pause_sc;
3247 thread->pause_sc = parse_bool_arg (args, "set thread pause");
3248 if (old_sc == 0 && thread->pause_sc != 0 && thread->inf->pause_sc == 0)
3249 /* If the task is currently unsuspended, immediately suspend it,
3250 otherwise wait until the next time it gets control. */
3251 inf_suspend (thread->inf);
3255 show_thread_pause_cmd (char *args, int from_tty)
3257 struct proc *thread = cur_thread ();
3258 int sc = thread->pause_sc;
3260 check_empty (args, "show task pause");
3261 printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n",
3262 proc_string (thread),
3263 sc ? "is" : "isn't",
3264 !sc && thread->inf->pause_sc ? " (but the task is)" : "");
3268 set_thread_run_cmd (char *args, int from_tty)
3270 struct proc *thread = cur_thread ();
3272 thread->run_sc = parse_bool_arg (args, "set thread run") ? 0 : 1;
3276 show_thread_run_cmd (char *args, int from_tty)
3278 struct proc *thread = cur_thread ();
3280 check_empty (args, "show thread run");
3281 printf_unfiltered ("Thread %s %s allowed to run.",
3282 proc_string (thread),
3283 thread->run_sc == 0 ? "is" : "isn't");
3287 set_thread_detach_sc_cmd (char *args, int from_tty)
3289 cur_thread ()->detach_sc = parse_int_arg (args,
3290 "set thread detach-suspend-count");
3294 show_thread_detach_sc_cmd (char *args, int from_tty)
3296 struct proc *thread = cur_thread ();
3298 check_empty (args, "show thread detach-suspend-count");
3299 printf_unfiltered ("Thread %s will be left with a suspend count"
3300 " of %d when detaching.\n",
3301 proc_string (thread),
3306 set_thread_exc_port_cmd (char *args, int from_tty)
3308 struct proc *thread = cur_thread ();
3311 error (_("No argument to \"set thread exception-port\" command."));
3312 steal_exc_port (thread, parse_and_eval_address (args));
3317 show_thread_cmd (char *args, int from_tty)
3319 struct proc *thread = cur_thread ();
3321 check_empty (args, "show thread");
3322 show_thread_run_cmd (0, from_tty);
3323 show_thread_pause_cmd (0, from_tty);
3324 if (thread->detach_sc != 0)
3325 show_thread_detach_sc_cmd (0, from_tty);
3330 thread_takeover_sc_cmd (char *args, int from_tty)
3332 struct proc *thread = cur_thread ();
3334 thread_basic_info_data_t _info;
3335 thread_basic_info_t info = &_info;
3336 mach_msg_type_number_t info_len = THREAD_BASIC_INFO_COUNT;
3338 thread_info (thread->port, THREAD_BASIC_INFO, (int *) &info, &info_len);
3340 error (("%s."), safe_strerror (err));
3341 thread->sc = info->suspend_count;
3343 printf_unfiltered ("Suspend count was %d.\n", thread->sc);
3345 vm_deallocate (mach_task_self (), (vm_address_t) info,
3346 info_len * sizeof (int));
3351 add_thread_commands (void)
3353 add_prefix_cmd ("thread", no_class, set_thread_cmd,
3354 _("Command prefix for setting thread properties."),
3355 &set_thread_cmd_list, "set thread ", 0, &setlist);
3356 add_prefix_cmd ("default", no_class, show_thread_cmd,
3357 _("Command prefix for setting default thread properties."),
3358 &set_thread_default_cmd_list, "set thread default ", 0,
3359 &set_thread_cmd_list);
3360 add_prefix_cmd ("thread", no_class, set_thread_default_cmd,
3361 _("Command prefix for showing thread properties."),
3362 &show_thread_cmd_list, "show thread ", 0, &showlist);
3363 add_prefix_cmd ("default", no_class, show_thread_default_cmd,
3364 _("Command prefix for showing default thread properties."),
3365 &show_thread_default_cmd_list, "show thread default ", 0,
3366 &show_thread_cmd_list);
3368 add_cmd ("pause", class_run, set_thread_pause_cmd, _("\
3369 Set whether the current thread is suspended while gdb has control.\n\
3370 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3371 until the next time the program is continued. This property normally\n\
3372 has no effect because the whole task is suspended, however, that may\n\
3373 be disabled with \"set task pause off\".\n\
3374 The default value is \"off\"."),
3375 &set_thread_cmd_list);
3376 add_cmd ("pause", no_class, show_thread_pause_cmd, _("\
3377 Show whether the current thread is suspended while gdb has control."),
3378 &show_thread_cmd_list);
3380 add_cmd ("run", class_run, set_thread_run_cmd,
3381 _("Set whether the current thread is allowed to run."),
3382 &set_thread_cmd_list);
3383 add_cmd ("run", no_class, show_thread_run_cmd,
3384 _("Show whether the current thread is allowed to run."),
3385 &show_thread_cmd_list);
3387 add_cmd ("detach-suspend-count", class_run, set_thread_detach_sc_cmd, _("\
3388 Set the suspend count will leave on the thread when detaching.\n\
3389 Note that this is relative to suspend count when gdb noticed the thread;\n\
3390 use the `thread takeover-suspend-count' to force it to an absolute value."),
3391 &set_thread_cmd_list);
3392 add_cmd ("detach-suspend-count", no_class, show_thread_detach_sc_cmd, _("\
3393 Show the suspend count will leave on the thread when detaching.\n\
3394 Note that this is relative to suspend count when gdb noticed the thread;\n\
3395 use the `thread takeover-suspend-count' to force it to an absolute value."),
3396 &show_thread_cmd_list);
3398 add_cmd ("exception-port", no_class, set_thread_exc_port_cmd, _("\
3399 Set the thread exception port to which we forward exceptions.\n\
3400 This overrides the task exception port.\n\
3401 The argument should be the value of the send right in the task."),
3402 &set_thread_cmd_list);
3403 add_alias_cmd ("excp", "exception-port", no_class, 1, &set_thread_cmd_list);
3404 add_alias_cmd ("exc-port", "exception-port", no_class, 1,
3405 &set_thread_cmd_list);
3407 add_cmd ("takeover-suspend-count", no_class, thread_takeover_sc_cmd, _("\
3408 Force the threads absolute suspend-count to be gdb's.\n\
3409 Prior to giving this command, gdb's thread suspend-counts are relative\n\
3410 to the thread's initial suspend-count when gdb notices the threads."),
3416 _initialize_gnu_nat (void)
3418 proc_server = getproc ();
3420 add_task_commands ();
3421 add_thread_commands ();
3422 add_setshow_boolean_cmd ("gnu-nat", class_maintenance,
3424 _("Set debugging output for the gnu backend."),
3425 _("Show debugging output for the gnu backend."),
3433 #ifdef FLUSH_INFERIOR_CACHE
3435 /* When over-writing code on some machines the I-Cache must be flushed
3436 explicitly, because it is not kept coherent by the lazy hardware.
3437 This definitely includes breakpoints, for instance, or else we
3438 end up looping in mysterious Bpt traps. */
3441 flush_inferior_icache (CORE_ADDR pc, int amount)
3443 vm_machine_attribute_val_t flush = MATTR_VAL_ICACHE_FLUSH;
3446 ret = vm_machine_attribute (gnu_current_inf->task->port,
3451 if (ret != KERN_SUCCESS)
3452 warning (_("Error flushing inferior's cache : %s"), safe_strerror (ret));
3454 #endif /* FLUSH_INFERIOR_CACHE */