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.
33 #include <sys/ptrace.h>
36 #include <mach_error.h>
37 #include <mach/exception.h>
38 #include <mach/message.h>
39 #include <mach/notify.h>
40 #include <mach/vm_attributes.h>
43 #include <hurd/interrupt.h>
45 #include <hurd/msg_request.h>
46 #include <hurd/process.h>
47 #include <hurd/process_request.h>
48 #include <hurd/signal.h>
49 #include <hurd/sigpreempt.h>
62 #include "gdbthread.h"
63 #include "gdb_assert.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 gdb_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 gdb_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
= xmalloc (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
= xmalloc (sizeof (struct inf
));
643 inf
->threads_up_to_date
= 0;
645 inf
->wait
.status
.kind
= TARGET_WAITKIND_SPURIOUS
;
646 inf
->wait
.thread
= 0;
647 inf
->wait
.exc
.handler
= MACH_PORT_NULL
;
648 inf
->wait
.exc
.reply
= MACH_PORT_NULL
;
649 inf
->step_thread
= 0;
650 inf
->signal_thread
= 0;
651 inf
->event_port
= MACH_PORT_NULL
;
657 inf
->pending_execs
= 0;
660 inf
->default_thread_run_sc
= 0;
661 inf
->default_thread_pause_sc
= 0;
662 inf
->default_thread_detach_sc
= 0;
663 inf
->want_signals
= 1; /* By default */
664 inf
->want_exceptions
= 1; /* By default */
669 /* Clear INF's target wait status. */
671 inf_clear_wait (struct inf
*inf
)
673 inf_debug (inf
, "clearing wait");
674 inf
->wait
.status
.kind
= TARGET_WAITKIND_SPURIOUS
;
675 inf
->wait
.thread
= 0;
676 inf
->wait
.suppress
= 0;
677 if (inf
->wait
.exc
.handler
!= MACH_PORT_NULL
)
679 mach_port_deallocate (mach_task_self (), inf
->wait
.exc
.handler
);
680 inf
->wait
.exc
.handler
= MACH_PORT_NULL
;
682 if (inf
->wait
.exc
.reply
!= MACH_PORT_NULL
)
684 mach_port_deallocate (mach_task_self (), inf
->wait
.exc
.reply
);
685 inf
->wait
.exc
.reply
= MACH_PORT_NULL
;
691 inf_cleanup (struct inf
*inf
)
693 inf_debug (inf
, "cleanup");
695 inf_clear_wait (inf
);
697 inf_set_pid (inf
, -1);
704 inf
->pending_execs
= 0;
708 mach_port_destroy (mach_task_self (), inf
->event_port
);
709 inf
->event_port
= MACH_PORT_NULL
;
714 inf_startup (struct inf
*inf
, int pid
)
718 inf_debug (inf
, "startup: pid = %d", pid
);
722 /* Make the port on which we receive all events. */
723 err
= mach_port_allocate (mach_task_self (),
724 MACH_PORT_RIGHT_RECEIVE
, &inf
->event_port
);
726 error ("Error allocating event port: %s", strerror (err
));
728 /* Make a send right for it, so we can easily copy it for other people. */
729 mach_port_insert_right (mach_task_self (), inf
->event_port
,
730 inf
->event_port
, MACH_MSG_TYPE_MAKE_SEND
);
731 inf_set_pid (inf
, pid
);
735 /* Close current process, if any, and attach INF to process PORT. */
737 inf_set_pid (struct inf
*inf
, pid_t pid
)
740 struct proc
*task
= inf
->task
;
742 inf_debug (inf
, "setting pid: %d", pid
);
745 task_port
= MACH_PORT_NULL
;
748 error_t err
= proc_pid2task (proc_server
, pid
, &task_port
);
750 error ("Error getting task for pid %d: %s", pid
, strerror (err
));
753 inf_debug (inf
, "setting task: %d", task_port
);
756 task_suspend (task_port
);
758 if (task
&& task
->port
!= task_port
)
761 inf_validate_procs (inf
); /* Trash all the threads. */
762 _proc_free (task
); /* And the task. */
765 if (task_port
!= MACH_PORT_NULL
)
767 inf
->task
= make_proc (inf
, task_port
, PROC_TID_TASK
);
768 inf
->threads_up_to_date
= 0;
775 /* Reflect task_suspend above. */
776 inf
->task
->sc
= inf
->task
->cur_sc
= 1;
783 /* Validates INF's stopped, nomsg and traced field from the actual
784 proc server state. Note that the traced field is only updated from
785 the proc server state if we do not have a message port. If we do
786 have a message port we'd better look at the tracemask itself. */
788 inf_validate_procinfo (struct inf
*inf
)
791 mach_msg_type_number_t noise_len
= 0;
793 mach_msg_type_number_t pi_len
= 0;
796 proc_getprocinfo (proc_server
, inf
->pid
, &info_flags
,
797 (procinfo_t
*) &pi
, &pi_len
, &noise
, &noise_len
);
801 inf
->stopped
= !!(pi
->state
& PI_STOPPED
);
802 inf
->nomsg
= !!(pi
->state
& PI_NOMSG
);
804 inf
->traced
= !!(pi
->state
& PI_TRACED
);
805 vm_deallocate (mach_task_self (), (vm_address_t
) pi
, pi_len
);
807 vm_deallocate (mach_task_self (), (vm_address_t
) noise
, noise_len
);
811 /* Validates INF's task suspend count. If it's higher than we expect,
812 verify with the user before `stealing' the extra count. */
814 inf_validate_task_sc (struct inf
*inf
)
817 mach_msg_type_number_t noise_len
= 0;
819 mach_msg_type_number_t pi_len
= 0;
820 int info_flags
= PI_FETCH_TASKINFO
;
821 int suspend_count
= -1;
825 err
= proc_getprocinfo (proc_server
, inf
->pid
, &info_flags
,
826 (procinfo_t
*) &pi
, &pi_len
, &noise
, &noise_len
);
829 inf
->task
->dead
= 1; /* oh well */
833 if (inf
->task
->cur_sc
< pi
->taskinfo
.suspend_count
&& suspend_count
== -1)
835 /* The proc server might have suspended the task while stopping
836 it. This happens when the task is handling a traced signal.
837 Refetch the suspend count. The proc server should be
838 finished stopping the task by now. */
839 suspend_count
= pi
->taskinfo
.suspend_count
;
843 suspend_count
= pi
->taskinfo
.suspend_count
;
845 vm_deallocate (mach_task_self (), (vm_address_t
) pi
, pi_len
);
847 vm_deallocate (mach_task_self (), (vm_address_t
) pi
, pi_len
);
849 if (inf
->task
->cur_sc
< suspend_count
)
853 target_terminal_ours (); /* Allow I/O. */
854 abort
= !query ("Pid %d has an additional task suspend count of %d;"
855 " clear it? ", inf
->pid
,
856 suspend_count
- inf
->task
->cur_sc
);
857 target_terminal_inferior (); /* Give it back to the child. */
860 error ("Additional task suspend count left untouched.");
862 inf
->task
->cur_sc
= suspend_count
;
866 /* Turns tracing for INF on or off, depending on ON, unless it already
867 is. If INF is running, the resume_sc count of INF's threads will
868 be modified, and the signal thread will briefly be run to change
871 inf_set_traced (struct inf
*inf
, int on
)
873 if (on
== inf
->traced
)
876 if (inf
->task
&& !inf
->task
->dead
)
877 /* Make it take effect immediately. */
879 sigset_t mask
= on
? ~(sigset_t
) 0 : 0;
881 INF_RESUME_MSGPORT_RPC (inf
, msg_set_init_int (msgport
, refport
,
882 INIT_TRACEMASK
, mask
));
886 warning ("Can't modify tracing state for pid %d: %s",
887 inf
->pid
, "No signal thread");
891 warning ("Can't modify tracing state for pid %d: %s",
892 inf
->pid
, strerror (err
));
901 /* Makes all the real suspend count deltas of all the procs in INF
902 match the desired values. Careful to always do thread/task suspend
903 counts in the safe order. Returns true if at least one thread is
904 thought to be running. */
906 inf_update_suspends (struct inf
*inf
)
908 struct proc
*task
= inf
->task
;
909 /* We don't have to update INF->threads even though we're iterating over it
910 because we'll change a thread only if it already has an existing proc
913 inf_debug (inf
, "updating suspend counts");
918 int task_running
= (task
->sc
== 0), thread_running
= 0;
920 if (task
->sc
> task
->cur_sc
)
921 /* The task is becoming _more_ suspended; do before any threads. */
922 task_running
= proc_update_sc (task
);
924 if (inf
->pending_execs
)
925 /* When we're waiting for an exec, things may be happening behind our
926 back, so be conservative. */
929 /* Do all the thread suspend counts. */
930 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
931 thread_running
|= proc_update_sc (thread
);
933 if (task
->sc
!= task
->cur_sc
)
934 /* We didn't do the task first, because we wanted to wait for the
935 threads; do it now. */
936 task_running
= proc_update_sc (task
);
938 inf_debug (inf
, "%srunning...",
939 (thread_running
&& task_running
) ? "" : "not ");
941 inf
->running
= thread_running
&& task_running
;
943 /* Once any thread has executed some code, we can't depend on the
944 threads list any more. */
946 inf
->threads_up_to_date
= 0;
955 /* Converts a GDB pid to a struct proc. */
957 inf_tid_to_thread (struct inf
*inf
, int tid
)
959 struct proc
*thread
= inf
->threads
;
962 if (thread
->tid
== tid
)
965 thread
= thread
->next
;
969 /* Converts a thread port to a struct proc. */
971 inf_port_to_thread (struct inf
*inf
, mach_port_t port
)
973 struct proc
*thread
= inf
->threads
;
975 if (thread
->port
== port
)
978 thread
= thread
->next
;
983 /* Make INF's list of threads be consistent with reality of TASK. */
985 inf_validate_procs (struct inf
*inf
)
987 thread_array_t threads
;
988 mach_msg_type_number_t num_threads
, i
;
989 struct proc
*task
= inf
->task
;
991 /* If no threads are currently running, this function will guarantee that
992 things are up to date. The exception is if there are zero threads --
993 then it is almost certainly in an odd state, and probably some outside
994 agent will create threads. */
995 inf
->threads_up_to_date
= inf
->threads
? !inf
->running
: 0;
999 error_t err
= task_threads (task
->port
, &threads
, &num_threads
);
1000 inf_debug (inf
, "fetching threads");
1002 /* TASK must be dead. */
1012 inf_debug (inf
, "no task");
1016 /* Make things normally linear. */
1017 mach_msg_type_number_t search_start
= 0;
1018 /* Which thread in PROCS corresponds to each task thread, & the task. */
1019 struct proc
*matched
[num_threads
+ 1];
1020 /* The last thread in INF->threads, so we can add to the end. */
1021 struct proc
*last
= 0;
1022 /* The current thread we're considering. */
1023 struct proc
*thread
= inf
->threads
;
1025 bzero (matched
, sizeof (matched
));
1029 mach_msg_type_number_t left
;
1031 for (i
= search_start
, left
= num_threads
; left
; i
++, left
--)
1033 if (i
>= num_threads
)
1034 i
-= num_threads
; /* I wrapped around. */
1035 if (thread
->port
== threads
[i
])
1036 /* We already know about this thread. */
1038 matched
[i
] = thread
;
1040 thread
= thread
->next
;
1048 proc_debug (thread
, "died!");
1049 thread
->port
= MACH_PORT_NULL
;
1050 thread
= _proc_free (thread
); /* THREAD is dead. */
1051 (last
? last
->next
: inf
->threads
) = thread
;
1055 for (i
= 0; i
< num_threads
; i
++)
1058 /* Throw away the duplicate send right. */
1059 mach_port_deallocate (mach_task_self (), threads
[i
]);
1061 /* THREADS[I] is a thread we don't know about yet! */
1063 thread
= make_proc (inf
, threads
[i
], next_thread_id
++);
1064 (last
? last
->next
: inf
->threads
) = thread
;
1066 proc_debug (thread
, "new thread: %d", threads
[i
]);
1067 add_thread (thread
->tid
); /* Tell GDB's generic thread code. */
1071 vm_deallocate (mach_task_self (),
1072 (vm_address_t
) threads
, (num_threads
* sizeof (thread_t
)));
1077 /* Makes sure that INF's thread list is synced with the actual process. */
1079 inf_update_procs (struct inf
*inf
)
1083 if (!inf
->threads_up_to_date
)
1084 inf_validate_procs (inf
);
1088 /* Sets the resume_sc of each thread in inf. That of RUN_THREAD is set to 0,
1089 and others are set to their run_sc if RUN_OTHERS is true, and otherwise
1092 inf_set_threads_resume_sc (struct inf
*inf
,
1093 struct proc
*run_thread
, int run_others
)
1095 struct proc
*thread
;
1096 inf_update_procs (inf
);
1097 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1098 if (thread
== run_thread
)
1099 thread
->resume_sc
= 0;
1100 else if (run_others
)
1101 thread
->resume_sc
= thread
->run_sc
;
1103 thread
->resume_sc
= thread
->pause_sc
;
1107 /* Cause INF to continue execution immediately; individual threads may still
1108 be suspended (but their suspend counts will be updated). */
1110 inf_resume (struct inf
*inf
)
1112 struct proc
*thread
;
1114 inf_update_procs (inf
);
1116 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1117 thread
->sc
= thread
->resume_sc
;
1121 if (!inf
->pending_execs
)
1122 /* Try to make sure our task count is correct -- in the case where
1123 we're waiting for an exec though, things are too volatile, so just
1124 assume things will be reasonable (which they usually will be). */
1125 inf_validate_task_sc (inf
);
1129 inf_update_suspends (inf
);
1132 /* Cause INF to stop execution immediately; individual threads may still
1135 inf_suspend (struct inf
*inf
)
1137 struct proc
*thread
;
1139 inf_update_procs (inf
);
1141 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1142 thread
->sc
= thread
->pause_sc
;
1145 inf
->task
->sc
= inf
->pause_sc
;
1147 inf_update_suspends (inf
);
1151 /* INF has one thread PROC that is in single-stepping mode. This
1152 function changes it to be PROC, changing any old step_thread to be
1153 a normal one. A PROC of 0 clears any existing value. */
1155 inf_set_step_thread (struct inf
*inf
, struct proc
*thread
)
1157 gdb_assert (!thread
|| proc_is_thread (thread
));
1160 inf_debug (inf
, "setting step thread: %d/%d", inf
->pid
, thread
->tid
);
1162 inf_debug (inf
, "clearing step thread");
1164 if (inf
->step_thread
!= thread
)
1166 if (inf
->step_thread
&& inf
->step_thread
->port
!= MACH_PORT_NULL
)
1167 if (!proc_trace (inf
->step_thread
, 0))
1169 if (thread
&& proc_trace (thread
, 1))
1170 inf
->step_thread
= thread
;
1172 inf
->step_thread
= 0;
1177 /* Set up the thread resume_sc's so that only the signal thread is running
1178 (plus whatever other thread are set to always run). Returns true if we
1179 did so, or false if we can't find a signal thread. */
1181 inf_set_threads_resume_sc_for_signal_thread (struct inf
*inf
)
1183 if (inf
->signal_thread
)
1185 inf_set_threads_resume_sc (inf
, inf
->signal_thread
, 0);
1193 inf_update_signal_thread (struct inf
*inf
)
1195 /* XXX for now we assume that if there's a msgport, the 2nd thread is
1196 the signal thread. */
1197 inf
->signal_thread
= inf
->threads
? inf
->threads
->next
: 0;
1201 /* Detachs from INF's inferior task, letting it run once again... */
1203 inf_detach (struct inf
*inf
)
1205 struct proc
*task
= inf
->task
;
1207 inf_debug (inf
, "detaching...");
1209 inf_clear_wait (inf
);
1210 inf_set_step_thread (inf
, 0);
1214 struct proc
*thread
;
1216 inf_validate_procinfo (inf
);
1218 inf_set_traced (inf
, 0);
1224 inf_signal (inf
, TARGET_SIGNAL_0
);
1227 proc_restore_exc_port (task
);
1228 task
->sc
= inf
->detach_sc
;
1230 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1232 proc_restore_exc_port (thread
);
1233 thread
->sc
= thread
->detach_sc
;
1236 inf_update_suspends (inf
);
1242 /* Attaches INF to the process with process id PID, returning it in a
1243 suspended state suitable for debugging. */
1245 inf_attach (struct inf
*inf
, int pid
)
1247 inf_debug (inf
, "attaching: %d", pid
);
1252 inf_startup (inf
, pid
);
1256 /* Makes sure that we've got our exception ports entrenched in the process. */
1258 inf_steal_exc_ports (struct inf
*inf
)
1260 struct proc
*thread
;
1262 inf_debug (inf
, "stealing exception ports");
1264 inf_set_step_thread (inf
, 0); /* The step thread is special. */
1266 proc_steal_exc_port (inf
->task
, inf
->event_port
);
1267 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1268 proc_steal_exc_port (thread
, MACH_PORT_NULL
);
1271 /* Makes sure the process has its own exception ports. */
1273 inf_restore_exc_ports (struct inf
*inf
)
1275 struct proc
*thread
;
1277 inf_debug (inf
, "restoring exception ports");
1279 inf_set_step_thread (inf
, 0); /* The step thread is special. */
1281 proc_restore_exc_port (inf
->task
);
1282 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1283 proc_restore_exc_port (thread
);
1287 /* Deliver signal SIG to INF. If INF is stopped, delivering a signal, even
1288 signal 0, will continue it. INF is assumed to be in a paused state, and
1289 the resume_sc's of INF's threads may be affected. */
1291 inf_signal (struct inf
*inf
, enum target_signal sig
)
1294 int host_sig
= target_signal_to_host (sig
);
1296 #define NAME target_signal_to_name (sig)
1298 if (host_sig
>= _NSIG
)
1299 /* A mach exception. Exceptions are encoded in the signal space by
1300 putting them after _NSIG; this assumes they're positive (and not
1301 extremely large)! */
1303 struct inf_wait
*w
= &inf
->wait
;
1304 if (w
->status
.kind
== TARGET_WAITKIND_STOPPED
1305 && w
->status
.value
.sig
== sig
1306 && w
->thread
&& !w
->thread
->aborted
)
1307 /* We're passing through the last exception we received. This is
1308 kind of bogus, because exceptions are per-thread whereas gdb
1309 treats signals as per-process. We just forward the exception to
1310 the correct handler, even it's not for the same thread as TID --
1311 i.e., we pretend it's global. */
1313 struct exc_state
*e
= &w
->exc
;
1314 inf_debug (inf
, "passing through exception:"
1315 " task = %d, thread = %d, exc = %d"
1316 ", code = %d, subcode = %d",
1317 w
->thread
->port
, inf
->task
->port
,
1318 e
->exception
, e
->code
, e
->subcode
);
1320 exception_raise_request (e
->handler
,
1321 e
->reply
, MACH_MSG_TYPE_MOVE_SEND_ONCE
,
1322 w
->thread
->port
, inf
->task
->port
,
1323 e
->exception
, e
->code
, e
->subcode
);
1326 error ("Can't forward spontaneous exception (%s).", NAME
);
1329 /* A Unix signal. */
1331 /* The process is stopped and expecting a signal. Just send off a
1332 request and let it get handled when we resume everything. */
1334 inf_debug (inf
, "sending %s to stopped process", NAME
);
1336 INF_MSGPORT_RPC (inf
,
1337 msg_sig_post_untraced_request (msgport
,
1339 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1343 /* Posting an untraced signal automatically continues it.
1344 We clear this here rather than when we get the reply
1345 because we'd rather assume it's not stopped when it
1346 actually is, than the reverse. */
1350 /* It's not expecting it. We have to let just the signal thread
1351 run, and wait for it to get into a reasonable state before we
1352 can continue the rest of the process. When we finally resume the
1353 process the signal we request will be the very first thing that
1356 inf_debug (inf
, "sending %s to unstopped process"
1357 " (so resuming signal thread)", NAME
);
1359 INF_RESUME_MSGPORT_RPC (inf
,
1360 msg_sig_post_untraced (msgport
, host_sig
,
1365 /* Can't do too much... */
1366 warning ("Can't deliver signal %s: No signal thread.", NAME
);
1368 warning ("Delivering signal %s: %s", NAME
, strerror (err
));
1374 /* Continue INF without delivering a signal. This is meant to be used
1375 when INF does not have a message port. */
1377 inf_continue (struct inf
*inf
)
1380 error_t err
= proc_pid2proc (proc_server
, inf
->pid
, &proc
);
1384 inf_debug (inf
, "continuing process");
1386 err
= proc_mark_cont (proc
);
1389 struct proc
*thread
;
1391 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1392 thread_resume (thread
->port
);
1399 warning ("Can't continue process: %s", strerror (err
));
1403 /* The inferior used for all gdb target ops. */
1404 struct inf
*current_inferior
= 0;
1406 /* The inferior being waited for by gnu_wait. Since GDB is decidely not
1407 multi-threaded, we don't bother to lock this. */
1408 struct inf
*waiting_inf
;
1410 /* Wait for something to happen in the inferior, returning what in STATUS. */
1412 gnu_wait (int tid
, struct target_waitstatus
*status
)
1416 mach_msg_header_t hdr
;
1417 mach_msg_type_t type
;
1421 struct proc
*thread
;
1422 struct inf
*inf
= current_inferior
;
1424 extern int exc_server (mach_msg_header_t
*, mach_msg_header_t
*);
1425 extern int msg_reply_server (mach_msg_header_t
*, mach_msg_header_t
*);
1426 extern int notify_server (mach_msg_header_t
*, mach_msg_header_t
*);
1427 extern int process_reply_server (mach_msg_header_t
*, mach_msg_header_t
*);
1429 gdb_assert (inf
->task
);
1431 if (!inf
->threads
&& !inf
->pending_execs
)
1432 /* No threads! Assume that maybe some outside agency is frobbing our
1433 task, and really look for new threads. If we can't find any, just tell
1434 the user to try again later. */
1436 inf_validate_procs (inf
);
1437 if (!inf
->threads
&& !inf
->task
->dead
)
1438 error ("There are no threads; try again later.");
1443 inf_debug (inf
, "waiting for: %d", tid
);
1446 if (proc_wait_pid
!= inf
->pid
&& !inf
->no_wait
)
1447 /* Always get information on events from the proc server. */
1449 inf_debug (inf
, "requesting wait on pid %d", inf
->pid
);
1452 /* The proc server is single-threaded, and only allows a single
1453 outstanding wait request, so we have to cancel the previous one. */
1455 inf_debug (inf
, "cancelling previous wait on pid %d", proc_wait_pid
);
1456 interrupt_operation (proc_server
, 0);
1460 proc_wait_request (proc_server
, inf
->event_port
, inf
->pid
, WUNTRACED
);
1462 warning ("wait request failed: %s", strerror (err
));
1465 inf_debug (inf
, "waits pending: %d", proc_waits_pending
);
1466 proc_wait_pid
= inf
->pid
;
1467 /* Even if proc_waits_pending was > 0 before, we still won't
1468 get any other replies, because it was either from a
1469 different INF, or a different process attached to INF --
1470 and the event port, which is the wait reply port, changes
1471 when you switch processes. */
1472 proc_waits_pending
= 1;
1476 inf_clear_wait (inf
);
1478 /* What can happen? (1) Dead name notification; (2) Exceptions arrive;
1479 (3) wait reply from the proc server. */
1481 inf_debug (inf
, "waiting for an event...");
1482 err
= mach_msg (&msg
.hdr
, MACH_RCV_MSG
| MACH_RCV_INTERRUPT
,
1483 0, sizeof (struct msg
), inf
->event_port
,
1484 MACH_MSG_TIMEOUT_NONE
, MACH_PORT_NULL
);
1486 /* Re-suspend the task. */
1489 if (!inf
->task
&& inf
->pending_execs
)
1490 /* When doing an exec, it's possible that the old task wasn't reused
1491 (e.g., setuid execs). So if the task seems to have disappeared,
1492 attempt to refetch it, as the pid should still be the same. */
1493 inf_set_pid (inf
, inf
->pid
);
1495 if (err
== EMACH_RCV_INTERRUPTED
)
1496 inf_debug (inf
, "interrupted");
1498 error ("Couldn't wait for an event: %s", strerror (err
));
1503 mach_msg_header_t hdr
;
1504 mach_msg_type_t err_type
;
1510 inf_debug (inf
, "event: msgid = %d", msg
.hdr
.msgh_id
);
1512 /* Handle what we got. */
1513 if (!notify_server (&msg
.hdr
, &reply
.hdr
)
1514 && !exc_server (&msg
.hdr
, &reply
.hdr
)
1515 && !process_reply_server (&msg
.hdr
, &reply
.hdr
)
1516 && !msg_reply_server (&msg
.hdr
, &reply
.hdr
))
1517 /* Whatever it is, it's something strange. */
1518 error ("Got a strange event, msg id = %d.", msg
.hdr
.msgh_id
);
1521 error ("Handling event, msgid = %d: %s",
1522 msg
.hdr
.msgh_id
, strerror (reply
.err
));
1525 if (inf
->pending_execs
)
1526 /* We're waiting for the inferior to finish execing. */
1528 struct inf_wait
*w
= &inf
->wait
;
1529 enum target_waitkind kind
= w
->status
.kind
;
1531 if (kind
== TARGET_WAITKIND_SPURIOUS
)
1532 /* Since gdb is actually counting the number of times the inferior
1533 stops, expecting one stop per exec, we only return major events
1537 inf_debug (inf
, "pending_execs = %d, ignoring minor event",
1538 inf
->pending_execs
);
1540 else if (kind
== TARGET_WAITKIND_STOPPED
1541 && w
->status
.value
.sig
== TARGET_SIGNAL_TRAP
)
1542 /* Ah hah! A SIGTRAP from the inferior while starting up probably
1543 means we've succesfully completed an exec! */
1545 if (--inf
->pending_execs
== 0)
1548 #if 0 /* do we need this? */
1549 prune_threads (1); /* Get rid of the old shell threads */
1550 renumber_threads (0); /* Give our threads reasonable names. */
1553 inf_debug (inf
, "pending exec completed, pending_execs => %d",
1554 inf
->pending_execs
);
1556 else if (kind
== TARGET_WAITKIND_STOPPED
)
1557 /* It's possible that this signal is because of a crashed process
1558 being handled by the hurd crash server; in this case, the process
1559 will have an extra task suspend, which we need to know about.
1560 Since the code in inf_resume that normally checks for this is
1561 disabled while INF->pending_execs, we do the check here instead. */
1562 inf_validate_task_sc (inf
);
1565 if (inf
->wait
.suppress
)
1566 /* Some totally spurious event happened that we don't consider
1567 worth returning to gdb. Just keep waiting. */
1569 inf_debug (inf
, "suppressing return, rewaiting...");
1574 /* Pass back out our results. */
1575 bcopy (&inf
->wait
.status
, status
, sizeof (*status
));
1577 thread
= inf
->wait
.thread
;
1581 thread
= inf_tid_to_thread (inf
, tid
);
1583 if (!thread
|| thread
->port
== MACH_PORT_NULL
)
1585 /* TID is dead; try and find a new thread. */
1586 if (inf_update_procs (inf
) && inf
->threads
)
1587 tid
= inf
->threads
->tid
; /* The first available thread. */
1589 tid
= inferior_pid
; /* let wait_for_inferior handle exit case */
1592 if (thread
&& tid
>= 0 && status
->kind
!= TARGET_WAITKIND_SPURIOUS
1593 && inf
->pause_sc
== 0 && thread
->pause_sc
== 0)
1594 /* If something actually happened to THREAD, make sure we
1598 inf_update_suspends (inf
);
1601 inf_debug (inf
, "returning tid = %d, status = %s (%d)", tid
,
1602 status
->kind
== TARGET_WAITKIND_EXITED
? "EXITED"
1603 : status
->kind
== TARGET_WAITKIND_STOPPED
? "STOPPED"
1604 : status
->kind
== TARGET_WAITKIND_SIGNALLED
? "SIGNALLED"
1605 : status
->kind
== TARGET_WAITKIND_LOADED
? "LOADED"
1606 : status
->kind
== TARGET_WAITKIND_SPURIOUS
? "SPURIOUS"
1608 status
->value
.integer
);
1614 /* The rpc handler called by exc_server. */
1616 S_exception_raise_request (mach_port_t port
, mach_port_t reply_port
,
1617 thread_t thread_port
, task_t task_port
,
1618 int exception
, int code
, int subcode
)
1620 struct inf
*inf
= waiting_inf
;
1621 struct proc
*thread
= inf_port_to_thread (inf
, thread_port
);
1623 inf_debug (waiting_inf
,
1624 "thread = %d, task = %d, exc = %d, code = %d, subcode = %d",
1625 thread_port
, task_port
, exception
, code
, subcode
);
1628 /* We don't know about thread? */
1630 inf_update_procs (inf
);
1631 thread
= inf_port_to_thread (inf
, thread_port
);
1633 /* Give up, the generating thread is gone. */
1637 mach_port_deallocate (mach_task_self (), thread_port
);
1638 mach_port_deallocate (mach_task_self (), task_port
);
1640 if (!thread
->aborted
)
1641 /* THREAD hasn't been aborted since this exception happened (abortion
1642 clears any exception state), so it must be real. */
1644 /* Store away the details; this will destroy any previous info. */
1645 inf
->wait
.thread
= thread
;
1647 inf
->wait
.status
.kind
= TARGET_WAITKIND_STOPPED
;
1649 if (exception
== EXC_BREAKPOINT
)
1650 /* GDB likes to get SIGTRAP for breakpoints. */
1652 inf
->wait
.status
.value
.sig
= TARGET_SIGNAL_TRAP
;
1653 mach_port_deallocate (mach_task_self (), reply_port
);
1656 /* Record the exception so that we can forward it later. */
1658 if (thread
->exc_port
== port
)
1660 inf_debug (waiting_inf
, "Handler is thread exception port <%d>",
1661 thread
->saved_exc_port
);
1662 inf
->wait
.exc
.handler
= thread
->saved_exc_port
;
1666 inf_debug (waiting_inf
, "Handler is task exception port <%d>",
1667 inf
->task
->saved_exc_port
);
1668 inf
->wait
.exc
.handler
= inf
->task
->saved_exc_port
;
1669 gdb_assert (inf
->task
->exc_port
== port
);
1671 if (inf
->wait
.exc
.handler
!= MACH_PORT_NULL
)
1672 /* Add a reference to the exception handler. */
1673 mach_port_mod_refs (mach_task_self (),
1674 inf
->wait
.exc
.handler
, MACH_PORT_RIGHT_SEND
,
1677 inf
->wait
.exc
.exception
= exception
;
1678 inf
->wait
.exc
.code
= code
;
1679 inf
->wait
.exc
.subcode
= subcode
;
1680 inf
->wait
.exc
.reply
= reply_port
;
1682 /* Exceptions are encoded in the signal space by putting them after
1683 _NSIG; this assumes they're positive (and not extremely large)! */
1684 inf
->wait
.status
.value
.sig
=
1685 target_signal_from_host (_NSIG
+ exception
);
1689 /* A supppressed exception, which ignore. */
1691 inf
->wait
.suppress
= 1;
1692 mach_port_deallocate (mach_task_self (), reply_port
);
1699 /* Fill in INF's wait field after a task has died without giving us more
1700 detailed information. */
1702 inf_task_died_status (struct inf
*inf
)
1704 warning ("Pid %d died with unknown exit status, using SIGKILL.", inf
->pid
);
1705 inf
->wait
.status
.kind
= TARGET_WAITKIND_SIGNALLED
;
1706 inf
->wait
.status
.value
.sig
= TARGET_SIGNAL_KILL
;
1709 /* Notify server routines. The only real one is dead name notification. */
1711 do_mach_notify_dead_name (mach_port_t notify
, mach_port_t dead_port
)
1713 struct inf
*inf
= waiting_inf
;
1715 inf_debug (waiting_inf
, "port = %d", dead_port
);
1717 if (inf
->task
&& inf
->task
->port
== dead_port
)
1719 proc_debug (inf
->task
, "is dead");
1720 inf
->task
->port
= MACH_PORT_NULL
;
1721 if (proc_wait_pid
== inf
->pid
)
1722 /* We have a wait outstanding on the process, which will return more
1723 detailed information, so delay until we get that. */
1724 inf
->wait
.suppress
= 1;
1726 /* We never waited for the process (maybe it wasn't a child), so just
1727 pretend it got a SIGKILL. */
1728 inf_task_died_status (inf
);
1732 struct proc
*thread
= inf_port_to_thread (inf
, dead_port
);
1735 proc_debug (thread
, "is dead");
1736 thread
->port
= MACH_PORT_NULL
;
1739 if (inf
->task
->dead
)
1740 /* Since the task is dead, its threads are dying with it. */
1741 inf
->wait
.suppress
= 1;
1744 mach_port_deallocate (mach_task_self (), dead_port
);
1745 inf
->threads_up_to_date
= 0; /* Just in case */
1754 warning ("illegal rpc: %s", fun
);
1759 do_mach_notify_no_senders (mach_port_t notify
, mach_port_mscount_t count
)
1761 return ill_rpc (__FUNCTION__
);
1765 do_mach_notify_port_deleted (mach_port_t notify
, mach_port_t name
)
1767 return ill_rpc (__FUNCTION__
);
1771 do_mach_notify_msg_accepted (mach_port_t notify
, mach_port_t name
)
1773 return ill_rpc (__FUNCTION__
);
1777 do_mach_notify_port_destroyed (mach_port_t notify
, mach_port_t name
)
1779 return ill_rpc (__FUNCTION__
);
1783 do_mach_notify_send_once (mach_port_t notify
)
1785 return ill_rpc (__FUNCTION__
);
1789 /* Process_reply server routines. We only use process_wait_reply. */
1792 S_proc_wait_reply (mach_port_t reply
, error_t err
,
1793 int status
, int sigcode
, rusage_t rusage
, pid_t pid
)
1795 struct inf
*inf
= waiting_inf
;
1797 inf_debug (inf
, "err = %s, pid = %d, status = 0x%x, sigcode = %d",
1798 err
? strerror (err
) : "0", pid
, status
, sigcode
);
1800 if (err
&& proc_wait_pid
&& (!inf
->task
|| !inf
->task
->port
))
1801 /* Ack. The task has died, but the task-died notification code didn't
1802 tell anyone because it thought a more detailed reply from the
1803 procserver was forthcoming. However, we now learn that won't
1804 happen... So we have to act like the task just died, and this time,
1806 inf_task_died_status (inf
);
1808 if (--proc_waits_pending
== 0)
1809 /* PROC_WAIT_PID represents the most recent wait. We will always get
1810 replies in order because the proc server is single threaded. */
1813 inf_debug (inf
, "waits pending now: %d", proc_waits_pending
);
1819 warning ("Can't wait for pid %d: %s", inf
->pid
, strerror (err
));
1822 /* Since we can't see the inferior's signals, don't trap them. */
1823 inf_set_traced (inf
, 0);
1826 else if (pid
== inf
->pid
)
1828 store_waitstatus (&inf
->wait
.status
, status
);
1829 if (inf
->wait
.status
.kind
== TARGET_WAITKIND_STOPPED
)
1830 /* The process has sent us a signal, and stopped itself in a sane
1831 state pending our actions. */
1833 inf_debug (inf
, "process has stopped itself");
1838 inf
->wait
.suppress
= 1; /* Something odd happened. Ignore. */
1844 S_proc_setmsgport_reply (mach_port_t reply
, error_t err
,
1845 mach_port_t old_msg_port
)
1847 return ill_rpc (__FUNCTION__
);
1851 S_proc_getmsgport_reply (mach_port_t reply
, error_t err
, mach_port_t msg_port
)
1853 return ill_rpc (__FUNCTION__
);
1857 /* Msg_reply server routines. We only use msg_sig_post_untraced_reply. */
1860 S_msg_sig_post_untraced_reply (mach_port_t reply
, error_t err
)
1862 struct inf
*inf
= waiting_inf
;
1865 /* EBUSY is what we get when the crash server has grabbed control of the
1866 process and doesn't like what signal we tried to send it. Just act
1867 like the process stopped (using a signal of 0 should mean that the
1868 *next* time the user continues, it will pass signal 0, which the crash
1869 server should like). */
1871 inf
->wait
.status
.kind
= TARGET_WAITKIND_STOPPED
;
1872 inf
->wait
.status
.value
.sig
= TARGET_SIGNAL_0
;
1875 warning ("Signal delivery failed: %s", strerror (err
));
1878 /* We only get this reply when we've posted a signal to a process which we
1879 thought was stopped, and which we expected to continue after the signal.
1880 Given that the signal has failed for some reason, it's reasonable to
1881 assume it's still stopped. */
1884 inf
->wait
.suppress
= 1;
1890 S_msg_sig_post_reply (mach_port_t reply
, error_t err
)
1892 return ill_rpc (__FUNCTION__
);
1896 /* Returns the number of messages queued for the receive right PORT. */
1897 static mach_port_msgcount_t
1898 port_msgs_queued (mach_port_t port
)
1900 struct mach_port_status status
;
1902 mach_port_get_receive_status (mach_task_self (), port
, &status
);
1907 return status
.mps_msgcount
;
1911 /* Resume execution of the inferior process.
1913 If STEP is nonzero, single-step it.
1914 If SIGNAL is nonzero, give it that signal.
1917 -1 true Single step the current thread allowing other threads to run.
1918 -1 false Continue the current thread allowing other threads to run.
1919 X true Single step the given thread, don't allow any others to run.
1920 X false Continue the given thread, do not allow any others to run.
1921 (Where X, of course, is anything except -1)
1923 Note that a resume may not `take' if there are pending exceptions/&c
1924 still unprocessed from the last resume we did (any given resume may result
1925 in multiple events returned by wait).
1928 gnu_resume (int tid
, int step
, enum target_signal sig
)
1930 struct proc
*step_thread
= 0;
1931 struct inf
*inf
= current_inferior
;
1933 inf_debug (inf
, "tid = %d, step = %d, sig = %d", tid
, step
, sig
);
1935 inf_validate_procinfo (inf
);
1937 if (sig
!= TARGET_SIGNAL_0
|| inf
->stopped
)
1939 if (sig
== TARGET_SIGNAL_0
&& inf
->nomsg
)
1942 inf_signal (inf
, sig
);
1944 else if (inf
->wait
.exc
.reply
!= MACH_PORT_NULL
)
1945 /* We received an exception to which we have chosen not to forward, so
1946 abort the faulting thread, which will perhaps retake it. */
1948 proc_abort (inf
->wait
.thread
, 1);
1949 warning ("Aborting %s with unforwarded exception %s.",
1950 proc_string (inf
->wait
.thread
),
1951 target_signal_to_name (inf
->wait
.status
.value
.sig
));
1954 if (port_msgs_queued (inf
->event_port
))
1955 /* If there are still messages in our event queue, don't bother resuming
1956 the process, as we're just going to stop it right away anyway. */
1959 inf_update_procs (inf
);
1962 /* Allow all threads to run, except perhaps single-stepping one. */
1964 inf_debug (inf
, "running all threads; tid = %d", inferior_pid
);
1965 tid
= inferior_pid
; /* What to step. */
1966 inf_set_threads_resume_sc (inf
, 0, 1);
1969 /* Just allow a single thread to run. */
1971 struct proc
*thread
= inf_tid_to_thread (inf
, tid
);
1973 error ("Can't run single thread id %d: no such thread!");
1974 inf_debug (inf
, "running one thread: %d/%d", inf
->pid
, thread
->tid
);
1975 inf_set_threads_resume_sc (inf
, thread
, 0);
1980 step_thread
= inf_tid_to_thread (inf
, tid
);
1982 warning ("Can't step thread id %d: no such thread.", tid
);
1984 inf_debug (inf
, "stepping thread: %d/%d", inf
->pid
, step_thread
->tid
);
1986 if (step_thread
!= inf
->step_thread
)
1987 inf_set_step_thread (inf
, step_thread
);
1989 inf_debug (inf
, "here we go...");
1995 gnu_kill_inferior (void)
1997 struct proc
*task
= current_inferior
->task
;
2000 proc_debug (task
, "terminating...");
2001 task_terminate (task
->port
);
2002 inf_set_pid (current_inferior
, -1);
2004 target_mourn_inferior ();
2007 /* Clean up after the inferior dies. */
2009 gnu_mourn_inferior (void)
2011 inf_debug (current_inferior
, "rip");
2012 inf_detach (current_inferior
);
2013 unpush_target (&gnu_ops
);
2014 generic_mourn_inferior ();
2018 /* Fork an inferior process, and start debugging it. */
2020 /* Set INFERIOR_PID to the first thread available in the child, if any. */
2022 inf_pick_first_thread (void)
2024 if (current_inferior
->task
&& current_inferior
->threads
)
2025 /* The first thread. */
2026 return current_inferior
->threads
->tid
;
2028 /* What may be the next thread. */
2029 return next_thread_id
;
2035 if (!current_inferior
)
2036 current_inferior
= make_inf ();
2037 return current_inferior
;
2041 gnu_create_inferior (char *exec_file
, char *allargs
, char **env
)
2043 struct inf
*inf
= cur_inf ();
2047 /* We're in the child; make this process stop as soon as it execs. */
2048 inf_debug (inf
, "tracing self");
2049 if (ptrace (PTRACE_TRACEME
) != 0)
2050 error ("ptrace (PTRACE_TRACEME) failed!");
2052 void attach_to_child (int pid
)
2054 /* Attach to the now stopped child, which is actually a shell... */
2055 inf_debug (inf
, "attaching to child: %d", pid
);
2057 inf_attach (inf
, pid
);
2060 push_target (&gnu_ops
);
2062 inf
->pending_execs
= 2;
2066 /* Now let the child run again, knowing that it will stop immediately
2067 because of the ptrace. */
2069 inferior_pid
= inf_pick_first_thread ();
2071 startup_inferior (inf
->pending_execs
);
2074 inf_debug (inf
, "creating inferior");
2076 fork_inferior (exec_file
, allargs
, env
, trace_me
, attach_to_child
,
2079 inf_validate_procinfo (inf
);
2080 inf_update_signal_thread (inf
);
2081 inf_set_traced (inf
, inf
->want_signals
);
2083 /* Execing the process will have trashed our exception ports; steal them
2084 back (or make sure they're restored if the user wants that). */
2085 if (inf
->want_exceptions
)
2086 inf_steal_exc_ports (inf
);
2088 inf_restore_exc_ports (inf
);
2091 proceed ((CORE_ADDR
) -1, 0, 0);
2094 /* Mark our target-struct as eligible for stray "run" and "attach"
2103 #ifdef ATTACH_DETACH
2105 /* Attach to process PID, then initialize for debugging it
2106 and wait for the trace-trap that results from attaching. */
2108 gnu_attach (char *args
, int from_tty
)
2112 struct inf
*inf
= cur_inf ();
2115 error_no_arg ("process-id to attach");
2119 if (pid
== getpid ()) /* Trying to masturbate? */
2120 error ("I refuse to debug myself!");
2124 exec_file
= (char *) get_exec_file (0);
2127 printf_unfiltered ("Attaching to program `%s', pid %d\n",
2130 printf_unfiltered ("Attaching to pid %d\n", pid
);
2132 gdb_flush (gdb_stdout
);
2135 inf_debug (inf
, "attaching to pid: %d", pid
);
2137 inf_attach (inf
, pid
);
2138 inf_update_procs (inf
);
2140 inferior_pid
= inf_pick_first_thread ();
2143 push_target (&gnu_ops
);
2145 /* We have to initialize the terminal settings now, since the code
2146 below might try to restore them. */
2147 target_terminal_init ();
2149 /* If the process was stopped before we attached, make it continue the next
2150 time the user does a continue. */
2151 inf_validate_procinfo (inf
);
2153 inf_update_signal_thread (inf
);
2154 inf_set_traced (inf
, inf
->want_signals
);
2156 #if 0 /* Do we need this? */
2157 renumber_threads (0); /* Give our threads reasonable names. */
2162 /* Take a program previously attached to and detaches it.
2163 The program resumes execution and will no longer stop
2164 on signals, etc. We'd better not have left any breakpoints
2165 in the program or it'll die when it hits one. For this
2166 to work, it may be necessary for the process to have been
2167 previously attached. It *might* work if the program was
2168 started via fork. */
2170 gnu_detach (char *args
, int from_tty
)
2174 char *exec_file
= get_exec_file (0);
2176 printf_unfiltered ("Detaching from program `%s' pid %d\n",
2177 exec_file
, current_inferior
->pid
);
2179 printf_unfiltered ("Detaching from pid %d\n", current_inferior
->pid
);
2180 gdb_flush (gdb_stdout
);
2183 inf_detach (current_inferior
);
2187 unpush_target (&gnu_ops
); /* Pop out of handling an inferior */
2189 #endif /* ATTACH_DETACH */
2193 gnu_terminal_init_inferior (void)
2195 gdb_assert (current_inferior
);
2196 terminal_init_inferior_with_pgrp (current_inferior
->pid
);
2199 /* Get ready to modify the registers array. On machines which store
2200 individual registers, this doesn't need to do anything. On machines
2201 which store all the registers in one fell swoop, this makes sure
2202 that registers contains all the registers from the program being
2205 gnu_prepare_to_store (void)
2207 #ifdef CHILD_PREPARE_TO_STORE
2208 CHILD_PREPARE_TO_STORE ();
2213 gnu_open (char *arg
, int from_tty
)
2215 error ("Use the \"run\" command to start a Unix child process.");
2221 error ("to_stop target function not implemented");
2225 gnu_pid_to_exec_file (void)
2227 error ("to_pid_to_exec_file target function not implemented");
2233 gnu_thread_alive (int tid
)
2235 inf_update_procs (current_inferior
);
2236 return !!inf_tid_to_thread (current_inferior
, tid
);
2240 /* Read inferior task's LEN bytes from ADDR and copy it to MYADDR in
2241 gdb's address space. Return 0 on failure; number of bytes read
2244 gnu_read_inferior (task_t task
, CORE_ADDR addr
, char *myaddr
, int length
)
2247 vm_address_t low_address
= (vm_address_t
) trunc_page (addr
);
2248 vm_size_t aligned_length
=
2249 (vm_size_t
) round_page (addr
+ length
) - low_address
;
2253 /* Get memory from inferior with page aligned addresses */
2254 err
= vm_read (task
, low_address
, aligned_length
, &copied
, ©_count
);
2258 err
= hurd_safe_copyin (myaddr
, (void *) addr
- low_address
+ copied
, length
);
2261 warning ("Read from inferior faulted: %s", strerror (err
));
2265 err
= vm_deallocate (mach_task_self (), copied
, copy_count
);
2267 warning ("gnu_read_inferior vm_deallocate failed: %s", strerror (err
));
2272 #define CHK_GOTO_OUT(str,ret) \
2273 do if (ret != KERN_SUCCESS) { errstr = #str; goto out; } while(0)
2275 struct vm_region_list
2277 struct vm_region_list
*next
;
2278 vm_prot_t protection
;
2283 struct obstack region_obstack
;
2285 /* Write gdb's LEN bytes from MYADDR and copy it to ADDR in inferior
2286 task's address space. */
2288 gnu_write_inferior (task_t task
, CORE_ADDR addr
, char *myaddr
, int length
)
2291 vm_address_t low_address
= (vm_address_t
) trunc_page (addr
);
2292 vm_size_t aligned_length
=
2293 (vm_size_t
) round_page (addr
+ length
) - low_address
;
2298 char *errstr
= "Bug in gnu_write_inferior";
2300 struct vm_region_list
*region_element
;
2301 struct vm_region_list
*region_head
= (struct vm_region_list
*) NULL
;
2303 /* Get memory from inferior with page aligned addresses */
2304 err
= vm_read (task
,
2309 CHK_GOTO_OUT ("gnu_write_inferior vm_read failed", err
);
2313 err
= hurd_safe_copyout ((void *) addr
- low_address
+ copied
,
2315 CHK_GOTO_OUT ("Write to inferior faulted", err
);
2317 obstack_init (®ion_obstack
);
2319 /* Do writes atomically.
2320 First check for holes and unwritable memory. */
2322 vm_size_t remaining_length
= aligned_length
;
2323 vm_address_t region_address
= low_address
;
2325 struct vm_region_list
*scan
;
2327 while (region_address
< low_address
+ aligned_length
)
2329 vm_prot_t protection
;
2330 vm_prot_t max_protection
;
2331 vm_inherit_t inheritance
;
2333 mach_port_t object_name
;
2335 vm_size_t region_length
= remaining_length
;
2336 vm_address_t old_address
= region_address
;
2338 err
= vm_region (task
,
2347 CHK_GOTO_OUT ("vm_region failed", err
);
2349 /* Check for holes in memory */
2350 if (old_address
!= region_address
)
2352 warning ("No memory at 0x%x. Nothing written",
2359 if (!(max_protection
& VM_PROT_WRITE
))
2361 warning ("Memory at address 0x%x is unwritable. Nothing written",
2368 /* Chain the regions for later use */
2370 (struct vm_region_list
*)
2371 obstack_alloc (®ion_obstack
, sizeof (struct vm_region_list
));
2373 region_element
->protection
= protection
;
2374 region_element
->start
= region_address
;
2375 region_element
->length
= region_length
;
2377 /* Chain the regions along with protections */
2378 region_element
->next
= region_head
;
2379 region_head
= region_element
;
2381 region_address
+= region_length
;
2382 remaining_length
= remaining_length
- region_length
;
2385 /* If things fail after this, we give up.
2386 Somebody is messing up inferior_task's mappings. */
2388 /* Enable writes to the chained vm regions */
2389 for (scan
= region_head
; scan
; scan
= scan
->next
)
2391 if (!(scan
->protection
& VM_PROT_WRITE
))
2393 err
= vm_protect (task
,
2397 scan
->protection
| VM_PROT_WRITE
);
2398 CHK_GOTO_OUT ("vm_protect: enable write failed", err
);
2402 err
= vm_write (task
,
2406 CHK_GOTO_OUT ("vm_write failed", err
);
2408 /* Set up the original region protections, if they were changed */
2409 for (scan
= region_head
; scan
; scan
= scan
->next
)
2411 if (!(scan
->protection
& VM_PROT_WRITE
))
2413 err
= vm_protect (task
,
2418 CHK_GOTO_OUT ("vm_protect: enable write failed", err
);
2426 obstack_free (®ion_obstack
, 0);
2428 (void) vm_deallocate (mach_task_self (),
2433 if (err
!= KERN_SUCCESS
)
2435 warning ("%s: %s", errstr
, mach_error_string (err
));
2443 /* Return 0 on failure, number of bytes handled otherwise. TARGET
2446 gnu_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
2447 struct mem_attrib
*attrib
,
2448 struct target_ops
*target
)
2450 task_t task
= (current_inferior
2451 ? (current_inferior
->task
2452 ? current_inferior
->task
->port
: 0)
2455 if (task
== MACH_PORT_NULL
)
2459 inf_debug (current_inferior
, "%s %p[%d] %s %p",
2460 write
? "writing" : "reading", memaddr
, len
,
2461 write
? "<--" : "-->", myaddr
);
2463 return gnu_write_inferior (task
, memaddr
, myaddr
, len
);
2465 return gnu_read_inferior (task
, memaddr
, myaddr
, len
);
2470 /* Return printable description of proc. */
2472 proc_string (struct proc
*proc
)
2474 static char tid_str
[80];
2475 if (proc_is_task (proc
))
2476 sprintf (tid_str
, "process %d", proc
->inf
->pid
);
2478 sprintf (tid_str
, "thread %d.%d",
2479 proc
->inf
->pid
, pid_to_thread_id (proc
->tid
));
2484 gnu_pid_to_str (int tid
)
2486 struct inf
*inf
= current_inferior
;
2487 struct proc
*thread
= inf_tid_to_thread (inf
, tid
);
2490 return proc_string (thread
);
2493 static char tid_str
[80];
2494 sprintf (tid_str
, "bogus thread id %d", tid
);
2500 extern void gnu_store_registers (int regno
);
2501 extern void gnu_fetch_registers (int regno
);
2503 struct target_ops gnu_ops
;
2508 gnu_ops
.to_shortname
= "GNU"; /* to_shortname */
2509 gnu_ops
.to_longname
= "GNU Hurd process"; /* to_longname */
2510 gnu_ops
.to_doc
= "GNU Hurd process"; /* to_doc */
2511 gnu_ops
.to_open
= gnu_open
; /* to_open */
2512 gnu_ops
.to_close
= 0; /* to_close */
2513 gnu_ops
.to_attach
= gnu_attach
; /* to_attach */
2514 gnu_ops
.to_post_attach
= NULL
;
2515 gnu_ops
.to_require_attach
= NULL
; /* to_require_attach */
2516 gnu_ops
.to_detach
= gnu_detach
; /* to_detach */
2517 gnu_ops
.to_require_detach
= NULL
; /* to_require_detach */
2518 gnu_ops
.to_resume
= gnu_resume
; /* to_resume */
2519 gnu_ops
.to_wait
= gnu_wait
; /* to_wait */
2520 gnu_ops
.to_post_wait
= NULL
; /* to_post_wait */
2521 gnu_ops
.to_fetch_registers
= gnu_fetch_registers
; /* to_fetch_registers */
2522 gnu_ops
.to_store_registers
= gnu_store_registers
; /* to_store_registers */
2523 gnu_ops
.to_prepare_to_store
= gnu_prepare_to_store
; /* to_prepare_to_store */
2524 gnu_ops
.to_xfer_memory
= gnu_xfer_memory
; /* to_xfer_memory */
2525 gnu_ops
.to_files_info
= 0; /* to_files_info */
2526 gnu_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
2527 gnu_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
2528 gnu_ops
.to_terminal_init
= gnu_terminal_init_inferior
;
2529 gnu_ops
.to_terminal_inferior
= terminal_inferior
;
2530 gnu_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
2531 gnu_ops
.to_terminal_ours
= terminal_ours
;
2532 gnu_ops
.to_terminal_info
= child_terminal_info
;
2533 gnu_ops
.to_kill
= gnu_kill_inferior
; /* to_kill */
2534 gnu_ops
.to_load
= 0; /* to_load */
2535 gnu_ops
.to_lookup_symbol
= 0; /* to_lookup_symbol */
2536 gnu_ops
.to_create_inferior
= gnu_create_inferior
; /* to_create_inferior */
2537 gnu_ops
.to_post_startup_inferior
= NULL
; /* to_post_startup_inferior */
2538 /* to_acknowledge_created_inferior */
2539 gnu_ops
.to_acknowledge_created_inferior
= NULL
;
2540 /* to_clone_and_follow_inferior */
2541 gnu_ops
.to_clone_and_follow_inferior
= NULL
;
2542 /* to_post_follow_inferior_by_clone */
2543 gnu_ops
.to_post_follow_inferior_by_clone
= NULL
;
2544 gnu_ops
.to_insert_fork_catchpoint
= NULL
;
2545 gnu_ops
.to_remove_fork_catchpoint
= NULL
;
2546 gnu_ops
.to_insert_vfork_catchpoint
= NULL
;
2547 gnu_ops
.to_remove_vfork_catchpoint
= NULL
;
2548 gnu_ops
.to_has_forked
= NULL
; /* to_has_forked */
2549 gnu_ops
.to_has_vforked
= NULL
; /* to_has_vforked */
2550 gnu_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
2551 gnu_ops
.to_post_follow_vfork
= NULL
; /* to_post_follow_vfork */
2552 gnu_ops
.to_insert_exec_catchpoint
= NULL
;
2553 gnu_ops
.to_remove_exec_catchpoint
= NULL
;
2554 gnu_ops
.to_has_execd
= NULL
;
2555 gnu_ops
.to_reported_exec_events_per_exec_call
= NULL
;
2556 gnu_ops
.to_has_exited
= NULL
;
2557 gnu_ops
.to_mourn_inferior
= gnu_mourn_inferior
; /* to_mourn_inferior */
2558 gnu_ops
.to_can_run
= gnu_can_run
; /* to_can_run */
2559 gnu_ops
.to_notice_signals
= 0; /* to_notice_signals */
2560 gnu_ops
.to_thread_alive
= gnu_thread_alive
; /* to_thread_alive */
2561 gnu_ops
.to_pid_to_str
= gnu_pid_to_str
; /* to_pid_to_str */
2562 gnu_ops
.to_stop
= gnu_stop
; /* to_stop */
2563 gnu_ops
.to_pid_to_exec_file
= gnu_pid_to_exec_file
; /* to_pid_to_exec_file */
2564 gnu_ops
.to_core_file_to_sym_file
= NULL
;
2565 gnu_ops
.to_stratum
= process_stratum
; /* to_stratum */
2566 gnu_ops
.DONT_USE
= 0; /* to_next */
2567 gnu_ops
.to_has_all_memory
= 1; /* to_has_all_memory */
2568 gnu_ops
.to_has_memory
= 1; /* to_has_memory */
2569 gnu_ops
.to_has_stack
= 1; /* to_has_stack */
2570 gnu_ops
.to_has_registers
= 1; /* to_has_registers */
2571 gnu_ops
.to_has_execution
= 1; /* to_has_execution */
2572 gnu_ops
.to_sections
= 0; /* sections */
2573 gnu_ops
.to_sections_end
= 0; /* sections_end */
2574 gnu_ops
.to_magic
= OPS_MAGIC
; /* to_magic */
2575 } /* init_gnu_ops */
2578 /* User task commands. */
2580 struct cmd_list_element
*set_task_cmd_list
= 0;
2581 struct cmd_list_element
*show_task_cmd_list
= 0;
2582 /* User thread commands. */
2584 /* Commands with a prefix of `set/show thread'. */
2585 extern struct cmd_list_element
*thread_cmd_list
;
2586 struct cmd_list_element
*set_thread_cmd_list
= NULL
;
2587 struct cmd_list_element
*show_thread_cmd_list
= NULL
;
2589 /* Commands with a prefix of `set/show thread default'. */
2590 struct cmd_list_element
*set_thread_default_cmd_list
= NULL
;
2591 struct cmd_list_element
*show_thread_default_cmd_list
= NULL
;
2594 set_thread_cmd (char *args
, int from_tty
)
2596 printf_unfiltered ("\"set thread\" must be followed by the name of a thread property, or \"default\".\n");
2600 show_thread_cmd (char *args
, int from_tty
)
2602 printf_unfiltered ("\"show thread\" must be followed by the name of a thread property, or \"default\".\n");
2606 set_thread_default_cmd (char *args
, int from_tty
)
2608 printf_unfiltered ("\"set thread default\" must be followed by the name of a thread property.\n");
2612 show_thread_default_cmd (char *args
, int from_tty
)
2614 printf_unfiltered ("\"show thread default\" must be followed by the name of a thread property.\n");
2618 parse_int_arg (char *args
, char *cmd_prefix
)
2623 int val
= strtoul (args
, &arg_end
, 10);
2624 if (*args
&& *arg_end
== '\0')
2627 error ("Illegal argument for \"%s\" command, should be an integer.", cmd_prefix
);
2631 _parse_bool_arg (char *args
, char *t_val
, char *f_val
, char *cmd_prefix
)
2633 if (!args
|| strcmp (args
, t_val
) == 0)
2635 else if (strcmp (args
, f_val
) == 0)
2638 error ("Illegal argument for \"%s\" command, should be \"%s\" or \"%s\".",
2639 cmd_prefix
, t_val
, f_val
);
2642 #define parse_bool_arg(args, cmd_prefix) \
2643 _parse_bool_arg (args, "on", "off", cmd_prefix)
2646 check_empty (char *args
, char *cmd_prefix
)
2649 error ("Garbage after \"%s\" command: `%s'", cmd_prefix
, args
);
2652 /* Returns the alive thread named by INFERIOR_PID, or signals an error. */
2653 static struct proc
*
2656 struct inf
*inf
= cur_inf ();
2657 struct proc
*thread
= inf_tid_to_thread (inf
, inferior_pid
);
2659 error ("No current thread.");
2663 /* Returns the current inferior, but signals an error if it has no task. */
2667 struct inf
*inf
= cur_inf ();
2669 error ("No current process.");
2675 set_task_pause_cmd (char *args
, int from_tty
)
2677 struct inf
*inf
= cur_inf ();
2678 int old_sc
= inf
->pause_sc
;
2680 inf
->pause_sc
= parse_bool_arg (args
, "set task pause");
2682 if (old_sc
== 0 && inf
->pause_sc
!= 0)
2683 /* If the task is currently unsuspended, immediately suspend it,
2684 otherwise wait until the next time it gets control. */
2689 show_task_pause_cmd (char *args
, int from_tty
)
2691 struct inf
*inf
= cur_inf ();
2692 check_empty (args
, "show task pause");
2693 printf_unfiltered ("The inferior task %s suspended while gdb has control.\n",
2695 ? (inf
->pause_sc
== 0 ? "isn't" : "is")
2696 : (inf
->pause_sc
== 0 ? "won't be" : "will be"));
2700 set_task_detach_sc_cmd (char *args
, int from_tty
)
2702 cur_inf ()->detach_sc
= parse_int_arg (args
, "set task detach-suspend-count");
2706 show_task_detach_sc_cmd (char *args
, int from_tty
)
2708 check_empty (args
, "show task detach-suspend-count");
2709 printf_unfiltered ("The inferior task will be left with a suspend count of %d when detaching.\n",
2710 cur_inf ()->detach_sc
);
2715 set_thread_default_pause_cmd (char *args
, int from_tty
)
2717 struct inf
*inf
= cur_inf ();
2718 inf
->default_thread_pause_sc
=
2719 parse_bool_arg (args
, "set thread default pause") ? 0 : 1;
2723 show_thread_default_pause_cmd (char *args
, int from_tty
)
2725 struct inf
*inf
= cur_inf ();
2726 int sc
= inf
->default_thread_pause_sc
;
2727 check_empty (args
, "show thread default pause");
2728 printf_unfiltered ("New threads %s suspended while gdb has control%s.\n",
2729 sc
? "are" : "aren't",
2730 !sc
&& inf
->pause_sc
? " (but the task is)" : "");
2734 set_thread_default_run_cmd (char *args
, int from_tty
)
2736 struct inf
*inf
= cur_inf ();
2737 inf
->default_thread_run_sc
=
2738 parse_bool_arg (args
, "set thread default run") ? 0 : 1;
2742 show_thread_default_run_cmd (char *args
, int from_tty
)
2744 struct inf
*inf
= cur_inf ();
2745 check_empty (args
, "show thread default run");
2746 printf_unfiltered ("New threads %s allowed to run.\n",
2747 inf
->default_thread_run_sc
== 0 ? "are" : "aren't");
2751 set_thread_default_detach_sc_cmd (char *args
, int from_tty
)
2753 cur_inf ()->default_thread_detach_sc
=
2754 parse_int_arg (args
, "set thread default detach-suspend-count");
2758 show_thread_default_detach_sc_cmd (char *args
, int from_tty
)
2760 check_empty (args
, "show thread default detach-suspend-count");
2761 printf_unfiltered ("New threads will get a detach-suspend-count of %d.\n",
2762 cur_inf ()->default_thread_detach_sc
);
2766 /* Steal a send right called NAME in the inferior task, and make it PROC's
2767 saved exception port. */
2769 steal_exc_port (struct proc
*proc
, mach_port_t name
)
2773 mach_msg_type_name_t port_type
;
2775 if (!proc
|| !proc
->inf
->task
)
2776 error ("No inferior task.");
2778 err
= mach_port_extract_right (proc
->inf
->task
->port
,
2779 name
, MACH_MSG_TYPE_COPY_SEND
,
2782 error ("Couldn't extract send right %d from inferior: %s",
2783 name
, strerror (err
));
2785 if (proc
->saved_exc_port
)
2786 /* Get rid of our reference to the old one. */
2787 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
2789 proc
->saved_exc_port
= port
;
2791 if (!proc
->exc_port
)
2792 /* If PROC is a thread, we may not have set its exception port before.
2793 We can't use proc_steal_exc_port because it also sets saved_exc_port. */
2795 proc
->exc_port
= proc
->inf
->event_port
;
2796 err
= proc_set_exception_port (proc
, proc
->exc_port
);
2797 error ("Can't set exception port for %s: %s",
2798 proc_string (proc
), strerror (err
));
2803 set_task_exc_port_cmd (char *args
, int from_tty
)
2805 struct inf
*inf
= cur_inf ();
2807 error ("No argument to \"set task exception-port\" command.");
2808 steal_exc_port (inf
->task
, parse_and_eval_address (args
));
2812 set_stopped_cmd (char *args
, int from_tty
)
2814 cur_inf ()->stopped
= _parse_bool_arg (args
, "yes", "no", "set stopped");
2818 show_stopped_cmd (char *args
, int from_tty
)
2820 struct inf
*inf
= active_inf ();
2821 check_empty (args
, "show stopped");
2822 printf_unfiltered ("The inferior process %s stopped.\n",
2823 inf
->stopped
? "is" : "isn't");
2827 set_sig_thread_cmd (char *args
, int from_tty
)
2829 struct inf
*inf
= cur_inf ();
2831 if (!args
|| (!isdigit (*args
) && strcmp (args
, "none") != 0))
2832 error ("Illegal argument to \"set signal-thread\" command.\n"
2833 "Should be an integer thread ID, or `none'.");
2835 if (strcmp (args
, "none") == 0)
2836 inf
->signal_thread
= 0;
2839 int tid
= thread_id_to_pid (atoi (args
));
2841 error ("Thread ID %s not known. Use the \"info threads\" command to\n"
2842 "see the IDs of currently known threads.", args
);
2843 inf
->signal_thread
= inf_tid_to_thread (inf
, tid
);
2848 show_sig_thread_cmd (char *args
, int from_tty
)
2850 struct inf
*inf
= active_inf ();
2851 check_empty (args
, "show signal-thread");
2852 if (inf
->signal_thread
)
2853 printf_unfiltered ("The signal thread is %s.\n",
2854 proc_string (inf
->signal_thread
));
2856 printf_unfiltered ("There is no signal thread.\n");
2861 set_signals_cmd (char *args
, int from_tty
)
2863 struct inf
*inf
= cur_inf ();
2865 inf
->want_signals
= parse_bool_arg (args
, "set signals");
2867 if (inf
->task
&& inf
->want_signals
!= inf
->traced
)
2868 /* Make this take effect immediately in a running process. */
2869 inf_set_traced (inf
, inf
->want_signals
);
2873 show_signals_cmd (char *args
, int from_tty
)
2875 struct inf
*inf
= cur_inf ();
2876 check_empty (args
, "show signals");
2877 printf_unfiltered ("The inferior process's signals %s intercepted.\n",
2879 ? (inf
->traced
? "are" : "aren't")
2880 : (inf
->want_signals
? "will be" : "won't be"));
2884 set_exceptions_cmd (char *args
, int from_tty
)
2886 struct inf
*inf
= cur_inf ();
2887 int val
= parse_bool_arg (args
, "set exceptions");
2889 if (inf
->task
&& inf
->want_exceptions
!= val
)
2890 /* Make this take effect immediately in a running process. */
2893 inf
->want_exceptions
= val
;
2897 show_exceptions_cmd (char *args
, int from_tty
)
2899 struct inf
*inf
= cur_inf ();
2900 check_empty (args
, "show exceptions");
2901 printf_unfiltered ("Exceptions in the inferior %s trapped.\n",
2903 ? (inf
->want_exceptions
? "are" : "aren't")
2904 : (inf
->want_exceptions
? "will be" : "won't be"));
2909 set_task_cmd (char *args
, int from_tty
)
2911 printf_unfiltered ("\"set task\" must be followed by the name"
2912 " of a task property.\n");
2916 show_task_cmd (char *args
, int from_tty
)
2918 struct inf
*inf
= cur_inf ();
2920 check_empty (args
, "show task");
2922 show_signals_cmd (0, from_tty
);
2923 show_exceptions_cmd (0, from_tty
);
2924 show_task_pause_cmd (0, from_tty
);
2926 if (inf
->pause_sc
== 0)
2927 show_thread_default_pause_cmd (0, from_tty
);
2928 show_thread_default_run_cmd (0, from_tty
);
2932 show_stopped_cmd (0, from_tty
);
2933 show_sig_thread_cmd (0, from_tty
);
2936 if (inf
->detach_sc
!= 0)
2937 show_task_detach_sc_cmd (0, from_tty
);
2938 if (inf
->default_thread_detach_sc
!= 0)
2939 show_thread_default_detach_sc_cmd (0, from_tty
);
2944 set_noninvasive_cmd (char *args
, int from_tty
)
2946 /* Invert the sense of the arg for each component. */
2947 char *inv_args
= parse_bool_arg (args
, "set noninvasive") ? "off" : "on";
2949 set_task_pause_cmd (inv_args
, from_tty
);
2950 set_signals_cmd (inv_args
, from_tty
);
2951 set_exceptions_cmd (inv_args
, from_tty
);
2956 info_port_rights (char *args
, mach_port_type_t only
)
2958 struct inf
*inf
= active_inf ();
2959 value_ptr vmark
= value_mark ();
2962 /* Explicit list of port rights. */
2966 value_ptr val
= parse_to_comma_and_eval (&args
);
2967 long right
= value_as_long (val
);
2969 print_port_info (right
, 0, inf
->task
->port
, PORTINFO_DETAILS
,
2972 error ("%ld: %s.", right
, strerror (err
));
2976 /* Print all of them. */
2979 print_task_ports_info (inf
->task
->port
, only
, PORTINFO_DETAILS
,
2982 error ("%s.", strerror (err
));
2985 value_free_to_mark (vmark
);
2989 info_send_rights_cmd (char *args
, int from_tty
)
2991 info_port_rights (args
, MACH_PORT_TYPE_SEND
);
2995 info_recv_rights_cmd (char *args
, int from_tty
)
2997 info_port_rights (args
, MACH_PORT_TYPE_RECEIVE
);
3001 info_port_sets_cmd (char *args
, int from_tty
)
3003 info_port_rights (args
, MACH_PORT_TYPE_PORT_SET
);
3007 info_dead_names_cmd (char *args
, int from_tty
)
3009 info_port_rights (args
, MACH_PORT_TYPE_DEAD_NAME
);
3013 info_port_rights_cmd (char *args
, int from_tty
)
3015 info_port_rights (args
, ~0);
3020 add_task_commands (void)
3022 add_cmd ("pause", class_run
, set_thread_default_pause_cmd
,
3023 "Set whether the new threads are suspended while gdb has control.\n\
3024 This property normally has no effect because the whole task is\n\
3025 suspended, however, that may be disabled with \"set task pause off\".\n\
3026 The default value is \"off\".",
3027 &set_thread_default_cmd_list
);
3028 add_cmd ("pause", no_class
, show_thread_default_pause_cmd
,
3029 "Show whether new threads are suspended while gdb has control.",
3030 &show_thread_default_cmd_list
);
3032 add_cmd ("run", class_run
, set_thread_default_run_cmd
,
3033 "Set whether new threads are allowed to run \
3034 (once gdb has noticed them).",
3035 &set_thread_default_cmd_list
);
3036 add_cmd ("run", no_class
, show_thread_default_run_cmd
,
3037 "Show whether new threads are allowed to run \
3038 (once gdb has noticed them).",
3039 &show_thread_default_cmd_list
);
3041 add_cmd ("detach-suspend-count", class_run
, set_thread_default_detach_sc_cmd
,
3042 "Set the default detach-suspend-count value for new threads.",
3043 &set_thread_default_cmd_list
);
3044 add_cmd ("detach-suspend-count", no_class
, show_thread_default_detach_sc_cmd
,
3045 "Show the default detach-suspend-count value for new threads.",
3046 &show_thread_default_cmd_list
);
3048 add_cmd ("signals", class_run
, set_signals_cmd
,
3049 "Set whether the inferior process's signals will be intercepted.\n\
3050 Mach exceptions (such as breakpoint traps) are not affected.",
3052 add_alias_cmd ("sigs", "signals", class_run
, 1, &setlist
);
3053 add_cmd ("signals", no_class
, show_signals_cmd
,
3054 "Show whether the inferior process's signals will be intercepted.",
3056 add_alias_cmd ("sigs", "signals", no_class
, 1, &showlist
);
3058 add_cmd ("signal-thread", class_run
, set_sig_thread_cmd
,
3059 "Set the thread that gdb thinks is the libc signal thread.\n\
3060 This thread is run when delivering a signal to a non-stopped process.",
3062 add_alias_cmd ("sigthread", "signal-thread", class_run
, 1, &setlist
);
3063 add_cmd ("signal-thread", no_class
, show_sig_thread_cmd
,
3064 "Set the thread that gdb thinks is the libc signal thread.",
3066 add_alias_cmd ("sigthread", "signal-thread", no_class
, 1, &showlist
);
3068 add_cmd ("stopped", class_run
, set_stopped_cmd
,
3069 "Set whether gdb thinks the inferior process is stopped \
3071 Stopped process will be continued by sending them a signal.",
3073 add_cmd ("stopped", no_class
, show_signals_cmd
,
3074 "Show whether gdb thinks the inferior process is stopped \
3078 add_cmd ("exceptions", class_run
, set_exceptions_cmd
,
3079 "Set whether exceptions in the inferior process will be trapped.\n\
3080 When exceptions are turned off, neither breakpoints nor single-stepping\n\
3083 /* Allow `set exc' despite conflict with `set exception-port'. */
3084 add_alias_cmd ("exc", "exceptions", class_run
, 1, &setlist
);
3085 add_cmd ("exceptions", no_class
, show_exceptions_cmd
,
3086 "Show whether exceptions in the inferior process will be trapped.",
3089 add_prefix_cmd ("task", no_class
, set_task_cmd
,
3090 "Command prefix for setting task attributes.",
3091 &set_task_cmd_list
, "set task ", 0, &setlist
);
3092 add_prefix_cmd ("task", no_class
, show_task_cmd
,
3093 "Command prefix for showing task attributes.",
3094 &show_task_cmd_list
, "show task ", 0, &showlist
);
3096 add_cmd ("pause", class_run
, set_task_pause_cmd
,
3097 "Set whether the task is suspended while gdb has control.\n\
3098 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3099 until the next time the program is continued.\n\
3100 When setting this to \"off\", \"set thread default pause on\" can be\n\
3101 used to pause individual threads by default instead.",
3102 &set_task_cmd_list
);
3103 add_cmd ("pause", no_class
, show_task_pause_cmd
,
3104 "Show whether the task is suspended while gdb has control.",
3105 &show_task_cmd_list
);
3107 add_cmd ("detach-suspend-count", class_run
, set_task_detach_sc_cmd
,
3108 "Set the suspend count will leave on the thread when detaching.",
3109 &set_task_cmd_list
);
3110 add_cmd ("detach-suspend-count", no_class
, show_task_detach_sc_cmd
,
3111 "Show the suspend count will leave on the thread when detaching.",
3112 &show_task_cmd_list
);
3114 add_cmd ("exception-port", no_class
, set_task_exc_port_cmd
,
3115 "Set the task exception port to which we forward exceptions.\n\
3116 The argument should be the value of the send right in the task.",
3117 &set_task_cmd_list
);
3118 add_alias_cmd ("excp", "exception-port", no_class
, 1, &set_task_cmd_list
);
3119 add_alias_cmd ("exc-port", "exception-port", no_class
, 1,
3120 &set_task_cmd_list
);
3122 /* A convenient way of turning on all options require to noninvasively
3123 debug running tasks. */
3124 add_cmd ("noninvasive", no_class
, set_noninvasive_cmd
,
3125 "Set task options so that we interfere as little as possible.\n\
3126 This is the same as setting `task pause', `exceptions', and\n\
3127 `signals' to the opposite value.",
3130 /* Commands to show information about the task's ports. */
3131 add_cmd ("send-rights", class_info
, info_send_rights_cmd
,
3132 "Show information about the task's send rights",
3134 add_cmd ("receive-rights", class_info
, info_recv_rights_cmd
,
3135 "Show information about the task's receive rights",
3137 add_cmd ("port-rights", class_info
, info_port_rights_cmd
,
3138 "Show information about the task's port rights",
3140 add_cmd ("port-sets", class_info
, info_port_sets_cmd
,
3141 "Show information about the task's port sets",
3143 add_cmd ("dead-names", class_info
, info_dead_names_cmd
,
3144 "Show information about the task's dead names",
3146 add_info_alias ("ports", "port-rights", 1);
3147 add_info_alias ("port", "port-rights", 1);
3148 add_info_alias ("psets", "port-sets", 1);
3153 set_thread_pause_cmd (char *args
, int from_tty
)
3155 struct proc
*thread
= cur_thread ();
3156 int old_sc
= thread
->pause_sc
;
3157 thread
->pause_sc
= parse_bool_arg (args
, "set thread pause");
3158 if (old_sc
== 0 && thread
->pause_sc
!= 0 && thread
->inf
->pause_sc
== 0)
3159 /* If the task is currently unsuspended, immediately suspend it,
3160 otherwise wait until the next time it gets control. */
3161 inf_suspend (thread
->inf
);
3165 show_thread_pause_cmd (char *args
, int from_tty
)
3167 struct proc
*thread
= cur_thread ();
3168 int sc
= thread
->pause_sc
;
3169 check_empty (args
, "show task pause");
3170 printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n",
3171 proc_string (thread
),
3172 sc
? "is" : "isn't",
3173 !sc
&& thread
->inf
->pause_sc
? " (but the task is)" : "");
3177 set_thread_run_cmd (char *args
, int from_tty
)
3179 struct proc
*thread
= cur_thread ();
3180 thread
->run_sc
= parse_bool_arg (args
, "set thread run") ? 0 : 1;
3184 show_thread_run_cmd (char *args
, int from_tty
)
3186 struct proc
*thread
= cur_thread ();
3187 check_empty (args
, "show thread run");
3188 printf_unfiltered ("Thread %s %s allowed to run.",
3189 proc_string (thread
),
3190 thread
->run_sc
== 0 ? "is" : "isn't");
3194 set_thread_detach_sc_cmd (char *args
, int from_tty
)
3196 cur_thread ()->detach_sc
= parse_int_arg (args
,
3197 "set thread detach-suspend-count");
3201 show_thread_detach_sc_cmd (char *args
, int from_tty
)
3203 struct proc
*thread
= cur_thread ();
3204 check_empty (args
, "show thread detach-suspend-count");
3205 printf_unfiltered ("Thread %s will be left with a suspend count"
3206 " of %d when detaching.\n",
3207 proc_string (thread
),
3212 set_thread_exc_port_cmd (char *args
, int from_tty
)
3214 struct proc
*thread
= cur_thread ();
3216 error ("No argument to \"set thread exception-port\" command.");
3217 steal_exc_port (thread
, parse_and_eval_address (args
));
3222 show_thread_cmd (char *args
, int from_tty
)
3224 struct proc
*thread
= cur_thread ();
3225 check_empty (args
, "show thread");
3226 show_thread_run_cmd (0, from_tty
);
3227 show_thread_pause_cmd (0, from_tty
);
3228 if (thread
->detach_sc
!= 0)
3229 show_thread_detach_sc_cmd (0, from_tty
);
3234 thread_takeover_sc_cmd (char *args
, int from_tty
)
3236 struct proc
*thread
= cur_thread ();
3237 thread_basic_info_data_t _info
;
3238 thread_basic_info_t info
= &_info
;
3239 mach_msg_type_number_t info_len
= THREAD_BASIC_INFO_COUNT
;
3241 thread_info (thread
->port
, THREAD_BASIC_INFO
, (int *) &info
, &info_len
);
3243 error ("%s.", strerror (err
));
3244 thread
->sc
= info
->suspend_count
;
3246 printf_unfiltered ("Suspend count was %d.\n", thread
->sc
);
3248 vm_deallocate (mach_task_self (), (vm_address_t
) info
,
3249 info_len
* sizeof (int));
3254 add_thread_commands (void)
3256 add_prefix_cmd ("thread", no_class
, set_thread_cmd
,
3257 "Command prefix for setting thread properties.",
3258 &set_thread_cmd_list
, "set thread ", 0, &setlist
);
3259 add_prefix_cmd ("default", no_class
, show_thread_cmd
,
3260 "Command prefix for setting default thread properties.",
3261 &set_thread_default_cmd_list
, "set thread default ", 0,
3262 &set_thread_cmd_list
);
3263 add_prefix_cmd ("thread", no_class
, set_thread_default_cmd
,
3264 "Command prefix for showing thread properties.",
3265 &show_thread_cmd_list
, "show thread ", 0, &showlist
);
3266 add_prefix_cmd ("default", no_class
, show_thread_default_cmd
,
3267 "Command prefix for showing default thread properties.",
3268 &show_thread_default_cmd_list
, "show thread default ", 0,
3269 &show_thread_cmd_list
);
3271 add_cmd ("pause", class_run
, set_thread_pause_cmd
,
3272 "Set whether the current thread is suspended \
3273 while gdb has control.\n\
3274 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3275 until the next time the program is continued. This property normally\n\
3276 has no effect because the whole task is suspended, however, that may\n\
3277 be disabled with \"set task pause off\".\n\
3278 The default value is \"off\".",
3279 &set_thread_cmd_list
);
3280 add_cmd ("pause", no_class
, show_thread_pause_cmd
,
3281 "Show whether the current thread is suspended \
3282 while gdb has control.",
3283 &show_thread_cmd_list
);
3285 add_cmd ("run", class_run
, set_thread_run_cmd
,
3286 "Set whether the current thread is allowed to run.",
3287 &set_thread_cmd_list
);
3288 add_cmd ("run", no_class
, show_thread_run_cmd
,
3289 "Show whether the current thread is allowed to run.",
3290 &show_thread_cmd_list
);
3292 add_cmd ("detach-suspend-count", class_run
, set_thread_detach_sc_cmd
,
3293 "Set the suspend count will leave on the thread when detaching.\n\
3294 Note that this is relative to suspend count when gdb noticed the thread;\n\
3295 use the `thread takeover-suspend-count' to force it to an absolute value.",
3296 &set_thread_cmd_list
);
3297 add_cmd ("detach-suspend-count", no_class
, show_thread_detach_sc_cmd
,
3298 "Show the suspend count will leave on the thread when detaching.\n\
3299 Note that this is relative to suspend count when gdb noticed the thread;\n\
3300 use the `thread takeover-suspend-count' to force it to an absolute value.",
3301 &show_thread_cmd_list
);
3303 add_cmd ("exception-port", no_class
, set_thread_exc_port_cmd
,
3304 "Set the thread exception port to which we forward exceptions.\n\
3305 This overrides the task exception port.\n\
3306 The argument should be the value of the send right in the task.",
3307 &set_thread_cmd_list
);
3308 add_alias_cmd ("excp", "exception-port", no_class
, 1, &set_thread_cmd_list
);
3309 add_alias_cmd ("exc-port", "exception-port", no_class
, 1,
3310 &set_thread_cmd_list
);
3312 add_cmd ("takeover-suspend-count", no_class
, thread_takeover_sc_cmd
,
3313 "Force the threads absolute suspend-count to be gdb's.\n\
3314 Prior to giving this command, gdb's thread suspend-counts are relative\n\
3315 to the thread's initial suspend-count when gdb notices the threads.",
3321 _initialize_gnu_nat (void)
3323 proc_server
= getproc ();
3326 add_target (&gnu_ops
);
3328 add_task_commands ();
3329 add_thread_commands ();
3330 add_set_cmd ("gnu-debug", class_maintenance
,
3331 var_boolean
, (char *) &gnu_debug_flag
,
3332 "Set debugging output for the gnu backend.", &maintenancelist
);
3335 #ifdef FLUSH_INFERIOR_CACHE
3337 /* When over-writing code on some machines the I-Cache must be flushed
3338 explicitly, because it is not kept coherent by the lazy hardware.
3339 This definitely includes breakpoints, for instance, or else we
3340 end up looping in mysterious Bpt traps */
3343 flush_inferior_icache (CORE_ADDR pc
, int amount
)
3345 vm_machine_attribute_val_t flush
= MATTR_VAL_ICACHE_FLUSH
;
3348 ret
= vm_machine_attribute (current_inferior
->task
->port
,
3353 if (ret
!= KERN_SUCCESS
)
3354 warning ("Error flushing inferior's cache : %s", strerror (ret
));
3356 #endif /* FLUSH_INFERIOR_CACHE */