1 /* Interface GDB to the GNU Hurd.
2 Copyright 1992, 1995, 1996, 1997, 1998, 1999, 2000
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 Written by Miles Bader <miles@gnu.ai.mit.edu>
9 Some code and ideas from m3-nat.c by Jukka Virtanen <jtv@hut.fi>
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 59 Temple Place - Suite 330,
24 Boston, MA 02111-1307, USA.
34 #include <sys/ptrace.h>
37 #include <mach_error.h>
38 #include <mach/exception.h>
39 #include <mach/message.h>
40 #include <mach/notify.h>
41 #include <mach/vm_attributes.h>
44 #include <hurd/interrupt.h>
46 #include <hurd/msg_request.h>
47 #include <hurd/process.h>
48 #include <hurd/process_request.h>
49 #include <hurd/signal.h>
50 #include <hurd/sigpreempt.h>
63 #include "gdbthread.h"
67 #include "exc_request_S.h"
69 #include "process_reply_S.h"
70 #include "msg_reply_S.h"
71 #include "exc_request_U.h"
74 static process_t proc_server = MACH_PORT_NULL;
76 /* If we've sent a proc_wait_request to the proc server, the pid of the
77 process we asked about. We can only ever have one outstanding. */
78 int proc_wait_pid = 0;
80 /* The number of wait requests we've sent, and expect replies from. */
81 int proc_waits_pending = 0;
83 int gnu_debug_flag = 0;
87 extern struct target_ops gnu_ops;
89 struct inf *make_inf ();
90 void inf_clear_wait (struct inf *inf);
91 void inf_cleanup (struct inf *inf);
92 void inf_startup (struct inf *inf, int pid);
93 int inf_update_suspends (struct inf *inf);
94 void inf_set_pid (struct inf *inf, pid_t pid);
95 void inf_validate_procs (struct inf *inf);
96 void inf_steal_exc_ports (struct inf *inf);
97 void inf_restore_exc_ports (struct inf *inf);
98 struct proc *inf_tid_to_proc (struct inf *inf, int tid);
99 inline void inf_set_threads_resume_sc (struct inf *inf,
100 struct proc *run_thread,
102 inline int inf_set_threads_resume_sc_for_signal_thread (struct inf *inf);
103 inline void inf_suspend (struct inf *inf);
104 inline void inf_resume (struct inf *inf);
105 void inf_set_step_thread (struct inf *inf, struct proc *proc);
106 void inf_detach (struct inf *inf);
107 void inf_attach (struct inf *inf, int pid);
108 void inf_signal (struct inf *inf, enum target_signal sig);
109 void inf_continue (struct inf *inf);
111 #define inf_debug(_inf, msg, args...) \
112 do { struct inf *__inf = (_inf); \
113 debug ("{inf %d %p}: " msg, __inf->pid, __inf , ##args); } while (0)
115 void proc_abort (struct proc *proc, int force);
116 struct proc *make_proc (struct inf *inf, mach_port_t port, int tid);
117 struct proc *_proc_free (struct proc *proc);
118 int proc_update_sc (struct proc *proc);
119 error_t proc_get_exception_port (struct proc *proc, mach_port_t * port);
120 error_t proc_set_exception_port (struct proc *proc, mach_port_t port);
121 static mach_port_t _proc_get_exc_port (struct proc *proc);
122 void proc_steal_exc_port (struct proc *proc, mach_port_t exc_port);
123 void proc_restore_exc_port (struct proc *proc);
124 int proc_trace (struct proc *proc, int set);
126 /* Evaluate RPC_EXPR in a scope with the variables MSGPORT and REFPORT bound
127 to INF's msg port and task port respectively. If it has no msg port,
128 EIEIO is returned. INF must refer to a running process! */
129 #define INF_MSGPORT_RPC(inf, rpc_expr) \
130 HURD_MSGPORT_RPC (proc_getmsgport (proc_server, inf->pid, &msgport), \
131 (refport = inf->task->port, 0), 0, \
132 msgport ? (rpc_expr) : EIEIO)
134 /* Like INF_MSGPORT_RPC, but will also resume the signal thread to ensure
135 there's someone around to deal with the RPC (and resuspend things
136 afterwards). This effects INF's threads' resume_sc count. */
137 #define INF_RESUME_MSGPORT_RPC(inf, rpc_expr) \
138 (inf_set_threads_resume_sc_for_signal_thread (inf) \
141 __e = INF_MSGPORT_RPC (inf, rpc_expr); \
147 /* The state passed by an exception message. */
150 int exception; /* The exception code */
152 mach_port_t handler; /* The real exception port to handle this. */
153 mach_port_t reply; /* The reply port from the exception call. */
156 /* The results of the last wait an inf did. */
159 struct target_waitstatus status; /* The status returned to gdb. */
160 struct exc_state exc; /* The exception that caused us to return. */
161 struct proc *thread; /* The thread in question. */
162 int suppress; /* Something trivial happened. */
165 /* The state of an inferior. */
168 /* Fields describing the current inferior. */
170 struct proc *task; /* The mach task. */
171 struct proc *threads; /* A linked list of all threads in TASK. */
173 /* True if THREADS needn't be validated by querying the task. We assume that
174 we and the task in question are the only ones frobbing the thread list,
175 so as long as we don't let any code run, we don't have to worry about
177 int threads_up_to_date;
179 pid_t pid; /* The real system PID. */
181 struct inf_wait wait; /* What to return from target_wait. */
183 /* One thread proc in INF may be in `single-stepping mode'. This is it. */
184 struct proc *step_thread;
186 /* The thread we think is the signal thread. */
187 struct proc *signal_thread;
189 mach_port_t event_port; /* Where we receive various msgs. */
191 /* True if we think at least one thread in the inferior could currently be
193 unsigned int running:1;
195 /* True if the process has stopped (in the proc server sense). Note that
196 since a proc server `stop' leaves the signal thread running, the inf can
197 be RUNNING && STOPPED... */
198 unsigned int stopped:1;
200 /* True if the inferior has no message port. */
201 unsigned int nomsg:1;
203 /* True if the inferior is traced. */
204 unsigned int traced:1;
206 /* True if we shouldn't try waiting for the inferior, usually because we
207 can't for some reason. */
208 unsigned int no_wait:1;
210 /* When starting a new inferior, we don't try to validate threads until all
211 the proper execs have been done. This is a count of how many execs we
213 unsigned pending_execs;
215 /* Fields describing global state */
217 /* The task suspend count used when gdb has control. This is normally 1 to
218 make things easier for us, but sometimes (like when attaching to vital
219 system servers) it may be desirable to let the task continue to run
220 (pausing individual threads as necessary). */
223 /* The task suspend count left when detaching from a task. */
226 /* The initial values used for the run_sc and pause_sc of newly discovered
227 threads -- see the definition of those fields in struct proc. */
228 int default_thread_run_sc;
229 int default_thread_pause_sc;
230 int default_thread_detach_sc;
232 /* True if the process should be traced when started/attached. Newly
233 started processes *must* be traced at first to exec them properly, but
234 if this is false, tracing is turned off as soon it has done so. */
237 /* True if exceptions from the inferior process should be trapped. This
238 must be on to use breakpoints. */
244 __proc_pid (struct proc *proc)
246 return proc->inf->pid;
250 /* Update PROC's real suspend count to match it's desired one. Returns true
251 if we think PROC is now in a runnable state. */
253 proc_update_sc (struct proc *proc)
257 int delta = proc->sc - proc->cur_sc;
260 proc_debug (proc, "sc: %d --> %d", proc->cur_sc, proc->sc);
262 if (proc->sc == 0 && proc->state_changed)
263 /* Since PROC may start running, we must write back any state changes. */
265 assert (proc_is_thread (proc));
266 proc_debug (proc, "storing back changed thread state");
267 err = thread_set_state (proc->port, THREAD_STATE_FLAVOR,
268 (thread_state_t) &proc->state, THREAD_STATE_SIZE);
270 proc->state_changed = 0;
275 while (delta-- > 0 && !err)
277 if (proc_is_task (proc))
278 err = task_suspend (proc->port);
280 err = thread_suspend (proc->port);
285 while (delta++ < 0 && !err)
287 if (proc_is_task (proc))
288 err = task_resume (proc->port);
290 err = thread_resume (proc->port);
294 proc->cur_sc = proc->sc;
296 /* If we got an error, then the task/thread has disappeared. */
297 running = !err && proc->sc == 0;
299 proc_debug (proc, "is %s", err ? "dead" : running ? "running" : "suspended");
301 proc_debug (proc, "err = %s", strerror (err));
306 proc->state_valid = proc->state_changed = 0;
307 proc->fetched_regs = 0;
314 /* Thread_abort is called on PROC if needed. PROC must be a thread proc.
315 If PROC is deemed `precious', then nothing is done unless FORCE is true.
316 In particular, a thread is precious if it's running (in which case forcing
317 it includes suspending it first), or if it has an exception pending. */
319 proc_abort (struct proc *proc, int force)
321 assert (proc_is_thread (proc));
325 struct inf *inf = proc->inf;
326 int running = (proc->cur_sc == 0 && inf->task->cur_sc == 0);
328 if (running && force)
331 inf_update_suspends (proc->inf);
333 warning ("Stopped %s.", proc_string (proc));
335 else if (proc == inf->wait.thread && inf->wait.exc.reply && !force)
336 /* An exception is pending on PROC, which don't mess with. */
340 /* We only abort the thread if it's not actually running. */
342 thread_abort (proc->port);
343 proc_debug (proc, "aborted");
347 proc_debug (proc, "not aborting");
351 /* Make sure that the state field in PROC is up to date, and return a pointer
352 to it, or 0 if something is wrong. If WILL_MODIFY is true, makes sure
353 that the thread is stopped and aborted first, and sets the state_changed
354 field in PROC to true. */
356 proc_get_state (struct proc *proc, int will_modify)
358 int was_aborted = proc->aborted;
360 proc_debug (proc, "updating state info%s",
361 will_modify ? " (with intention to modify)" : "");
363 proc_abort (proc, will_modify);
365 if (!was_aborted && proc->aborted)
366 /* PROC's state may have changed since we last fetched it. */
367 proc->state_valid = 0;
369 if (!proc->state_valid)
371 mach_msg_type_number_t state_size = THREAD_STATE_SIZE;
373 thread_get_state (proc->port, THREAD_STATE_FLAVOR,
374 (thread_state_t) &proc->state, &state_size);
375 proc_debug (proc, "getting thread state");
376 proc->state_valid = !err;
379 if (proc->state_valid)
382 proc->state_changed = 1;
383 return (thread_state_t) &proc->state;
390 /* Set PORT to PROC's exception port. */
392 proc_get_exception_port (struct proc * proc, mach_port_t * port)
394 if (proc_is_task (proc))
395 return task_get_exception_port (proc->port, port);
397 return thread_get_exception_port (proc->port, port);
400 /* Set PROC's exception port to PORT. */
402 proc_set_exception_port (struct proc * proc, mach_port_t port)
404 proc_debug (proc, "setting exception port: %d", port);
405 if (proc_is_task (proc))
406 return task_set_exception_port (proc->port, port);
408 return thread_set_exception_port (proc->port, port);
411 /* Get PROC's exception port, cleaning up a bit if proc has died. */
413 _proc_get_exc_port (struct proc *proc)
415 mach_port_t exc_port;
416 error_t err = proc_get_exception_port (proc, &exc_port);
419 /* PROC must be dead. */
422 mach_port_deallocate (mach_task_self (), proc->exc_port);
423 proc->exc_port = MACH_PORT_NULL;
424 if (proc->saved_exc_port)
425 mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
426 proc->saved_exc_port = MACH_PORT_NULL;
432 /* Replace PROC's exception port with EXC_PORT, unless it's already been
433 done. Stash away any existing exception port so we can restore it later. */
435 proc_steal_exc_port (struct proc *proc, mach_port_t exc_port)
437 mach_port_t cur_exc_port = _proc_get_exc_port (proc);
443 proc_debug (proc, "inserting exception port: %d", exc_port);
445 if (cur_exc_port != exc_port)
446 /* Put in our exception port. */
447 err = proc_set_exception_port (proc, exc_port);
449 if (err || cur_exc_port == proc->exc_port)
450 /* We previously set the exception port, and it's still set. So we
451 just keep the old saved port which is what the proc set. */
454 mach_port_deallocate (mach_task_self (), cur_exc_port);
457 /* Keep a copy of PROC's old exception port so it can be restored. */
459 if (proc->saved_exc_port)
460 mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
461 proc->saved_exc_port = cur_exc_port;
464 proc_debug (proc, "saved exception port: %d", proc->saved_exc_port);
467 proc->exc_port = exc_port;
469 warning ("Error setting exception port for %s: %s",
470 proc_string (proc), strerror (err));
474 /* If we previously replaced PROC's exception port, put back what we
475 found there at the time, unless *our* exception port has since been
476 overwritten, in which case who knows what's going on. */
478 proc_restore_exc_port (struct proc *proc)
480 mach_port_t cur_exc_port = _proc_get_exc_port (proc);
486 proc_debug (proc, "restoring real exception port");
488 if (proc->exc_port == cur_exc_port)
489 /* Our's is still there. */
490 err = proc_set_exception_port (proc, proc->saved_exc_port);
492 if (proc->saved_exc_port)
493 mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
494 proc->saved_exc_port = MACH_PORT_NULL;
497 proc->exc_port = MACH_PORT_NULL;
499 warning ("Error setting exception port for %s: %s",
500 proc_string (proc), strerror (err));
505 /* Turns hardware tracing in PROC on or off when SET is true or false,
506 respectively. Returns true on success. */
508 proc_trace (struct proc *proc, int set)
510 thread_state_t state = proc_get_state (proc, 1);
513 return 0; /* the thread must be dead. */
515 proc_debug (proc, "tracing %s", set ? "on" : "off");
519 /* XXX We don't get the exception unless the thread has its own
520 exception port???? */
521 if (proc->exc_port == MACH_PORT_NULL)
522 proc_steal_exc_port (proc, proc->inf->event_port);
523 THREAD_STATE_SET_TRACED (state);
526 THREAD_STATE_CLEAR_TRACED (state);
532 /* A variable from which to assign new TIDs. */
533 static int next_thread_id = 1;
535 /* Returns a new proc structure with the given fields. Also adds a
536 notification for PORT becoming dead to be sent to INF's notify port. */
538 make_proc (struct inf *inf, mach_port_t port, int tid)
541 mach_port_t prev_port = MACH_PORT_NULL;
542 struct proc *proc = malloc (sizeof (struct proc));
548 proc->saved_exc_port = MACH_PORT_NULL;
549 proc->exc_port = MACH_PORT_NULL;
554 /* Note that these are all the values for threads; the task simply uses the
555 corresponding field in INF directly. */
556 proc->run_sc = inf->default_thread_run_sc;
557 proc->pause_sc = inf->default_thread_pause_sc;
558 proc->detach_sc = inf->default_thread_detach_sc;
559 proc->resume_sc = proc->run_sc;
563 proc->state_valid = 0;
564 proc->state_changed = 0;
566 proc_debug (proc, "is new");
568 /* Get notified when things die. */
570 mach_port_request_notification (mach_task_self (), port,
571 MACH_NOTIFY_DEAD_NAME, 1,
573 MACH_MSG_TYPE_MAKE_SEND_ONCE,
576 warning ("Couldn't request notification for port %d: %s",
577 port, strerror (err));
580 proc_debug (proc, "notifications to: %d", inf->event_port);
581 if (prev_port != MACH_PORT_NULL)
582 mach_port_deallocate (mach_task_self (), prev_port);
585 if (inf->want_exceptions)
587 if (proc_is_task (proc))
588 /* Make the task exception port point to us. */
589 proc_steal_exc_port (proc, inf->event_port);
591 /* Just clear thread exception ports -- they default to the
593 proc_steal_exc_port (proc, MACH_PORT_NULL);
599 /* Frees PROC and any resources it uses, and returns the value of PROC's
602 _proc_free (struct proc *proc)
604 struct inf *inf = proc->inf;
605 struct proc *next = proc->next;
607 proc_debug (proc, "freeing...");
609 if (proc == inf->step_thread)
610 /* Turn off single stepping. */
611 inf_set_step_thread (inf, 0);
612 if (proc == inf->wait.thread)
613 inf_clear_wait (inf);
614 if (proc == inf->signal_thread)
615 inf->signal_thread = 0;
617 if (proc->port != MACH_PORT_NULL)
619 if (proc->exc_port != MACH_PORT_NULL)
620 /* Restore the original exception port. */
621 proc_restore_exc_port (proc);
622 if (proc->cur_sc != 0)
623 /* Resume the thread/task. */
626 proc_update_sc (proc);
628 mach_port_deallocate (mach_task_self (), proc->port);
639 struct inf *inf = malloc (sizeof (struct inf));
646 inf->threads_up_to_date = 0;
648 inf->wait.status.kind = TARGET_WAITKIND_SPURIOUS;
649 inf->wait.thread = 0;
650 inf->wait.exc.handler = MACH_PORT_NULL;
651 inf->wait.exc.reply = MACH_PORT_NULL;
652 inf->step_thread = 0;
653 inf->signal_thread = 0;
654 inf->event_port = MACH_PORT_NULL;
660 inf->pending_execs = 0;
663 inf->default_thread_run_sc = 0;
664 inf->default_thread_pause_sc = 0;
665 inf->default_thread_detach_sc = 0;
666 inf->want_signals = 1; /* By default */
667 inf->want_exceptions = 1; /* By default */
672 /* Clear INF's target wait status. */
674 inf_clear_wait (struct inf *inf)
676 inf_debug (inf, "clearing wait");
677 inf->wait.status.kind = TARGET_WAITKIND_SPURIOUS;
678 inf->wait.thread = 0;
679 inf->wait.suppress = 0;
680 if (inf->wait.exc.handler != MACH_PORT_NULL)
682 mach_port_deallocate (mach_task_self (), inf->wait.exc.handler);
683 inf->wait.exc.handler = MACH_PORT_NULL;
685 if (inf->wait.exc.reply != MACH_PORT_NULL)
687 mach_port_deallocate (mach_task_self (), inf->wait.exc.reply);
688 inf->wait.exc.reply = MACH_PORT_NULL;
694 inf_cleanup (struct inf *inf)
696 inf_debug (inf, "cleanup");
698 inf_clear_wait (inf);
700 inf_set_pid (inf, -1);
707 inf->pending_execs = 0;
711 mach_port_destroy (mach_task_self (), inf->event_port);
712 inf->event_port = MACH_PORT_NULL;
717 inf_startup (struct inf *inf, int pid)
721 inf_debug (inf, "startup: pid = %d", pid);
725 /* Make the port on which we receive all events. */
726 err = mach_port_allocate (mach_task_self (),
727 MACH_PORT_RIGHT_RECEIVE, &inf->event_port);
729 error ("Error allocating event port: %s", strerror (err));
731 /* Make a send right for it, so we can easily copy it for other people. */
732 mach_port_insert_right (mach_task_self (), inf->event_port,
733 inf->event_port, MACH_MSG_TYPE_MAKE_SEND);
734 inf_set_pid (inf, pid);
738 /* Close current process, if any, and attach INF to process PORT. */
740 inf_set_pid (struct inf *inf, pid_t pid)
743 struct proc *task = inf->task;
745 inf_debug (inf, "setting pid: %d", pid);
748 task_port = MACH_PORT_NULL;
751 error_t err = proc_pid2task (proc_server, pid, &task_port);
753 error ("Error getting task for pid %d: %s", pid, strerror (err));
756 inf_debug (inf, "setting task: %d", task_port);
759 task_suspend (task_port);
761 if (task && task->port != task_port)
764 inf_validate_procs (inf); /* Trash all the threads. */
765 _proc_free (task); /* And the task. */
768 if (task_port != MACH_PORT_NULL)
770 inf->task = make_proc (inf, task_port, PROC_TID_TASK);
771 inf->threads_up_to_date = 0;
778 /* Reflect task_suspend above. */
779 inf->task->sc = inf->task->cur_sc = 1;
786 /* Validates INF's stopped, nomsg and traced field from the actual
787 proc server state. Note that the traced field is only updated from
788 the proc server state if we do not have a message port. If we do
789 have a message port we'd better look at the tracemask itself. */
791 inf_validate_procinfo (struct inf *inf)
794 mach_msg_type_number_t noise_len = 0;
796 mach_msg_type_number_t pi_len = 0;
799 proc_getprocinfo (proc_server, inf->pid, &info_flags,
800 (procinfo_t *) &pi, &pi_len, &noise, &noise_len);
804 inf->stopped = !!(pi->state & PI_STOPPED);
805 inf->nomsg = !!(pi->state & PI_NOMSG);
807 inf->traced = !!(pi->state & PI_TRACED);
808 vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len);
810 vm_deallocate (mach_task_self (), (vm_address_t) noise, noise_len);
814 /* Validates INF's task suspend count. If it's higher than we expect,
815 verify with the user before `stealing' the extra count. */
817 inf_validate_task_sc (struct inf *inf)
820 mach_msg_type_number_t noise_len = 0;
822 mach_msg_type_number_t pi_len = 0;
823 int info_flags = PI_FETCH_TASKINFO;
824 int suspend_count = -1;
828 err = proc_getprocinfo (proc_server, inf->pid, &info_flags,
829 (procinfo_t *) &pi, &pi_len, &noise, &noise_len);
832 inf->task->dead = 1; /* oh well */
836 if (inf->task->cur_sc < pi->taskinfo.suspend_count && suspend_count == -1)
838 /* The proc server might have suspended the task while stopping
839 it. This happens when the task is handling a traced signal.
840 Refetch the suspend count. The proc server should be
841 finished stopping the task by now. */
842 suspend_count = pi->taskinfo.suspend_count;
846 suspend_count = pi->taskinfo.suspend_count;
848 vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len);
850 vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len);
852 if (inf->task->cur_sc < suspend_count)
856 target_terminal_ours (); /* Allow I/O. */
857 abort = !query ("Pid %d has an additional task suspend count of %d;"
858 " clear it? ", inf->pid,
859 suspend_count - inf->task->cur_sc);
860 target_terminal_inferior (); /* Give it back to the child. */
863 error ("Additional task suspend count left untouched.");
865 inf->task->cur_sc = suspend_count;
869 /* Turns tracing for INF on or off, depending on ON, unless it already
870 is. If INF is running, the resume_sc count of INF's threads will
871 be modified, and the signal thread will briefly be run to change
874 inf_set_traced (struct inf *inf, int on)
876 if (on == inf->traced)
879 if (inf->task && !inf->task->dead)
880 /* Make it take effect immediately. */
882 sigset_t mask = on ? ~(sigset_t) 0 : 0;
884 INF_RESUME_MSGPORT_RPC (inf, msg_set_init_int (msgport, refport,
885 INIT_TRACEMASK, mask));
889 warning ("Can't modify tracing state for pid %d: %s",
890 inf->pid, "No signal thread");
894 warning ("Can't modify tracing state for pid %d: %s",
895 inf->pid, strerror (err));
904 /* Makes all the real suspend count deltas of all the procs in INF
905 match the desired values. Careful to always do thread/task suspend
906 counts in the safe order. Returns true if at least one thread is
907 thought to be running. */
909 inf_update_suspends (struct inf *inf)
911 struct proc *task = inf->task;
912 /* We don't have to update INF->threads even though we're iterating over it
913 because we'll change a thread only if it already has an existing proc
916 inf_debug (inf, "updating suspend counts");
921 int task_running = (task->sc == 0), thread_running = 0;
923 if (task->sc > task->cur_sc)
924 /* The task is becoming _more_ suspended; do before any threads. */
925 task_running = proc_update_sc (task);
927 if (inf->pending_execs)
928 /* When we're waiting for an exec, things may be happening behind our
929 back, so be conservative. */
932 /* Do all the thread suspend counts. */
933 for (thread = inf->threads; thread; thread = thread->next)
934 thread_running |= proc_update_sc (thread);
936 if (task->sc != task->cur_sc)
937 /* We didn't do the task first, because we wanted to wait for the
938 threads; do it now. */
939 task_running = proc_update_sc (task);
941 inf_debug (inf, "%srunning...",
942 (thread_running && task_running) ? "" : "not ");
944 inf->running = thread_running && task_running;
946 /* Once any thread has executed some code, we can't depend on the
947 threads list any more. */
949 inf->threads_up_to_date = 0;
958 /* Converts a GDB pid to a struct proc. */
960 inf_tid_to_thread (struct inf *inf, int tid)
962 struct proc *thread = inf->threads;
965 if (thread->tid == tid)
968 thread = thread->next;
972 /* Converts a thread port to a struct proc. */
974 inf_port_to_thread (struct inf *inf, mach_port_t port)
976 struct proc *thread = inf->threads;
978 if (thread->port == port)
981 thread = thread->next;
986 /* Make INF's list of threads be consistent with reality of TASK. */
988 inf_validate_procs (struct inf *inf)
990 thread_array_t threads;
991 mach_msg_type_number_t num_threads, i;
992 struct proc *task = inf->task;
994 /* If no threads are currently running, this function will guarantee that
995 things are up to date. The exception is if there are zero threads --
996 then it is almost certainly in an odd state, and probably some outside
997 agent will create threads. */
998 inf->threads_up_to_date = inf->threads ? !inf->running : 0;
1002 error_t err = task_threads (task->port, &threads, &num_threads);
1003 inf_debug (inf, "fetching threads");
1005 /* TASK must be dead. */
1015 inf_debug (inf, "no task");
1019 /* Make things normally linear. */
1020 mach_msg_type_number_t search_start = 0;
1021 /* Which thread in PROCS corresponds to each task thread, & the task. */
1022 struct proc *matched[num_threads + 1];
1023 /* The last thread in INF->threads, so we can add to the end. */
1024 struct proc *last = 0;
1025 /* The current thread we're considering. */
1026 struct proc *thread = inf->threads;
1028 bzero (matched, sizeof (matched));
1032 mach_msg_type_number_t left;
1034 for (i = search_start, left = num_threads; left; i++, left--)
1036 if (i >= num_threads)
1037 i -= num_threads; /* I wrapped around. */
1038 if (thread->port == threads[i])
1039 /* We already know about this thread. */
1041 matched[i] = thread;
1043 thread = thread->next;
1051 proc_debug (thread, "died!");
1052 thread->port = MACH_PORT_NULL;
1053 thread = _proc_free (thread); /* THREAD is dead. */
1054 (last ? last->next : inf->threads) = thread;
1058 for (i = 0; i < num_threads; i++)
1061 /* Throw away the duplicate send right. */
1062 mach_port_deallocate (mach_task_self (), threads[i]);
1064 /* THREADS[I] is a thread we don't know about yet! */
1066 thread = make_proc (inf, threads[i], next_thread_id++);
1067 (last ? last->next : inf->threads) = thread;
1069 proc_debug (thread, "new thread: %d", threads[i]);
1070 add_thread (thread->tid); /* Tell GDB's generic thread code. */
1074 vm_deallocate (mach_task_self (),
1075 (vm_address_t) threads, (num_threads * sizeof (thread_t)));
1080 /* Makes sure that INF's thread list is synced with the actual process. */
1082 inf_update_procs (struct inf *inf)
1086 if (!inf->threads_up_to_date)
1087 inf_validate_procs (inf);
1091 /* Sets the resume_sc of each thread in inf. That of RUN_THREAD is set to 0,
1092 and others are set to their run_sc if RUN_OTHERS is true, and otherwise
1095 inf_set_threads_resume_sc (struct inf *inf,
1096 struct proc *run_thread, int run_others)
1098 struct proc *thread;
1099 inf_update_procs (inf);
1100 for (thread = inf->threads; thread; thread = thread->next)
1101 if (thread == run_thread)
1102 thread->resume_sc = 0;
1103 else if (run_others)
1104 thread->resume_sc = thread->run_sc;
1106 thread->resume_sc = thread->pause_sc;
1110 /* Cause INF to continue execution immediately; individual threads may still
1111 be suspended (but their suspend counts will be updated). */
1113 inf_resume (struct inf *inf)
1115 struct proc *thread;
1117 inf_update_procs (inf);
1119 for (thread = inf->threads; thread; thread = thread->next)
1120 thread->sc = thread->resume_sc;
1124 if (!inf->pending_execs)
1125 /* Try to make sure our task count is correct -- in the case where
1126 we're waiting for an exec though, things are too volatile, so just
1127 assume things will be reasonable (which they usually will be). */
1128 inf_validate_task_sc (inf);
1132 inf_update_suspends (inf);
1135 /* Cause INF to stop execution immediately; individual threads may still
1138 inf_suspend (struct inf *inf)
1140 struct proc *thread;
1142 inf_update_procs (inf);
1144 for (thread = inf->threads; thread; thread = thread->next)
1145 thread->sc = thread->pause_sc;
1148 inf->task->sc = inf->pause_sc;
1150 inf_update_suspends (inf);
1154 /* INF has one thread PROC that is in single-stepping mode. This
1155 function changes it to be PROC, changing any old step_thread to be
1156 a normal one. A PROC of 0 clears any existing value. */
1158 inf_set_step_thread (struct inf *inf, struct proc *thread)
1160 assert (!thread || proc_is_thread (thread));
1163 inf_debug (inf, "setting step thread: %d/%d", inf->pid, thread->tid);
1165 inf_debug (inf, "clearing step thread");
1167 if (inf->step_thread != thread)
1169 if (inf->step_thread && inf->step_thread->port != MACH_PORT_NULL)
1170 if (!proc_trace (inf->step_thread, 0))
1172 if (thread && proc_trace (thread, 1))
1173 inf->step_thread = thread;
1175 inf->step_thread = 0;
1180 /* Set up the thread resume_sc's so that only the signal thread is running
1181 (plus whatever other thread are set to always run). Returns true if we
1182 did so, or false if we can't find a signal thread. */
1184 inf_set_threads_resume_sc_for_signal_thread (struct inf *inf)
1186 if (inf->signal_thread)
1188 inf_set_threads_resume_sc (inf, inf->signal_thread, 0);
1196 inf_update_signal_thread (struct inf *inf)
1198 /* XXX for now we assume that if there's a msgport, the 2nd thread is
1199 the signal thread. */
1200 inf->signal_thread = inf->threads ? inf->threads->next : 0;
1204 /* Detachs from INF's inferior task, letting it run once again... */
1206 inf_detach (struct inf *inf)
1208 struct proc *task = inf->task;
1210 inf_debug (inf, "detaching...");
1212 inf_clear_wait (inf);
1213 inf_set_step_thread (inf, 0);
1217 struct proc *thread;
1219 inf_validate_procinfo (inf);
1221 inf_set_traced (inf, 0);
1227 inf_signal (inf, TARGET_SIGNAL_0);
1230 proc_restore_exc_port (task);
1231 task->sc = inf->detach_sc;
1233 for (thread = inf->threads; thread; thread = thread->next)
1235 proc_restore_exc_port (thread);
1236 thread->sc = thread->detach_sc;
1239 inf_update_suspends (inf);
1245 /* Attaches INF to the process with process id PID, returning it in a
1246 suspended state suitable for debugging. */
1248 inf_attach (struct inf *inf, int pid)
1250 inf_debug (inf, "attaching: %d", pid);
1255 inf_startup (inf, pid);
1259 /* Makes sure that we've got our exception ports entrenched in the process. */
1261 inf_steal_exc_ports (struct inf *inf)
1263 struct proc *thread;
1265 inf_debug (inf, "stealing exception ports");
1267 inf_set_step_thread (inf, 0); /* The step thread is special. */
1269 proc_steal_exc_port (inf->task, inf->event_port);
1270 for (thread = inf->threads; thread; thread = thread->next)
1271 proc_steal_exc_port (thread, MACH_PORT_NULL);
1274 /* Makes sure the process has its own exception ports. */
1276 inf_restore_exc_ports (struct inf *inf)
1278 struct proc *thread;
1280 inf_debug (inf, "restoring exception ports");
1282 inf_set_step_thread (inf, 0); /* The step thread is special. */
1284 proc_restore_exc_port (inf->task);
1285 for (thread = inf->threads; thread; thread = thread->next)
1286 proc_restore_exc_port (thread);
1290 /* Deliver signal SIG to INF. If INF is stopped, delivering a signal, even
1291 signal 0, will continue it. INF is assumed to be in a paused state, and
1292 the resume_sc's of INF's threads may be affected. */
1294 inf_signal (struct inf *inf, enum target_signal sig)
1297 int host_sig = target_signal_to_host (sig);
1299 #define NAME target_signal_to_name (sig)
1301 if (host_sig >= _NSIG)
1302 /* A mach exception. Exceptions are encoded in the signal space by
1303 putting them after _NSIG; this assumes they're positive (and not
1304 extremely large)! */
1306 struct inf_wait *w = &inf->wait;
1307 if (w->status.kind == TARGET_WAITKIND_STOPPED
1308 && w->status.value.sig == sig
1309 && w->thread && !w->thread->aborted)
1310 /* We're passing through the last exception we received. This is
1311 kind of bogus, because exceptions are per-thread whereas gdb
1312 treats signals as per-process. We just forward the exception to
1313 the correct handler, even it's not for the same thread as TID --
1314 i.e., we pretend it's global. */
1316 struct exc_state *e = &w->exc;
1317 inf_debug (inf, "passing through exception:"
1318 " task = %d, thread = %d, exc = %d"
1319 ", code = %d, subcode = %d",
1320 w->thread->port, inf->task->port,
1321 e->exception, e->code, e->subcode);
1323 exception_raise_request (e->handler,
1324 e->reply, MACH_MSG_TYPE_MOVE_SEND_ONCE,
1325 w->thread->port, inf->task->port,
1326 e->exception, e->code, e->subcode);
1329 error ("Can't forward spontaneous exception (%s).", NAME);
1332 /* A Unix signal. */
1334 /* The process is stopped and expecting a signal. Just send off a
1335 request and let it get handled when we resume everything. */
1337 inf_debug (inf, "sending %s to stopped process", NAME);
1339 INF_MSGPORT_RPC (inf,
1340 msg_sig_post_untraced_request (msgport,
1342 MACH_MSG_TYPE_MAKE_SEND_ONCE,
1346 /* Posting an untraced signal automatically continues it.
1347 We clear this here rather than when we get the reply
1348 because we'd rather assume it's not stopped when it
1349 actually is, than the reverse. */
1353 /* It's not expecting it. We have to let just the signal thread
1354 run, and wait for it to get into a reasonable state before we
1355 can continue the rest of the process. When we finally resume the
1356 process the signal we request will be the very first thing that
1359 inf_debug (inf, "sending %s to unstopped process"
1360 " (so resuming signal thread)", NAME);
1362 INF_RESUME_MSGPORT_RPC (inf,
1363 msg_sig_post_untraced (msgport, host_sig,
1368 /* Can't do too much... */
1369 warning ("Can't deliver signal %s: No signal thread.", NAME);
1371 warning ("Delivering signal %s: %s", NAME, strerror (err));
1377 /* Continue INF without delivering a signal. This is meant to be used
1378 when INF does not have a message port. */
1380 inf_continue (struct inf *inf)
1383 error_t err = proc_pid2proc (proc_server, inf->pid, &proc);
1387 inf_debug (inf, "continuing process");
1389 err = proc_mark_cont (proc);
1392 struct proc *thread;
1394 for (thread = inf->threads; thread; thread = thread->next)
1395 thread_resume (thread->port);
1402 warning ("Can't continue process: %s", strerror (err));
1406 /* The inferior used for all gdb target ops. */
1407 struct inf *current_inferior = 0;
1409 /* The inferior being waited for by gnu_wait. Since GDB is decidely not
1410 multi-threaded, we don't bother to lock this. */
1411 struct inf *waiting_inf;
1413 /* Wait for something to happen in the inferior, returning what in STATUS. */
1415 gnu_wait (int tid, struct target_waitstatus *status)
1419 mach_msg_header_t hdr;
1420 mach_msg_type_t type;
1424 struct proc *thread;
1425 struct inf *inf = current_inferior;
1427 extern int exc_server (mach_msg_header_t *, mach_msg_header_t *);
1428 extern int msg_reply_server (mach_msg_header_t *, mach_msg_header_t *);
1429 extern int notify_server (mach_msg_header_t *, mach_msg_header_t *);
1430 extern int process_reply_server (mach_msg_header_t *, mach_msg_header_t *);
1434 if (!inf->threads && !inf->pending_execs)
1435 /* No threads! Assume that maybe some outside agency is frobbing our
1436 task, and really look for new threads. If we can't find any, just tell
1437 the user to try again later. */
1439 inf_validate_procs (inf);
1440 if (!inf->threads && !inf->task->dead)
1441 error ("There are no threads; try again later.");
1446 inf_debug (inf, "waiting for: %d", tid);
1449 if (proc_wait_pid != inf->pid && !inf->no_wait)
1450 /* Always get information on events from the proc server. */
1452 inf_debug (inf, "requesting wait on pid %d", inf->pid);
1455 /* The proc server is single-threaded, and only allows a single
1456 outstanding wait request, so we have to cancel the previous one. */
1458 inf_debug (inf, "cancelling previous wait on pid %d", proc_wait_pid);
1459 interrupt_operation (proc_server, 0);
1463 proc_wait_request (proc_server, inf->event_port, inf->pid, WUNTRACED);
1465 warning ("wait request failed: %s", strerror (err));
1468 inf_debug (inf, "waits pending: %d", proc_waits_pending);
1469 proc_wait_pid = inf->pid;
1470 /* Even if proc_waits_pending was > 0 before, we still won't
1471 get any other replies, because it was either from a
1472 different INF, or a different process attached to INF --
1473 and the event port, which is the wait reply port, changes
1474 when you switch processes. */
1475 proc_waits_pending = 1;
1479 inf_clear_wait (inf);
1481 /* What can happen? (1) Dead name notification; (2) Exceptions arrive;
1482 (3) wait reply from the proc server. */
1484 inf_debug (inf, "waiting for an event...");
1485 err = mach_msg (&msg.hdr, MACH_RCV_MSG | MACH_RCV_INTERRUPT,
1486 0, sizeof (struct msg), inf->event_port,
1487 MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
1489 /* Re-suspend the task. */
1492 if (!inf->task && inf->pending_execs)
1493 /* When doing an exec, it's possible that the old task wasn't reused
1494 (e.g., setuid execs). So if the task seems to have disappeared,
1495 attempt to refetch it, as the pid should still be the same. */
1496 inf_set_pid (inf, inf->pid);
1498 if (err == EMACH_RCV_INTERRUPTED)
1499 inf_debug (inf, "interrupted");
1501 error ("Couldn't wait for an event: %s", strerror (err));
1506 mach_msg_header_t hdr;
1507 mach_msg_type_t err_type;
1513 inf_debug (inf, "event: msgid = %d", msg.hdr.msgh_id);
1515 /* Handle what we got. */
1516 if (!notify_server (&msg.hdr, &reply.hdr)
1517 && !exc_server (&msg.hdr, &reply.hdr)
1518 && !process_reply_server (&msg.hdr, &reply.hdr)
1519 && !msg_reply_server (&msg.hdr, &reply.hdr))
1520 /* Whatever it is, it's something strange. */
1521 error ("Got a strange event, msg id = %d.", msg.hdr.msgh_id);
1524 error ("Handling event, msgid = %d: %s",
1525 msg.hdr.msgh_id, strerror (reply.err));
1528 if (inf->pending_execs)
1529 /* We're waiting for the inferior to finish execing. */
1531 struct inf_wait *w = &inf->wait;
1532 enum target_waitkind kind = w->status.kind;
1534 if (kind == TARGET_WAITKIND_SPURIOUS)
1535 /* Since gdb is actually counting the number of times the inferior
1536 stops, expecting one stop per exec, we only return major events
1540 inf_debug (inf, "pending_execs = %d, ignoring minor event",
1541 inf->pending_execs);
1543 else if (kind == TARGET_WAITKIND_STOPPED
1544 && w->status.value.sig == TARGET_SIGNAL_TRAP)
1545 /* Ah hah! A SIGTRAP from the inferior while starting up probably
1546 means we've succesfully completed an exec! */
1548 if (--inf->pending_execs == 0)
1551 #if 0 /* do we need this? */
1552 prune_threads (1); /* Get rid of the old shell threads */
1553 renumber_threads (0); /* Give our threads reasonable names. */
1556 inf_debug (inf, "pending exec completed, pending_execs => %d",
1557 inf->pending_execs);
1559 else if (kind == TARGET_WAITKIND_STOPPED)
1560 /* It's possible that this signal is because of a crashed process
1561 being handled by the hurd crash server; in this case, the process
1562 will have an extra task suspend, which we need to know about.
1563 Since the code in inf_resume that normally checks for this is
1564 disabled while INF->pending_execs, we do the check here instead. */
1565 inf_validate_task_sc (inf);
1568 if (inf->wait.suppress)
1569 /* Some totally spurious event happened that we don't consider
1570 worth returning to gdb. Just keep waiting. */
1572 inf_debug (inf, "suppressing return, rewaiting...");
1577 /* Pass back out our results. */
1578 bcopy (&inf->wait.status, status, sizeof (*status));
1580 thread = inf->wait.thread;
1584 thread = inf_tid_to_thread (inf, tid);
1586 if (!thread || thread->port == MACH_PORT_NULL)
1588 /* TID is dead; try and find a new thread. */
1589 if (inf_update_procs (inf) && inf->threads)
1590 tid = inf->threads->tid; /* The first available thread. */
1592 tid = inferior_pid; /* let wait_for_inferior handle exit case */
1595 if (thread && tid >= 0 && status->kind != TARGET_WAITKIND_SPURIOUS
1596 && inf->pause_sc == 0 && thread->pause_sc == 0)
1597 /* If something actually happened to THREAD, make sure we
1601 inf_update_suspends (inf);
1604 inf_debug (inf, "returning tid = %d, status = %s (%d)", tid,
1605 status->kind == TARGET_WAITKIND_EXITED ? "EXITED"
1606 : status->kind == TARGET_WAITKIND_STOPPED ? "STOPPED"
1607 : status->kind == TARGET_WAITKIND_SIGNALLED ? "SIGNALLED"
1608 : status->kind == TARGET_WAITKIND_LOADED ? "LOADED"
1609 : status->kind == TARGET_WAITKIND_SPURIOUS ? "SPURIOUS"
1611 status->value.integer);
1617 /* The rpc handler called by exc_server. */
1619 S_exception_raise_request (mach_port_t port, mach_port_t reply_port,
1620 thread_t thread_port, task_t task_port,
1621 int exception, int code, int subcode)
1623 struct inf *inf = waiting_inf;
1624 struct proc *thread = inf_port_to_thread (inf, thread_port);
1626 inf_debug (waiting_inf,
1627 "thread = %d, task = %d, exc = %d, code = %d, subcode = %d",
1628 thread_port, task_port, exception, code, subcode);
1631 /* We don't know about thread? */
1633 inf_update_procs (inf);
1634 thread = inf_port_to_thread (inf, thread_port);
1636 /* Give up, the generating thread is gone. */
1640 mach_port_deallocate (mach_task_self (), thread_port);
1641 mach_port_deallocate (mach_task_self (), task_port);
1643 if (!thread->aborted)
1644 /* THREAD hasn't been aborted since this exception happened (abortion
1645 clears any exception state), so it must be real. */
1647 /* Store away the details; this will destroy any previous info. */
1648 inf->wait.thread = thread;
1650 inf->wait.status.kind = TARGET_WAITKIND_STOPPED;
1652 if (exception == EXC_BREAKPOINT)
1653 /* GDB likes to get SIGTRAP for breakpoints. */
1655 inf->wait.status.value.sig = TARGET_SIGNAL_TRAP;
1656 mach_port_deallocate (mach_task_self (), reply_port);
1659 /* Record the exception so that we can forward it later. */
1661 if (thread->exc_port == port)
1663 inf_debug (waiting_inf, "Handler is thread exception port <%d>",
1664 thread->saved_exc_port);
1665 inf->wait.exc.handler = thread->saved_exc_port;
1669 inf_debug (waiting_inf, "Handler is task exception port <%d>",
1670 inf->task->saved_exc_port);
1671 inf->wait.exc.handler = inf->task->saved_exc_port;
1672 assert (inf->task->exc_port == port);
1674 if (inf->wait.exc.handler != MACH_PORT_NULL)
1675 /* Add a reference to the exception handler. */
1676 mach_port_mod_refs (mach_task_self (),
1677 inf->wait.exc.handler, MACH_PORT_RIGHT_SEND,
1680 inf->wait.exc.exception = exception;
1681 inf->wait.exc.code = code;
1682 inf->wait.exc.subcode = subcode;
1683 inf->wait.exc.reply = reply_port;
1685 /* Exceptions are encoded in the signal space by putting them after
1686 _NSIG; this assumes they're positive (and not extremely large)! */
1687 inf->wait.status.value.sig =
1688 target_signal_from_host (_NSIG + exception);
1692 /* A supppressed exception, which ignore. */
1694 inf->wait.suppress = 1;
1695 mach_port_deallocate (mach_task_self (), reply_port);
1702 /* Fill in INF's wait field after a task has died without giving us more
1703 detailed information. */
1705 inf_task_died_status (struct inf *inf)
1707 warning ("Pid %d died with unknown exit status, using SIGKILL.", inf->pid);
1708 inf->wait.status.kind = TARGET_WAITKIND_SIGNALLED;
1709 inf->wait.status.value.sig = TARGET_SIGNAL_KILL;
1712 /* Notify server routines. The only real one is dead name notification. */
1714 do_mach_notify_dead_name (mach_port_t notify, mach_port_t dead_port)
1716 struct inf *inf = waiting_inf;
1718 inf_debug (waiting_inf, "port = %d", dead_port);
1720 if (inf->task && inf->task->port == dead_port)
1722 proc_debug (inf->task, "is dead");
1723 inf->task->port = MACH_PORT_NULL;
1724 if (proc_wait_pid == inf->pid)
1725 /* We have a wait outstanding on the process, which will return more
1726 detailed information, so delay until we get that. */
1727 inf->wait.suppress = 1;
1729 /* We never waited for the process (maybe it wasn't a child), so just
1730 pretend it got a SIGKILL. */
1731 inf_task_died_status (inf);
1735 struct proc *thread = inf_port_to_thread (inf, dead_port);
1738 proc_debug (thread, "is dead");
1739 thread->port = MACH_PORT_NULL;
1742 if (inf->task->dead)
1743 /* Since the task is dead, its threads are dying with it. */
1744 inf->wait.suppress = 1;
1747 mach_port_deallocate (mach_task_self (), dead_port);
1748 inf->threads_up_to_date = 0; /* Just in case */
1757 warning ("illegal rpc: %s", fun);
1762 do_mach_notify_no_senders (mach_port_t notify, mach_port_mscount_t count)
1764 return ill_rpc (__FUNCTION__);
1768 do_mach_notify_port_deleted (mach_port_t notify, mach_port_t name)
1770 return ill_rpc (__FUNCTION__);
1774 do_mach_notify_msg_accepted (mach_port_t notify, mach_port_t name)
1776 return ill_rpc (__FUNCTION__);
1780 do_mach_notify_port_destroyed (mach_port_t notify, mach_port_t name)
1782 return ill_rpc (__FUNCTION__);
1786 do_mach_notify_send_once (mach_port_t notify)
1788 return ill_rpc (__FUNCTION__);
1792 /* Process_reply server routines. We only use process_wait_reply. */
1795 S_proc_wait_reply (mach_port_t reply, error_t err,
1796 int status, int sigcode, rusage_t rusage, pid_t pid)
1798 struct inf *inf = waiting_inf;
1800 inf_debug (inf, "err = %s, pid = %d, status = 0x%x, sigcode = %d",
1801 err ? strerror (err) : "0", pid, status, sigcode);
1803 if (err && proc_wait_pid && (!inf->task || !inf->task->port))
1804 /* Ack. The task has died, but the task-died notification code didn't
1805 tell anyone because it thought a more detailed reply from the
1806 procserver was forthcoming. However, we now learn that won't
1807 happen... So we have to act like the task just died, and this time,
1809 inf_task_died_status (inf);
1811 if (--proc_waits_pending == 0)
1812 /* PROC_WAIT_PID represents the most recent wait. We will always get
1813 replies in order because the proc server is single threaded. */
1816 inf_debug (inf, "waits pending now: %d", proc_waits_pending);
1822 warning ("Can't wait for pid %d: %s", inf->pid, strerror (err));
1825 /* Since we can't see the inferior's signals, don't trap them. */
1826 inf_set_traced (inf, 0);
1829 else if (pid == inf->pid)
1831 store_waitstatus (&inf->wait.status, status);
1832 if (inf->wait.status.kind == TARGET_WAITKIND_STOPPED)
1833 /* The process has sent us a signal, and stopped itself in a sane
1834 state pending our actions. */
1836 inf_debug (inf, "process has stopped itself");
1841 inf->wait.suppress = 1; /* Something odd happened. Ignore. */
1847 S_proc_setmsgport_reply (mach_port_t reply, error_t err,
1848 mach_port_t old_msg_port)
1850 return ill_rpc (__FUNCTION__);
1854 S_proc_getmsgport_reply (mach_port_t reply, error_t err, mach_port_t msg_port)
1856 return ill_rpc (__FUNCTION__);
1860 /* Msg_reply server routines. We only use msg_sig_post_untraced_reply. */
1863 S_msg_sig_post_untraced_reply (mach_port_t reply, error_t err)
1865 struct inf *inf = waiting_inf;
1868 /* EBUSY is what we get when the crash server has grabbed control of the
1869 process and doesn't like what signal we tried to send it. Just act
1870 like the process stopped (using a signal of 0 should mean that the
1871 *next* time the user continues, it will pass signal 0, which the crash
1872 server should like). */
1874 inf->wait.status.kind = TARGET_WAITKIND_STOPPED;
1875 inf->wait.status.value.sig = TARGET_SIGNAL_0;
1878 warning ("Signal delivery failed: %s", strerror (err));
1881 /* We only get this reply when we've posted a signal to a process which we
1882 thought was stopped, and which we expected to continue after the signal.
1883 Given that the signal has failed for some reason, it's reasonable to
1884 assume it's still stopped. */
1887 inf->wait.suppress = 1;
1893 S_msg_sig_post_reply (mach_port_t reply, error_t err)
1895 return ill_rpc (__FUNCTION__);
1899 /* Returns the number of messages queued for the receive right PORT. */
1900 static mach_port_msgcount_t
1901 port_msgs_queued (mach_port_t port)
1903 struct mach_port_status status;
1905 mach_port_get_receive_status (mach_task_self (), port, &status);
1910 return status.mps_msgcount;
1914 /* Resume execution of the inferior process.
1916 If STEP is nonzero, single-step it.
1917 If SIGNAL is nonzero, give it that signal.
1920 -1 true Single step the current thread allowing other threads to run.
1921 -1 false Continue the current thread allowing other threads to run.
1922 X true Single step the given thread, don't allow any others to run.
1923 X false Continue the given thread, do not allow any others to run.
1924 (Where X, of course, is anything except -1)
1926 Note that a resume may not `take' if there are pending exceptions/&c
1927 still unprocessed from the last resume we did (any given resume may result
1928 in multiple events returned by wait).
1931 gnu_resume (int tid, int step, enum target_signal sig)
1933 struct proc *step_thread = 0;
1934 struct inf *inf = current_inferior;
1936 inf_debug (inf, "tid = %d, step = %d, sig = %d", tid, step, sig);
1938 inf_validate_procinfo (inf);
1940 if (sig != TARGET_SIGNAL_0 || inf->stopped)
1942 if (sig == TARGET_SIGNAL_0 && inf->nomsg)
1945 inf_signal (inf, sig);
1947 else if (inf->wait.exc.reply != MACH_PORT_NULL)
1948 /* We received an exception to which we have chosen not to forward, so
1949 abort the faulting thread, which will perhaps retake it. */
1951 proc_abort (inf->wait.thread, 1);
1952 warning ("Aborting %s with unforwarded exception %s.",
1953 proc_string (inf->wait.thread),
1954 target_signal_to_name (inf->wait.status.value.sig));
1957 if (port_msgs_queued (inf->event_port))
1958 /* If there are still messages in our event queue, don't bother resuming
1959 the process, as we're just going to stop it right away anyway. */
1962 inf_update_procs (inf);
1965 /* Allow all threads to run, except perhaps single-stepping one. */
1967 inf_debug (inf, "running all threads; tid = %d", inferior_pid);
1968 tid = inferior_pid; /* What to step. */
1969 inf_set_threads_resume_sc (inf, 0, 1);
1972 /* Just allow a single thread to run. */
1974 struct proc *thread = inf_tid_to_thread (inf, tid);
1976 error ("Can't run single thread id %d: no such thread!");
1977 inf_debug (inf, "running one thread: %d/%d", inf->pid, thread->tid);
1978 inf_set_threads_resume_sc (inf, thread, 0);
1983 step_thread = inf_tid_to_thread (inf, tid);
1985 warning ("Can't step thread id %d: no such thread.", tid);
1987 inf_debug (inf, "stepping thread: %d/%d", inf->pid, step_thread->tid);
1989 if (step_thread != inf->step_thread)
1990 inf_set_step_thread (inf, step_thread);
1992 inf_debug (inf, "here we go...");
1998 gnu_kill_inferior (void)
2000 struct proc *task = current_inferior->task;
2003 proc_debug (task, "terminating...");
2004 task_terminate (task->port);
2005 inf_set_pid (current_inferior, -1);
2007 target_mourn_inferior ();
2010 /* Clean up after the inferior dies. */
2012 gnu_mourn_inferior (void)
2014 inf_debug (current_inferior, "rip");
2015 inf_detach (current_inferior);
2016 unpush_target (&gnu_ops);
2017 generic_mourn_inferior ();
2021 /* Fork an inferior process, and start debugging it. */
2023 /* Set INFERIOR_PID to the first thread available in the child, if any. */
2025 inf_pick_first_thread (void)
2027 if (current_inferior->task && current_inferior->threads)
2028 /* The first thread. */
2029 return current_inferior->threads->tid;
2031 /* What may be the next thread. */
2032 return next_thread_id;
2038 if (!current_inferior)
2039 current_inferior = make_inf ();
2040 return current_inferior;
2044 gnu_create_inferior (char *exec_file, char *allargs, char **env)
2046 struct inf *inf = cur_inf ();
2050 /* We're in the child; make this process stop as soon as it execs. */
2051 inf_debug (inf, "tracing self");
2052 if (ptrace (PTRACE_TRACEME) != 0)
2053 error ("ptrace (PTRACE_TRACEME) failed!");
2055 void attach_to_child (int pid)
2057 /* Attach to the now stopped child, which is actually a shell... */
2058 inf_debug (inf, "attaching to child: %d", pid);
2060 inf_attach (inf, pid);
2063 push_target (&gnu_ops);
2065 inf->pending_execs = 2;
2069 /* Now let the child run again, knowing that it will stop immediately
2070 because of the ptrace. */
2072 inferior_pid = inf_pick_first_thread ();
2074 startup_inferior (inf->pending_execs);
2077 inf_debug (inf, "creating inferior");
2079 fork_inferior (exec_file, allargs, env, trace_me, attach_to_child,
2082 inf_validate_procinfo (inf);
2083 inf_update_signal_thread (inf);
2084 inf_set_traced (inf, inf->want_signals);
2086 /* Execing the process will have trashed our exception ports; steal them
2087 back (or make sure they're restored if the user wants that). */
2088 if (inf->want_exceptions)
2089 inf_steal_exc_ports (inf);
2091 inf_restore_exc_ports (inf);
2094 proceed ((CORE_ADDR) -1, 0, 0);
2097 /* Mark our target-struct as eligible for stray "run" and "attach"
2106 #ifdef ATTACH_DETACH
2108 /* Attach to process PID, then initialize for debugging it
2109 and wait for the trace-trap that results from attaching. */
2111 gnu_attach (char *args, int from_tty)
2115 struct inf *inf = cur_inf ();
2118 error_no_arg ("process-id to attach");
2122 if (pid == getpid ()) /* Trying to masturbate? */
2123 error ("I refuse to debug myself!");
2127 exec_file = (char *) get_exec_file (0);
2130 printf_unfiltered ("Attaching to program `%s', pid %d\n",
2133 printf_unfiltered ("Attaching to pid %d\n", pid);
2135 gdb_flush (gdb_stdout);
2138 inf_debug (inf, "attaching to pid: %d", pid);
2140 inf_attach (inf, pid);
2141 inf_update_procs (inf);
2143 inferior_pid = inf_pick_first_thread ();
2146 push_target (&gnu_ops);
2148 /* We have to initialize the terminal settings now, since the code
2149 below might try to restore them. */
2150 target_terminal_init ();
2152 /* If the process was stopped before we attached, make it continue the next
2153 time the user does a continue. */
2154 inf_validate_procinfo (inf);
2156 inf_update_signal_thread (inf);
2157 inf_set_traced (inf, inf->want_signals);
2159 #if 0 /* Do we need this? */
2160 renumber_threads (0); /* Give our threads reasonable names. */
2165 /* Take a program previously attached to and detaches it.
2166 The program resumes execution and will no longer stop
2167 on signals, etc. We'd better not have left any breakpoints
2168 in the program or it'll die when it hits one. For this
2169 to work, it may be necessary for the process to have been
2170 previously attached. It *might* work if the program was
2171 started via fork. */
2173 gnu_detach (char *args, int from_tty)
2177 char *exec_file = get_exec_file (0);
2179 printf_unfiltered ("Detaching from program `%s' pid %d\n",
2180 exec_file, current_inferior->pid);
2182 printf_unfiltered ("Detaching from pid %d\n", current_inferior->pid);
2183 gdb_flush (gdb_stdout);
2186 inf_detach (current_inferior);
2190 unpush_target (&gnu_ops); /* Pop out of handling an inferior */
2192 #endif /* ATTACH_DETACH */
2196 gnu_terminal_init_inferior (void)
2198 assert (current_inferior);
2199 terminal_init_inferior_with_pgrp (current_inferior->pid);
2202 /* Get ready to modify the registers array. On machines which store
2203 individual registers, this doesn't need to do anything. On machines
2204 which store all the registers in one fell swoop, this makes sure
2205 that registers contains all the registers from the program being
2208 gnu_prepare_to_store (void)
2210 #ifdef CHILD_PREPARE_TO_STORE
2211 CHILD_PREPARE_TO_STORE ();
2216 gnu_open (char *arg, int from_tty)
2218 error ("Use the \"run\" command to start a Unix child process.");
2224 error ("to_stop target function not implemented");
2228 gnu_pid_to_exec_file (void)
2230 error ("to_pid_to_exec_file target function not implemented");
2236 gnu_thread_alive (int tid)
2238 inf_update_procs (current_inferior);
2239 return !!inf_tid_to_thread (current_inferior, tid);
2243 /* Read inferior task's LEN bytes from ADDR and copy it to MYADDR in
2244 gdb's address space. Return 0 on failure; number of bytes read
2247 gnu_read_inferior (task_t task, CORE_ADDR addr, char *myaddr, int length)
2250 vm_address_t low_address = (vm_address_t) trunc_page (addr);
2251 vm_size_t aligned_length =
2252 (vm_size_t) round_page (addr + length) - low_address;
2256 /* Get memory from inferior with page aligned addresses */
2257 err = vm_read (task, low_address, aligned_length, &copied, ©_count);
2261 err = hurd_safe_copyin (myaddr, (void *) addr - low_address + copied, length);
2264 warning ("Read from inferior faulted: %s", strerror (err));
2268 err = vm_deallocate (mach_task_self (), copied, copy_count);
2270 warning ("gnu_read_inferior vm_deallocate failed: %s", strerror (err));
2275 #define CHK_GOTO_OUT(str,ret) \
2276 do if (ret != KERN_SUCCESS) { errstr = #str; goto out; } while(0)
2278 struct vm_region_list
2280 struct vm_region_list *next;
2281 vm_prot_t protection;
2286 struct obstack region_obstack;
2288 /* Write gdb's LEN bytes from MYADDR and copy it to ADDR in inferior
2289 task's address space. */
2291 gnu_write_inferior (task_t task, CORE_ADDR addr, char *myaddr, int length)
2294 vm_address_t low_address = (vm_address_t) trunc_page (addr);
2295 vm_size_t aligned_length =
2296 (vm_size_t) round_page (addr + length) - low_address;
2301 char *errstr = "Bug in gnu_write_inferior";
2303 struct vm_region_list *region_element;
2304 struct vm_region_list *region_head = (struct vm_region_list *) NULL;
2306 /* Get memory from inferior with page aligned addresses */
2307 err = vm_read (task,
2312 CHK_GOTO_OUT ("gnu_write_inferior vm_read failed", err);
2316 err = hurd_safe_copyout ((void *) addr - low_address + copied,
2318 CHK_GOTO_OUT ("Write to inferior faulted", err);
2320 obstack_init (®ion_obstack);
2322 /* Do writes atomically.
2323 First check for holes and unwritable memory. */
2325 vm_size_t remaining_length = aligned_length;
2326 vm_address_t region_address = low_address;
2328 struct vm_region_list *scan;
2330 while (region_address < low_address + aligned_length)
2332 vm_prot_t protection;
2333 vm_prot_t max_protection;
2334 vm_inherit_t inheritance;
2336 mach_port_t object_name;
2338 vm_size_t region_length = remaining_length;
2339 vm_address_t old_address = region_address;
2341 err = vm_region (task,
2350 CHK_GOTO_OUT ("vm_region failed", err);
2352 /* Check for holes in memory */
2353 if (old_address != region_address)
2355 warning ("No memory at 0x%x. Nothing written",
2362 if (!(max_protection & VM_PROT_WRITE))
2364 warning ("Memory at address 0x%x is unwritable. Nothing written",
2371 /* Chain the regions for later use */
2373 (struct vm_region_list *)
2374 obstack_alloc (®ion_obstack, sizeof (struct vm_region_list));
2376 region_element->protection = protection;
2377 region_element->start = region_address;
2378 region_element->length = region_length;
2380 /* Chain the regions along with protections */
2381 region_element->next = region_head;
2382 region_head = region_element;
2384 region_address += region_length;
2385 remaining_length = remaining_length - region_length;
2388 /* If things fail after this, we give up.
2389 Somebody is messing up inferior_task's mappings. */
2391 /* Enable writes to the chained vm regions */
2392 for (scan = region_head; scan; scan = scan->next)
2394 if (!(scan->protection & VM_PROT_WRITE))
2396 err = vm_protect (task,
2400 scan->protection | VM_PROT_WRITE);
2401 CHK_GOTO_OUT ("vm_protect: enable write failed", err);
2405 err = vm_write (task,
2409 CHK_GOTO_OUT ("vm_write failed", err);
2411 /* Set up the original region protections, if they were changed */
2412 for (scan = region_head; scan; scan = scan->next)
2414 if (!(scan->protection & VM_PROT_WRITE))
2416 err = vm_protect (task,
2421 CHK_GOTO_OUT ("vm_protect: enable write failed", err);
2429 obstack_free (®ion_obstack, 0);
2431 (void) vm_deallocate (mach_task_self (),
2436 if (err != KERN_SUCCESS)
2438 warning ("%s: %s", errstr, mach_error_string (err));
2446 /* Return 0 on failure, number of bytes handled otherwise. TARGET
2449 gnu_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
2450 struct target_ops *target)
2452 task_t task = (current_inferior
2453 ? (current_inferior->task
2454 ? current_inferior->task->port : 0)
2457 if (task == MACH_PORT_NULL)
2461 inf_debug (current_inferior, "%s %p[%d] %s %p",
2462 write ? "writing" : "reading", memaddr, len,
2463 write ? "<--" : "-->", myaddr);
2465 return gnu_write_inferior (task, memaddr, myaddr, len);
2467 return gnu_read_inferior (task, memaddr, myaddr, len);
2472 /* Return printable description of proc. */
2474 proc_string (struct proc *proc)
2476 static char tid_str[80];
2477 if (proc_is_task (proc))
2478 sprintf (tid_str, "process %d", proc->inf->pid);
2480 sprintf (tid_str, "thread %d.%d",
2481 proc->inf->pid, pid_to_thread_id (proc->tid));
2486 gnu_pid_to_str (int tid)
2488 struct inf *inf = current_inferior;
2489 struct proc *thread = inf_tid_to_thread (inf, tid);
2492 return proc_string (thread);
2495 static char tid_str[80];
2496 sprintf (tid_str, "bogus thread id %d", tid);
2502 extern void gnu_store_registers (int regno);
2503 extern void gnu_fetch_registers (int regno);
2505 struct target_ops gnu_ops;
2510 gnu_ops.to_shortname = "GNU"; /* to_shortname */
2511 gnu_ops.to_longname = "GNU Hurd process"; /* to_longname */
2512 gnu_ops.to_doc = "GNU Hurd process"; /* to_doc */
2513 gnu_ops.to_open = gnu_open; /* to_open */
2514 gnu_ops.to_close = 0; /* to_close */
2515 gnu_ops.to_attach = gnu_attach; /* to_attach */
2516 gnu_ops.to_post_attach = NULL;
2517 gnu_ops.to_require_attach = NULL; /* to_require_attach */
2518 gnu_ops.to_detach = gnu_detach; /* to_detach */
2519 gnu_ops.to_require_detach = NULL; /* to_require_detach */
2520 gnu_ops.to_resume = gnu_resume; /* to_resume */
2521 gnu_ops.to_wait = gnu_wait; /* to_wait */
2522 gnu_ops.to_post_wait = NULL; /* to_post_wait */
2523 gnu_ops.to_fetch_registers = gnu_fetch_registers; /* to_fetch_registers */
2524 gnu_ops.to_store_registers = gnu_store_registers; /* to_store_registers */
2525 gnu_ops.to_prepare_to_store = gnu_prepare_to_store; /* to_prepare_to_store */
2526 gnu_ops.to_xfer_memory = gnu_xfer_memory; /* to_xfer_memory */
2527 gnu_ops.to_files_info = 0; /* to_files_info */
2528 gnu_ops.to_insert_breakpoint = memory_insert_breakpoint;
2529 gnu_ops.to_remove_breakpoint = memory_remove_breakpoint;
2530 gnu_ops.to_terminal_init = gnu_terminal_init_inferior;
2531 gnu_ops.to_terminal_inferior = terminal_inferior;
2532 gnu_ops.to_terminal_ours_for_output = terminal_ours_for_output;
2533 gnu_ops.to_terminal_ours = terminal_ours;
2534 gnu_ops.to_terminal_info = child_terminal_info;
2535 gnu_ops.to_kill = gnu_kill_inferior; /* to_kill */
2536 gnu_ops.to_load = 0; /* to_load */
2537 gnu_ops.to_lookup_symbol = 0; /* to_lookup_symbol */
2538 gnu_ops.to_create_inferior = gnu_create_inferior; /* to_create_inferior */
2539 gnu_ops.to_post_startup_inferior = NULL; /* to_post_startup_inferior */
2540 /* to_acknowledge_created_inferior */
2541 gnu_ops.to_acknowledge_created_inferior = NULL;
2542 /* to_clone_and_follow_inferior */
2543 gnu_ops.to_clone_and_follow_inferior = NULL;
2544 /* to_post_follow_inferior_by_clone */
2545 gnu_ops.to_post_follow_inferior_by_clone = NULL;
2546 gnu_ops.to_insert_fork_catchpoint = NULL;
2547 gnu_ops.to_remove_fork_catchpoint = NULL;
2548 gnu_ops.to_insert_vfork_catchpoint = NULL;
2549 gnu_ops.to_remove_vfork_catchpoint = NULL;
2550 gnu_ops.to_has_forked = NULL; /* to_has_forked */
2551 gnu_ops.to_has_vforked = NULL; /* to_has_vforked */
2552 gnu_ops.to_can_follow_vfork_prior_to_exec = NULL;
2553 gnu_ops.to_post_follow_vfork = NULL; /* to_post_follow_vfork */
2554 gnu_ops.to_insert_exec_catchpoint = NULL;
2555 gnu_ops.to_remove_exec_catchpoint = NULL;
2556 gnu_ops.to_has_execd = NULL;
2557 gnu_ops.to_reported_exec_events_per_exec_call = NULL;
2558 gnu_ops.to_has_exited = NULL;
2559 gnu_ops.to_mourn_inferior = gnu_mourn_inferior; /* to_mourn_inferior */
2560 gnu_ops.to_can_run = gnu_can_run; /* to_can_run */
2561 gnu_ops.to_notice_signals = 0; /* to_notice_signals */
2562 gnu_ops.to_thread_alive = gnu_thread_alive; /* to_thread_alive */
2563 gnu_ops.to_pid_to_str = gnu_pid_to_str; /* to_pid_to_str */
2564 gnu_ops.to_stop = gnu_stop; /* to_stop */
2565 gnu_ops.to_pid_to_exec_file = gnu_pid_to_exec_file; /* to_pid_to_exec_file */
2566 gnu_ops.to_core_file_to_sym_file = NULL;
2567 gnu_ops.to_stratum = process_stratum; /* to_stratum */
2568 gnu_ops.DONT_USE = 0; /* to_next */
2569 gnu_ops.to_has_all_memory = 1; /* to_has_all_memory */
2570 gnu_ops.to_has_memory = 1; /* to_has_memory */
2571 gnu_ops.to_has_stack = 1; /* to_has_stack */
2572 gnu_ops.to_has_registers = 1; /* to_has_registers */
2573 gnu_ops.to_has_execution = 1; /* to_has_execution */
2574 gnu_ops.to_sections = 0; /* sections */
2575 gnu_ops.to_sections_end = 0; /* sections_end */
2576 gnu_ops.to_magic = OPS_MAGIC; /* to_magic */
2577 } /* init_gnu_ops */
2580 /* User task commands. */
2582 struct cmd_list_element *set_task_cmd_list = 0;
2583 struct cmd_list_element *show_task_cmd_list = 0;
2584 /* User thread commands. */
2586 /* Commands with a prefix of `set/show thread'. */
2587 extern struct cmd_list_element *thread_cmd_list;
2588 struct cmd_list_element *set_thread_cmd_list = NULL;
2589 struct cmd_list_element *show_thread_cmd_list = NULL;
2591 /* Commands with a prefix of `set/show thread default'. */
2592 struct cmd_list_element *set_thread_default_cmd_list = NULL;
2593 struct cmd_list_element *show_thread_default_cmd_list = NULL;
2596 set_thread_cmd (char *args, int from_tty)
2598 printf_unfiltered ("\"set thread\" must be followed by the name of a thread property, or \"default\".\n");
2602 show_thread_cmd (char *args, int from_tty)
2604 printf_unfiltered ("\"show thread\" must be followed by the name of a thread property, or \"default\".\n");
2608 set_thread_default_cmd (char *args, int from_tty)
2610 printf_unfiltered ("\"set thread default\" must be followed by the name of a thread property.\n");
2614 show_thread_default_cmd (char *args, int from_tty)
2616 printf_unfiltered ("\"show thread default\" must be followed by the name of a thread property.\n");
2620 parse_int_arg (char *args, char *cmd_prefix)
2625 int val = strtoul (args, &arg_end, 10);
2626 if (*args && *arg_end == '\0')
2629 error ("Illegal argument for \"%s\" command, should be an integer.", cmd_prefix);
2633 _parse_bool_arg (char *args, char *t_val, char *f_val, char *cmd_prefix)
2635 if (!args || strcmp (args, t_val) == 0)
2637 else if (strcmp (args, f_val) == 0)
2640 error ("Illegal argument for \"%s\" command, should be \"%s\" or \"%s\".",
2641 cmd_prefix, t_val, f_val);
2644 #define parse_bool_arg(args, cmd_prefix) \
2645 _parse_bool_arg (args, "on", "off", cmd_prefix)
2648 check_empty (char *args, char *cmd_prefix)
2651 error ("Garbage after \"%s\" command: `%s'", cmd_prefix, args);
2654 /* Returns the alive thread named by INFERIOR_PID, or signals an error. */
2655 static struct proc *
2658 struct inf *inf = cur_inf ();
2659 struct proc *thread = inf_tid_to_thread (inf, inferior_pid);
2661 error ("No current thread.");
2665 /* Returns the current inferior, but signals an error if it has no task. */
2669 struct inf *inf = cur_inf ();
2671 error ("No current process.");
2677 set_task_pause_cmd (char *args, int from_tty)
2679 struct inf *inf = cur_inf ();
2680 int old_sc = inf->pause_sc;
2682 inf->pause_sc = parse_bool_arg (args, "set task pause");
2684 if (old_sc == 0 && inf->pause_sc != 0)
2685 /* If the task is currently unsuspended, immediately suspend it,
2686 otherwise wait until the next time it gets control. */
2691 show_task_pause_cmd (char *args, int from_tty)
2693 struct inf *inf = cur_inf ();
2694 check_empty (args, "show task pause");
2695 printf_unfiltered ("The inferior task %s suspended while gdb has control.\n",
2697 ? (inf->pause_sc == 0 ? "isn't" : "is")
2698 : (inf->pause_sc == 0 ? "won't be" : "will be"));
2702 set_task_detach_sc_cmd (char *args, int from_tty)
2704 cur_inf ()->detach_sc = parse_int_arg (args, "set task detach-suspend-count");
2708 show_task_detach_sc_cmd (char *args, int from_tty)
2710 check_empty (args, "show task detach-suspend-count");
2711 printf_unfiltered ("The inferior task will be left with a suspend count of %d when detaching.\n",
2712 cur_inf ()->detach_sc);
2717 set_thread_default_pause_cmd (char *args, int from_tty)
2719 struct inf *inf = cur_inf ();
2720 inf->default_thread_pause_sc =
2721 parse_bool_arg (args, "set thread default pause") ? 0 : 1;
2725 show_thread_default_pause_cmd (char *args, int from_tty)
2727 struct inf *inf = cur_inf ();
2728 int sc = inf->default_thread_pause_sc;
2729 check_empty (args, "show thread default pause");
2730 printf_unfiltered ("New threads %s suspended while gdb has control%s.\n",
2731 sc ? "are" : "aren't",
2732 !sc && inf->pause_sc ? " (but the task is)" : "");
2736 set_thread_default_run_cmd (char *args, int from_tty)
2738 struct inf *inf = cur_inf ();
2739 inf->default_thread_run_sc =
2740 parse_bool_arg (args, "set thread default run") ? 0 : 1;
2744 show_thread_default_run_cmd (char *args, int from_tty)
2746 struct inf *inf = cur_inf ();
2747 check_empty (args, "show thread default run");
2748 printf_unfiltered ("New threads %s allowed to run.\n",
2749 inf->default_thread_run_sc == 0 ? "are" : "aren't");
2753 set_thread_default_detach_sc_cmd (char *args, int from_tty)
2755 cur_inf ()->default_thread_detach_sc =
2756 parse_int_arg (args, "set thread default detach-suspend-count");
2760 show_thread_default_detach_sc_cmd (char *args, int from_tty)
2762 check_empty (args, "show thread default detach-suspend-count");
2763 printf_unfiltered ("New threads will get a detach-suspend-count of %d.\n",
2764 cur_inf ()->default_thread_detach_sc);
2768 /* Steal a send right called NAME in the inferior task, and make it PROC's
2769 saved exception port. */
2771 steal_exc_port (struct proc *proc, mach_port_t name)
2775 mach_msg_type_name_t port_type;
2777 if (!proc || !proc->inf->task)
2778 error ("No inferior task.");
2780 err = mach_port_extract_right (proc->inf->task->port,
2781 name, MACH_MSG_TYPE_COPY_SEND,
2784 error ("Couldn't extract send right %d from inferior: %s",
2785 name, strerror (err));
2787 if (proc->saved_exc_port)
2788 /* Get rid of our reference to the old one. */
2789 mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
2791 proc->saved_exc_port = port;
2793 if (!proc->exc_port)
2794 /* If PROC is a thread, we may not have set its exception port before.
2795 We can't use proc_steal_exc_port because it also sets saved_exc_port. */
2797 proc->exc_port = proc->inf->event_port;
2798 err = proc_set_exception_port (proc, proc->exc_port);
2799 error ("Can't set exception port for %s: %s",
2800 proc_string (proc), strerror (err));
2805 set_task_exc_port_cmd (char *args, int from_tty)
2807 struct inf *inf = cur_inf ();
2809 error ("No argument to \"set task exception-port\" command.");
2810 steal_exc_port (inf->task, parse_and_eval_address (args));
2814 set_stopped_cmd (char *args, int from_tty)
2816 cur_inf ()->stopped = _parse_bool_arg (args, "yes", "no", "set stopped");
2820 show_stopped_cmd (char *args, int from_tty)
2822 struct inf *inf = active_inf ();
2823 check_empty (args, "show stopped");
2824 printf_unfiltered ("The inferior process %s stopped.\n",
2825 inf->stopped ? "is" : "isn't");
2829 set_sig_thread_cmd (char *args, int from_tty)
2831 struct inf *inf = cur_inf ();
2833 if (!args || (!isdigit (*args) && strcmp (args, "none") != 0))
2834 error ("Illegal argument to \"set signal-thread\" command.\n"
2835 "Should be an integer thread ID, or `none'.");
2837 if (strcmp (args, "none") == 0)
2838 inf->signal_thread = 0;
2841 int tid = thread_id_to_pid (atoi (args));
2843 error ("Thread ID %s not known. Use the \"info threads\" command to\n"
2844 "see the IDs of currently known threads.", args);
2845 inf->signal_thread = inf_tid_to_thread (inf, tid);
2850 show_sig_thread_cmd (char *args, int from_tty)
2852 struct inf *inf = active_inf ();
2853 check_empty (args, "show signal-thread");
2854 if (inf->signal_thread)
2855 printf_unfiltered ("The signal thread is %s.\n",
2856 proc_string (inf->signal_thread));
2858 printf_unfiltered ("There is no signal thread.\n");
2863 set_signals_cmd (char *args, int from_tty)
2865 struct inf *inf = cur_inf ();
2867 inf->want_signals = parse_bool_arg (args, "set signals");
2869 if (inf->task && inf->want_signals != inf->traced)
2870 /* Make this take effect immediately in a running process. */
2871 inf_set_traced (inf, inf->want_signals);
2875 show_signals_cmd (char *args, int from_tty)
2877 struct inf *inf = cur_inf ();
2878 check_empty (args, "show signals");
2879 printf_unfiltered ("The inferior process's signals %s intercepted.\n",
2881 ? (inf->traced ? "are" : "aren't")
2882 : (inf->want_signals ? "will be" : "won't be"));
2886 set_exceptions_cmd (char *args, int from_tty)
2888 struct inf *inf = cur_inf ();
2889 int val = parse_bool_arg (args, "set exceptions");
2891 if (inf->task && inf->want_exceptions != val)
2892 /* Make this take effect immediately in a running process. */
2895 inf->want_exceptions = val;
2899 show_exceptions_cmd (char *args, int from_tty)
2901 struct inf *inf = cur_inf ();
2902 check_empty (args, "show exceptions");
2903 printf_unfiltered ("Exceptions in the inferior %s trapped.\n",
2905 ? (inf->want_exceptions ? "are" : "aren't")
2906 : (inf->want_exceptions ? "will be" : "won't be"));
2911 set_task_cmd (char *args, int from_tty)
2913 printf_unfiltered ("\"set task\" must be followed by the name"
2914 " of a task property.\n");
2918 show_task_cmd (char *args, int from_tty)
2920 struct inf *inf = cur_inf ();
2922 check_empty (args, "show task");
2924 show_signals_cmd (0, from_tty);
2925 show_exceptions_cmd (0, from_tty);
2926 show_task_pause_cmd (0, from_tty);
2928 if (inf->pause_sc == 0)
2929 show_thread_default_pause_cmd (0, from_tty);
2930 show_thread_default_run_cmd (0, from_tty);
2934 show_stopped_cmd (0, from_tty);
2935 show_sig_thread_cmd (0, from_tty);
2938 if (inf->detach_sc != 0)
2939 show_task_detach_sc_cmd (0, from_tty);
2940 if (inf->default_thread_detach_sc != 0)
2941 show_thread_default_detach_sc_cmd (0, from_tty);
2946 set_noninvasive_cmd (char *args, int from_tty)
2948 /* Invert the sense of the arg for each component. */
2949 char *inv_args = parse_bool_arg (args, "set noninvasive") ? "off" : "on";
2951 set_task_pause_cmd (inv_args, from_tty);
2952 set_signals_cmd (inv_args, from_tty);
2953 set_exceptions_cmd (inv_args, from_tty);
2958 info_port_rights (char *args, mach_port_type_t only)
2960 struct inf *inf = active_inf ();
2961 value_ptr vmark = value_mark ();
2964 /* Explicit list of port rights. */
2968 value_ptr val = parse_to_comma_and_eval (&args);
2969 long right = value_as_long (val);
2971 print_port_info (right, 0, inf->task->port, PORTINFO_DETAILS,
2974 error ("%ld: %s.", right, strerror (err));
2978 /* Print all of them. */
2981 print_task_ports_info (inf->task->port, only, PORTINFO_DETAILS,
2984 error ("%s.", strerror (err));
2987 value_free_to_mark (vmark);
2991 info_send_rights_cmd (char *args, int from_tty)
2993 info_port_rights (args, MACH_PORT_TYPE_SEND);
2997 info_recv_rights_cmd (char *args, int from_tty)
2999 info_port_rights (args, MACH_PORT_TYPE_RECEIVE);
3003 info_port_sets_cmd (char *args, int from_tty)
3005 info_port_rights (args, MACH_PORT_TYPE_PORT_SET);
3009 info_dead_names_cmd (char *args, int from_tty)
3011 info_port_rights (args, MACH_PORT_TYPE_DEAD_NAME);
3015 info_port_rights_cmd (char *args, int from_tty)
3017 info_port_rights (args, ~0);
3022 add_task_commands (void)
3024 add_cmd ("pause", class_run, set_thread_default_pause_cmd,
3025 "Set whether the new threads are suspended while gdb has control.\n\
3026 This property normally has no effect because the whole task is\n\
3027 suspended, however, that may be disabled with \"set task pause off\".\n\
3028 The default value is \"off\".",
3029 &set_thread_default_cmd_list);
3030 add_cmd ("pause", no_class, show_thread_default_pause_cmd,
3031 "Show whether new threads are suspended while gdb has control.",
3032 &show_thread_default_cmd_list);
3034 add_cmd ("run", class_run, set_thread_default_run_cmd,
3035 "Set whether new threads are allowed to run \
3036 (once gdb has noticed them).",
3037 &set_thread_default_cmd_list);
3038 add_cmd ("run", no_class, show_thread_default_run_cmd,
3039 "Show whether new threads are allowed to run \
3040 (once gdb has noticed them).",
3041 &show_thread_default_cmd_list);
3043 add_cmd ("detach-suspend-count", class_run, set_thread_default_detach_sc_cmd,
3044 "Set the default detach-suspend-count value for new threads.",
3045 &set_thread_default_cmd_list);
3046 add_cmd ("detach-suspend-count", no_class, show_thread_default_detach_sc_cmd,
3047 "Show the default detach-suspend-count value for new threads.",
3048 &show_thread_default_cmd_list);
3050 add_cmd ("signals", class_run, set_signals_cmd,
3051 "Set whether the inferior process's signals will be intercepted.\n\
3052 Mach exceptions (such as breakpoint traps) are not affected.",
3054 add_alias_cmd ("sigs", "signals", class_run, 1, &setlist);
3055 add_cmd ("signals", no_class, show_signals_cmd,
3056 "Show whether the inferior process's signals will be intercepted.",
3058 add_alias_cmd ("sigs", "signals", no_class, 1, &showlist);
3060 add_cmd ("signal-thread", class_run, set_sig_thread_cmd,
3061 "Set the thread that gdb thinks is the libc signal thread.\n\
3062 This thread is run when delivering a signal to a non-stopped process.",
3064 add_alias_cmd ("sigthread", "signal-thread", class_run, 1, &setlist);
3065 add_cmd ("signal-thread", no_class, show_sig_thread_cmd,
3066 "Set the thread that gdb thinks is the libc signal thread.",
3068 add_alias_cmd ("sigthread", "signal-thread", no_class, 1, &showlist);
3070 add_cmd ("stopped", class_run, set_stopped_cmd,
3071 "Set whether gdb thinks the inferior process is stopped \
3073 Stopped process will be continued by sending them a signal.",
3075 add_cmd ("stopped", no_class, show_signals_cmd,
3076 "Show whether gdb thinks the inferior process is stopped \
3080 add_cmd ("exceptions", class_run, set_exceptions_cmd,
3081 "Set whether exceptions in the inferior process will be trapped.\n\
3082 When exceptions are turned off, neither breakpoints nor single-stepping\n\
3085 /* Allow `set exc' despite conflict with `set exception-port'. */
3086 add_alias_cmd ("exc", "exceptions", class_run, 1, &setlist);
3087 add_cmd ("exceptions", no_class, show_exceptions_cmd,
3088 "Show whether exceptions in the inferior process will be trapped.",
3091 add_prefix_cmd ("task", no_class, set_task_cmd,
3092 "Command prefix for setting task attributes.",
3093 &set_task_cmd_list, "set task ", 0, &setlist);
3094 add_prefix_cmd ("task", no_class, show_task_cmd,
3095 "Command prefix for showing task attributes.",
3096 &show_task_cmd_list, "show task ", 0, &showlist);
3098 add_cmd ("pause", class_run, set_task_pause_cmd,
3099 "Set whether the task is suspended while gdb has control.\n\
3100 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3101 until the next time the program is continued.\n\
3102 When setting this to \"off\", \"set thread default pause on\" can be\n\
3103 used to pause individual threads by default instead.",
3104 &set_task_cmd_list);
3105 add_cmd ("pause", no_class, show_task_pause_cmd,
3106 "Show whether the task is suspended while gdb has control.",
3107 &show_task_cmd_list);
3109 add_cmd ("detach-suspend-count", class_run, set_task_detach_sc_cmd,
3110 "Set the suspend count will leave on the thread when detaching.",
3111 &set_task_cmd_list);
3112 add_cmd ("detach-suspend-count", no_class, show_task_detach_sc_cmd,
3113 "Show the suspend count will leave on the thread when detaching.",
3114 &show_task_cmd_list);
3116 add_cmd ("exception-port", no_class, set_task_exc_port_cmd,
3117 "Set the task exception port to which we forward exceptions.\n\
3118 The argument should be the value of the send right in the task.",
3119 &set_task_cmd_list);
3120 add_alias_cmd ("excp", "exception-port", no_class, 1, &set_task_cmd_list);
3121 add_alias_cmd ("exc-port", "exception-port", no_class, 1,
3122 &set_task_cmd_list);
3124 /* A convenient way of turning on all options require to noninvasively
3125 debug running tasks. */
3126 add_cmd ("noninvasive", no_class, set_noninvasive_cmd,
3127 "Set task options so that we interfere as little as possible.\n\
3128 This is the same as setting `task pause', `exceptions', and\n\
3129 `signals' to the opposite value.",
3132 /* Commands to show information about the task's ports. */
3133 add_cmd ("send-rights", class_info, info_send_rights_cmd,
3134 "Show information about the task's send rights",
3136 add_cmd ("receive-rights", class_info, info_recv_rights_cmd,
3137 "Show information about the task's receive rights",
3139 add_cmd ("port-rights", class_info, info_port_rights_cmd,
3140 "Show information about the task's port rights",
3142 add_cmd ("port-sets", class_info, info_port_sets_cmd,
3143 "Show information about the task's port sets",
3145 add_cmd ("dead-names", class_info, info_dead_names_cmd,
3146 "Show information about the task's dead names",
3148 add_info_alias ("ports", "port-rights", 1);
3149 add_info_alias ("port", "port-rights", 1);
3150 add_info_alias ("psets", "port-sets", 1);
3155 set_thread_pause_cmd (char *args, int from_tty)
3157 struct proc *thread = cur_thread ();
3158 int old_sc = thread->pause_sc;
3159 thread->pause_sc = parse_bool_arg (args, "set thread pause");
3160 if (old_sc == 0 && thread->pause_sc != 0 && thread->inf->pause_sc == 0)
3161 /* If the task is currently unsuspended, immediately suspend it,
3162 otherwise wait until the next time it gets control. */
3163 inf_suspend (thread->inf);
3167 show_thread_pause_cmd (char *args, int from_tty)
3169 struct proc *thread = cur_thread ();
3170 int sc = thread->pause_sc;
3171 check_empty (args, "show task pause");
3172 printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n",
3173 proc_string (thread),
3174 sc ? "is" : "isn't",
3175 !sc && thread->inf->pause_sc ? " (but the task is)" : "");
3179 set_thread_run_cmd (char *args, int from_tty)
3181 struct proc *thread = cur_thread ();
3182 thread->run_sc = parse_bool_arg (args, "set thread run") ? 0 : 1;
3186 show_thread_run_cmd (char *args, int from_tty)
3188 struct proc *thread = cur_thread ();
3189 check_empty (args, "show thread run");
3190 printf_unfiltered ("Thread %s %s allowed to run.",
3191 proc_string (thread),
3192 thread->run_sc == 0 ? "is" : "isn't");
3196 set_thread_detach_sc_cmd (char *args, int from_tty)
3198 cur_thread ()->detach_sc = parse_int_arg (args,
3199 "set thread detach-suspend-count");
3203 show_thread_detach_sc_cmd (char *args, int from_tty)
3205 struct proc *thread = cur_thread ();
3206 check_empty (args, "show thread detach-suspend-count");
3207 printf_unfiltered ("Thread %s will be left with a suspend count"
3208 " of %d when detaching.\n",
3209 proc_string (thread),
3214 set_thread_exc_port_cmd (char *args, int from_tty)
3216 struct proc *thread = cur_thread ();
3218 error ("No argument to \"set thread exception-port\" command.");
3219 steal_exc_port (thread, parse_and_eval_address (args));
3224 show_thread_cmd (char *args, int from_tty)
3226 struct proc *thread = cur_thread ();
3227 check_empty (args, "show thread");
3228 show_thread_run_cmd (0, from_tty);
3229 show_thread_pause_cmd (0, from_tty);
3230 if (thread->detach_sc != 0)
3231 show_thread_detach_sc_cmd (0, from_tty);
3236 thread_takeover_sc_cmd (char *args, int from_tty)
3238 struct proc *thread = cur_thread ();
3239 thread_basic_info_data_t _info;
3240 thread_basic_info_t info = &_info;
3241 mach_msg_type_number_t info_len = THREAD_BASIC_INFO_COUNT;
3243 thread_info (thread->port, THREAD_BASIC_INFO, (int *) &info, &info_len);
3245 error ("%s.", strerror (err));
3246 thread->sc = info->suspend_count;
3248 printf_unfiltered ("Suspend count was %d.\n", thread->sc);
3250 vm_deallocate (mach_task_self (), (vm_address_t) info,
3251 info_len * sizeof (int));
3256 add_thread_commands (void)
3258 add_prefix_cmd ("thread", no_class, set_thread_cmd,
3259 "Command prefix for setting thread properties.",
3260 &set_thread_cmd_list, "set thread ", 0, &setlist);
3261 add_prefix_cmd ("default", no_class, show_thread_cmd,
3262 "Command prefix for setting default thread properties.",
3263 &set_thread_default_cmd_list, "set thread default ", 0,
3264 &set_thread_cmd_list);
3265 add_prefix_cmd ("thread", no_class, set_thread_default_cmd,
3266 "Command prefix for showing thread properties.",
3267 &show_thread_cmd_list, "show thread ", 0, &showlist);
3268 add_prefix_cmd ("default", no_class, show_thread_default_cmd,
3269 "Command prefix for showing default thread properties.",
3270 &show_thread_default_cmd_list, "show thread default ", 0,
3271 &show_thread_cmd_list);
3273 add_cmd ("pause", class_run, set_thread_pause_cmd,
3274 "Set whether the current thread is suspended \
3275 while gdb has control.\n\
3276 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3277 until the next time the program is continued. This property normally\n\
3278 has no effect because the whole task is suspended, however, that may\n\
3279 be disabled with \"set task pause off\".\n\
3280 The default value is \"off\".",
3281 &set_thread_cmd_list);
3282 add_cmd ("pause", no_class, show_thread_pause_cmd,
3283 "Show whether the current thread is suspended \
3284 while gdb has control.",
3285 &show_thread_cmd_list);
3287 add_cmd ("run", class_run, set_thread_run_cmd,
3288 "Set whether the current thread is allowed to run.",
3289 &set_thread_cmd_list);
3290 add_cmd ("run", no_class, show_thread_run_cmd,
3291 "Show whether the current thread is allowed to run.",
3292 &show_thread_cmd_list);
3294 add_cmd ("detach-suspend-count", class_run, set_thread_detach_sc_cmd,
3295 "Set the suspend count will leave on the thread when detaching.\n\
3296 Note that this is relative to suspend count when gdb noticed the thread;\n\
3297 use the `thread takeover-suspend-count' to force it to an absolute value.",
3298 &set_thread_cmd_list);
3299 add_cmd ("detach-suspend-count", no_class, show_thread_detach_sc_cmd,
3300 "Show the suspend count will leave on the thread when detaching.\n\
3301 Note that this is relative to suspend count when gdb noticed the thread;\n\
3302 use the `thread takeover-suspend-count' to force it to an absolute value.",
3303 &show_thread_cmd_list);
3305 add_cmd ("exception-port", no_class, set_thread_exc_port_cmd,
3306 "Set the thread exception port to which we forward exceptions.\n\
3307 This overrides the task exception port.\n\
3308 The argument should be the value of the send right in the task.",
3309 &set_thread_cmd_list);
3310 add_alias_cmd ("excp", "exception-port", no_class, 1, &set_thread_cmd_list);
3311 add_alias_cmd ("exc-port", "exception-port", no_class, 1,
3312 &set_thread_cmd_list);
3314 add_cmd ("takeover-suspend-count", no_class, thread_takeover_sc_cmd,
3315 "Force the threads absolute suspend-count to be gdb's.\n\
3316 Prior to giving this command, gdb's thread suspend-counts are relative\n\
3317 to the thread's initial suspend-count when gdb notices the threads.",
3323 _initialize_gnu_nat (void)
3325 proc_server = getproc ();
3328 add_target (&gnu_ops);
3330 add_task_commands ();
3331 add_thread_commands ();
3332 add_set_cmd ("gnu-debug", class_maintenance,
3333 var_boolean, (char *) &gnu_debug_flag,
3334 "Set debugging output for the gnu backend.", &maintenancelist);
3337 #ifdef FLUSH_INFERIOR_CACHE
3339 /* When over-writing code on some machines the I-Cache must be flushed
3340 explicitly, because it is not kept coherent by the lazy hardware.
3341 This definitely includes breakpoints, for instance, or else we
3342 end up looping in mysterious Bpt traps */
3345 flush_inferior_icache (CORE_ADDR pc, int amount)
3347 vm_machine_attribute_val_t flush = MATTR_VAL_ICACHE_FLUSH;
3350 ret = vm_machine_attribute (current_inferior->task->port,
3355 if (ret != KERN_SUCCESS)
3356 warning ("Error flushing inferior's cache : %s", strerror (ret));
3358 #endif /* FLUSH_INFERIOR_CACHE */