1 /* Interface GDB to the GNU Hurd.
2 Copyright (C) 1992, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2006, 2007,
3 2008 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 3 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, see <http://www.gnu.org/licenses/>.
31 #include "gdb_string.h"
32 #include <sys/ptrace.h>
35 #include <mach_error.h>
36 #include <mach/exception.h>
37 #include <mach/message.h>
38 #include <mach/notify.h>
39 #include <mach/vm_attributes.h>
42 #include <hurd/interrupt.h>
44 #include <hurd/msg_request.h>
45 #include <hurd/process.h>
46 /* Defined in <hurd/process.h>, but we need forward declarations from
47 <hurd/process_request.h> as well. */
49 #include <hurd/process_request.h>
50 #include <hurd/signal.h>
51 #include <hurd/sigpreempt.h>
64 #include "gdbthread.h"
65 #include "gdb_assert.h"
66 #include "gdb_obstack.h"
70 #include "exc_request_S.h"
72 #include "process_reply_S.h"
73 #include "msg_reply_S.h"
74 #include "exc_request_U.h"
77 static process_t proc_server
= MACH_PORT_NULL
;
79 /* If we've sent a proc_wait_request to the proc server, the pid of the
80 process we asked about. We can only ever have one outstanding. */
81 int proc_wait_pid
= 0;
83 /* The number of wait requests we've sent, and expect replies from. */
84 int proc_waits_pending
= 0;
86 int gnu_debug_flag
= 0;
90 extern struct target_ops gnu_ops
;
92 struct inf
*make_inf ();
93 void inf_clear_wait (struct inf
*inf
);
94 void inf_cleanup (struct inf
*inf
);
95 void inf_startup (struct inf
*inf
, int pid
);
96 int inf_update_suspends (struct inf
*inf
);
97 void inf_set_pid (struct inf
*inf
, pid_t pid
);
98 void inf_validate_procs (struct inf
*inf
);
99 void inf_steal_exc_ports (struct inf
*inf
);
100 void inf_restore_exc_ports (struct inf
*inf
);
101 struct proc
*inf_tid_to_proc (struct inf
*inf
, int tid
);
102 void inf_set_threads_resume_sc (struct inf
*inf
,
103 struct proc
*run_thread
,
105 int inf_set_threads_resume_sc_for_signal_thread (struct inf
*inf
);
106 void inf_suspend (struct inf
*inf
);
107 void inf_resume (struct inf
*inf
);
108 void inf_set_step_thread (struct inf
*inf
, struct proc
*proc
);
109 void inf_detach (struct inf
*inf
);
110 void inf_attach (struct inf
*inf
, int pid
);
111 void inf_signal (struct inf
*inf
, enum target_signal sig
);
112 void inf_continue (struct inf
*inf
);
114 #define inf_debug(_inf, msg, args...) \
115 do { struct inf *__inf = (_inf); \
116 debug ("{inf %d %p}: " msg, __inf->pid, __inf , ##args); } while (0)
118 void proc_abort (struct proc
*proc
, int force
);
119 struct proc
*make_proc (struct inf
*inf
, mach_port_t port
, int tid
);
120 struct proc
*_proc_free (struct proc
*proc
);
121 int proc_update_sc (struct proc
*proc
);
122 error_t
proc_get_exception_port (struct proc
*proc
, mach_port_t
* port
);
123 error_t
proc_set_exception_port (struct proc
*proc
, mach_port_t port
);
124 static mach_port_t
_proc_get_exc_port (struct proc
*proc
);
125 void proc_steal_exc_port (struct proc
*proc
, mach_port_t exc_port
);
126 void proc_restore_exc_port (struct proc
*proc
);
127 int proc_trace (struct proc
*proc
, int set
);
129 /* Evaluate RPC_EXPR in a scope with the variables MSGPORT and REFPORT bound
130 to INF's msg port and task port respectively. If it has no msg port,
131 EIEIO is returned. INF must refer to a running process! */
132 #define INF_MSGPORT_RPC(inf, rpc_expr) \
133 HURD_MSGPORT_RPC (proc_getmsgport (proc_server, inf->pid, &msgport), \
134 (refport = inf->task->port, 0), 0, \
135 msgport ? (rpc_expr) : EIEIO)
137 /* Like INF_MSGPORT_RPC, but will also resume the signal thread to ensure
138 there's someone around to deal with the RPC (and resuspend things
139 afterwards). This effects INF's threads' resume_sc count. */
140 #define INF_RESUME_MSGPORT_RPC(inf, rpc_expr) \
141 (inf_set_threads_resume_sc_for_signal_thread (inf) \
144 __e = INF_MSGPORT_RPC (inf, rpc_expr); \
150 /* The state passed by an exception message. */
153 int exception
; /* The exception code */
155 mach_port_t handler
; /* The real exception port to handle this. */
156 mach_port_t reply
; /* The reply port from the exception call. */
159 /* The results of the last wait an inf did. */
162 struct target_waitstatus status
; /* The status returned to gdb. */
163 struct exc_state exc
; /* The exception that caused us to return. */
164 struct proc
*thread
; /* The thread in question. */
165 int suppress
; /* Something trivial happened. */
168 /* The state of an inferior. */
171 /* Fields describing the current inferior. */
173 struct proc
*task
; /* The mach task. */
174 struct proc
*threads
; /* A linked list of all threads in TASK. */
176 /* True if THREADS needn't be validated by querying the task. We assume that
177 we and the task in question are the only ones frobbing the thread list,
178 so as long as we don't let any code run, we don't have to worry about
180 int threads_up_to_date
;
182 pid_t pid
; /* The real system PID. */
184 struct inf_wait wait
; /* What to return from target_wait. */
186 /* One thread proc in INF may be in `single-stepping mode'. This is it. */
187 struct proc
*step_thread
;
189 /* The thread we think is the signal thread. */
190 struct proc
*signal_thread
;
192 mach_port_t event_port
; /* Where we receive various msgs. */
194 /* True if we think at least one thread in the inferior could currently be
196 unsigned int running
:1;
198 /* True if the process has stopped (in the proc server sense). Note that
199 since a proc server `stop' leaves the signal thread running, the inf can
200 be RUNNING && STOPPED... */
201 unsigned int stopped
:1;
203 /* True if the inferior has no message port. */
204 unsigned int nomsg
:1;
206 /* True if the inferior is traced. */
207 unsigned int traced
:1;
209 /* True if we shouldn't try waiting for the inferior, usually because we
210 can't for some reason. */
211 unsigned int no_wait
:1;
213 /* When starting a new inferior, we don't try to validate threads until all
214 the proper execs have been done. This is a count of how many execs we
216 unsigned pending_execs
;
218 /* Fields describing global state */
220 /* The task suspend count used when gdb has control. This is normally 1 to
221 make things easier for us, but sometimes (like when attaching to vital
222 system servers) it may be desirable to let the task continue to run
223 (pausing individual threads as necessary). */
226 /* The task suspend count left when detaching from a task. */
229 /* The initial values used for the run_sc and pause_sc of newly discovered
230 threads -- see the definition of those fields in struct proc. */
231 int default_thread_run_sc
;
232 int default_thread_pause_sc
;
233 int default_thread_detach_sc
;
235 /* True if the process should be traced when started/attached. Newly
236 started processes *must* be traced at first to exec them properly, but
237 if this is false, tracing is turned off as soon it has done so. */
240 /* True if exceptions from the inferior process should be trapped. This
241 must be on to use breakpoints. */
247 __proc_pid (struct proc
*proc
)
249 return proc
->inf
->pid
;
253 /* Update PROC's real suspend count to match it's desired one. Returns true
254 if we think PROC is now in a runnable state. */
256 proc_update_sc (struct proc
*proc
)
260 int delta
= proc
->sc
- proc
->cur_sc
;
263 proc_debug (proc
, "sc: %d --> %d", proc
->cur_sc
, proc
->sc
);
265 if (proc
->sc
== 0 && proc
->state_changed
)
266 /* Since PROC may start running, we must write back any state changes. */
268 gdb_assert (proc_is_thread (proc
));
269 proc_debug (proc
, "storing back changed thread state");
270 err
= thread_set_state (proc
->port
, THREAD_STATE_FLAVOR
,
271 (thread_state_t
) &proc
->state
, THREAD_STATE_SIZE
);
273 proc
->state_changed
= 0;
278 while (delta
-- > 0 && !err
)
280 if (proc_is_task (proc
))
281 err
= task_suspend (proc
->port
);
283 err
= thread_suspend (proc
->port
);
288 while (delta
++ < 0 && !err
)
290 if (proc_is_task (proc
))
291 err
= task_resume (proc
->port
);
293 err
= thread_resume (proc
->port
);
297 proc
->cur_sc
= proc
->sc
;
299 /* If we got an error, then the task/thread has disappeared. */
300 running
= !err
&& proc
->sc
== 0;
302 proc_debug (proc
, "is %s", err
? "dead" : running
? "running" : "suspended");
304 proc_debug (proc
, "err = %s", safe_strerror (err
));
309 proc
->state_valid
= proc
->state_changed
= 0;
310 proc
->fetched_regs
= 0;
317 /* Thread_abort is called on PROC if needed. PROC must be a thread proc.
318 If PROC is deemed `precious', then nothing is done unless FORCE is true.
319 In particular, a thread is precious if it's running (in which case forcing
320 it includes suspending it first), or if it has an exception pending. */
322 proc_abort (struct proc
*proc
, int force
)
324 gdb_assert (proc_is_thread (proc
));
328 struct inf
*inf
= proc
->inf
;
329 int running
= (proc
->cur_sc
== 0 && inf
->task
->cur_sc
== 0);
331 if (running
&& force
)
334 inf_update_suspends (proc
->inf
);
336 warning (_("Stopped %s."), proc_string (proc
));
338 else if (proc
== inf
->wait
.thread
&& inf
->wait
.exc
.reply
&& !force
)
339 /* An exception is pending on PROC, which don't mess with. */
343 /* We only abort the thread if it's not actually running. */
345 thread_abort (proc
->port
);
346 proc_debug (proc
, "aborted");
350 proc_debug (proc
, "not aborting");
354 /* Make sure that the state field in PROC is up to date, and return a pointer
355 to it, or 0 if something is wrong. If WILL_MODIFY is true, makes sure
356 that the thread is stopped and aborted first, and sets the state_changed
357 field in PROC to true. */
359 proc_get_state (struct proc
*proc
, int will_modify
)
361 int was_aborted
= proc
->aborted
;
363 proc_debug (proc
, "updating state info%s",
364 will_modify
? " (with intention to modify)" : "");
366 proc_abort (proc
, will_modify
);
368 if (!was_aborted
&& proc
->aborted
)
369 /* PROC's state may have changed since we last fetched it. */
370 proc
->state_valid
= 0;
372 if (!proc
->state_valid
)
374 mach_msg_type_number_t state_size
= THREAD_STATE_SIZE
;
376 thread_get_state (proc
->port
, THREAD_STATE_FLAVOR
,
377 (thread_state_t
) &proc
->state
, &state_size
);
378 proc_debug (proc
, "getting thread state");
379 proc
->state_valid
= !err
;
382 if (proc
->state_valid
)
385 proc
->state_changed
= 1;
386 return (thread_state_t
) &proc
->state
;
393 /* Set PORT to PROC's exception port. */
395 proc_get_exception_port (struct proc
* proc
, mach_port_t
* port
)
397 if (proc_is_task (proc
))
398 return task_get_exception_port (proc
->port
, port
);
400 return thread_get_exception_port (proc
->port
, port
);
403 /* Set PROC's exception port to PORT. */
405 proc_set_exception_port (struct proc
* proc
, mach_port_t port
)
407 proc_debug (proc
, "setting exception port: %d", port
);
408 if (proc_is_task (proc
))
409 return task_set_exception_port (proc
->port
, port
);
411 return thread_set_exception_port (proc
->port
, port
);
414 /* Get PROC's exception port, cleaning up a bit if proc has died. */
416 _proc_get_exc_port (struct proc
*proc
)
418 mach_port_t exc_port
;
419 error_t err
= proc_get_exception_port (proc
, &exc_port
);
422 /* PROC must be dead. */
425 mach_port_deallocate (mach_task_self (), proc
->exc_port
);
426 proc
->exc_port
= MACH_PORT_NULL
;
427 if (proc
->saved_exc_port
)
428 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
429 proc
->saved_exc_port
= MACH_PORT_NULL
;
435 /* Replace PROC's exception port with EXC_PORT, unless it's already been
436 done. Stash away any existing exception port so we can restore it later. */
438 proc_steal_exc_port (struct proc
*proc
, mach_port_t exc_port
)
440 mach_port_t cur_exc_port
= _proc_get_exc_port (proc
);
446 proc_debug (proc
, "inserting exception port: %d", exc_port
);
448 if (cur_exc_port
!= exc_port
)
449 /* Put in our exception port. */
450 err
= proc_set_exception_port (proc
, exc_port
);
452 if (err
|| cur_exc_port
== proc
->exc_port
)
453 /* We previously set the exception port, and it's still set. So we
454 just keep the old saved port which is what the proc set. */
457 mach_port_deallocate (mach_task_self (), cur_exc_port
);
460 /* Keep a copy of PROC's old exception port so it can be restored. */
462 if (proc
->saved_exc_port
)
463 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
464 proc
->saved_exc_port
= cur_exc_port
;
467 proc_debug (proc
, "saved exception port: %d", proc
->saved_exc_port
);
470 proc
->exc_port
= exc_port
;
472 warning (_("Error setting exception port for %s: %s"),
473 proc_string (proc
), safe_strerror (err
));
477 /* If we previously replaced PROC's exception port, put back what we
478 found there at the time, unless *our* exception port has since been
479 overwritten, in which case who knows what's going on. */
481 proc_restore_exc_port (struct proc
*proc
)
483 mach_port_t cur_exc_port
= _proc_get_exc_port (proc
);
489 proc_debug (proc
, "restoring real exception port");
491 if (proc
->exc_port
== cur_exc_port
)
492 /* Our's is still there. */
493 err
= proc_set_exception_port (proc
, proc
->saved_exc_port
);
495 if (proc
->saved_exc_port
)
496 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
497 proc
->saved_exc_port
= MACH_PORT_NULL
;
500 proc
->exc_port
= MACH_PORT_NULL
;
502 warning (_("Error setting exception port for %s: %s"),
503 proc_string (proc
), safe_strerror (err
));
508 /* Turns hardware tracing in PROC on or off when SET is true or false,
509 respectively. Returns true on success. */
511 proc_trace (struct proc
*proc
, int set
)
513 thread_state_t state
= proc_get_state (proc
, 1);
516 return 0; /* the thread must be dead. */
518 proc_debug (proc
, "tracing %s", set
? "on" : "off");
522 /* XXX We don't get the exception unless the thread has its own
523 exception port???? */
524 if (proc
->exc_port
== MACH_PORT_NULL
)
525 proc_steal_exc_port (proc
, proc
->inf
->event_port
);
526 THREAD_STATE_SET_TRACED (state
);
529 THREAD_STATE_CLEAR_TRACED (state
);
535 /* A variable from which to assign new TIDs. */
536 static int next_thread_id
= 1;
538 /* Returns a new proc structure with the given fields. Also adds a
539 notification for PORT becoming dead to be sent to INF's notify port. */
541 make_proc (struct inf
*inf
, mach_port_t port
, int tid
)
544 mach_port_t prev_port
= MACH_PORT_NULL
;
545 struct proc
*proc
= xmalloc (sizeof (struct proc
));
551 proc
->saved_exc_port
= MACH_PORT_NULL
;
552 proc
->exc_port
= MACH_PORT_NULL
;
557 /* Note that these are all the values for threads; the task simply uses the
558 corresponding field in INF directly. */
559 proc
->run_sc
= inf
->default_thread_run_sc
;
560 proc
->pause_sc
= inf
->default_thread_pause_sc
;
561 proc
->detach_sc
= inf
->default_thread_detach_sc
;
562 proc
->resume_sc
= proc
->run_sc
;
566 proc
->state_valid
= 0;
567 proc
->state_changed
= 0;
569 proc_debug (proc
, "is new");
571 /* Get notified when things die. */
573 mach_port_request_notification (mach_task_self (), port
,
574 MACH_NOTIFY_DEAD_NAME
, 1,
576 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
579 warning (_("Couldn't request notification for port %d: %s"),
580 port
, safe_strerror (err
));
583 proc_debug (proc
, "notifications to: %d", inf
->event_port
);
584 if (prev_port
!= MACH_PORT_NULL
)
585 mach_port_deallocate (mach_task_self (), prev_port
);
588 if (inf
->want_exceptions
)
590 if (proc_is_task (proc
))
591 /* Make the task exception port point to us. */
592 proc_steal_exc_port (proc
, inf
->event_port
);
594 /* Just clear thread exception ports -- they default to the
596 proc_steal_exc_port (proc
, MACH_PORT_NULL
);
602 /* Frees PROC and any resources it uses, and returns the value of PROC's
605 _proc_free (struct proc
*proc
)
607 struct inf
*inf
= proc
->inf
;
608 struct proc
*next
= proc
->next
;
610 proc_debug (proc
, "freeing...");
612 if (proc
== inf
->step_thread
)
613 /* Turn off single stepping. */
614 inf_set_step_thread (inf
, 0);
615 if (proc
== inf
->wait
.thread
)
616 inf_clear_wait (inf
);
617 if (proc
== inf
->signal_thread
)
618 inf
->signal_thread
= 0;
620 if (proc
->port
!= MACH_PORT_NULL
)
622 if (proc
->exc_port
!= MACH_PORT_NULL
)
623 /* Restore the original exception port. */
624 proc_restore_exc_port (proc
);
625 if (proc
->cur_sc
!= 0)
626 /* Resume the thread/task. */
629 proc_update_sc (proc
);
631 mach_port_deallocate (mach_task_self (), proc
->port
);
642 struct inf
*inf
= xmalloc (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"), safe_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
, safe_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
, safe_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 memset (matched
, 0, 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. */
1055 last
->next
= thread
;
1057 inf
->threads
= thread
;
1061 for (i
= 0; i
< num_threads
; i
++)
1064 /* Throw away the duplicate send right. */
1065 mach_port_deallocate (mach_task_self (), threads
[i
]);
1067 /* THREADS[I] is a thread we don't know about yet! */
1071 thread
= make_proc (inf
, threads
[i
], next_thread_id
++);
1073 last
->next
= thread
;
1075 inf
->threads
= thread
;
1077 proc_debug (thread
, "new thread: %d", threads
[i
]);
1079 ptid
= ptid_build (inf
->pid
, 0, thread
->tid
);
1081 /* Tell GDB's generic thread code. */
1083 if (ptid_equal (inferior_ptid
, pid_to_ptid (inf
->pid
)))
1084 /* This is the first time we're hearing about thread
1085 ids, after a fork-child. */
1086 thread_change_ptid (inferior_ptid
, ptid
);
1087 else if (inf
->pending_execs
!= 0)
1088 /* This is a shell thread. */
1089 add_thread_silent (ptid
);
1095 vm_deallocate (mach_task_self (),
1096 (vm_address_t
) threads
, (num_threads
* sizeof (thread_t
)));
1101 /* Makes sure that INF's thread list is synced with the actual process. */
1103 inf_update_procs (struct inf
*inf
)
1107 if (!inf
->threads_up_to_date
)
1108 inf_validate_procs (inf
);
1112 /* Sets the resume_sc of each thread in inf. That of RUN_THREAD is set to 0,
1113 and others are set to their run_sc if RUN_OTHERS is true, and otherwise
1116 inf_set_threads_resume_sc (struct inf
*inf
,
1117 struct proc
*run_thread
, int run_others
)
1119 struct proc
*thread
;
1120 inf_update_procs (inf
);
1121 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1122 if (thread
== run_thread
)
1123 thread
->resume_sc
= 0;
1124 else if (run_others
)
1125 thread
->resume_sc
= thread
->run_sc
;
1127 thread
->resume_sc
= thread
->pause_sc
;
1131 /* Cause INF to continue execution immediately; individual threads may still
1132 be suspended (but their suspend counts will be updated). */
1134 inf_resume (struct inf
*inf
)
1136 struct proc
*thread
;
1138 inf_update_procs (inf
);
1140 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1141 thread
->sc
= thread
->resume_sc
;
1145 if (!inf
->pending_execs
)
1146 /* Try to make sure our task count is correct -- in the case where
1147 we're waiting for an exec though, things are too volatile, so just
1148 assume things will be reasonable (which they usually will be). */
1149 inf_validate_task_sc (inf
);
1153 inf_update_suspends (inf
);
1156 /* Cause INF to stop execution immediately; individual threads may still
1159 inf_suspend (struct inf
*inf
)
1161 struct proc
*thread
;
1163 inf_update_procs (inf
);
1165 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1166 thread
->sc
= thread
->pause_sc
;
1169 inf
->task
->sc
= inf
->pause_sc
;
1171 inf_update_suspends (inf
);
1175 /* INF has one thread PROC that is in single-stepping mode. This
1176 function changes it to be PROC, changing any old step_thread to be
1177 a normal one. A PROC of 0 clears any existing value. */
1179 inf_set_step_thread (struct inf
*inf
, struct proc
*thread
)
1181 gdb_assert (!thread
|| proc_is_thread (thread
));
1184 inf_debug (inf
, "setting step thread: %d/%d", inf
->pid
, thread
->tid
);
1186 inf_debug (inf
, "clearing step thread");
1188 if (inf
->step_thread
!= thread
)
1190 if (inf
->step_thread
&& inf
->step_thread
->port
!= MACH_PORT_NULL
)
1191 if (!proc_trace (inf
->step_thread
, 0))
1193 if (thread
&& proc_trace (thread
, 1))
1194 inf
->step_thread
= thread
;
1196 inf
->step_thread
= 0;
1201 /* Set up the thread resume_sc's so that only the signal thread is running
1202 (plus whatever other thread are set to always run). Returns true if we
1203 did so, or false if we can't find a signal thread. */
1205 inf_set_threads_resume_sc_for_signal_thread (struct inf
*inf
)
1207 if (inf
->signal_thread
)
1209 inf_set_threads_resume_sc (inf
, inf
->signal_thread
, 0);
1217 inf_update_signal_thread (struct inf
*inf
)
1219 /* XXX for now we assume that if there's a msgport, the 2nd thread is
1220 the signal thread. */
1221 inf
->signal_thread
= inf
->threads
? inf
->threads
->next
: 0;
1225 /* Detachs from INF's inferior task, letting it run once again... */
1227 inf_detach (struct inf
*inf
)
1229 struct proc
*task
= inf
->task
;
1231 inf_debug (inf
, "detaching...");
1233 inf_clear_wait (inf
);
1234 inf_set_step_thread (inf
, 0);
1238 struct proc
*thread
;
1240 inf_validate_procinfo (inf
);
1242 inf_set_traced (inf
, 0);
1248 inf_signal (inf
, TARGET_SIGNAL_0
);
1251 proc_restore_exc_port (task
);
1252 task
->sc
= inf
->detach_sc
;
1254 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1256 proc_restore_exc_port (thread
);
1257 thread
->sc
= thread
->detach_sc
;
1260 inf_update_suspends (inf
);
1266 /* Attaches INF to the process with process id PID, returning it in a
1267 suspended state suitable for debugging. */
1269 inf_attach (struct inf
*inf
, int pid
)
1271 inf_debug (inf
, "attaching: %d", pid
);
1276 inf_startup (inf
, pid
);
1280 /* Makes sure that we've got our exception ports entrenched in the process. */
1282 inf_steal_exc_ports (struct inf
*inf
)
1284 struct proc
*thread
;
1286 inf_debug (inf
, "stealing exception ports");
1288 inf_set_step_thread (inf
, 0); /* The step thread is special. */
1290 proc_steal_exc_port (inf
->task
, inf
->event_port
);
1291 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1292 proc_steal_exc_port (thread
, MACH_PORT_NULL
);
1295 /* Makes sure the process has its own exception ports. */
1297 inf_restore_exc_ports (struct inf
*inf
)
1299 struct proc
*thread
;
1301 inf_debug (inf
, "restoring exception ports");
1303 inf_set_step_thread (inf
, 0); /* The step thread is special. */
1305 proc_restore_exc_port (inf
->task
);
1306 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1307 proc_restore_exc_port (thread
);
1311 /* Deliver signal SIG to INF. If INF is stopped, delivering a signal, even
1312 signal 0, will continue it. INF is assumed to be in a paused state, and
1313 the resume_sc's of INF's threads may be affected. */
1315 inf_signal (struct inf
*inf
, enum target_signal sig
)
1318 int host_sig
= target_signal_to_host (sig
);
1320 #define NAME target_signal_to_name (sig)
1322 if (host_sig
>= _NSIG
)
1323 /* A mach exception. Exceptions are encoded in the signal space by
1324 putting them after _NSIG; this assumes they're positive (and not
1325 extremely large)! */
1327 struct inf_wait
*w
= &inf
->wait
;
1328 if (w
->status
.kind
== TARGET_WAITKIND_STOPPED
1329 && w
->status
.value
.sig
== sig
1330 && w
->thread
&& !w
->thread
->aborted
)
1331 /* We're passing through the last exception we received. This is
1332 kind of bogus, because exceptions are per-thread whereas gdb
1333 treats signals as per-process. We just forward the exception to
1334 the correct handler, even it's not for the same thread as TID --
1335 i.e., we pretend it's global. */
1337 struct exc_state
*e
= &w
->exc
;
1338 inf_debug (inf
, "passing through exception:"
1339 " task = %d, thread = %d, exc = %d"
1340 ", code = %d, subcode = %d",
1341 w
->thread
->port
, inf
->task
->port
,
1342 e
->exception
, e
->code
, e
->subcode
);
1344 exception_raise_request (e
->handler
,
1345 e
->reply
, MACH_MSG_TYPE_MOVE_SEND_ONCE
,
1346 w
->thread
->port
, inf
->task
->port
,
1347 e
->exception
, e
->code
, e
->subcode
);
1350 error (_("Can't forward spontaneous exception (%s)."), NAME
);
1353 /* A Unix signal. */
1355 /* The process is stopped and expecting a signal. Just send off a
1356 request and let it get handled when we resume everything. */
1358 inf_debug (inf
, "sending %s to stopped process", NAME
);
1360 INF_MSGPORT_RPC (inf
,
1361 msg_sig_post_untraced_request (msgport
,
1363 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1367 /* Posting an untraced signal automatically continues it.
1368 We clear this here rather than when we get the reply
1369 because we'd rather assume it's not stopped when it
1370 actually is, than the reverse. */
1374 /* It's not expecting it. We have to let just the signal thread
1375 run, and wait for it to get into a reasonable state before we
1376 can continue the rest of the process. When we finally resume the
1377 process the signal we request will be the very first thing that
1380 inf_debug (inf
, "sending %s to unstopped process"
1381 " (so resuming signal thread)", NAME
);
1383 INF_RESUME_MSGPORT_RPC (inf
,
1384 msg_sig_post_untraced (msgport
, host_sig
,
1389 /* Can't do too much... */
1390 warning (_("Can't deliver signal %s: No signal thread."), NAME
);
1392 warning (_("Delivering signal %s: %s"), NAME
, safe_strerror (err
));
1398 /* Continue INF without delivering a signal. This is meant to be used
1399 when INF does not have a message port. */
1401 inf_continue (struct inf
*inf
)
1404 error_t err
= proc_pid2proc (proc_server
, inf
->pid
, &proc
);
1408 inf_debug (inf
, "continuing process");
1410 err
= proc_mark_cont (proc
);
1413 struct proc
*thread
;
1415 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1416 thread_resume (thread
->port
);
1423 warning (_("Can't continue process: %s"), safe_strerror (err
));
1427 /* The inferior used for all gdb target ops. */
1428 struct inf
*gnu_current_inf
= 0;
1430 /* The inferior being waited for by gnu_wait. Since GDB is decidely not
1431 multi-threaded, we don't bother to lock this. */
1432 struct inf
*waiting_inf
;
1434 /* Wait for something to happen in the inferior, returning what in STATUS. */
1436 gnu_wait (ptid_t ptid
, struct target_waitstatus
*status
)
1440 mach_msg_header_t hdr
;
1441 mach_msg_type_t type
;
1445 struct proc
*thread
;
1446 struct inf
*inf
= gnu_current_inf
;
1448 extern int exc_server (mach_msg_header_t
*, mach_msg_header_t
*);
1449 extern int msg_reply_server (mach_msg_header_t
*, mach_msg_header_t
*);
1450 extern int notify_server (mach_msg_header_t
*, mach_msg_header_t
*);
1451 extern int process_reply_server (mach_msg_header_t
*, mach_msg_header_t
*);
1453 gdb_assert (inf
->task
);
1455 if (!inf
->threads
&& !inf
->pending_execs
)
1456 /* No threads! Assume that maybe some outside agency is frobbing our
1457 task, and really look for new threads. If we can't find any, just tell
1458 the user to try again later. */
1460 inf_validate_procs (inf
);
1461 if (!inf
->threads
&& !inf
->task
->dead
)
1462 error (_("There are no threads; try again later."));
1467 inf_debug (inf
, "waiting for: %s", target_pid_to_str (ptid
));
1470 if (proc_wait_pid
!= inf
->pid
&& !inf
->no_wait
)
1471 /* Always get information on events from the proc server. */
1473 inf_debug (inf
, "requesting wait on pid %d", inf
->pid
);
1476 /* The proc server is single-threaded, and only allows a single
1477 outstanding wait request, so we have to cancel the previous one. */
1479 inf_debug (inf
, "cancelling previous wait on pid %d", proc_wait_pid
);
1480 interrupt_operation (proc_server
, 0);
1484 proc_wait_request (proc_server
, inf
->event_port
, inf
->pid
, WUNTRACED
);
1486 warning (_("wait request failed: %s"), safe_strerror (err
));
1489 inf_debug (inf
, "waits pending: %d", proc_waits_pending
);
1490 proc_wait_pid
= inf
->pid
;
1491 /* Even if proc_waits_pending was > 0 before, we still won't
1492 get any other replies, because it was either from a
1493 different INF, or a different process attached to INF --
1494 and the event port, which is the wait reply port, changes
1495 when you switch processes. */
1496 proc_waits_pending
= 1;
1500 inf_clear_wait (inf
);
1502 /* What can happen? (1) Dead name notification; (2) Exceptions arrive;
1503 (3) wait reply from the proc server. */
1505 inf_debug (inf
, "waiting for an event...");
1506 err
= mach_msg (&msg
.hdr
, MACH_RCV_MSG
| MACH_RCV_INTERRUPT
,
1507 0, sizeof (struct msg
), inf
->event_port
,
1508 MACH_MSG_TIMEOUT_NONE
, MACH_PORT_NULL
);
1510 /* Re-suspend the task. */
1513 if (!inf
->task
&& inf
->pending_execs
)
1514 /* When doing an exec, it's possible that the old task wasn't reused
1515 (e.g., setuid execs). So if the task seems to have disappeared,
1516 attempt to refetch it, as the pid should still be the same. */
1517 inf_set_pid (inf
, inf
->pid
);
1519 if (err
== EMACH_RCV_INTERRUPTED
)
1520 inf_debug (inf
, "interrupted");
1522 error (_("Couldn't wait for an event: %s"), safe_strerror (err
));
1527 mach_msg_header_t hdr
;
1528 mach_msg_type_t err_type
;
1534 inf_debug (inf
, "event: msgid = %d", msg
.hdr
.msgh_id
);
1536 /* Handle what we got. */
1537 if (!notify_server (&msg
.hdr
, &reply
.hdr
)
1538 && !exc_server (&msg
.hdr
, &reply
.hdr
)
1539 && !process_reply_server (&msg
.hdr
, &reply
.hdr
)
1540 && !msg_reply_server (&msg
.hdr
, &reply
.hdr
))
1541 /* Whatever it is, it's something strange. */
1542 error (_("Got a strange event, msg id = %d."), msg
.hdr
.msgh_id
);
1545 error (_("Handling event, msgid = %d: %s"),
1546 msg
.hdr
.msgh_id
, safe_strerror (reply
.err
));
1549 if (inf
->pending_execs
)
1550 /* We're waiting for the inferior to finish execing. */
1552 struct inf_wait
*w
= &inf
->wait
;
1553 enum target_waitkind kind
= w
->status
.kind
;
1555 if (kind
== TARGET_WAITKIND_SPURIOUS
)
1556 /* Since gdb is actually counting the number of times the inferior
1557 stops, expecting one stop per exec, we only return major events
1561 inf_debug (inf
, "pending_execs = %d, ignoring minor event",
1562 inf
->pending_execs
);
1564 else if (kind
== TARGET_WAITKIND_STOPPED
1565 && w
->status
.value
.sig
== TARGET_SIGNAL_TRAP
)
1566 /* Ah hah! A SIGTRAP from the inferior while starting up probably
1567 means we've succesfully completed an exec! */
1569 if (--inf
->pending_execs
== 0)
1572 #if 0 /* do we need this? */
1573 prune_threads (1); /* Get rid of the old shell threads */
1574 renumber_threads (0); /* Give our threads reasonable names. */
1577 inf_debug (inf
, "pending exec completed, pending_execs => %d",
1578 inf
->pending_execs
);
1580 else if (kind
== TARGET_WAITKIND_STOPPED
)
1581 /* It's possible that this signal is because of a crashed process
1582 being handled by the hurd crash server; in this case, the process
1583 will have an extra task suspend, which we need to know about.
1584 Since the code in inf_resume that normally checks for this is
1585 disabled while INF->pending_execs, we do the check here instead. */
1586 inf_validate_task_sc (inf
);
1589 if (inf
->wait
.suppress
)
1590 /* Some totally spurious event happened that we don't consider
1591 worth returning to gdb. Just keep waiting. */
1593 inf_debug (inf
, "suppressing return, rewaiting...");
1598 /* Pass back out our results. */
1599 memcpy (status
, &inf
->wait
.status
, sizeof (*status
));
1601 thread
= inf
->wait
.thread
;
1603 ptid
= ptid_build (inf
->pid
, 0, thread
->tid
);
1604 else if (ptid_equal (ptid
, minus_one_ptid
))
1605 thread
= inf_tid_to_thread (inf
, -1);
1607 thread
= inf_tid_to_thread (inf
, ptid_get_tid (ptid
));
1609 if (!thread
|| thread
->port
== MACH_PORT_NULL
)
1611 /* TID is dead; try and find a new thread. */
1612 if (inf_update_procs (inf
) && inf
->threads
)
1613 ptid
= ptid_build (inf
->pid
, 0, inf
->threads
->tid
); /* The first available thread. */
1615 ptid
= inferior_ptid
; /* let wait_for_inferior handle exit case */
1619 && !ptid_equal (ptid
, minus_one_ptid
)
1620 && status
->kind
!= TARGET_WAITKIND_SPURIOUS
1621 && inf
->pause_sc
== 0 && thread
->pause_sc
== 0)
1622 /* If something actually happened to THREAD, make sure we
1626 inf_update_suspends (inf
);
1629 inf_debug (inf
, "returning ptid = %s, status = %s (%d)",
1630 target_pid_to_str (ptid
),
1631 status
->kind
== TARGET_WAITKIND_EXITED
? "EXITED"
1632 : status
->kind
== TARGET_WAITKIND_STOPPED
? "STOPPED"
1633 : status
->kind
== TARGET_WAITKIND_SIGNALLED
? "SIGNALLED"
1634 : status
->kind
== TARGET_WAITKIND_LOADED
? "LOADED"
1635 : status
->kind
== TARGET_WAITKIND_SPURIOUS
? "SPURIOUS"
1637 status
->value
.integer
);
1643 /* The rpc handler called by exc_server. */
1645 S_exception_raise_request (mach_port_t port
, mach_port_t reply_port
,
1646 thread_t thread_port
, task_t task_port
,
1647 int exception
, int code
, int subcode
)
1649 struct inf
*inf
= waiting_inf
;
1650 struct proc
*thread
= inf_port_to_thread (inf
, thread_port
);
1652 inf_debug (waiting_inf
,
1653 "thread = %d, task = %d, exc = %d, code = %d, subcode = %d",
1654 thread_port
, task_port
, exception
, code
, subcode
);
1657 /* We don't know about thread? */
1659 inf_update_procs (inf
);
1660 thread
= inf_port_to_thread (inf
, thread_port
);
1662 /* Give up, the generating thread is gone. */
1666 mach_port_deallocate (mach_task_self (), thread_port
);
1667 mach_port_deallocate (mach_task_self (), task_port
);
1669 if (!thread
->aborted
)
1670 /* THREAD hasn't been aborted since this exception happened (abortion
1671 clears any exception state), so it must be real. */
1673 /* Store away the details; this will destroy any previous info. */
1674 inf
->wait
.thread
= thread
;
1676 inf
->wait
.status
.kind
= TARGET_WAITKIND_STOPPED
;
1678 if (exception
== EXC_BREAKPOINT
)
1679 /* GDB likes to get SIGTRAP for breakpoints. */
1681 inf
->wait
.status
.value
.sig
= TARGET_SIGNAL_TRAP
;
1682 mach_port_deallocate (mach_task_self (), reply_port
);
1685 /* Record the exception so that we can forward it later. */
1687 if (thread
->exc_port
== port
)
1689 inf_debug (waiting_inf
, "Handler is thread exception port <%d>",
1690 thread
->saved_exc_port
);
1691 inf
->wait
.exc
.handler
= thread
->saved_exc_port
;
1695 inf_debug (waiting_inf
, "Handler is task exception port <%d>",
1696 inf
->task
->saved_exc_port
);
1697 inf
->wait
.exc
.handler
= inf
->task
->saved_exc_port
;
1698 gdb_assert (inf
->task
->exc_port
== port
);
1700 if (inf
->wait
.exc
.handler
!= MACH_PORT_NULL
)
1701 /* Add a reference to the exception handler. */
1702 mach_port_mod_refs (mach_task_self (),
1703 inf
->wait
.exc
.handler
, MACH_PORT_RIGHT_SEND
,
1706 inf
->wait
.exc
.exception
= exception
;
1707 inf
->wait
.exc
.code
= code
;
1708 inf
->wait
.exc
.subcode
= subcode
;
1709 inf
->wait
.exc
.reply
= reply_port
;
1711 /* Exceptions are encoded in the signal space by putting them after
1712 _NSIG; this assumes they're positive (and not extremely large)! */
1713 inf
->wait
.status
.value
.sig
=
1714 target_signal_from_host (_NSIG
+ exception
);
1718 /* A supppressed exception, which ignore. */
1720 inf
->wait
.suppress
= 1;
1721 mach_port_deallocate (mach_task_self (), reply_port
);
1728 /* Fill in INF's wait field after a task has died without giving us more
1729 detailed information. */
1731 inf_task_died_status (struct inf
*inf
)
1733 warning (_("Pid %d died with unknown exit status, using SIGKILL."), inf
->pid
);
1734 inf
->wait
.status
.kind
= TARGET_WAITKIND_SIGNALLED
;
1735 inf
->wait
.status
.value
.sig
= TARGET_SIGNAL_KILL
;
1738 /* Notify server routines. The only real one is dead name notification. */
1740 do_mach_notify_dead_name (mach_port_t notify
, mach_port_t dead_port
)
1742 struct inf
*inf
= waiting_inf
;
1744 inf_debug (waiting_inf
, "port = %d", dead_port
);
1746 if (inf
->task
&& inf
->task
->port
== dead_port
)
1748 proc_debug (inf
->task
, "is dead");
1749 inf
->task
->port
= MACH_PORT_NULL
;
1750 if (proc_wait_pid
== inf
->pid
)
1751 /* We have a wait outstanding on the process, which will return more
1752 detailed information, so delay until we get that. */
1753 inf
->wait
.suppress
= 1;
1755 /* We never waited for the process (maybe it wasn't a child), so just
1756 pretend it got a SIGKILL. */
1757 inf_task_died_status (inf
);
1761 struct proc
*thread
= inf_port_to_thread (inf
, dead_port
);
1764 proc_debug (thread
, "is dead");
1765 thread
->port
= MACH_PORT_NULL
;
1768 if (inf
->task
->dead
)
1769 /* Since the task is dead, its threads are dying with it. */
1770 inf
->wait
.suppress
= 1;
1773 mach_port_deallocate (mach_task_self (), dead_port
);
1774 inf
->threads_up_to_date
= 0; /* Just in case */
1783 warning (_("illegal rpc: %s"), fun
);
1788 do_mach_notify_no_senders (mach_port_t notify
, mach_port_mscount_t count
)
1790 return ill_rpc ("do_mach_notify_no_senders");
1794 do_mach_notify_port_deleted (mach_port_t notify
, mach_port_t name
)
1796 return ill_rpc ("do_mach_notify_port_deleted");
1800 do_mach_notify_msg_accepted (mach_port_t notify
, mach_port_t name
)
1802 return ill_rpc ("do_mach_notify_msg_accepted");
1806 do_mach_notify_port_destroyed (mach_port_t notify
, mach_port_t name
)
1808 return ill_rpc ("do_mach_notify_port_destroyed");
1812 do_mach_notify_send_once (mach_port_t notify
)
1814 return ill_rpc ("do_mach_notify_send_once");
1818 /* Process_reply server routines. We only use process_wait_reply. */
1821 S_proc_wait_reply (mach_port_t reply
, error_t err
,
1822 int status
, int sigcode
, rusage_t rusage
, pid_t pid
)
1824 struct inf
*inf
= waiting_inf
;
1826 inf_debug (inf
, "err = %s, pid = %d, status = 0x%x, sigcode = %d",
1827 err
? safe_strerror (err
) : "0", pid
, status
, sigcode
);
1829 if (err
&& proc_wait_pid
&& (!inf
->task
|| !inf
->task
->port
))
1830 /* Ack. The task has died, but the task-died notification code didn't
1831 tell anyone because it thought a more detailed reply from the
1832 procserver was forthcoming. However, we now learn that won't
1833 happen... So we have to act like the task just died, and this time,
1835 inf_task_died_status (inf
);
1837 if (--proc_waits_pending
== 0)
1838 /* PROC_WAIT_PID represents the most recent wait. We will always get
1839 replies in order because the proc server is single threaded. */
1842 inf_debug (inf
, "waits pending now: %d", proc_waits_pending
);
1848 warning (_("Can't wait for pid %d: %s"), inf
->pid
, safe_strerror (err
));
1851 /* Since we can't see the inferior's signals, don't trap them. */
1852 inf_set_traced (inf
, 0);
1855 else if (pid
== inf
->pid
)
1857 store_waitstatus (&inf
->wait
.status
, status
);
1858 if (inf
->wait
.status
.kind
== TARGET_WAITKIND_STOPPED
)
1859 /* The process has sent us a signal, and stopped itself in a sane
1860 state pending our actions. */
1862 inf_debug (inf
, "process has stopped itself");
1867 inf
->wait
.suppress
= 1; /* Something odd happened. Ignore. */
1873 S_proc_setmsgport_reply (mach_port_t reply
, error_t err
,
1874 mach_port_t old_msg_port
)
1876 return ill_rpc ("S_proc_setmsgport_reply");
1880 S_proc_getmsgport_reply (mach_port_t reply
, error_t err
, mach_port_t msg_port
)
1882 return ill_rpc ("S_proc_getmsgport_reply");
1886 /* Msg_reply server routines. We only use msg_sig_post_untraced_reply. */
1889 S_msg_sig_post_untraced_reply (mach_port_t reply
, error_t err
)
1891 struct inf
*inf
= waiting_inf
;
1894 /* EBUSY is what we get when the crash server has grabbed control of the
1895 process and doesn't like what signal we tried to send it. Just act
1896 like the process stopped (using a signal of 0 should mean that the
1897 *next* time the user continues, it will pass signal 0, which the crash
1898 server should like). */
1900 inf
->wait
.status
.kind
= TARGET_WAITKIND_STOPPED
;
1901 inf
->wait
.status
.value
.sig
= TARGET_SIGNAL_0
;
1904 warning (_("Signal delivery failed: %s"), safe_strerror (err
));
1907 /* We only get this reply when we've posted a signal to a process which we
1908 thought was stopped, and which we expected to continue after the signal.
1909 Given that the signal has failed for some reason, it's reasonable to
1910 assume it's still stopped. */
1913 inf
->wait
.suppress
= 1;
1919 S_msg_sig_post_reply (mach_port_t reply
, error_t err
)
1921 return ill_rpc ("S_msg_sig_post_reply");
1925 /* Returns the number of messages queued for the receive right PORT. */
1926 static mach_port_msgcount_t
1927 port_msgs_queued (mach_port_t port
)
1929 struct mach_port_status status
;
1931 mach_port_get_receive_status (mach_task_self (), port
, &status
);
1936 return status
.mps_msgcount
;
1940 /* Resume execution of the inferior process.
1942 If STEP is nonzero, single-step it.
1943 If SIGNAL is nonzero, give it that signal.
1946 -1 true Single step the current thread allowing other threads to run.
1947 -1 false Continue the current thread allowing other threads to run.
1948 X true Single step the given thread, don't allow any others to run.
1949 X false Continue the given thread, do not allow any others to run.
1950 (Where X, of course, is anything except -1)
1952 Note that a resume may not `take' if there are pending exceptions/&c
1953 still unprocessed from the last resume we did (any given resume may result
1954 in multiple events returned by wait).
1957 gnu_resume (ptid_t ptid
, int step
, enum target_signal sig
)
1959 struct proc
*step_thread
= 0;
1961 struct inf
*inf
= gnu_current_inf
;
1963 inf_debug (inf
, "ptid = %s, step = %d, sig = %d",
1964 target_pid_to_str (ptid
), step
, sig
);
1966 inf_validate_procinfo (inf
);
1968 if (sig
!= TARGET_SIGNAL_0
|| inf
->stopped
)
1970 if (sig
== TARGET_SIGNAL_0
&& inf
->nomsg
)
1973 inf_signal (inf
, sig
);
1975 else if (inf
->wait
.exc
.reply
!= MACH_PORT_NULL
)
1976 /* We received an exception to which we have chosen not to forward, so
1977 abort the faulting thread, which will perhaps retake it. */
1979 proc_abort (inf
->wait
.thread
, 1);
1980 warning (_("Aborting %s with unforwarded exception %s."),
1981 proc_string (inf
->wait
.thread
),
1982 target_signal_to_name (inf
->wait
.status
.value
.sig
));
1985 if (port_msgs_queued (inf
->event_port
))
1986 /* If there are still messages in our event queue, don't bother resuming
1987 the process, as we're just going to stop it right away anyway. */
1990 inf_update_procs (inf
);
1992 /* A specific PTID means `step only this process id'. */
1993 resume_all
= ptid_equal (ptid
, minus_one_ptid
);
1996 /* Allow all threads to run, except perhaps single-stepping one. */
1998 inf_debug (inf
, "running all threads; tid = %d", PIDGET (inferior_ptid
));
1999 ptid
= inferior_ptid
; /* What to step. */
2000 inf_set_threads_resume_sc (inf
, 0, 1);
2003 /* Just allow a single thread to run. */
2005 struct proc
*thread
= inf_tid_to_thread (inf
, ptid_get_tid (ptid
));
2007 error (_("Can't run single thread id %s: no such thread!"),
2008 target_pid_to_str (ptid
));
2009 inf_debug (inf
, "running one thread: %s", target_pid_to_str (ptid
));
2010 inf_set_threads_resume_sc (inf
, thread
, 0);
2015 step_thread
= inf_tid_to_thread (inf
, ptid_get_tid (ptid
));
2017 warning (_("Can't step thread id %s: no such thread."),
2018 target_pid_to_str (ptid
));
2020 inf_debug (inf
, "stepping thread: %s", target_pid_to_str (ptid
));
2022 if (step_thread
!= inf
->step_thread
)
2023 inf_set_step_thread (inf
, step_thread
);
2025 inf_debug (inf
, "here we go...");
2031 gnu_kill_inferior (void)
2033 struct proc
*task
= gnu_current_inf
->task
;
2036 proc_debug (task
, "terminating...");
2037 task_terminate (task
->port
);
2038 inf_set_pid (gnu_current_inf
, -1);
2040 target_mourn_inferior ();
2043 /* Clean up after the inferior dies. */
2045 gnu_mourn_inferior (void)
2047 inf_debug (gnu_current_inf
, "rip");
2048 inf_detach (gnu_current_inf
);
2049 unpush_target (&gnu_ops
);
2050 generic_mourn_inferior ();
2054 /* Fork an inferior process, and start debugging it. */
2056 /* Set INFERIOR_PID to the first thread available in the child, if any. */
2058 inf_pick_first_thread (void)
2060 if (gnu_current_inf
->task
&& gnu_current_inf
->threads
)
2061 /* The first thread. */
2062 return gnu_current_inf
->threads
->tid
;
2064 /* What may be the next thread. */
2065 return next_thread_id
;
2071 if (!gnu_current_inf
)
2072 gnu_current_inf
= make_inf ();
2073 return gnu_current_inf
;
2077 gnu_create_inferior (char *exec_file
, char *allargs
, char **env
,
2080 struct inf
*inf
= cur_inf ();
2084 /* We're in the child; make this process stop as soon as it execs. */
2085 inf_debug (inf
, "tracing self");
2086 if (ptrace (PTRACE_TRACEME
) != 0)
2087 error (_("ptrace (PTRACE_TRACEME) failed!"));
2089 void attach_to_child (int pid
)
2091 /* Attach to the now stopped child, which is actually a shell... */
2092 inf_debug (inf
, "attaching to child: %d", pid
);
2094 inf_attach (inf
, pid
);
2096 push_target (&gnu_ops
);
2098 inf
->pending_execs
= 2;
2102 /* Now let the child run again, knowing that it will stop immediately
2103 because of the ptrace. */
2106 /* We now have thread info. */
2107 thread_change_ptid (inferior_ptid
,
2108 ptid_build (inf
->pid
, 0, inf_pick_first_thread ()));
2110 startup_inferior (inf
->pending_execs
);
2113 inf_debug (inf
, "creating inferior");
2115 fork_inferior (exec_file
, allargs
, env
, trace_me
, attach_to_child
,
2118 inf_validate_procinfo (inf
);
2119 inf_update_signal_thread (inf
);
2120 inf_set_traced (inf
, inf
->want_signals
);
2122 /* Execing the process will have trashed our exception ports; steal them
2123 back (or make sure they're restored if the user wants that). */
2124 if (inf
->want_exceptions
)
2125 inf_steal_exc_ports (inf
);
2127 inf_restore_exc_ports (inf
);
2130 /* Mark our target-struct as eligible for stray "run" and "attach"
2139 /* Attach to process PID, then initialize for debugging it
2140 and wait for the trace-trap that results from attaching. */
2142 gnu_attach (char *args
, int from_tty
)
2146 struct inf
*inf
= cur_inf ();
2147 struct inferior
*inferior
;
2150 error_no_arg (_("process-id to attach"));
2154 if (pid
== getpid ()) /* Trying to masturbate? */
2155 error (_("I refuse to debug myself!"));
2159 exec_file
= (char *) get_exec_file (0);
2162 printf_unfiltered ("Attaching to program `%s', pid %d\n",
2165 printf_unfiltered ("Attaching to pid %d\n", pid
);
2167 gdb_flush (gdb_stdout
);
2170 inf_debug (inf
, "attaching to pid: %d", pid
);
2172 inf_attach (inf
, pid
);
2174 push_target (&gnu_ops
);
2176 inferior
= add_inferior (pid
);
2177 inferior
->attach_flag
= 1;
2179 inf_update_procs (inf
);
2181 inferior_ptid
= ptid_build (pid
, 0, inf_pick_first_thread ());
2183 /* We have to initialize the terminal settings now, since the code
2184 below might try to restore them. */
2185 target_terminal_init ();
2187 /* If the process was stopped before we attached, make it continue the next
2188 time the user does a continue. */
2189 inf_validate_procinfo (inf
);
2191 inf_update_signal_thread (inf
);
2192 inf_set_traced (inf
, inf
->want_signals
);
2194 #if 0 /* Do we need this? */
2195 renumber_threads (0); /* Give our threads reasonable names. */
2200 /* Take a program previously attached to and detaches it.
2201 The program resumes execution and will no longer stop
2202 on signals, etc. We'd better not have left any breakpoints
2203 in the program or it'll die when it hits one. For this
2204 to work, it may be necessary for the process to have been
2205 previously attached. It *might* work if the program was
2206 started via fork. */
2208 gnu_detach (char *args
, int from_tty
)
2214 char *exec_file
= get_exec_file (0);
2216 printf_unfiltered ("Detaching from program `%s' pid %d\n",
2217 exec_file
, gnu_current_inf
->pid
);
2219 printf_unfiltered ("Detaching from pid %d\n", gnu_current_inf
->pid
);
2220 gdb_flush (gdb_stdout
);
2223 pid
= gnu_current_inf
->pid
;
2225 inf_detach (gnu_current_inf
);
2227 inferior_ptid
= null_ptid
;
2228 detach_inferior (pid
);
2230 unpush_target (&gnu_ops
); /* Pop out of handling an inferior */
2234 gnu_terminal_init_inferior (void)
2236 gdb_assert (gnu_current_inf
);
2237 terminal_init_inferior_with_pgrp (gnu_current_inf
->pid
);
2240 /* Get ready to modify the registers array. On machines which store
2241 individual registers, this doesn't need to do anything. On machines
2242 which store all the registers in one fell swoop, this makes sure
2243 that registers contains all the registers from the program being
2246 gnu_prepare_to_store (struct regcache
*regcache
)
2251 gnu_open (char *arg
, int from_tty
)
2253 error (_("Use the \"run\" command to start a Unix child process."));
2257 gnu_stop (ptid_t ptid
)
2259 error (_("to_stop target function not implemented"));
2263 gnu_thread_alive (ptid_t ptid
)
2265 inf_update_procs (gnu_current_inf
);
2266 return !!inf_tid_to_thread (gnu_current_inf
,
2267 ptid_get_tid (ptid
));
2271 /* Read inferior task's LEN bytes from ADDR and copy it to MYADDR in
2272 gdb's address space. Return 0 on failure; number of bytes read
2275 gnu_read_inferior (task_t task
, CORE_ADDR addr
, char *myaddr
, int length
)
2278 vm_address_t low_address
= (vm_address_t
) trunc_page (addr
);
2279 vm_size_t aligned_length
=
2280 (vm_size_t
) round_page (addr
+ length
) - low_address
;
2284 /* Get memory from inferior with page aligned addresses */
2285 err
= vm_read (task
, low_address
, aligned_length
, &copied
, ©_count
);
2289 err
= hurd_safe_copyin (myaddr
, (void *) (addr
- low_address
+ copied
), length
);
2292 warning (_("Read from inferior faulted: %s"), safe_strerror (err
));
2296 err
= vm_deallocate (mach_task_self (), copied
, copy_count
);
2298 warning (_("gnu_read_inferior vm_deallocate failed: %s"), safe_strerror (err
));
2303 #define CHK_GOTO_OUT(str,ret) \
2304 do if (ret != KERN_SUCCESS) { errstr = #str; goto out; } while(0)
2306 struct vm_region_list
2308 struct vm_region_list
*next
;
2309 vm_prot_t protection
;
2314 struct obstack region_obstack
;
2316 /* Write gdb's LEN bytes from MYADDR and copy it to ADDR in inferior
2317 task's address space. */
2319 gnu_write_inferior (task_t task
, CORE_ADDR addr
, char *myaddr
, int length
)
2322 vm_address_t low_address
= (vm_address_t
) trunc_page (addr
);
2323 vm_size_t aligned_length
=
2324 (vm_size_t
) round_page (addr
+ length
) - low_address
;
2329 char *errstr
= "Bug in gnu_write_inferior";
2331 struct vm_region_list
*region_element
;
2332 struct vm_region_list
*region_head
= (struct vm_region_list
*) NULL
;
2334 /* Get memory from inferior with page aligned addresses */
2335 err
= vm_read (task
,
2340 CHK_GOTO_OUT ("gnu_write_inferior vm_read failed", err
);
2344 err
= hurd_safe_copyout ((void *) (addr
- low_address
+ copied
),
2346 CHK_GOTO_OUT ("Write to inferior faulted", err
);
2348 obstack_init (®ion_obstack
);
2350 /* Do writes atomically.
2351 First check for holes and unwritable memory. */
2353 vm_size_t remaining_length
= aligned_length
;
2354 vm_address_t region_address
= low_address
;
2356 struct vm_region_list
*scan
;
2358 while (region_address
< low_address
+ aligned_length
)
2360 vm_prot_t protection
;
2361 vm_prot_t max_protection
;
2362 vm_inherit_t inheritance
;
2364 mach_port_t object_name
;
2366 vm_size_t region_length
= remaining_length
;
2367 vm_address_t old_address
= region_address
;
2369 err
= vm_region (task
,
2378 CHK_GOTO_OUT ("vm_region failed", err
);
2380 /* Check for holes in memory */
2381 if (old_address
!= region_address
)
2383 warning (_("No memory at 0x%x. Nothing written"),
2390 if (!(max_protection
& VM_PROT_WRITE
))
2392 warning (_("Memory at address 0x%x is unwritable. Nothing written"),
2399 /* Chain the regions for later use */
2401 (struct vm_region_list
*)
2402 obstack_alloc (®ion_obstack
, sizeof (struct vm_region_list
));
2404 region_element
->protection
= protection
;
2405 region_element
->start
= region_address
;
2406 region_element
->length
= region_length
;
2408 /* Chain the regions along with protections */
2409 region_element
->next
= region_head
;
2410 region_head
= region_element
;
2412 region_address
+= region_length
;
2413 remaining_length
= remaining_length
- region_length
;
2416 /* If things fail after this, we give up.
2417 Somebody is messing up inferior_task's mappings. */
2419 /* Enable writes to the chained vm regions */
2420 for (scan
= region_head
; scan
; scan
= scan
->next
)
2422 if (!(scan
->protection
& VM_PROT_WRITE
))
2424 err
= vm_protect (task
,
2428 scan
->protection
| VM_PROT_WRITE
);
2429 CHK_GOTO_OUT ("vm_protect: enable write failed", err
);
2433 err
= vm_write (task
,
2437 CHK_GOTO_OUT ("vm_write failed", err
);
2439 /* Set up the original region protections, if they were changed */
2440 for (scan
= region_head
; scan
; scan
= scan
->next
)
2442 if (!(scan
->protection
& VM_PROT_WRITE
))
2444 err
= vm_protect (task
,
2449 CHK_GOTO_OUT ("vm_protect: enable write failed", err
);
2457 obstack_free (®ion_obstack
, 0);
2459 (void) vm_deallocate (mach_task_self (),
2464 if (err
!= KERN_SUCCESS
)
2466 warning (_("%s: %s"), errstr
, mach_error_string (err
));
2474 /* Return 0 on failure, number of bytes handled otherwise. TARGET
2477 gnu_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int write
,
2478 struct mem_attrib
*attrib
,
2479 struct target_ops
*target
)
2481 task_t task
= (gnu_current_inf
2482 ? (gnu_current_inf
->task
2483 ? gnu_current_inf
->task
->port
: 0)
2486 if (task
== MACH_PORT_NULL
)
2490 inf_debug (gnu_current_inf
, "%s %p[%d] %s %p",
2491 write
? "writing" : "reading", (void *) memaddr
, len
,
2492 write
? "<--" : "-->", myaddr
);
2494 return gnu_write_inferior (task
, memaddr
, myaddr
, len
);
2496 return gnu_read_inferior (task
, memaddr
, myaddr
, len
);
2500 /* Call FUNC on each memory region in the task. */
2502 gnu_find_memory_regions (int (*func
) (CORE_ADDR
,
2510 vm_address_t region_address
, last_region_address
, last_region_end
;
2511 vm_prot_t last_protection
;
2513 if (gnu_current_inf
== 0 || gnu_current_inf
->task
== 0)
2515 task
= gnu_current_inf
->task
->port
;
2516 if (task
== MACH_PORT_NULL
)
2519 region_address
= last_region_address
= last_region_end
= VM_MIN_ADDRESS
;
2520 last_protection
= VM_PROT_NONE
;
2521 while (region_address
< VM_MAX_ADDRESS
)
2523 vm_prot_t protection
;
2524 vm_prot_t max_protection
;
2525 vm_inherit_t inheritance
;
2527 mach_port_t object_name
;
2529 vm_size_t region_length
= VM_MAX_ADDRESS
- region_address
;
2530 vm_address_t old_address
= region_address
;
2532 err
= vm_region (task
,
2541 if (err
== KERN_NO_SPACE
)
2543 if (err
!= KERN_SUCCESS
)
2545 warning (_("vm_region failed: %s"), mach_error_string (err
));
2549 if (protection
== last_protection
&& region_address
== last_region_end
)
2550 /* This region is contiguous with and indistinguishable from
2551 the previous one, so we just extend that one. */
2552 last_region_end
= region_address
+= region_length
;
2555 /* This region is distinct from the last one we saw, so report
2556 that previous one. */
2557 if (last_protection
!= VM_PROT_NONE
)
2558 (*func
) (last_region_address
,
2559 last_region_end
- last_region_address
,
2560 last_protection
& VM_PROT_READ
,
2561 last_protection
& VM_PROT_WRITE
,
2562 last_protection
& VM_PROT_EXECUTE
,
2564 last_region_address
= region_address
;
2565 last_region_end
= region_address
+= region_length
;
2566 last_protection
= protection
;
2570 /* Report the final region. */
2571 if (last_region_end
> last_region_address
&& last_protection
!= VM_PROT_NONE
)
2572 (*func
) (last_region_address
, last_region_end
- last_region_address
,
2573 last_protection
& VM_PROT_READ
,
2574 last_protection
& VM_PROT_WRITE
,
2575 last_protection
& VM_PROT_EXECUTE
,
2582 /* Return printable description of proc. */
2584 proc_string (struct proc
*proc
)
2586 static char tid_str
[80];
2587 if (proc_is_task (proc
))
2588 sprintf (tid_str
, "process %d", proc
->inf
->pid
);
2590 sprintf (tid_str
, "Thread %d.%d",
2591 proc
->inf
->pid
, proc
->tid
);
2596 gnu_pid_to_str (ptid_t ptid
)
2598 struct inf
*inf
= gnu_current_inf
;
2599 int tid
= ptid_get_tid (ptid
);
2600 struct proc
*thread
= inf_tid_to_thread (inf
, tid
);
2603 return proc_string (thread
);
2606 static char tid_str
[80];
2607 sprintf (tid_str
, "bogus thread id %d", tid
);
2613 extern void gnu_store_registers (struct regcache
*regcache
, int regno
);
2614 extern void gnu_fetch_registers (struct regcache
*regcache
, int regno
);
2616 struct target_ops gnu_ops
;
2621 gnu_ops
.to_shortname
= "GNU"; /* to_shortname */
2622 gnu_ops
.to_longname
= "GNU Hurd process"; /* to_longname */
2623 gnu_ops
.to_doc
= "GNU Hurd process"; /* to_doc */
2624 gnu_ops
.to_open
= gnu_open
; /* to_open */
2625 gnu_ops
.to_attach
= gnu_attach
; /* to_attach */
2626 gnu_ops
.to_attach_no_wait
= 1; /* to_attach_no_wait */
2627 gnu_ops
.to_detach
= gnu_detach
; /* to_detach */
2628 gnu_ops
.to_resume
= gnu_resume
; /* to_resume */
2629 gnu_ops
.to_wait
= gnu_wait
; /* to_wait */
2630 gnu_ops
.to_fetch_registers
= gnu_fetch_registers
; /* to_fetch_registers */
2631 gnu_ops
.to_store_registers
= gnu_store_registers
; /* to_store_registers */
2632 gnu_ops
.to_prepare_to_store
= gnu_prepare_to_store
; /* to_prepare_to_store */
2633 gnu_ops
.deprecated_xfer_memory
= gnu_xfer_memory
;
2634 gnu_ops
.to_find_memory_regions
= gnu_find_memory_regions
;
2635 gnu_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
2636 gnu_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
2637 gnu_ops
.to_terminal_init
= gnu_terminal_init_inferior
;
2638 gnu_ops
.to_terminal_inferior
= terminal_inferior
;
2639 gnu_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
2640 gnu_ops
.to_terminal_save_ours
= terminal_save_ours
;
2641 gnu_ops
.to_terminal_ours
= terminal_ours
;
2642 gnu_ops
.to_terminal_info
= child_terminal_info
;
2643 gnu_ops
.to_kill
= gnu_kill_inferior
; /* to_kill */
2644 gnu_ops
.to_create_inferior
= gnu_create_inferior
; /* to_create_inferior */
2645 gnu_ops
.to_mourn_inferior
= gnu_mourn_inferior
; /* to_mourn_inferior */
2646 gnu_ops
.to_can_run
= gnu_can_run
; /* to_can_run */
2647 gnu_ops
.to_thread_alive
= gnu_thread_alive
; /* to_thread_alive */
2648 gnu_ops
.to_pid_to_str
= gnu_pid_to_str
; /* to_pid_to_str */
2649 gnu_ops
.to_stop
= gnu_stop
; /* to_stop */
2650 gnu_ops
.to_stratum
= process_stratum
; /* to_stratum */
2651 gnu_ops
.to_has_all_memory
= 1; /* to_has_all_memory */
2652 gnu_ops
.to_has_memory
= 1; /* to_has_memory */
2653 gnu_ops
.to_has_stack
= 1; /* to_has_stack */
2654 gnu_ops
.to_has_registers
= 1; /* to_has_registers */
2655 gnu_ops
.to_has_execution
= 1; /* to_has_execution */
2656 gnu_ops
.to_magic
= OPS_MAGIC
; /* to_magic */
2657 } /* init_gnu_ops */
2660 /* User task commands. */
2662 struct cmd_list_element
*set_task_cmd_list
= 0;
2663 struct cmd_list_element
*show_task_cmd_list
= 0;
2664 /* User thread commands. */
2666 /* Commands with a prefix of `set/show thread'. */
2667 extern struct cmd_list_element
*thread_cmd_list
;
2668 struct cmd_list_element
*set_thread_cmd_list
= NULL
;
2669 struct cmd_list_element
*show_thread_cmd_list
= NULL
;
2671 /* Commands with a prefix of `set/show thread default'. */
2672 struct cmd_list_element
*set_thread_default_cmd_list
= NULL
;
2673 struct cmd_list_element
*show_thread_default_cmd_list
= NULL
;
2676 set_thread_cmd (char *args
, int from_tty
)
2678 printf_unfiltered ("\"set thread\" must be followed by the name of a thread property, or \"default\".\n");
2682 show_thread_cmd (char *args
, int from_tty
)
2684 printf_unfiltered ("\"show thread\" must be followed by the name of a thread property, or \"default\".\n");
2688 set_thread_default_cmd (char *args
, int from_tty
)
2690 printf_unfiltered ("\"set thread default\" must be followed by the name of a thread property.\n");
2694 show_thread_default_cmd (char *args
, int from_tty
)
2696 printf_unfiltered ("\"show thread default\" must be followed by the name of a thread property.\n");
2700 parse_int_arg (char *args
, char *cmd_prefix
)
2705 int val
= strtoul (args
, &arg_end
, 10);
2706 if (*args
&& *arg_end
== '\0')
2709 error (_("Illegal argument for \"%s\" command, should be an integer."), cmd_prefix
);
2713 _parse_bool_arg (char *args
, char *t_val
, char *f_val
, char *cmd_prefix
)
2715 if (!args
|| strcmp (args
, t_val
) == 0)
2717 else if (strcmp (args
, f_val
) == 0)
2720 error (_("Illegal argument for \"%s\" command, should be \"%s\" or \"%s\"."),
2721 cmd_prefix
, t_val
, f_val
);
2724 #define parse_bool_arg(args, cmd_prefix) \
2725 _parse_bool_arg (args, "on", "off", cmd_prefix)
2728 check_empty (char *args
, char *cmd_prefix
)
2731 error (_("Garbage after \"%s\" command: `%s'"), cmd_prefix
, args
);
2734 /* Returns the alive thread named by INFERIOR_PID, or signals an error. */
2735 static struct proc
*
2738 struct inf
*inf
= cur_inf ();
2739 struct proc
*thread
= inf_tid_to_thread (inf
,
2740 ptid_get_tid (inferior_ptid
));
2742 error (_("No current thread."));
2746 /* Returns the current inferior, but signals an error if it has no task. */
2750 struct inf
*inf
= cur_inf ();
2752 error (_("No current process."));
2758 set_task_pause_cmd (char *args
, int from_tty
)
2760 struct inf
*inf
= cur_inf ();
2761 int old_sc
= inf
->pause_sc
;
2763 inf
->pause_sc
= parse_bool_arg (args
, "set task pause");
2765 if (old_sc
== 0 && inf
->pause_sc
!= 0)
2766 /* If the task is currently unsuspended, immediately suspend it,
2767 otherwise wait until the next time it gets control. */
2772 show_task_pause_cmd (char *args
, int from_tty
)
2774 struct inf
*inf
= cur_inf ();
2775 check_empty (args
, "show task pause");
2776 printf_unfiltered ("The inferior task %s suspended while gdb has control.\n",
2778 ? (inf
->pause_sc
== 0 ? "isn't" : "is")
2779 : (inf
->pause_sc
== 0 ? "won't be" : "will be"));
2783 set_task_detach_sc_cmd (char *args
, int from_tty
)
2785 cur_inf ()->detach_sc
= parse_int_arg (args
, "set task detach-suspend-count");
2789 show_task_detach_sc_cmd (char *args
, int from_tty
)
2791 check_empty (args
, "show task detach-suspend-count");
2792 printf_unfiltered ("The inferior task will be left with a suspend count of %d when detaching.\n",
2793 cur_inf ()->detach_sc
);
2798 set_thread_default_pause_cmd (char *args
, int from_tty
)
2800 struct inf
*inf
= cur_inf ();
2801 inf
->default_thread_pause_sc
=
2802 parse_bool_arg (args
, "set thread default pause") ? 0 : 1;
2806 show_thread_default_pause_cmd (char *args
, int from_tty
)
2808 struct inf
*inf
= cur_inf ();
2809 int sc
= inf
->default_thread_pause_sc
;
2810 check_empty (args
, "show thread default pause");
2811 printf_unfiltered ("New threads %s suspended while gdb has control%s.\n",
2812 sc
? "are" : "aren't",
2813 !sc
&& inf
->pause_sc
? " (but the task is)" : "");
2817 set_thread_default_run_cmd (char *args
, int from_tty
)
2819 struct inf
*inf
= cur_inf ();
2820 inf
->default_thread_run_sc
=
2821 parse_bool_arg (args
, "set thread default run") ? 0 : 1;
2825 show_thread_default_run_cmd (char *args
, int from_tty
)
2827 struct inf
*inf
= cur_inf ();
2828 check_empty (args
, "show thread default run");
2829 printf_unfiltered ("New threads %s allowed to run.\n",
2830 inf
->default_thread_run_sc
== 0 ? "are" : "aren't");
2834 set_thread_default_detach_sc_cmd (char *args
, int from_tty
)
2836 cur_inf ()->default_thread_detach_sc
=
2837 parse_int_arg (args
, "set thread default detach-suspend-count");
2841 show_thread_default_detach_sc_cmd (char *args
, int from_tty
)
2843 check_empty (args
, "show thread default detach-suspend-count");
2844 printf_unfiltered ("New threads will get a detach-suspend-count of %d.\n",
2845 cur_inf ()->default_thread_detach_sc
);
2849 /* Steal a send right called NAME in the inferior task, and make it PROC's
2850 saved exception port. */
2852 steal_exc_port (struct proc
*proc
, mach_port_t name
)
2856 mach_msg_type_name_t port_type
;
2858 if (!proc
|| !proc
->inf
->task
)
2859 error (_("No inferior task."));
2861 err
= mach_port_extract_right (proc
->inf
->task
->port
,
2862 name
, MACH_MSG_TYPE_COPY_SEND
,
2865 error (_("Couldn't extract send right %d from inferior: %s"),
2866 name
, safe_strerror (err
));
2868 if (proc
->saved_exc_port
)
2869 /* Get rid of our reference to the old one. */
2870 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
2872 proc
->saved_exc_port
= port
;
2874 if (!proc
->exc_port
)
2875 /* If PROC is a thread, we may not have set its exception port before.
2876 We can't use proc_steal_exc_port because it also sets saved_exc_port. */
2878 proc
->exc_port
= proc
->inf
->event_port
;
2879 err
= proc_set_exception_port (proc
, proc
->exc_port
);
2880 error (_("Can't set exception port for %s: %s"),
2881 proc_string (proc
), safe_strerror (err
));
2886 set_task_exc_port_cmd (char *args
, int from_tty
)
2888 struct inf
*inf
= cur_inf ();
2890 error (_("No argument to \"set task exception-port\" command."));
2891 steal_exc_port (inf
->task
, parse_and_eval_address (args
));
2895 set_stopped_cmd (char *args
, int from_tty
)
2897 cur_inf ()->stopped
= _parse_bool_arg (args
, "yes", "no", "set stopped");
2901 show_stopped_cmd (char *args
, int from_tty
)
2903 struct inf
*inf
= active_inf ();
2904 check_empty (args
, "show stopped");
2905 printf_unfiltered ("The inferior process %s stopped.\n",
2906 inf
->stopped
? "is" : "isn't");
2910 set_sig_thread_cmd (char *args
, int from_tty
)
2912 struct inf
*inf
= cur_inf ();
2914 if (!args
|| (!isdigit (*args
) && strcmp (args
, "none") != 0))
2915 error (_("Illegal argument to \"set signal-thread\" command.\n"
2916 "Should be an integer thread ID, or `none'."));
2918 if (strcmp (args
, "none") == 0)
2919 inf
->signal_thread
= 0;
2922 int tid
= ptid_get_tid (thread_id_to_pid (atoi (args
)));
2924 error (_("Thread ID %s not known. Use the \"info threads\" command to\n"
2925 "see the IDs of currently known threads."), args
);
2926 inf
->signal_thread
= inf_tid_to_thread (inf
, tid
);
2931 show_sig_thread_cmd (char *args
, int from_tty
)
2933 struct inf
*inf
= active_inf ();
2934 check_empty (args
, "show signal-thread");
2935 if (inf
->signal_thread
)
2936 printf_unfiltered ("The signal thread is %s.\n",
2937 proc_string (inf
->signal_thread
));
2939 printf_unfiltered ("There is no signal thread.\n");
2944 set_signals_cmd (char *args
, int from_tty
)
2946 struct inf
*inf
= cur_inf ();
2948 inf
->want_signals
= parse_bool_arg (args
, "set signals");
2950 if (inf
->task
&& inf
->want_signals
!= inf
->traced
)
2951 /* Make this take effect immediately in a running process. */
2952 inf_set_traced (inf
, inf
->want_signals
);
2956 show_signals_cmd (char *args
, int from_tty
)
2958 struct inf
*inf
= cur_inf ();
2959 check_empty (args
, "show signals");
2960 printf_unfiltered ("The inferior process's signals %s intercepted.\n",
2962 ? (inf
->traced
? "are" : "aren't")
2963 : (inf
->want_signals
? "will be" : "won't be"));
2967 set_exceptions_cmd (char *args
, int from_tty
)
2969 struct inf
*inf
= cur_inf ();
2970 int val
= parse_bool_arg (args
, "set exceptions");
2972 if (inf
->task
&& inf
->want_exceptions
!= val
)
2973 /* Make this take effect immediately in a running process. */
2976 inf
->want_exceptions
= val
;
2980 show_exceptions_cmd (char *args
, int from_tty
)
2982 struct inf
*inf
= cur_inf ();
2983 check_empty (args
, "show exceptions");
2984 printf_unfiltered ("Exceptions in the inferior %s trapped.\n",
2986 ? (inf
->want_exceptions
? "are" : "aren't")
2987 : (inf
->want_exceptions
? "will be" : "won't be"));
2992 set_task_cmd (char *args
, int from_tty
)
2994 printf_unfiltered ("\"set task\" must be followed by the name"
2995 " of a task property.\n");
2999 show_task_cmd (char *args
, int from_tty
)
3001 struct inf
*inf
= cur_inf ();
3003 check_empty (args
, "show task");
3005 show_signals_cmd (0, from_tty
);
3006 show_exceptions_cmd (0, from_tty
);
3007 show_task_pause_cmd (0, from_tty
);
3009 if (inf
->pause_sc
== 0)
3010 show_thread_default_pause_cmd (0, from_tty
);
3011 show_thread_default_run_cmd (0, from_tty
);
3015 show_stopped_cmd (0, from_tty
);
3016 show_sig_thread_cmd (0, from_tty
);
3019 if (inf
->detach_sc
!= 0)
3020 show_task_detach_sc_cmd (0, from_tty
);
3021 if (inf
->default_thread_detach_sc
!= 0)
3022 show_thread_default_detach_sc_cmd (0, from_tty
);
3027 set_noninvasive_cmd (char *args
, int from_tty
)
3029 /* Invert the sense of the arg for each component. */
3030 char *inv_args
= parse_bool_arg (args
, "set noninvasive") ? "off" : "on";
3032 set_task_pause_cmd (inv_args
, from_tty
);
3033 set_signals_cmd (inv_args
, from_tty
);
3034 set_exceptions_cmd (inv_args
, from_tty
);
3039 info_port_rights (char *args
, mach_port_type_t only
)
3041 struct inf
*inf
= active_inf ();
3042 struct value
*vmark
= value_mark ();
3045 /* Explicit list of port rights. */
3049 struct value
*val
= parse_to_comma_and_eval (&args
);
3050 long right
= value_as_long (val
);
3052 print_port_info (right
, 0, inf
->task
->port
, PORTINFO_DETAILS
,
3055 error (_("%ld: %s."), right
, safe_strerror (err
));
3059 /* Print all of them. */
3062 print_task_ports_info (inf
->task
->port
, only
, PORTINFO_DETAILS
,
3065 error (_("%s."), safe_strerror (err
));
3068 value_free_to_mark (vmark
);
3072 info_send_rights_cmd (char *args
, int from_tty
)
3074 info_port_rights (args
, MACH_PORT_TYPE_SEND
);
3078 info_recv_rights_cmd (char *args
, int from_tty
)
3080 info_port_rights (args
, MACH_PORT_TYPE_RECEIVE
);
3084 info_port_sets_cmd (char *args
, int from_tty
)
3086 info_port_rights (args
, MACH_PORT_TYPE_PORT_SET
);
3090 info_dead_names_cmd (char *args
, int from_tty
)
3092 info_port_rights (args
, MACH_PORT_TYPE_DEAD_NAME
);
3096 info_port_rights_cmd (char *args
, int from_tty
)
3098 info_port_rights (args
, ~0);
3103 add_task_commands (void)
3105 add_cmd ("pause", class_run
, set_thread_default_pause_cmd
, _("\
3106 Set whether the new threads are suspended while gdb has control.\n\
3107 This property normally has no effect because the whole task is\n\
3108 suspended, however, that may be disabled with \"set task pause off\".\n\
3109 The default value is \"off\"."),
3110 &set_thread_default_cmd_list
);
3111 add_cmd ("pause", no_class
, show_thread_default_pause_cmd
, _("\
3112 Show whether new threads are suspended while gdb has control."),
3113 &show_thread_default_cmd_list
);
3115 add_cmd ("run", class_run
, set_thread_default_run_cmd
, _("\
3116 Set whether new threads are allowed to run (once gdb has noticed them)."),
3117 &set_thread_default_cmd_list
);
3118 add_cmd ("run", no_class
, show_thread_default_run_cmd
, _("\
3119 Show whether new threads are allowed to run (once gdb has noticed them)."),
3120 &show_thread_default_cmd_list
);
3122 add_cmd ("detach-suspend-count", class_run
, set_thread_default_detach_sc_cmd
,
3123 _("Set the default detach-suspend-count value for new threads."),
3124 &set_thread_default_cmd_list
);
3125 add_cmd ("detach-suspend-count", no_class
, show_thread_default_detach_sc_cmd
,
3126 _("Show the default detach-suspend-count value for new threads."),
3127 &show_thread_default_cmd_list
);
3129 add_cmd ("signals", class_run
, set_signals_cmd
, _("\
3130 Set whether the inferior process's signals will be intercepted.\n\
3131 Mach exceptions (such as breakpoint traps) are not affected."),
3133 add_alias_cmd ("sigs", "signals", class_run
, 1, &setlist
);
3134 add_cmd ("signals", no_class
, show_signals_cmd
, _("\
3135 Show whether the inferior process's signals will be intercepted."),
3137 add_alias_cmd ("sigs", "signals", no_class
, 1, &showlist
);
3139 add_cmd ("signal-thread", class_run
, set_sig_thread_cmd
, _("\
3140 Set the thread that gdb thinks is the libc signal thread.\n\
3141 This thread is run when delivering a signal to a non-stopped process."),
3143 add_alias_cmd ("sigthread", "signal-thread", class_run
, 1, &setlist
);
3144 add_cmd ("signal-thread", no_class
, show_sig_thread_cmd
, _("\
3145 Set the thread that gdb thinks is the libc signal thread."),
3147 add_alias_cmd ("sigthread", "signal-thread", no_class
, 1, &showlist
);
3149 add_cmd ("stopped", class_run
, set_stopped_cmd
, _("\
3150 Set whether gdb thinks the inferior process is stopped as with SIGSTOP.\n\
3151 Stopped process will be continued by sending them a signal."),
3153 add_cmd ("stopped", no_class
, show_signals_cmd
, _("\
3154 Show whether gdb thinks the inferior process is stopped as with SIGSTOP."),
3157 add_cmd ("exceptions", class_run
, set_exceptions_cmd
, _("\
3158 Set whether exceptions in the inferior process will be trapped.\n\
3159 When exceptions are turned off, neither breakpoints nor single-stepping\n\
3162 /* Allow `set exc' despite conflict with `set exception-port'. */
3163 add_alias_cmd ("exc", "exceptions", class_run
, 1, &setlist
);
3164 add_cmd ("exceptions", no_class
, show_exceptions_cmd
, _("\
3165 Show whether exceptions in the inferior process will be trapped."),
3168 add_prefix_cmd ("task", no_class
, set_task_cmd
,
3169 _("Command prefix for setting task attributes."),
3170 &set_task_cmd_list
, "set task ", 0, &setlist
);
3171 add_prefix_cmd ("task", no_class
, show_task_cmd
,
3172 _("Command prefix for showing task attributes."),
3173 &show_task_cmd_list
, "show task ", 0, &showlist
);
3175 add_cmd ("pause", class_run
, set_task_pause_cmd
, _("\
3176 Set whether the task is suspended while gdb has control.\n\
3177 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3178 until the next time the program is continued.\n\
3179 When setting this to \"off\", \"set thread default pause on\" can be\n\
3180 used to pause individual threads by default instead."),
3181 &set_task_cmd_list
);
3182 add_cmd ("pause", no_class
, show_task_pause_cmd
,
3183 _("Show whether the task is suspended while gdb has control."),
3184 &show_task_cmd_list
);
3186 add_cmd ("detach-suspend-count", class_run
, set_task_detach_sc_cmd
,
3187 _("Set the suspend count will leave on the thread when detaching."),
3188 &set_task_cmd_list
);
3189 add_cmd ("detach-suspend-count", no_class
, show_task_detach_sc_cmd
,
3190 _("Show the suspend count will leave on the thread when detaching."),
3191 &show_task_cmd_list
);
3193 add_cmd ("exception-port", no_class
, set_task_exc_port_cmd
, _("\
3194 Set the task exception port to which we forward exceptions.\n\
3195 The argument should be the value of the send right in the task."),
3196 &set_task_cmd_list
);
3197 add_alias_cmd ("excp", "exception-port", no_class
, 1, &set_task_cmd_list
);
3198 add_alias_cmd ("exc-port", "exception-port", no_class
, 1,
3199 &set_task_cmd_list
);
3201 /* A convenient way of turning on all options require to noninvasively
3202 debug running tasks. */
3203 add_cmd ("noninvasive", no_class
, set_noninvasive_cmd
, _("\
3204 Set task options so that we interfere as little as possible.\n\
3205 This is the same as setting `task pause', `exceptions', and\n\
3206 `signals' to the opposite value."),
3209 /* Commands to show information about the task's ports. */
3210 add_cmd ("send-rights", class_info
, info_send_rights_cmd
,
3211 _("Show information about the task's send rights"),
3213 add_cmd ("receive-rights", class_info
, info_recv_rights_cmd
,
3214 _("Show information about the task's receive rights"),
3216 add_cmd ("port-rights", class_info
, info_port_rights_cmd
,
3217 _("Show information about the task's port rights"),
3219 add_cmd ("port-sets", class_info
, info_port_sets_cmd
,
3220 _("Show information about the task's port sets"),
3222 add_cmd ("dead-names", class_info
, info_dead_names_cmd
,
3223 _("Show information about the task's dead names"),
3225 add_info_alias ("ports", "port-rights", 1);
3226 add_info_alias ("port", "port-rights", 1);
3227 add_info_alias ("psets", "port-sets", 1);
3232 set_thread_pause_cmd (char *args
, int from_tty
)
3234 struct proc
*thread
= cur_thread ();
3235 int old_sc
= thread
->pause_sc
;
3236 thread
->pause_sc
= parse_bool_arg (args
, "set thread pause");
3237 if (old_sc
== 0 && thread
->pause_sc
!= 0 && thread
->inf
->pause_sc
== 0)
3238 /* If the task is currently unsuspended, immediately suspend it,
3239 otherwise wait until the next time it gets control. */
3240 inf_suspend (thread
->inf
);
3244 show_thread_pause_cmd (char *args
, int from_tty
)
3246 struct proc
*thread
= cur_thread ();
3247 int sc
= thread
->pause_sc
;
3248 check_empty (args
, "show task pause");
3249 printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n",
3250 proc_string (thread
),
3251 sc
? "is" : "isn't",
3252 !sc
&& thread
->inf
->pause_sc
? " (but the task is)" : "");
3256 set_thread_run_cmd (char *args
, int from_tty
)
3258 struct proc
*thread
= cur_thread ();
3259 thread
->run_sc
= parse_bool_arg (args
, "set thread run") ? 0 : 1;
3263 show_thread_run_cmd (char *args
, int from_tty
)
3265 struct proc
*thread
= cur_thread ();
3266 check_empty (args
, "show thread run");
3267 printf_unfiltered ("Thread %s %s allowed to run.",
3268 proc_string (thread
),
3269 thread
->run_sc
== 0 ? "is" : "isn't");
3273 set_thread_detach_sc_cmd (char *args
, int from_tty
)
3275 cur_thread ()->detach_sc
= parse_int_arg (args
,
3276 "set thread detach-suspend-count");
3280 show_thread_detach_sc_cmd (char *args
, int from_tty
)
3282 struct proc
*thread
= cur_thread ();
3283 check_empty (args
, "show thread detach-suspend-count");
3284 printf_unfiltered ("Thread %s will be left with a suspend count"
3285 " of %d when detaching.\n",
3286 proc_string (thread
),
3291 set_thread_exc_port_cmd (char *args
, int from_tty
)
3293 struct proc
*thread
= cur_thread ();
3295 error (_("No argument to \"set thread exception-port\" command."));
3296 steal_exc_port (thread
, parse_and_eval_address (args
));
3301 show_thread_cmd (char *args
, int from_tty
)
3303 struct proc
*thread
= cur_thread ();
3304 check_empty (args
, "show thread");
3305 show_thread_run_cmd (0, from_tty
);
3306 show_thread_pause_cmd (0, from_tty
);
3307 if (thread
->detach_sc
!= 0)
3308 show_thread_detach_sc_cmd (0, from_tty
);
3313 thread_takeover_sc_cmd (char *args
, int from_tty
)
3315 struct proc
*thread
= cur_thread ();
3316 thread_basic_info_data_t _info
;
3317 thread_basic_info_t info
= &_info
;
3318 mach_msg_type_number_t info_len
= THREAD_BASIC_INFO_COUNT
;
3320 thread_info (thread
->port
, THREAD_BASIC_INFO
, (int *) &info
, &info_len
);
3322 error (("%s."), safe_strerror (err
));
3323 thread
->sc
= info
->suspend_count
;
3325 printf_unfiltered ("Suspend count was %d.\n", thread
->sc
);
3327 vm_deallocate (mach_task_self (), (vm_address_t
) info
,
3328 info_len
* sizeof (int));
3333 add_thread_commands (void)
3335 add_prefix_cmd ("thread", no_class
, set_thread_cmd
,
3336 _("Command prefix for setting thread properties."),
3337 &set_thread_cmd_list
, "set thread ", 0, &setlist
);
3338 add_prefix_cmd ("default", no_class
, show_thread_cmd
,
3339 _("Command prefix for setting default thread properties."),
3340 &set_thread_default_cmd_list
, "set thread default ", 0,
3341 &set_thread_cmd_list
);
3342 add_prefix_cmd ("thread", no_class
, set_thread_default_cmd
,
3343 _("Command prefix for showing thread properties."),
3344 &show_thread_cmd_list
, "show thread ", 0, &showlist
);
3345 add_prefix_cmd ("default", no_class
, show_thread_default_cmd
,
3346 _("Command prefix for showing default thread properties."),
3347 &show_thread_default_cmd_list
, "show thread default ", 0,
3348 &show_thread_cmd_list
);
3350 add_cmd ("pause", class_run
, set_thread_pause_cmd
, _("\
3351 Set whether the current thread is suspended while gdb has control.\n\
3352 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3353 until the next time the program is continued. This property normally\n\
3354 has no effect because the whole task is suspended, however, that may\n\
3355 be disabled with \"set task pause off\".\n\
3356 The default value is \"off\"."),
3357 &set_thread_cmd_list
);
3358 add_cmd ("pause", no_class
, show_thread_pause_cmd
, _("\
3359 Show whether the current thread is suspended while gdb has control."),
3360 &show_thread_cmd_list
);
3362 add_cmd ("run", class_run
, set_thread_run_cmd
,
3363 _("Set whether the current thread is allowed to run."),
3364 &set_thread_cmd_list
);
3365 add_cmd ("run", no_class
, show_thread_run_cmd
,
3366 _("Show whether the current thread is allowed to run."),
3367 &show_thread_cmd_list
);
3369 add_cmd ("detach-suspend-count", class_run
, set_thread_detach_sc_cmd
, _("\
3370 Set the suspend count will leave on the thread when detaching.\n\
3371 Note that this is relative to suspend count when gdb noticed the thread;\n\
3372 use the `thread takeover-suspend-count' to force it to an absolute value."),
3373 &set_thread_cmd_list
);
3374 add_cmd ("detach-suspend-count", no_class
, show_thread_detach_sc_cmd
, _("\
3375 Show the suspend count will leave on the thread when detaching.\n\
3376 Note that this is relative to suspend count when gdb noticed the thread;\n\
3377 use the `thread takeover-suspend-count' to force it to an absolute value."),
3378 &show_thread_cmd_list
);
3380 add_cmd ("exception-port", no_class
, set_thread_exc_port_cmd
, _("\
3381 Set the thread exception port to which we forward exceptions.\n\
3382 This overrides the task exception port.\n\
3383 The argument should be the value of the send right in the task."),
3384 &set_thread_cmd_list
);
3385 add_alias_cmd ("excp", "exception-port", no_class
, 1, &set_thread_cmd_list
);
3386 add_alias_cmd ("exc-port", "exception-port", no_class
, 1,
3387 &set_thread_cmd_list
);
3389 add_cmd ("takeover-suspend-count", no_class
, thread_takeover_sc_cmd
, _("\
3390 Force the threads absolute suspend-count to be gdb's.\n\
3391 Prior to giving this command, gdb's thread suspend-counts are relative\n\
3392 to the thread's initial suspend-count when gdb notices the threads."),
3398 _initialize_gnu_nat (void)
3400 proc_server
= getproc ();
3403 add_target (&gnu_ops
);
3405 add_task_commands ();
3406 add_thread_commands ();
3407 deprecated_add_set_cmd ("gnu-debug", class_maintenance
,
3408 var_boolean
, (char *) &gnu_debug_flag
,
3409 "Set debugging output for the gnu backend.",
3413 #ifdef FLUSH_INFERIOR_CACHE
3415 /* When over-writing code on some machines the I-Cache must be flushed
3416 explicitly, because it is not kept coherent by the lazy hardware.
3417 This definitely includes breakpoints, for instance, or else we
3418 end up looping in mysterious Bpt traps */
3421 flush_inferior_icache (CORE_ADDR pc
, int amount
)
3423 vm_machine_attribute_val_t flush
= MATTR_VAL_ICACHE_FLUSH
;
3426 ret
= vm_machine_attribute (gnu_current_inf
->task
->port
,
3431 if (ret
!= KERN_SUCCESS
)
3432 warning (_("Error flushing inferior's cache : %s"), safe_strerror (ret
));
3434 #endif /* FLUSH_INFERIOR_CACHE */