1 /* Interface GDB to the GNU Hurd.
2 Copyright (C) 1992-2014 Free Software Foundation, Inc.
4 This file is part of GDB.
6 Written by Miles Bader <miles@gnu.ai.mit.edu>
8 Some code and ideas from m3-nat.c by Jukka Virtanen <jtv@hut.fi>
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
30 #include <sys/ptrace.h>
33 #include <mach_error.h>
34 #include <mach/exception.h>
35 #include <mach/message.h>
36 #include <mach/notify.h>
37 #include <mach/vm_attributes.h>
40 #include <hurd/interrupt.h>
42 #include <hurd/msg_request.h>
43 #include <hurd/process.h>
44 /* Defined in <hurd/process.h>, but we need forward declarations from
45 <hurd/process_request.h> as well. */
47 #include <hurd/process_request.h>
48 #include <hurd/signal.h>
49 #include <hurd/sigpreempt.h>
61 #include "gdbthread.h"
62 #include "gdb_obstack.h"
65 #include "inf-child.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 static struct inf
*make_inf ();
88 void inf_clear_wait (struct inf
*inf
);
89 void inf_cleanup (struct inf
*inf
);
90 void inf_startup (struct inf
*inf
, int pid
);
91 int inf_update_suspends (struct inf
*inf
);
92 void inf_set_pid (struct inf
*inf
, pid_t pid
);
93 void inf_validate_procs (struct inf
*inf
);
94 void inf_steal_exc_ports (struct inf
*inf
);
95 void inf_restore_exc_ports (struct inf
*inf
);
96 void inf_set_threads_resume_sc (struct inf
*inf
,
97 struct proc
*run_thread
,
99 int inf_set_threads_resume_sc_for_signal_thread (struct inf
*inf
);
100 void inf_suspend (struct inf
*inf
);
101 void inf_resume (struct inf
*inf
);
102 void inf_set_step_thread (struct inf
*inf
, struct proc
*proc
);
103 void inf_detach (struct inf
*inf
);
104 void inf_attach (struct inf
*inf
, int pid
);
105 void inf_signal (struct inf
*inf
, enum gdb_signal sig
);
106 void inf_continue (struct inf
*inf
);
108 #define inf_debug(_inf, msg, args...) \
109 do { struct inf *__inf = (_inf); \
110 debug ("{inf %d %s}: " msg, __inf->pid, \
111 host_address_to_string (__inf) , ##args); } while (0)
113 void proc_abort (struct proc
*proc
, int force
);
114 struct proc
*make_proc (struct inf
*inf
, mach_port_t port
, int tid
);
115 struct proc
*_proc_free (struct proc
*proc
);
116 int proc_update_sc (struct proc
*proc
);
117 error_t
proc_get_exception_port (struct proc
*proc
, mach_port_t
* port
);
118 error_t
proc_set_exception_port (struct proc
*proc
, mach_port_t port
);
119 static mach_port_t
_proc_get_exc_port (struct proc
*proc
);
120 void proc_steal_exc_port (struct proc
*proc
, mach_port_t exc_port
);
121 void proc_restore_exc_port (struct proc
*proc
);
122 int proc_trace (struct proc
*proc
, int set
);
124 /* Evaluate RPC_EXPR in a scope with the variables MSGPORT and REFPORT bound
125 to INF's msg port and task port respectively. If it has no msg port,
126 EIEIO is returned. INF must refer to a running process! */
127 #define INF_MSGPORT_RPC(inf, rpc_expr) \
128 HURD_MSGPORT_RPC (proc_getmsgport (proc_server, inf->pid, &msgport), \
129 (refport = inf->task->port, 0), 0, \
130 msgport ? (rpc_expr) : EIEIO)
132 /* Like INF_MSGPORT_RPC, but will also resume the signal thread to ensure
133 there's someone around to deal with the RPC (and resuspend things
134 afterwards). This effects INF's threads' resume_sc count. */
135 #define INF_RESUME_MSGPORT_RPC(inf, rpc_expr) \
136 (inf_set_threads_resume_sc_for_signal_thread (inf) \
139 __e = INF_MSGPORT_RPC (inf, rpc_expr); \
145 /* The state passed by an exception message. */
148 int exception
; /* The exception code. */
150 mach_port_t handler
; /* The real exception port to handle this. */
151 mach_port_t reply
; /* The reply port from the exception call. */
154 /* The results of the last wait an inf did. */
157 struct target_waitstatus status
; /* The status returned to gdb. */
158 struct exc_state exc
; /* The exception that caused us to return. */
159 struct proc
*thread
; /* The thread in question. */
160 int suppress
; /* Something trivial happened. */
163 /* The state of an inferior. */
166 /* Fields describing the current inferior. */
168 struct proc
*task
; /* The mach task. */
169 struct proc
*threads
; /* A linked list of all threads in TASK. */
171 /* True if THREADS needn't be validated by querying the task. We
172 assume that we and the task in question are the only ones
173 frobbing the thread list, so as long as we don't let any code
174 run, we don't have to worry about THREADS changing. */
175 int threads_up_to_date
;
177 pid_t pid
; /* The real system PID. */
179 struct inf_wait wait
; /* What to return from target_wait. */
181 /* One thread proc in INF may be in `single-stepping mode'. This
183 struct proc
*step_thread
;
185 /* The thread we think is the signal thread. */
186 struct proc
*signal_thread
;
188 mach_port_t event_port
; /* Where we receive various msgs. */
190 /* True if we think at least one thread in the inferior could currently be
192 unsigned int running
:1;
194 /* True if the process has stopped (in the proc server sense). Note that
195 since a proc server `stop' leaves the signal thread running, the inf can
196 be RUNNING && STOPPED... */
197 unsigned int stopped
:1;
199 /* True if the inferior has no message port. */
200 unsigned int nomsg
:1;
202 /* True if the inferior is traced. */
203 unsigned int traced
:1;
205 /* True if we shouldn't try waiting for the inferior, usually because we
206 can't for some reason. */
207 unsigned int no_wait
:1;
209 /* When starting a new inferior, we don't try to validate threads until all
210 the proper execs have been done, which this flag states we still
212 unsigned int pending_execs
:1;
214 /* Fields describing global state. */
216 /* The task suspend count used when gdb has control. This is normally 1 to
217 make things easier for us, but sometimes (like when attaching to vital
218 system servers) it may be desirable to let the task continue to run
219 (pausing individual threads as necessary). */
222 /* The task suspend count left when detaching from a task. */
225 /* The initial values used for the run_sc and pause_sc of newly discovered
226 threads -- see the definition of those fields in struct proc. */
227 int default_thread_run_sc
;
228 int default_thread_pause_sc
;
229 int default_thread_detach_sc
;
231 /* True if the process should be traced when started/attached. Newly
232 started processes *must* be traced at first to exec them properly, but
233 if this is false, tracing is turned off as soon it has done so. */
236 /* True if exceptions from the inferior process should be trapped. This
237 must be on to use breakpoints. */
243 __proc_pid (struct proc
*proc
)
245 return proc
->inf
->pid
;
249 /* Update PROC's real suspend count to match it's desired one. Returns true
250 if we think PROC is now in a runnable state. */
252 proc_update_sc (struct proc
*proc
)
256 int delta
= proc
->sc
- proc
->cur_sc
;
259 proc_debug (proc
, "sc: %d --> %d", proc
->cur_sc
, proc
->sc
);
261 if (proc
->sc
== 0 && proc
->state_changed
)
262 /* Since PROC may start running, we must write back any state changes. */
264 gdb_assert (proc_is_thread (proc
));
265 proc_debug (proc
, "storing back changed thread state");
266 err
= thread_set_state (proc
->port
, THREAD_STATE_FLAVOR
,
267 (thread_state_t
) &proc
->state
, THREAD_STATE_SIZE
);
269 proc
->state_changed
= 0;
274 while (delta
-- > 0 && !err
)
276 if (proc_is_task (proc
))
277 err
= task_suspend (proc
->port
);
279 err
= thread_suspend (proc
->port
);
284 while (delta
++ < 0 && !err
)
286 if (proc_is_task (proc
))
287 err
= task_resume (proc
->port
);
289 err
= thread_resume (proc
->port
);
293 proc
->cur_sc
= proc
->sc
;
295 /* If we got an error, then the task/thread has disappeared. */
296 running
= !err
&& proc
->sc
== 0;
298 proc_debug (proc
, "is %s", err
? "dead" : running
? "running" : "suspended");
300 proc_debug (proc
, "err = %s", safe_strerror (err
));
305 proc
->state_valid
= proc
->state_changed
= 0;
306 proc
->fetched_regs
= 0;
313 /* Thread_abort is called on PROC if needed. PROC must be a thread proc.
314 If PROC is deemed `precious', then nothing is done unless FORCE is true.
315 In particular, a thread is precious if it's running (in which case forcing
316 it includes suspending it first), or if it has an exception pending. */
318 proc_abort (struct proc
*proc
, int force
)
320 gdb_assert (proc_is_thread (proc
));
324 struct inf
*inf
= proc
->inf
;
325 int running
= (proc
->cur_sc
== 0 && inf
->task
->cur_sc
== 0);
327 if (running
&& force
)
330 inf_update_suspends (proc
->inf
);
332 warning (_("Stopped %s."), proc_string (proc
));
334 else if (proc
== inf
->wait
.thread
&& inf
->wait
.exc
.reply
&& !force
)
335 /* An exception is pending on PROC, which don't mess with. */
339 /* We only abort the thread if it's not actually running. */
341 thread_abort (proc
->port
);
342 proc_debug (proc
, "aborted");
346 proc_debug (proc
, "not aborting");
350 /* Make sure that the state field in PROC is up to date, and return a pointer
351 to it, or 0 if something is wrong. If WILL_MODIFY is true, makes sure
352 that the thread is stopped and aborted first, and sets the state_changed
353 field in PROC to true. */
355 proc_get_state (struct proc
*proc
, int will_modify
)
357 int was_aborted
= proc
->aborted
;
359 proc_debug (proc
, "updating state info%s",
360 will_modify
? " (with intention to modify)" : "");
362 proc_abort (proc
, will_modify
);
364 if (!was_aborted
&& proc
->aborted
)
365 /* PROC's state may have changed since we last fetched it. */
366 proc
->state_valid
= 0;
368 if (!proc
->state_valid
)
370 mach_msg_type_number_t state_size
= THREAD_STATE_SIZE
;
372 thread_get_state (proc
->port
, THREAD_STATE_FLAVOR
,
373 (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: %lu", 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
433 been done. Stash away any existing exception port so we can
436 proc_steal_exc_port (struct proc
*proc
, mach_port_t exc_port
)
438 mach_port_t cur_exc_port
= _proc_get_exc_port (proc
);
444 proc_debug (proc
, "inserting exception port: %lu", exc_port
);
446 if (cur_exc_port
!= exc_port
)
447 /* Put in our exception port. */
448 err
= proc_set_exception_port (proc
, exc_port
);
450 if (err
|| cur_exc_port
== proc
->exc_port
)
451 /* We previously set the exception port, and it's still set. So we
452 just keep the old saved port which is what the proc set. */
455 mach_port_deallocate (mach_task_self (), cur_exc_port
);
458 /* Keep a copy of PROC's old exception port so it can be restored. */
460 if (proc
->saved_exc_port
)
461 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
462 proc
->saved_exc_port
= cur_exc_port
;
465 proc_debug (proc
, "saved exception port: %lu", proc
->saved_exc_port
);
468 proc
->exc_port
= exc_port
;
470 warning (_("Error setting exception port for %s: %s"),
471 proc_string (proc
), safe_strerror (err
));
475 /* If we previously replaced PROC's exception port, put back what we
476 found there at the time, unless *our* exception port has since been
477 overwritten, in which case who knows what's going on. */
479 proc_restore_exc_port (struct proc
*proc
)
481 mach_port_t cur_exc_port
= _proc_get_exc_port (proc
);
487 proc_debug (proc
, "restoring real exception port");
489 if (proc
->exc_port
== cur_exc_port
)
490 /* Our's is still there. */
491 err
= proc_set_exception_port (proc
, proc
->saved_exc_port
);
493 if (proc
->saved_exc_port
)
494 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
495 proc
->saved_exc_port
= MACH_PORT_NULL
;
498 proc
->exc_port
= MACH_PORT_NULL
;
500 warning (_("Error setting exception port for %s: %s"),
501 proc_string (proc
), safe_strerror (err
));
506 /* Turns hardware tracing in PROC on or off when SET is true or false,
507 respectively. Returns true on success. */
509 proc_trace (struct proc
*proc
, int set
)
511 thread_state_t state
= proc_get_state (proc
, 1);
514 return 0; /* The thread must be dead. */
516 proc_debug (proc
, "tracing %s", set
? "on" : "off");
520 /* XXX We don't get the exception unless the thread has its own
521 exception port???? */
522 if (proc
->exc_port
== MACH_PORT_NULL
)
523 proc_steal_exc_port (proc
, proc
->inf
->event_port
);
524 THREAD_STATE_SET_TRACED (state
);
527 THREAD_STATE_CLEAR_TRACED (state
);
533 /* A variable from which to assign new TIDs. */
534 static int next_thread_id
= 1;
536 /* Returns a new proc structure with the given fields. Also adds a
537 notification for PORT becoming dead to be sent to INF's notify port. */
539 make_proc (struct inf
*inf
, mach_port_t port
, int tid
)
542 mach_port_t prev_port
= MACH_PORT_NULL
;
543 struct proc
*proc
= xmalloc (sizeof (struct proc
));
549 proc
->saved_exc_port
= MACH_PORT_NULL
;
550 proc
->exc_port
= MACH_PORT_NULL
;
555 /* Note that these are all the values for threads; the task simply uses the
556 corresponding field in INF directly. */
557 proc
->run_sc
= inf
->default_thread_run_sc
;
558 proc
->pause_sc
= inf
->default_thread_pause_sc
;
559 proc
->detach_sc
= inf
->default_thread_detach_sc
;
560 proc
->resume_sc
= proc
->run_sc
;
564 proc
->state_valid
= 0;
565 proc
->state_changed
= 0;
567 proc_debug (proc
, "is new");
569 /* Get notified when things die. */
571 mach_port_request_notification (mach_task_self (), port
,
572 MACH_NOTIFY_DEAD_NAME
, 1,
574 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
577 warning (_("Couldn't request notification for port %lu: %s"),
578 port
, safe_strerror (err
));
581 proc_debug (proc
, "notifications to: %lu", inf
->event_port
);
582 if (prev_port
!= MACH_PORT_NULL
)
583 mach_port_deallocate (mach_task_self (), prev_port
);
586 if (inf
->want_exceptions
)
588 if (proc_is_task (proc
))
589 /* Make the task exception port point to us. */
590 proc_steal_exc_port (proc
, inf
->event_port
);
592 /* Just clear thread exception ports -- they default to the
594 proc_steal_exc_port (proc
, MACH_PORT_NULL
);
600 /* Frees PROC and any resources it uses, and returns the value of PROC's
603 _proc_free (struct proc
*proc
)
605 struct inf
*inf
= proc
->inf
;
606 struct proc
*next
= proc
->next
;
608 proc_debug (proc
, "freeing...");
610 if (proc
== inf
->step_thread
)
611 /* Turn off single stepping. */
612 inf_set_step_thread (inf
, 0);
613 if (proc
== inf
->wait
.thread
)
614 inf_clear_wait (inf
);
615 if (proc
== inf
->signal_thread
)
616 inf
->signal_thread
= 0;
618 if (proc
->port
!= MACH_PORT_NULL
)
620 if (proc
->exc_port
!= MACH_PORT_NULL
)
621 /* Restore the original exception port. */
622 proc_restore_exc_port (proc
);
623 if (proc
->cur_sc
!= 0)
624 /* Resume the thread/task. */
627 proc_update_sc (proc
);
629 mach_port_deallocate (mach_task_self (), proc
->port
);
640 struct inf
*inf
= xmalloc (sizeof (struct inf
));
644 inf
->threads_up_to_date
= 0;
646 inf
->wait
.status
.kind
= TARGET_WAITKIND_SPURIOUS
;
647 inf
->wait
.thread
= 0;
648 inf
->wait
.exc
.handler
= MACH_PORT_NULL
;
649 inf
->wait
.exc
.reply
= MACH_PORT_NULL
;
650 inf
->step_thread
= 0;
651 inf
->signal_thread
= 0;
652 inf
->event_port
= MACH_PORT_NULL
;
658 inf
->pending_execs
= 0;
661 inf
->default_thread_run_sc
= 0;
662 inf
->default_thread_pause_sc
= 0;
663 inf
->default_thread_detach_sc
= 0;
664 inf
->want_signals
= 1; /* By default */
665 inf
->want_exceptions
= 1; /* By default */
670 /* Clear INF's target wait status. */
672 inf_clear_wait (struct inf
*inf
)
674 inf_debug (inf
, "clearing wait");
675 inf
->wait
.status
.kind
= TARGET_WAITKIND_SPURIOUS
;
676 inf
->wait
.thread
= 0;
677 inf
->wait
.suppress
= 0;
678 if (inf
->wait
.exc
.handler
!= MACH_PORT_NULL
)
680 mach_port_deallocate (mach_task_self (), inf
->wait
.exc
.handler
);
681 inf
->wait
.exc
.handler
= MACH_PORT_NULL
;
683 if (inf
->wait
.exc
.reply
!= MACH_PORT_NULL
)
685 mach_port_deallocate (mach_task_self (), inf
->wait
.exc
.reply
);
686 inf
->wait
.exc
.reply
= MACH_PORT_NULL
;
692 inf_cleanup (struct inf
*inf
)
694 inf_debug (inf
, "cleanup");
696 inf_clear_wait (inf
);
698 inf_set_pid (inf
, -1);
705 inf
->pending_execs
= 0;
709 mach_port_destroy (mach_task_self (), inf
->event_port
);
710 inf
->event_port
= MACH_PORT_NULL
;
715 inf_startup (struct inf
*inf
, int pid
)
719 inf_debug (inf
, "startup: pid = %d", pid
);
723 /* Make the port on which we receive all events. */
724 err
= mach_port_allocate (mach_task_self (),
725 MACH_PORT_RIGHT_RECEIVE
, &inf
->event_port
);
727 error (_("Error allocating event port: %s"), safe_strerror (err
));
729 /* Make a send right for it, so we can easily copy it for other people. */
730 mach_port_insert_right (mach_task_self (), inf
->event_port
,
731 inf
->event_port
, MACH_MSG_TYPE_MAKE_SEND
);
732 inf_set_pid (inf
, pid
);
736 /* Close current process, if any, and attach INF to process PORT. */
738 inf_set_pid (struct inf
*inf
, pid_t pid
)
741 struct proc
*task
= inf
->task
;
743 inf_debug (inf
, "setting pid: %d", pid
);
746 task_port
= MACH_PORT_NULL
;
749 error_t err
= proc_pid2task (proc_server
, pid
, &task_port
);
752 error (_("Error getting task for pid %d: %s"),
753 pid
, safe_strerror (err
));
756 inf_debug (inf
, "setting task: %lu", 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
));
890 warning (_("Can't modify tracing state for pid %d: %s"),
891 inf
->pid
, "No signal thread");
895 warning (_("Can't modify tracing state for pid %d: %s"),
896 inf
->pid
, safe_strerror (err
));
905 /* Makes all the real suspend count deltas of all the procs in INF
906 match the desired values. Careful to always do thread/task suspend
907 counts in the safe order. Returns true if at least one thread is
908 thought to be running. */
910 inf_update_suspends (struct inf
*inf
)
912 struct proc
*task
= inf
->task
;
914 /* We don't have to update INF->threads even though we're iterating over it
915 because we'll change a thread only if it already has an existing proc
917 inf_debug (inf
, "updating suspend counts");
922 int task_running
= (task
->sc
== 0), thread_running
= 0;
924 if (task
->sc
> task
->cur_sc
)
925 /* The task is becoming _more_ suspended; do before any threads. */
926 task_running
= proc_update_sc (task
);
928 if (inf
->pending_execs
)
929 /* When we're waiting for an exec, things may be happening behind our
930 back, so be conservative. */
933 /* Do all the thread suspend counts. */
934 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
935 thread_running
|= proc_update_sc (thread
);
937 if (task
->sc
!= task
->cur_sc
)
938 /* We didn't do the task first, because we wanted to wait for the
939 threads; do it now. */
940 task_running
= proc_update_sc (task
);
942 inf_debug (inf
, "%srunning...",
943 (thread_running
&& task_running
) ? "" : "not ");
945 inf
->running
= thread_running
&& task_running
;
947 /* Once any thread has executed some code, we can't depend on the
948 threads list any more. */
950 inf
->threads_up_to_date
= 0;
959 /* Converts a GDB pid to a struct proc. */
961 inf_tid_to_thread (struct inf
*inf
, int tid
)
963 struct proc
*thread
= inf
->threads
;
966 if (thread
->tid
== tid
)
969 thread
= thread
->next
;
973 /* Converts a thread port to a struct proc. */
975 inf_port_to_thread (struct inf
*inf
, mach_port_t port
)
977 struct proc
*thread
= inf
->threads
;
980 if (thread
->port
== port
)
983 thread
= thread
->next
;
988 /* Make INF's list of threads be consistent with reality of TASK. */
990 inf_validate_procs (struct inf
*inf
)
992 thread_array_t threads
;
993 mach_msg_type_number_t num_threads
, i
;
994 struct proc
*task
= inf
->task
;
996 /* If no threads are currently running, this function will guarantee that
997 things are up to date. The exception is if there are zero threads --
998 then it is almost certainly in an odd state, and probably some outside
999 agent will create threads. */
1000 inf
->threads_up_to_date
= inf
->threads
? !inf
->running
: 0;
1004 error_t err
= task_threads (task
->port
, &threads
, &num_threads
);
1006 inf_debug (inf
, "fetching threads");
1008 /* TASK must be dead. */
1018 inf_debug (inf
, "no task");
1022 /* Make things normally linear. */
1023 mach_msg_type_number_t search_start
= 0;
1024 /* Which thread in PROCS corresponds to each task thread, & the task. */
1025 struct proc
*matched
[num_threads
+ 1];
1026 /* The last thread in INF->threads, so we can add to the end. */
1027 struct proc
*last
= 0;
1028 /* The current thread we're considering. */
1029 struct proc
*thread
= inf
->threads
;
1031 memset (matched
, 0, sizeof (matched
));
1035 mach_msg_type_number_t left
;
1037 for (i
= search_start
, left
= num_threads
; left
; i
++, left
--)
1039 if (i
>= num_threads
)
1040 i
-= num_threads
; /* I wrapped around. */
1041 if (thread
->port
== threads
[i
])
1042 /* We already know about this thread. */
1044 matched
[i
] = thread
;
1046 thread
= thread
->next
;
1054 proc_debug (thread
, "died!");
1055 thread
->port
= MACH_PORT_NULL
;
1056 thread
= _proc_free (thread
); /* THREAD is dead. */
1058 last
->next
= thread
;
1060 inf
->threads
= thread
;
1064 for (i
= 0; i
< num_threads
; i
++)
1067 /* Throw away the duplicate send right. */
1068 mach_port_deallocate (mach_task_self (), threads
[i
]);
1070 /* THREADS[I] is a thread we don't know about yet! */
1074 thread
= make_proc (inf
, threads
[i
], next_thread_id
++);
1076 last
->next
= thread
;
1078 inf
->threads
= thread
;
1080 proc_debug (thread
, "new thread: %lu", threads
[i
]);
1082 ptid
= ptid_build (inf
->pid
, thread
->tid
, 0);
1084 /* Tell GDB's generic thread code. */
1086 if (ptid_equal (inferior_ptid
, pid_to_ptid (inf
->pid
)))
1087 /* This is the first time we're hearing about thread
1088 ids, after a fork-child. */
1089 thread_change_ptid (inferior_ptid
, ptid
);
1090 else if (inf
->pending_execs
!= 0)
1091 /* This is a shell thread. */
1092 add_thread_silent (ptid
);
1098 vm_deallocate (mach_task_self (),
1099 (vm_address_t
) threads
, (num_threads
* sizeof (thread_t
)));
1104 /* Makes sure that INF's thread list is synced with the actual process. */
1106 inf_update_procs (struct inf
*inf
)
1110 if (!inf
->threads_up_to_date
)
1111 inf_validate_procs (inf
);
1115 /* Sets the resume_sc of each thread in inf. That of RUN_THREAD is set to 0,
1116 and others are set to their run_sc if RUN_OTHERS is true, and otherwise
1119 inf_set_threads_resume_sc (struct inf
*inf
,
1120 struct proc
*run_thread
, int run_others
)
1122 struct proc
*thread
;
1124 inf_update_procs (inf
);
1125 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1126 if (thread
== run_thread
)
1127 thread
->resume_sc
= 0;
1128 else if (run_others
)
1129 thread
->resume_sc
= thread
->run_sc
;
1131 thread
->resume_sc
= thread
->pause_sc
;
1135 /* Cause INF to continue execution immediately; individual threads may still
1136 be suspended (but their suspend counts will be updated). */
1138 inf_resume (struct inf
*inf
)
1140 struct proc
*thread
;
1142 inf_update_procs (inf
);
1144 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1145 thread
->sc
= thread
->resume_sc
;
1149 if (!inf
->pending_execs
)
1150 /* Try to make sure our task count is correct -- in the case where
1151 we're waiting for an exec though, things are too volatile, so just
1152 assume things will be reasonable (which they usually will be). */
1153 inf_validate_task_sc (inf
);
1157 inf_update_suspends (inf
);
1160 /* Cause INF to stop execution immediately; individual threads may still
1163 inf_suspend (struct inf
*inf
)
1165 struct proc
*thread
;
1167 inf_update_procs (inf
);
1169 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1170 thread
->sc
= thread
->pause_sc
;
1173 inf
->task
->sc
= inf
->pause_sc
;
1175 inf_update_suspends (inf
);
1179 /* INF has one thread PROC that is in single-stepping mode. This
1180 function changes it to be PROC, changing any old step_thread to be
1181 a normal one. A PROC of 0 clears any existing value. */
1183 inf_set_step_thread (struct inf
*inf
, struct proc
*thread
)
1185 gdb_assert (!thread
|| proc_is_thread (thread
));
1188 inf_debug (inf
, "setting step thread: %d/%d", inf
->pid
, thread
->tid
);
1190 inf_debug (inf
, "clearing step thread");
1192 if (inf
->step_thread
!= thread
)
1194 if (inf
->step_thread
&& inf
->step_thread
->port
!= MACH_PORT_NULL
)
1195 if (!proc_trace (inf
->step_thread
, 0))
1197 if (thread
&& proc_trace (thread
, 1))
1198 inf
->step_thread
= thread
;
1200 inf
->step_thread
= 0;
1205 /* Set up the thread resume_sc's so that only the signal thread is running
1206 (plus whatever other thread are set to always run). Returns true if we
1207 did so, or false if we can't find a signal thread. */
1209 inf_set_threads_resume_sc_for_signal_thread (struct inf
*inf
)
1211 if (inf
->signal_thread
)
1213 inf_set_threads_resume_sc (inf
, inf
->signal_thread
, 0);
1221 inf_update_signal_thread (struct inf
*inf
)
1223 /* XXX for now we assume that if there's a msgport, the 2nd thread is
1224 the signal thread. */
1225 inf
->signal_thread
= inf
->threads
? inf
->threads
->next
: 0;
1229 /* Detachs from INF's inferior task, letting it run once again... */
1231 inf_detach (struct inf
*inf
)
1233 struct proc
*task
= inf
->task
;
1235 inf_debug (inf
, "detaching...");
1237 inf_clear_wait (inf
);
1238 inf_set_step_thread (inf
, 0);
1242 struct proc
*thread
;
1244 inf_validate_procinfo (inf
);
1246 inf_set_traced (inf
, 0);
1252 inf_signal (inf
, GDB_SIGNAL_0
);
1255 proc_restore_exc_port (task
);
1256 task
->sc
= inf
->detach_sc
;
1258 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1260 proc_restore_exc_port (thread
);
1261 thread
->sc
= thread
->detach_sc
;
1264 inf_update_suspends (inf
);
1270 /* Attaches INF to the process with process id PID, returning it in a
1271 suspended state suitable for debugging. */
1273 inf_attach (struct inf
*inf
, int pid
)
1275 inf_debug (inf
, "attaching: %d", pid
);
1280 inf_startup (inf
, pid
);
1284 /* Makes sure that we've got our exception ports entrenched in the process. */
1286 inf_steal_exc_ports (struct inf
*inf
)
1288 struct proc
*thread
;
1290 inf_debug (inf
, "stealing exception ports");
1292 inf_set_step_thread (inf
, 0); /* The step thread is special. */
1294 proc_steal_exc_port (inf
->task
, inf
->event_port
);
1295 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1296 proc_steal_exc_port (thread
, MACH_PORT_NULL
);
1299 /* Makes sure the process has its own exception ports. */
1301 inf_restore_exc_ports (struct inf
*inf
)
1303 struct proc
*thread
;
1305 inf_debug (inf
, "restoring exception ports");
1307 inf_set_step_thread (inf
, 0); /* The step thread is special. */
1309 proc_restore_exc_port (inf
->task
);
1310 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1311 proc_restore_exc_port (thread
);
1315 /* Deliver signal SIG to INF. If INF is stopped, delivering a signal, even
1316 signal 0, will continue it. INF is assumed to be in a paused state, and
1317 the resume_sc's of INF's threads may be affected. */
1319 inf_signal (struct inf
*inf
, enum gdb_signal sig
)
1322 int host_sig
= gdb_signal_to_host (sig
);
1324 #define NAME gdb_signal_to_name (sig)
1326 if (host_sig
>= _NSIG
)
1327 /* A mach exception. Exceptions are encoded in the signal space by
1328 putting them after _NSIG; this assumes they're positive (and not
1329 extremely large)! */
1331 struct inf_wait
*w
= &inf
->wait
;
1333 if (w
->status
.kind
== TARGET_WAITKIND_STOPPED
1334 && w
->status
.value
.sig
== sig
1335 && w
->thread
&& !w
->thread
->aborted
)
1336 /* We're passing through the last exception we received. This is
1337 kind of bogus, because exceptions are per-thread whereas gdb
1338 treats signals as per-process. We just forward the exception to
1339 the correct handler, even it's not for the same thread as TID --
1340 i.e., we pretend it's global. */
1342 struct exc_state
*e
= &w
->exc
;
1344 inf_debug (inf
, "passing through exception:"
1345 " task = %lu, thread = %lu, exc = %d"
1346 ", code = %d, subcode = %d",
1347 w
->thread
->port
, inf
->task
->port
,
1348 e
->exception
, e
->code
, e
->subcode
);
1350 exception_raise_request (e
->handler
,
1351 e
->reply
, MACH_MSG_TYPE_MOVE_SEND_ONCE
,
1352 w
->thread
->port
, inf
->task
->port
,
1353 e
->exception
, e
->code
, e
->subcode
);
1356 error (_("Can't forward spontaneous exception (%s)."), NAME
);
1359 /* A Unix signal. */
1361 /* The process is stopped and expecting a signal. Just send off a
1362 request and let it get handled when we resume everything. */
1364 inf_debug (inf
, "sending %s to stopped process", NAME
);
1366 INF_MSGPORT_RPC (inf
,
1367 msg_sig_post_untraced_request (msgport
,
1369 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1373 /* Posting an untraced signal automatically continues it.
1374 We clear this here rather than when we get the reply
1375 because we'd rather assume it's not stopped when it
1376 actually is, than the reverse. */
1380 /* It's not expecting it. We have to let just the signal thread
1381 run, and wait for it to get into a reasonable state before we
1382 can continue the rest of the process. When we finally resume the
1383 process the signal we request will be the very first thing that
1386 inf_debug (inf
, "sending %s to unstopped process"
1387 " (so resuming signal thread)", NAME
);
1389 INF_RESUME_MSGPORT_RPC (inf
,
1390 msg_sig_post_untraced (msgport
, host_sig
,
1395 /* Can't do too much... */
1396 warning (_("Can't deliver signal %s: No signal thread."), NAME
);
1398 warning (_("Delivering signal %s: %s"), NAME
, safe_strerror (err
));
1404 /* Continue INF without delivering a signal. This is meant to be used
1405 when INF does not have a message port. */
1407 inf_continue (struct inf
*inf
)
1410 error_t err
= proc_pid2proc (proc_server
, inf
->pid
, &proc
);
1414 inf_debug (inf
, "continuing process");
1416 err
= proc_mark_cont (proc
);
1419 struct proc
*thread
;
1421 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1422 thread_resume (thread
->port
);
1429 warning (_("Can't continue process: %s"), safe_strerror (err
));
1433 /* The inferior used for all gdb target ops. */
1434 struct inf
*gnu_current_inf
= 0;
1436 /* The inferior being waited for by gnu_wait. Since GDB is decidely not
1437 multi-threaded, we don't bother to lock this. */
1438 struct inf
*waiting_inf
;
1440 /* Wait for something to happen in the inferior, returning what in STATUS. */
1442 gnu_wait (struct target_ops
*ops
,
1443 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
1447 mach_msg_header_t hdr
;
1448 mach_msg_type_t type
;
1452 struct proc
*thread
;
1453 struct inf
*inf
= gnu_current_inf
;
1455 extern int exc_server (mach_msg_header_t
*, mach_msg_header_t
*);
1456 extern int msg_reply_server (mach_msg_header_t
*, mach_msg_header_t
*);
1457 extern int notify_server (mach_msg_header_t
*, mach_msg_header_t
*);
1458 extern int process_reply_server (mach_msg_header_t
*, mach_msg_header_t
*);
1460 gdb_assert (inf
->task
);
1462 if (!inf
->threads
&& !inf
->pending_execs
)
1463 /* No threads! Assume that maybe some outside agency is frobbing our
1464 task, and really look for new threads. If we can't find any, just tell
1465 the user to try again later. */
1467 inf_validate_procs (inf
);
1468 if (!inf
->threads
&& !inf
->task
->dead
)
1469 error (_("There are no threads; try again later."));
1474 inf_debug (inf
, "waiting for: %s", target_pid_to_str (ptid
));
1477 if (proc_wait_pid
!= inf
->pid
&& !inf
->no_wait
)
1478 /* Always get information on events from the proc server. */
1480 inf_debug (inf
, "requesting wait on pid %d", inf
->pid
);
1483 /* The proc server is single-threaded, and only allows a single
1484 outstanding wait request, so we have to cancel the previous one. */
1486 inf_debug (inf
, "cancelling previous wait on pid %d", proc_wait_pid
);
1487 interrupt_operation (proc_server
, 0);
1491 proc_wait_request (proc_server
, inf
->event_port
, inf
->pid
, WUNTRACED
);
1493 warning (_("wait request failed: %s"), safe_strerror (err
));
1496 inf_debug (inf
, "waits pending: %d", proc_waits_pending
);
1497 proc_wait_pid
= inf
->pid
;
1498 /* Even if proc_waits_pending was > 0 before, we still won't
1499 get any other replies, because it was either from a
1500 different INF, or a different process attached to INF --
1501 and the event port, which is the wait reply port, changes
1502 when you switch processes. */
1503 proc_waits_pending
= 1;
1507 inf_clear_wait (inf
);
1509 /* What can happen? (1) Dead name notification; (2) Exceptions arrive;
1510 (3) wait reply from the proc server. */
1512 inf_debug (inf
, "waiting for an event...");
1513 err
= mach_msg (&msg
.hdr
, MACH_RCV_MSG
| MACH_RCV_INTERRUPT
,
1514 0, sizeof (struct msg
), inf
->event_port
,
1515 MACH_MSG_TIMEOUT_NONE
, MACH_PORT_NULL
);
1517 /* Re-suspend the task. */
1520 if (!inf
->task
&& inf
->pending_execs
)
1521 /* When doing an exec, it's possible that the old task wasn't reused
1522 (e.g., setuid execs). So if the task seems to have disappeared,
1523 attempt to refetch it, as the pid should still be the same. */
1524 inf_set_pid (inf
, inf
->pid
);
1526 if (err
== EMACH_RCV_INTERRUPTED
)
1527 inf_debug (inf
, "interrupted");
1529 error (_("Couldn't wait for an event: %s"), safe_strerror (err
));
1534 mach_msg_header_t hdr
;
1535 mach_msg_type_t err_type
;
1541 inf_debug (inf
, "event: msgid = %d", msg
.hdr
.msgh_id
);
1543 /* Handle what we got. */
1544 if (!notify_server (&msg
.hdr
, &reply
.hdr
)
1545 && !exc_server (&msg
.hdr
, &reply
.hdr
)
1546 && !process_reply_server (&msg
.hdr
, &reply
.hdr
)
1547 && !msg_reply_server (&msg
.hdr
, &reply
.hdr
))
1548 /* Whatever it is, it's something strange. */
1549 error (_("Got a strange event, msg id = %d."), msg
.hdr
.msgh_id
);
1552 error (_("Handling event, msgid = %d: %s"),
1553 msg
.hdr
.msgh_id
, safe_strerror (reply
.err
));
1556 if (inf
->pending_execs
)
1557 /* We're waiting for the inferior to finish execing. */
1559 struct inf_wait
*w
= &inf
->wait
;
1560 enum target_waitkind kind
= w
->status
.kind
;
1562 if (kind
== TARGET_WAITKIND_SPURIOUS
)
1563 /* Since gdb is actually counting the number of times the inferior
1564 stops, expecting one stop per exec, we only return major events
1568 inf_debug (inf
, "pending_execs, ignoring minor event");
1570 else if (kind
== TARGET_WAITKIND_STOPPED
1571 && w
->status
.value
.sig
== GDB_SIGNAL_TRAP
)
1572 /* Ah hah! A SIGTRAP from the inferior while starting up probably
1573 means we've succesfully completed an exec! */
1575 inf_debug (inf
, "one pending exec completed");
1577 else if (kind
== TARGET_WAITKIND_STOPPED
)
1578 /* It's possible that this signal is because of a crashed process
1579 being handled by the hurd crash server; in this case, the process
1580 will have an extra task suspend, which we need to know about.
1581 Since the code in inf_resume that normally checks for this is
1582 disabled while INF->pending_execs, we do the check here instead. */
1583 inf_validate_task_sc (inf
);
1586 if (inf
->wait
.suppress
)
1587 /* Some totally spurious event happened that we don't consider
1588 worth returning to gdb. Just keep waiting. */
1590 inf_debug (inf
, "suppressing return, rewaiting...");
1595 /* Pass back out our results. */
1596 memcpy (status
, &inf
->wait
.status
, sizeof (*status
));
1598 thread
= inf
->wait
.thread
;
1600 ptid
= ptid_build (inf
->pid
, thread
->tid
, 0);
1601 else if (ptid_equal (ptid
, minus_one_ptid
))
1602 thread
= inf_tid_to_thread (inf
, -1);
1604 thread
= inf_tid_to_thread (inf
, ptid_get_lwp (ptid
));
1606 if (!thread
|| thread
->port
== MACH_PORT_NULL
)
1608 /* TID is dead; try and find a new thread. */
1609 if (inf_update_procs (inf
) && inf
->threads
)
1610 ptid
= ptid_build (inf
->pid
, inf
->threads
->tid
, 0); /* The first
1614 ptid
= inferior_ptid
; /* let wait_for_inferior handle exit case */
1618 && !ptid_equal (ptid
, minus_one_ptid
)
1619 && status
->kind
!= TARGET_WAITKIND_SPURIOUS
1620 && inf
->pause_sc
== 0 && thread
->pause_sc
== 0)
1621 /* If something actually happened to THREAD, make sure we
1625 inf_update_suspends (inf
);
1628 inf_debug (inf
, "returning ptid = %s, status = %s (%d)",
1629 target_pid_to_str (ptid
),
1630 status
->kind
== TARGET_WAITKIND_EXITED
? "EXITED"
1631 : status
->kind
== TARGET_WAITKIND_STOPPED
? "STOPPED"
1632 : status
->kind
== TARGET_WAITKIND_SIGNALLED
? "SIGNALLED"
1633 : status
->kind
== TARGET_WAITKIND_LOADED
? "LOADED"
1634 : status
->kind
== TARGET_WAITKIND_SPURIOUS
? "SPURIOUS"
1636 status
->value
.integer
);
1642 /* The rpc handler called by exc_server. */
1644 S_exception_raise_request (mach_port_t port
, mach_port_t reply_port
,
1645 thread_t thread_port
, task_t task_port
,
1646 int exception
, int code
, int subcode
)
1648 struct inf
*inf
= waiting_inf
;
1649 struct proc
*thread
= inf_port_to_thread (inf
, thread_port
);
1651 inf_debug (waiting_inf
,
1652 "thread = %lu, task = %lu, exc = %d, code = %d, subcode = %d",
1653 thread_port
, task_port
, exception
, code
, subcode
);
1656 /* We don't know about thread? */
1658 inf_update_procs (inf
);
1659 thread
= inf_port_to_thread (inf
, thread_port
);
1661 /* Give up, the generating thread is gone. */
1665 mach_port_deallocate (mach_task_self (), thread_port
);
1666 mach_port_deallocate (mach_task_self (), task_port
);
1668 if (!thread
->aborted
)
1669 /* THREAD hasn't been aborted since this exception happened (abortion
1670 clears any exception state), so it must be real. */
1672 /* Store away the details; this will destroy any previous info. */
1673 inf
->wait
.thread
= thread
;
1675 inf
->wait
.status
.kind
= TARGET_WAITKIND_STOPPED
;
1677 if (exception
== EXC_BREAKPOINT
)
1678 /* GDB likes to get SIGTRAP for breakpoints. */
1680 inf
->wait
.status
.value
.sig
= GDB_SIGNAL_TRAP
;
1681 mach_port_deallocate (mach_task_self (), reply_port
);
1684 /* Record the exception so that we can forward it later. */
1686 if (thread
->exc_port
== port
)
1688 inf_debug (waiting_inf
, "Handler is thread exception port <%lu>",
1689 thread
->saved_exc_port
);
1690 inf
->wait
.exc
.handler
= thread
->saved_exc_port
;
1694 inf_debug (waiting_inf
, "Handler is task exception port <%lu>",
1695 inf
->task
->saved_exc_port
);
1696 inf
->wait
.exc
.handler
= inf
->task
->saved_exc_port
;
1697 gdb_assert (inf
->task
->exc_port
== port
);
1699 if (inf
->wait
.exc
.handler
!= MACH_PORT_NULL
)
1700 /* Add a reference to the exception handler. */
1701 mach_port_mod_refs (mach_task_self (),
1702 inf
->wait
.exc
.handler
, MACH_PORT_RIGHT_SEND
,
1705 inf
->wait
.exc
.exception
= exception
;
1706 inf
->wait
.exc
.code
= code
;
1707 inf
->wait
.exc
.subcode
= subcode
;
1708 inf
->wait
.exc
.reply
= reply_port
;
1710 /* Exceptions are encoded in the signal space by putting
1711 them after _NSIG; this assumes they're positive (and not
1712 extremely large)! */
1713 inf
->wait
.status
.value
.sig
=
1714 gdb_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."),
1735 inf
->wait
.status
.kind
= TARGET_WAITKIND_SIGNALLED
;
1736 inf
->wait
.status
.value
.sig
= GDB_SIGNAL_KILL
;
1739 /* Notify server routines. The only real one is dead name notification. */
1741 do_mach_notify_dead_name (mach_port_t notify
, mach_port_t dead_port
)
1743 struct inf
*inf
= waiting_inf
;
1745 inf_debug (waiting_inf
, "port = %lu", dead_port
);
1747 if (inf
->task
&& inf
->task
->port
== dead_port
)
1749 proc_debug (inf
->task
, "is dead");
1750 inf
->task
->port
= MACH_PORT_NULL
;
1751 if (proc_wait_pid
== inf
->pid
)
1752 /* We have a wait outstanding on the process, which will return more
1753 detailed information, so delay until we get that. */
1754 inf
->wait
.suppress
= 1;
1756 /* We never waited for the process (maybe it wasn't a child), so just
1757 pretend it got a SIGKILL. */
1758 inf_task_died_status (inf
);
1762 struct proc
*thread
= inf_port_to_thread (inf
, dead_port
);
1766 proc_debug (thread
, "is dead");
1767 thread
->port
= MACH_PORT_NULL
;
1770 if (inf
->task
->dead
)
1771 /* Since the task is dead, its threads are dying with it. */
1772 inf
->wait
.suppress
= 1;
1775 mach_port_deallocate (mach_task_self (), dead_port
);
1776 inf
->threads_up_to_date
= 0; /* Just in case. */
1782 #define ILL_RPC(fun, ...) \
1783 extern kern_return_t fun (__VA_ARGS__); \
1784 kern_return_t fun (__VA_ARGS__) \
1786 warning (_("illegal rpc: %s"), #fun); \
1790 ILL_RPC (do_mach_notify_no_senders
,
1791 mach_port_t notify
, mach_port_mscount_t count
)
1792 ILL_RPC (do_mach_notify_port_deleted
,
1793 mach_port_t notify
, mach_port_t name
)
1794 ILL_RPC (do_mach_notify_msg_accepted
,
1795 mach_port_t notify
, mach_port_t name
)
1796 ILL_RPC (do_mach_notify_port_destroyed
,
1797 mach_port_t notify
, mach_port_t name
)
1798 ILL_RPC (do_mach_notify_send_once
,
1801 /* Process_reply server routines. We only use process_wait_reply. */
1804 S_proc_wait_reply (mach_port_t reply
, error_t err
,
1805 int status
, int sigcode
, rusage_t rusage
, pid_t pid
)
1807 struct inf
*inf
= waiting_inf
;
1809 inf_debug (inf
, "err = %s, pid = %d, status = 0x%x, sigcode = %d",
1810 err
? safe_strerror (err
) : "0", pid
, status
, sigcode
);
1812 if (err
&& proc_wait_pid
&& (!inf
->task
|| !inf
->task
->port
))
1813 /* Ack. The task has died, but the task-died notification code didn't
1814 tell anyone because it thought a more detailed reply from the
1815 procserver was forthcoming. However, we now learn that won't
1816 happen... So we have to act like the task just died, and this time,
1818 inf_task_died_status (inf
);
1820 if (--proc_waits_pending
== 0)
1821 /* PROC_WAIT_PID represents the most recent wait. We will always get
1822 replies in order because the proc server is single threaded. */
1825 inf_debug (inf
, "waits pending now: %d", proc_waits_pending
);
1831 warning (_("Can't wait for pid %d: %s"),
1832 inf
->pid
, safe_strerror (err
));
1835 /* Since we can't see the inferior's signals, don't trap them. */
1836 inf_set_traced (inf
, 0);
1839 else if (pid
== inf
->pid
)
1841 store_waitstatus (&inf
->wait
.status
, status
);
1842 if (inf
->wait
.status
.kind
== TARGET_WAITKIND_STOPPED
)
1843 /* The process has sent us a signal, and stopped itself in a sane
1844 state pending our actions. */
1846 inf_debug (inf
, "process has stopped itself");
1851 inf
->wait
.suppress
= 1; /* Something odd happened. Ignore. */
1856 ILL_RPC (S_proc_setmsgport_reply
,
1857 mach_port_t reply_port
, kern_return_t return_code
,
1858 mach_port_t oldmsgport
)
1859 ILL_RPC (S_proc_getmsgport_reply
,
1860 mach_port_t reply_port
, kern_return_t return_code
,
1861 mach_port_t msgports
)
1862 ILL_RPC (S_proc_pid2task_reply
,
1863 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t task
)
1864 ILL_RPC (S_proc_task2pid_reply
,
1865 mach_port_t reply_port
, kern_return_t return_code
, pid_t pid
)
1866 ILL_RPC (S_proc_task2proc_reply
,
1867 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t proc
)
1868 ILL_RPC (S_proc_proc2task_reply
,
1869 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t task
)
1870 ILL_RPC (S_proc_pid2proc_reply
,
1871 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t proc
)
1872 ILL_RPC (S_proc_getprocinfo_reply
,
1873 mach_port_t reply_port
, kern_return_t return_code
,
1874 int flags
, procinfo_t procinfo
, mach_msg_type_number_t procinfoCnt
,
1875 data_t threadwaits
, mach_msg_type_number_t threadwaitsCnt
)
1876 ILL_RPC (S_proc_getprocargs_reply
,
1877 mach_port_t reply_port
, kern_return_t return_code
,
1878 data_t procargs
, mach_msg_type_number_t procargsCnt
)
1879 ILL_RPC (S_proc_getprocenv_reply
,
1880 mach_port_t reply_port
, kern_return_t return_code
,
1881 data_t procenv
, mach_msg_type_number_t procenvCnt
)
1882 ILL_RPC (S_proc_getloginid_reply
,
1883 mach_port_t reply_port
, kern_return_t return_code
, pid_t login_id
)
1884 ILL_RPC (S_proc_getloginpids_reply
,
1885 mach_port_t reply_port
, kern_return_t return_code
,
1886 pidarray_t pids
, mach_msg_type_number_t pidsCnt
)
1887 ILL_RPC (S_proc_getlogin_reply
,
1888 mach_port_t reply_port
, kern_return_t return_code
, string_t logname
)
1889 ILL_RPC (S_proc_getsid_reply
,
1890 mach_port_t reply_port
, kern_return_t return_code
, pid_t sid
)
1891 ILL_RPC (S_proc_getsessionpgids_reply
,
1892 mach_port_t reply_port
, kern_return_t return_code
,
1893 pidarray_t pgidset
, mach_msg_type_number_t pgidsetCnt
)
1894 ILL_RPC (S_proc_getsessionpids_reply
,
1895 mach_port_t reply_port
, kern_return_t return_code
,
1896 pidarray_t pidset
, mach_msg_type_number_t pidsetCnt
)
1897 ILL_RPC (S_proc_getsidport_reply
,
1898 mach_port_t reply_port
, kern_return_t return_code
,
1899 mach_port_t sessport
)
1900 ILL_RPC (S_proc_getpgrp_reply
,
1901 mach_port_t reply_port
, kern_return_t return_code
, pid_t pgrp
)
1902 ILL_RPC (S_proc_getpgrppids_reply
,
1903 mach_port_t reply_port
, kern_return_t return_code
,
1904 pidarray_t pidset
, mach_msg_type_number_t pidsetCnt
)
1905 ILL_RPC (S_proc_get_tty_reply
,
1906 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t tty
)
1907 ILL_RPC (S_proc_getnports_reply
,
1908 mach_port_t reply_port
, kern_return_t return_code
,
1909 mach_msg_type_number_t nports
)
1910 ILL_RPC (S_proc_is_important_reply
,
1911 mach_port_t reply_port
, kern_return_t return_code
,
1912 boolean_t essential
)
1913 ILL_RPC (S_proc_get_code_reply
,
1914 mach_port_t reply_port
, kern_return_t return_code
,
1915 vm_address_t start_code
, vm_address_t end_code
)
1917 /* Msg_reply server routines. We only use msg_sig_post_untraced_reply. */
1920 S_msg_sig_post_untraced_reply (mach_port_t reply
, error_t err
)
1922 struct inf
*inf
= waiting_inf
;
1925 /* EBUSY is what we get when the crash server has grabbed control of the
1926 process and doesn't like what signal we tried to send it. Just act
1927 like the process stopped (using a signal of 0 should mean that the
1928 *next* time the user continues, it will pass signal 0, which the crash
1929 server should like). */
1931 inf
->wait
.status
.kind
= TARGET_WAITKIND_STOPPED
;
1932 inf
->wait
.status
.value
.sig
= GDB_SIGNAL_0
;
1935 warning (_("Signal delivery failed: %s"), safe_strerror (err
));
1938 /* We only get this reply when we've posted a signal to a process which we
1939 thought was stopped, and which we expected to continue after the signal.
1940 Given that the signal has failed for some reason, it's reasonable to
1941 assume it's still stopped. */
1944 inf
->wait
.suppress
= 1;
1949 ILL_RPC (S_msg_sig_post_reply
,
1950 mach_port_t reply
, error_t err
)
1952 /* Returns the number of messages queued for the receive right PORT. */
1953 static mach_port_msgcount_t
1954 port_msgs_queued (mach_port_t port
)
1956 struct mach_port_status status
;
1958 mach_port_get_receive_status (mach_task_self (), port
, &status
);
1963 return status
.mps_msgcount
;
1967 /* Resume execution of the inferior process.
1969 If STEP is nonzero, single-step it.
1970 If SIGNAL is nonzero, give it that signal.
1973 -1 true Single step the current thread allowing other threads to run.
1974 -1 false Continue the current thread allowing other threads to run.
1975 X true Single step the given thread, don't allow any others to run.
1976 X false Continue the given thread, do not allow any others to run.
1977 (Where X, of course, is anything except -1)
1979 Note that a resume may not `take' if there are pending exceptions/&c
1980 still unprocessed from the last resume we did (any given resume may result
1981 in multiple events returned by wait). */
1984 gnu_resume (struct target_ops
*ops
,
1985 ptid_t ptid
, int step
, enum gdb_signal sig
)
1987 struct proc
*step_thread
= 0;
1989 struct inf
*inf
= gnu_current_inf
;
1991 inf_debug (inf
, "ptid = %s, step = %d, sig = %d",
1992 target_pid_to_str (ptid
), step
, sig
);
1994 inf_validate_procinfo (inf
);
1996 if (sig
!= GDB_SIGNAL_0
|| inf
->stopped
)
1998 if (sig
== GDB_SIGNAL_0
&& inf
->nomsg
)
2001 inf_signal (inf
, sig
);
2003 else if (inf
->wait
.exc
.reply
!= MACH_PORT_NULL
)
2004 /* We received an exception to which we have chosen not to forward, so
2005 abort the faulting thread, which will perhaps retake it. */
2007 proc_abort (inf
->wait
.thread
, 1);
2008 warning (_("Aborting %s with unforwarded exception %s."),
2009 proc_string (inf
->wait
.thread
),
2010 gdb_signal_to_name (inf
->wait
.status
.value
.sig
));
2013 if (port_msgs_queued (inf
->event_port
))
2014 /* If there are still messages in our event queue, don't bother resuming
2015 the process, as we're just going to stop it right away anyway. */
2018 inf_update_procs (inf
);
2020 /* A specific PTID means `step only this process id'. */
2021 resume_all
= ptid_equal (ptid
, minus_one_ptid
);
2024 /* Allow all threads to run, except perhaps single-stepping one. */
2026 inf_debug (inf
, "running all threads; tid = %d",
2027 ptid_get_pid (inferior_ptid
));
2028 ptid
= inferior_ptid
; /* What to step. */
2029 inf_set_threads_resume_sc (inf
, 0, 1);
2032 /* Just allow a single thread to run. */
2034 struct proc
*thread
= inf_tid_to_thread (inf
, ptid_get_lwp (ptid
));
2037 error (_("Can't run single thread id %s: no such thread!"),
2038 target_pid_to_str (ptid
));
2039 inf_debug (inf
, "running one thread: %s", target_pid_to_str (ptid
));
2040 inf_set_threads_resume_sc (inf
, thread
, 0);
2045 step_thread
= inf_tid_to_thread (inf
, ptid_get_lwp (ptid
));
2047 warning (_("Can't step thread id %s: no such thread."),
2048 target_pid_to_str (ptid
));
2050 inf_debug (inf
, "stepping thread: %s", target_pid_to_str (ptid
));
2052 if (step_thread
!= inf
->step_thread
)
2053 inf_set_step_thread (inf
, step_thread
);
2055 inf_debug (inf
, "here we go...");
2061 gnu_kill_inferior (struct target_ops
*ops
)
2063 struct proc
*task
= gnu_current_inf
->task
;
2067 proc_debug (task
, "terminating...");
2068 task_terminate (task
->port
);
2069 inf_set_pid (gnu_current_inf
, -1);
2071 target_mourn_inferior ();
2074 /* Clean up after the inferior dies. */
2076 gnu_mourn_inferior (struct target_ops
*ops
)
2078 inf_debug (gnu_current_inf
, "rip");
2079 inf_detach (gnu_current_inf
);
2080 inf_child_mourn_inferior (ops
);
2084 /* Fork an inferior process, and start debugging it. */
2086 /* Set INFERIOR_PID to the first thread available in the child, if any. */
2088 inf_pick_first_thread (void)
2090 if (gnu_current_inf
->task
&& gnu_current_inf
->threads
)
2091 /* The first thread. */
2092 return gnu_current_inf
->threads
->tid
;
2094 /* What may be the next thread. */
2095 return next_thread_id
;
2101 if (!gnu_current_inf
)
2102 gnu_current_inf
= make_inf ();
2103 return gnu_current_inf
;
2107 gnu_create_inferior (struct target_ops
*ops
,
2108 char *exec_file
, char *allargs
, char **env
,
2111 struct inf
*inf
= cur_inf ();
2114 void trace_me (void)
2116 /* We're in the child; make this process stop as soon as it execs. */
2117 inf_debug (inf
, "tracing self");
2118 if (ptrace (PTRACE_TRACEME
) != 0)
2119 error (_("ptrace (PTRACE_TRACEME) failed!"));
2122 inf_debug (inf
, "creating inferior");
2124 pid
= fork_inferior (exec_file
, allargs
, env
, trace_me
,
2125 NULL
, NULL
, NULL
, NULL
);
2127 /* Attach to the now stopped child, which is actually a shell... */
2128 inf_debug (inf
, "attaching to child: %d", pid
);
2130 inf_attach (inf
, pid
);
2134 inf
->pending_execs
= 1;
2138 /* Now let the child run again, knowing that it will stop
2139 immediately because of the ptrace. */
2142 /* We now have thread info. */
2143 thread_change_ptid (inferior_ptid
,
2144 ptid_build (inf
->pid
, inf_pick_first_thread (), 0));
2146 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
2147 inf
->pending_execs
= 0;
2149 inf_validate_procinfo (inf
);
2150 inf_update_signal_thread (inf
);
2151 inf_set_traced (inf
, inf
->want_signals
);
2153 /* Execing the process will have trashed our exception ports; steal them
2154 back (or make sure they're restored if the user wants that). */
2155 if (inf
->want_exceptions
)
2156 inf_steal_exc_ports (inf
);
2158 inf_restore_exc_ports (inf
);
2162 /* Attach to process PID, then initialize for debugging it
2163 and wait for the trace-trap that results from attaching. */
2165 gnu_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
2169 struct inf
*inf
= cur_inf ();
2170 struct inferior
*inferior
;
2172 pid
= parse_pid_to_attach (args
);
2174 if (pid
== getpid ()) /* Trying to masturbate? */
2175 error (_("I refuse to debug myself!"));
2179 exec_file
= (char *) get_exec_file (0);
2182 printf_unfiltered ("Attaching to program `%s', pid %d\n",
2185 printf_unfiltered ("Attaching to pid %d\n", pid
);
2187 gdb_flush (gdb_stdout
);
2190 inf_debug (inf
, "attaching to pid: %d", pid
);
2192 inf_attach (inf
, pid
);
2196 inferior
= current_inferior ();
2197 inferior_appeared (inferior
, pid
);
2198 inferior
->attach_flag
= 1;
2200 inf_update_procs (inf
);
2202 inferior_ptid
= ptid_build (pid
, inf_pick_first_thread (), 0);
2204 /* We have to initialize the terminal settings now, since the code
2205 below might try to restore them. */
2206 target_terminal_init ();
2208 /* If the process was stopped before we attached, make it continue the next
2209 time the user does a continue. */
2210 inf_validate_procinfo (inf
);
2212 inf_update_signal_thread (inf
);
2213 inf_set_traced (inf
, inf
->want_signals
);
2215 #if 0 /* Do we need this? */
2216 renumber_threads (0); /* Give our threads reasonable names. */
2221 /* Take a program previously attached to and detaches it.
2222 The program resumes execution and will no longer stop
2223 on signals, etc. We'd better not have left any breakpoints
2224 in the program or it'll die when it hits one. For this
2225 to work, it may be necessary for the process to have been
2226 previously attached. It *might* work if the program was
2227 started via fork. */
2229 gnu_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
2235 char *exec_file
= get_exec_file (0);
2238 printf_unfiltered ("Detaching from program `%s' pid %d\n",
2239 exec_file
, gnu_current_inf
->pid
);
2241 printf_unfiltered ("Detaching from pid %d\n", gnu_current_inf
->pid
);
2242 gdb_flush (gdb_stdout
);
2245 pid
= gnu_current_inf
->pid
;
2247 inf_detach (gnu_current_inf
);
2249 inferior_ptid
= null_ptid
;
2250 detach_inferior (pid
);
2252 inf_child_maybe_unpush_target (ops
);
2256 gnu_terminal_init (struct target_ops
*self
)
2258 gdb_assert (gnu_current_inf
);
2259 child_terminal_init_with_pgrp (gnu_current_inf
->pid
);
2263 gnu_stop (struct target_ops
*self
, ptid_t ptid
)
2265 error (_("to_stop target function not implemented"));
2269 gnu_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2271 inf_update_procs (gnu_current_inf
);
2272 return !!inf_tid_to_thread (gnu_current_inf
,
2273 ptid_get_lwp (ptid
));
2277 /* Read inferior task's LEN bytes from ADDR and copy it to MYADDR in
2278 gdb's address space. Return 0 on failure; number of bytes read
2281 gnu_read_inferior (task_t task
, CORE_ADDR addr
, gdb_byte
*myaddr
, int length
)
2284 vm_address_t low_address
= (vm_address_t
) trunc_page (addr
);
2285 vm_size_t aligned_length
=
2286 (vm_size_t
) round_page (addr
+ length
) - low_address
;
2288 mach_msg_type_number_t copy_count
;
2290 /* Get memory from inferior with page aligned addresses. */
2291 err
= vm_read (task
, low_address
, aligned_length
, &copied
, ©_count
);
2295 err
= hurd_safe_copyin (myaddr
, (void *) (addr
- low_address
+ copied
),
2299 warning (_("Read from inferior faulted: %s"), safe_strerror (err
));
2303 err
= vm_deallocate (mach_task_self (), copied
, copy_count
);
2305 warning (_("gnu_read_inferior vm_deallocate failed: %s"),
2306 safe_strerror (err
));
2311 #define CHK_GOTO_OUT(str,ret) \
2312 do if (ret != KERN_SUCCESS) { errstr = #str; goto out; } while(0)
2314 struct vm_region_list
2316 struct vm_region_list
*next
;
2317 vm_prot_t protection
;
2322 struct obstack region_obstack
;
2324 /* Write gdb's LEN bytes from MYADDR and copy it to ADDR in inferior
2325 task's address space. */
2327 gnu_write_inferior (task_t task
, CORE_ADDR addr
,
2328 const gdb_byte
*myaddr
, int length
)
2331 vm_address_t low_address
= (vm_address_t
) trunc_page (addr
);
2332 vm_size_t aligned_length
=
2333 (vm_size_t
) round_page (addr
+ length
) - low_address
;
2335 mach_msg_type_number_t copy_count
;
2338 char *errstr
= "Bug in gnu_write_inferior";
2340 struct vm_region_list
*region_element
;
2341 struct vm_region_list
*region_head
= (struct vm_region_list
*) NULL
;
2343 /* Get memory from inferior with page aligned addresses. */
2344 err
= vm_read (task
,
2349 CHK_GOTO_OUT ("gnu_write_inferior vm_read failed", err
);
2353 err
= hurd_safe_copyout ((void *) (addr
- low_address
+ copied
),
2355 CHK_GOTO_OUT ("Write to inferior faulted", err
);
2357 obstack_init (®ion_obstack
);
2359 /* Do writes atomically.
2360 First check for holes and unwritable memory. */
2362 vm_size_t remaining_length
= aligned_length
;
2363 vm_address_t region_address
= low_address
;
2365 struct vm_region_list
*scan
;
2367 while (region_address
< low_address
+ aligned_length
)
2369 vm_prot_t protection
;
2370 vm_prot_t max_protection
;
2371 vm_inherit_t inheritance
;
2373 mach_port_t object_name
;
2375 vm_size_t region_length
= remaining_length
;
2376 vm_address_t old_address
= region_address
;
2378 err
= vm_region (task
,
2387 CHK_GOTO_OUT ("vm_region failed", err
);
2389 /* Check for holes in memory. */
2390 if (old_address
!= region_address
)
2392 warning (_("No memory at 0x%lx. Nothing written"),
2399 if (!(max_protection
& VM_PROT_WRITE
))
2401 warning (_("Memory at address 0x%lx is unwritable. "
2409 /* Chain the regions for later use. */
2411 (struct vm_region_list
*)
2412 obstack_alloc (®ion_obstack
, sizeof (struct vm_region_list
));
2414 region_element
->protection
= protection
;
2415 region_element
->start
= region_address
;
2416 region_element
->length
= region_length
;
2418 /* Chain the regions along with protections. */
2419 region_element
->next
= region_head
;
2420 region_head
= region_element
;
2422 region_address
+= region_length
;
2423 remaining_length
= remaining_length
- region_length
;
2426 /* If things fail after this, we give up.
2427 Somebody is messing up inferior_task's mappings. */
2429 /* Enable writes to the chained vm regions. */
2430 for (scan
= region_head
; scan
; scan
= scan
->next
)
2432 if (!(scan
->protection
& VM_PROT_WRITE
))
2434 err
= vm_protect (task
,
2438 scan
->protection
| VM_PROT_WRITE
);
2439 CHK_GOTO_OUT ("vm_protect: enable write failed", err
);
2443 err
= vm_write (task
,
2447 CHK_GOTO_OUT ("vm_write failed", err
);
2449 /* Set up the original region protections, if they were changed. */
2450 for (scan
= region_head
; scan
; scan
= scan
->next
)
2452 if (!(scan
->protection
& VM_PROT_WRITE
))
2454 err
= vm_protect (task
,
2459 CHK_GOTO_OUT ("vm_protect: enable write failed", err
);
2467 obstack_free (®ion_obstack
, 0);
2469 (void) vm_deallocate (mach_task_self (),
2474 if (err
!= KERN_SUCCESS
)
2476 warning (_("%s: %s"), errstr
, mach_error_string (err
));
2485 /* Implement the to_xfer_partial target_ops method for
2486 TARGET_OBJECT_MEMORY. */
2488 static enum target_xfer_status
2489 gnu_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2490 CORE_ADDR memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2492 task_t task
= (gnu_current_inf
2493 ? (gnu_current_inf
->task
2494 ? gnu_current_inf
->task
->port
: 0)
2498 if (task
== MACH_PORT_NULL
)
2499 return TARGET_XFER_E_IO
;
2501 if (writebuf
!= NULL
)
2503 inf_debug (gnu_current_inf
, "writing %s[%s] <-- %s",
2504 paddress (target_gdbarch (), memaddr
), pulongest (len
),
2505 host_address_to_string (writebuf
));
2506 res
= gnu_write_inferior (task
, memaddr
, writebuf
, len
);
2510 inf_debug (gnu_current_inf
, "reading %s[%s] --> %s",
2511 paddress (target_gdbarch (), memaddr
), pulongest (len
),
2512 host_address_to_string (readbuf
));
2513 res
= gnu_read_inferior (task
, memaddr
, readbuf
, len
);
2515 gdb_assert (res
>= 0);
2517 return TARGET_XFER_E_IO
;
2520 *xfered_len
= (ULONGEST
) res
;
2521 return TARGET_XFER_OK
;
2525 /* Target to_xfer_partial implementation. */
2527 static enum target_xfer_status
2528 gnu_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2529 const char *annex
, gdb_byte
*readbuf
,
2530 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
2531 ULONGEST
*xfered_len
)
2535 case TARGET_OBJECT_MEMORY
:
2536 return gnu_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2538 return TARGET_XFER_E_IO
;
2542 /* Call FUNC on each memory region in the task. */
2544 gnu_find_memory_regions (struct target_ops
*self
,
2545 find_memory_region_ftype func
, void *data
)
2549 vm_address_t region_address
, last_region_address
, last_region_end
;
2550 vm_prot_t last_protection
;
2552 if (gnu_current_inf
== 0 || gnu_current_inf
->task
== 0)
2554 task
= gnu_current_inf
->task
->port
;
2555 if (task
== MACH_PORT_NULL
)
2558 region_address
= last_region_address
= last_region_end
= VM_MIN_ADDRESS
;
2559 last_protection
= VM_PROT_NONE
;
2560 while (region_address
< VM_MAX_ADDRESS
)
2562 vm_prot_t protection
;
2563 vm_prot_t max_protection
;
2564 vm_inherit_t inheritance
;
2566 mach_port_t object_name
;
2568 vm_size_t region_length
= VM_MAX_ADDRESS
- region_address
;
2569 vm_address_t old_address
= region_address
;
2571 err
= vm_region (task
,
2580 if (err
== KERN_NO_SPACE
)
2582 if (err
!= KERN_SUCCESS
)
2584 warning (_("vm_region failed: %s"), mach_error_string (err
));
2588 if (protection
== last_protection
&& region_address
== last_region_end
)
2589 /* This region is contiguous with and indistinguishable from
2590 the previous one, so we just extend that one. */
2591 last_region_end
= region_address
+= region_length
;
2594 /* This region is distinct from the last one we saw, so report
2595 that previous one. */
2596 if (last_protection
!= VM_PROT_NONE
)
2597 (*func
) (last_region_address
,
2598 last_region_end
- last_region_address
,
2599 last_protection
& VM_PROT_READ
,
2600 last_protection
& VM_PROT_WRITE
,
2601 last_protection
& VM_PROT_EXECUTE
,
2602 1, /* MODIFIED is unknown, pass it as true. */
2604 last_region_address
= region_address
;
2605 last_region_end
= region_address
+= region_length
;
2606 last_protection
= protection
;
2610 /* Report the final region. */
2611 if (last_region_end
> last_region_address
&& last_protection
!= VM_PROT_NONE
)
2612 (*func
) (last_region_address
, last_region_end
- last_region_address
,
2613 last_protection
& VM_PROT_READ
,
2614 last_protection
& VM_PROT_WRITE
,
2615 last_protection
& VM_PROT_EXECUTE
,
2616 1, /* MODIFIED is unknown, pass it as true. */
2623 /* Return printable description of proc. */
2625 proc_string (struct proc
*proc
)
2627 static char tid_str
[80];
2629 if (proc_is_task (proc
))
2630 xsnprintf (tid_str
, sizeof (tid_str
), "process %d", proc
->inf
->pid
);
2632 xsnprintf (tid_str
, sizeof (tid_str
), "Thread %d.%d",
2633 proc
->inf
->pid
, proc
->tid
);
2638 gnu_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2640 struct inf
*inf
= gnu_current_inf
;
2641 int tid
= ptid_get_lwp (ptid
);
2642 struct proc
*thread
= inf_tid_to_thread (inf
, tid
);
2645 return proc_string (thread
);
2648 static char tid_str
[80];
2650 xsnprintf (tid_str
, sizeof (tid_str
), "bogus thread id %d", tid
);
2656 /* Create a prototype generic GNU/Hurd target. The client can
2657 override it with local methods. */
2662 struct target_ops
*t
= inf_child_target ();
2664 t
->to_attach
= gnu_attach
;
2665 t
->to_attach_no_wait
= 1;
2666 t
->to_detach
= gnu_detach
;
2667 t
->to_resume
= gnu_resume
;
2668 t
->to_wait
= gnu_wait
;
2669 t
->to_xfer_partial
= gnu_xfer_partial
;
2670 t
->to_find_memory_regions
= gnu_find_memory_regions
;
2671 t
->to_terminal_init
= gnu_terminal_init
;
2672 t
->to_kill
= gnu_kill_inferior
;
2673 t
->to_create_inferior
= gnu_create_inferior
;
2674 t
->to_mourn_inferior
= gnu_mourn_inferior
;
2675 t
->to_thread_alive
= gnu_thread_alive
;
2676 t
->to_pid_to_str
= gnu_pid_to_str
;
2677 t
->to_stop
= gnu_stop
;
2683 /* User task commands. */
2685 static struct cmd_list_element
*set_task_cmd_list
= 0;
2686 static struct cmd_list_element
*show_task_cmd_list
= 0;
2687 /* User thread commands. */
2689 /* Commands with a prefix of `set/show thread'. */
2690 extern struct cmd_list_element
*thread_cmd_list
;
2691 struct cmd_list_element
*set_thread_cmd_list
= NULL
;
2692 struct cmd_list_element
*show_thread_cmd_list
= NULL
;
2694 /* Commands with a prefix of `set/show thread default'. */
2695 struct cmd_list_element
*set_thread_default_cmd_list
= NULL
;
2696 struct cmd_list_element
*show_thread_default_cmd_list
= NULL
;
2699 set_thread_cmd (char *args
, int from_tty
)
2701 printf_unfiltered ("\"set thread\" must be followed by the "
2702 "name of a thread property, or \"default\".\n");
2706 show_thread_cmd (char *args
, int from_tty
)
2708 printf_unfiltered ("\"show thread\" must be followed by the "
2709 "name of a thread property, or \"default\".\n");
2713 set_thread_default_cmd (char *args
, int from_tty
)
2715 printf_unfiltered ("\"set thread default\" must be followed "
2716 "by the name of a thread property.\n");
2720 show_thread_default_cmd (char *args
, int from_tty
)
2722 printf_unfiltered ("\"show thread default\" must be followed "
2723 "by the name of a thread property.\n");
2727 parse_int_arg (char *args
, char *cmd_prefix
)
2732 int val
= strtoul (args
, &arg_end
, 10);
2734 if (*args
&& *arg_end
== '\0')
2737 error (_("Illegal argument for \"%s\" command, should be an integer."),
2742 _parse_bool_arg (char *args
, char *t_val
, char *f_val
, char *cmd_prefix
)
2744 if (!args
|| strcmp (args
, t_val
) == 0)
2746 else if (strcmp (args
, f_val
) == 0)
2749 error (_("Illegal argument for \"%s\" command, "
2750 "should be \"%s\" or \"%s\"."),
2751 cmd_prefix
, t_val
, f_val
);
2754 #define parse_bool_arg(args, cmd_prefix) \
2755 _parse_bool_arg (args, "on", "off", cmd_prefix)
2758 check_empty (char *args
, char *cmd_prefix
)
2761 error (_("Garbage after \"%s\" command: `%s'"), cmd_prefix
, args
);
2764 /* Returns the alive thread named by INFERIOR_PID, or signals an error. */
2765 static struct proc
*
2768 struct inf
*inf
= cur_inf ();
2769 struct proc
*thread
= inf_tid_to_thread (inf
,
2770 ptid_get_lwp (inferior_ptid
));
2772 error (_("No current thread."));
2776 /* Returns the current inferior, but signals an error if it has no task. */
2780 struct inf
*inf
= cur_inf ();
2783 error (_("No current process."));
2789 set_task_pause_cmd (char *args
, int from_tty
)
2791 struct inf
*inf
= cur_inf ();
2792 int old_sc
= inf
->pause_sc
;
2794 inf
->pause_sc
= parse_bool_arg (args
, "set task pause");
2796 if (old_sc
== 0 && inf
->pause_sc
!= 0)
2797 /* If the task is currently unsuspended, immediately suspend it,
2798 otherwise wait until the next time it gets control. */
2803 show_task_pause_cmd (char *args
, int from_tty
)
2805 struct inf
*inf
= cur_inf ();
2807 check_empty (args
, "show task pause");
2808 printf_unfiltered ("The inferior task %s suspended while gdb has control.\n",
2810 ? (inf
->pause_sc
== 0 ? "isn't" : "is")
2811 : (inf
->pause_sc
== 0 ? "won't be" : "will be"));
2815 set_task_detach_sc_cmd (char *args
, int from_tty
)
2817 cur_inf ()->detach_sc
= parse_int_arg (args
,
2818 "set task detach-suspend-count");
2822 show_task_detach_sc_cmd (char *args
, int from_tty
)
2824 check_empty (args
, "show task detach-suspend-count");
2825 printf_unfiltered ("The inferior task will be left with a "
2826 "suspend count of %d when detaching.\n",
2827 cur_inf ()->detach_sc
);
2832 set_thread_default_pause_cmd (char *args
, int from_tty
)
2834 struct inf
*inf
= cur_inf ();
2836 inf
->default_thread_pause_sc
=
2837 parse_bool_arg (args
, "set thread default pause") ? 0 : 1;
2841 show_thread_default_pause_cmd (char *args
, int from_tty
)
2843 struct inf
*inf
= cur_inf ();
2844 int sc
= inf
->default_thread_pause_sc
;
2846 check_empty (args
, "show thread default pause");
2847 printf_unfiltered ("New threads %s suspended while gdb has control%s.\n",
2848 sc
? "are" : "aren't",
2849 !sc
&& inf
->pause_sc
? " (but the task is)" : "");
2853 set_thread_default_run_cmd (char *args
, int from_tty
)
2855 struct inf
*inf
= cur_inf ();
2857 inf
->default_thread_run_sc
=
2858 parse_bool_arg (args
, "set thread default run") ? 0 : 1;
2862 show_thread_default_run_cmd (char *args
, int from_tty
)
2864 struct inf
*inf
= cur_inf ();
2866 check_empty (args
, "show thread default run");
2867 printf_unfiltered ("New threads %s allowed to run.\n",
2868 inf
->default_thread_run_sc
== 0 ? "are" : "aren't");
2872 set_thread_default_detach_sc_cmd (char *args
, int from_tty
)
2874 cur_inf ()->default_thread_detach_sc
=
2875 parse_int_arg (args
, "set thread default detach-suspend-count");
2879 show_thread_default_detach_sc_cmd (char *args
, int from_tty
)
2881 check_empty (args
, "show thread default detach-suspend-count");
2882 printf_unfiltered ("New threads will get a detach-suspend-count of %d.\n",
2883 cur_inf ()->default_thread_detach_sc
);
2887 /* Steal a send right called NAME in the inferior task, and make it PROC's
2888 saved exception port. */
2890 steal_exc_port (struct proc
*proc
, mach_port_t name
)
2894 mach_msg_type_name_t port_type
;
2896 if (!proc
|| !proc
->inf
->task
)
2897 error (_("No inferior task."));
2899 err
= mach_port_extract_right (proc
->inf
->task
->port
,
2900 name
, MACH_MSG_TYPE_COPY_SEND
,
2903 error (_("Couldn't extract send right %lu from inferior: %s"),
2904 name
, safe_strerror (err
));
2906 if (proc
->saved_exc_port
)
2907 /* Get rid of our reference to the old one. */
2908 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
2910 proc
->saved_exc_port
= port
;
2912 if (!proc
->exc_port
)
2913 /* If PROC is a thread, we may not have set its exception port
2914 before. We can't use proc_steal_exc_port because it also sets
2917 proc
->exc_port
= proc
->inf
->event_port
;
2918 err
= proc_set_exception_port (proc
, proc
->exc_port
);
2919 error (_("Can't set exception port for %s: %s"),
2920 proc_string (proc
), safe_strerror (err
));
2925 set_task_exc_port_cmd (char *args
, int from_tty
)
2927 struct inf
*inf
= cur_inf ();
2930 error (_("No argument to \"set task exception-port\" command."));
2931 steal_exc_port (inf
->task
, parse_and_eval_address (args
));
2935 set_stopped_cmd (char *args
, int from_tty
)
2937 cur_inf ()->stopped
= _parse_bool_arg (args
, "yes", "no", "set stopped");
2941 show_stopped_cmd (char *args
, int from_tty
)
2943 struct inf
*inf
= active_inf ();
2945 check_empty (args
, "show stopped");
2946 printf_unfiltered ("The inferior process %s stopped.\n",
2947 inf
->stopped
? "is" : "isn't");
2951 set_sig_thread_cmd (char *args
, int from_tty
)
2953 struct inf
*inf
= cur_inf ();
2955 if (!args
|| (!isdigit (*args
) && strcmp (args
, "none") != 0))
2956 error (_("Illegal argument to \"set signal-thread\" command.\n"
2957 "Should be an integer thread ID, or `none'."));
2959 if (strcmp (args
, "none") == 0)
2960 inf
->signal_thread
= 0;
2963 ptid_t ptid
= thread_id_to_pid (atoi (args
));
2965 if (ptid_equal (ptid
, minus_one_ptid
))
2966 error (_("Thread ID %s not known. "
2967 "Use the \"info threads\" command to\n"
2968 "see the IDs of currently known threads."), args
);
2969 inf
->signal_thread
= inf_tid_to_thread (inf
, ptid_get_lwp (ptid
));
2974 show_sig_thread_cmd (char *args
, int from_tty
)
2976 struct inf
*inf
= active_inf ();
2978 check_empty (args
, "show signal-thread");
2979 if (inf
->signal_thread
)
2980 printf_unfiltered ("The signal thread is %s.\n",
2981 proc_string (inf
->signal_thread
));
2983 printf_unfiltered ("There is no signal thread.\n");
2988 set_signals_cmd (char *args
, int from_tty
)
2990 struct inf
*inf
= cur_inf ();
2992 inf
->want_signals
= parse_bool_arg (args
, "set signals");
2994 if (inf
->task
&& inf
->want_signals
!= inf
->traced
)
2995 /* Make this take effect immediately in a running process. */
2996 inf_set_traced (inf
, inf
->want_signals
);
3000 show_signals_cmd (char *args
, int from_tty
)
3002 struct inf
*inf
= cur_inf ();
3004 check_empty (args
, "show signals");
3005 printf_unfiltered ("The inferior process's signals %s intercepted.\n",
3007 ? (inf
->traced
? "are" : "aren't")
3008 : (inf
->want_signals
? "will be" : "won't be"));
3012 set_exceptions_cmd (char *args
, int from_tty
)
3014 struct inf
*inf
= cur_inf ();
3015 int val
= parse_bool_arg (args
, "set exceptions");
3017 /* Make this take effect immediately in a running process. */
3020 inf
->want_exceptions
= val
;
3024 show_exceptions_cmd (char *args
, int from_tty
)
3026 struct inf
*inf
= cur_inf ();
3028 check_empty (args
, "show exceptions");
3029 printf_unfiltered ("Exceptions in the inferior %s trapped.\n",
3031 ? (inf
->want_exceptions
? "are" : "aren't")
3032 : (inf
->want_exceptions
? "will be" : "won't be"));
3037 set_task_cmd (char *args
, int from_tty
)
3039 printf_unfiltered ("\"set task\" must be followed by the name"
3040 " of a task property.\n");
3044 show_task_cmd (char *args
, int from_tty
)
3046 struct inf
*inf
= cur_inf ();
3048 check_empty (args
, "show task");
3050 show_signals_cmd (0, from_tty
);
3051 show_exceptions_cmd (0, from_tty
);
3052 show_task_pause_cmd (0, from_tty
);
3054 if (inf
->pause_sc
== 0)
3055 show_thread_default_pause_cmd (0, from_tty
);
3056 show_thread_default_run_cmd (0, from_tty
);
3060 show_stopped_cmd (0, from_tty
);
3061 show_sig_thread_cmd (0, from_tty
);
3064 if (inf
->detach_sc
!= 0)
3065 show_task_detach_sc_cmd (0, from_tty
);
3066 if (inf
->default_thread_detach_sc
!= 0)
3067 show_thread_default_detach_sc_cmd (0, from_tty
);
3072 set_noninvasive_cmd (char *args
, int from_tty
)
3074 /* Invert the sense of the arg for each component. */
3075 char *inv_args
= parse_bool_arg (args
, "set noninvasive") ? "off" : "on";
3077 set_task_pause_cmd (inv_args
, from_tty
);
3078 set_signals_cmd (inv_args
, from_tty
);
3079 set_exceptions_cmd (inv_args
, from_tty
);
3084 info_port_rights (const char *args
, mach_port_type_t only
)
3086 struct inf
*inf
= active_inf ();
3087 struct value
*vmark
= value_mark ();
3090 /* Explicit list of port rights. */
3094 struct value
*val
= parse_to_comma_and_eval (&args
);
3095 long right
= value_as_long (val
);
3097 print_port_info (right
, 0, inf
->task
->port
, PORTINFO_DETAILS
,
3101 error (_("%ld: %s."), right
, safe_strerror (err
));
3105 /* Print all of them. */
3108 print_task_ports_info (inf
->task
->port
, only
, PORTINFO_DETAILS
,
3111 error (_("%s."), safe_strerror (err
));
3114 value_free_to_mark (vmark
);
3118 info_send_rights_cmd (char *args
, int from_tty
)
3120 info_port_rights (args
, MACH_PORT_TYPE_SEND
);
3124 info_recv_rights_cmd (char *args
, int from_tty
)
3126 info_port_rights (args
, MACH_PORT_TYPE_RECEIVE
);
3130 info_port_sets_cmd (char *args
, int from_tty
)
3132 info_port_rights (args
, MACH_PORT_TYPE_PORT_SET
);
3136 info_dead_names_cmd (char *args
, int from_tty
)
3138 info_port_rights (args
, MACH_PORT_TYPE_DEAD_NAME
);
3142 info_port_rights_cmd (char *args
, int from_tty
)
3144 info_port_rights (args
, ~0);
3149 add_task_commands (void)
3151 add_cmd ("pause", class_run
, set_thread_default_pause_cmd
, _("\
3152 Set whether the new threads are suspended while gdb has control.\n\
3153 This property normally has no effect because the whole task is\n\
3154 suspended, however, that may be disabled with \"set task pause off\".\n\
3155 The default value is \"off\"."),
3156 &set_thread_default_cmd_list
);
3157 add_cmd ("pause", no_class
, show_thread_default_pause_cmd
, _("\
3158 Show whether new threads are suspended while gdb has control."),
3159 &show_thread_default_cmd_list
);
3161 add_cmd ("run", class_run
, set_thread_default_run_cmd
, _("\
3162 Set whether new threads are allowed to run (once gdb has noticed them)."),
3163 &set_thread_default_cmd_list
);
3164 add_cmd ("run", no_class
, show_thread_default_run_cmd
, _("\
3165 Show whether new threads are allowed to run (once gdb has noticed them)."),
3166 &show_thread_default_cmd_list
);
3168 add_cmd ("detach-suspend-count", class_run
, set_thread_default_detach_sc_cmd
,
3169 _("Set the default detach-suspend-count value for new threads."),
3170 &set_thread_default_cmd_list
);
3171 add_cmd ("detach-suspend-count", no_class
, show_thread_default_detach_sc_cmd
,
3172 _("Show the default detach-suspend-count value for new threads."),
3173 &show_thread_default_cmd_list
);
3175 add_cmd ("signals", class_run
, set_signals_cmd
, _("\
3176 Set whether the inferior process's signals will be intercepted.\n\
3177 Mach exceptions (such as breakpoint traps) are not affected."),
3179 add_alias_cmd ("sigs", "signals", class_run
, 1, &setlist
);
3180 add_cmd ("signals", no_class
, show_signals_cmd
, _("\
3181 Show whether the inferior process's signals will be intercepted."),
3183 add_alias_cmd ("sigs", "signals", no_class
, 1, &showlist
);
3185 add_cmd ("signal-thread", class_run
, set_sig_thread_cmd
, _("\
3186 Set the thread that gdb thinks is the libc signal thread.\n\
3187 This thread is run when delivering a signal to a non-stopped process."),
3189 add_alias_cmd ("sigthread", "signal-thread", class_run
, 1, &setlist
);
3190 add_cmd ("signal-thread", no_class
, show_sig_thread_cmd
, _("\
3191 Set the thread that gdb thinks is the libc signal thread."),
3193 add_alias_cmd ("sigthread", "signal-thread", no_class
, 1, &showlist
);
3195 add_cmd ("stopped", class_run
, set_stopped_cmd
, _("\
3196 Set whether gdb thinks the inferior process is stopped as with SIGSTOP.\n\
3197 Stopped process will be continued by sending them a signal."),
3199 add_cmd ("stopped", no_class
, show_stopped_cmd
, _("\
3200 Show whether gdb thinks the inferior process is stopped as with SIGSTOP."),
3203 add_cmd ("exceptions", class_run
, set_exceptions_cmd
, _("\
3204 Set whether exceptions in the inferior process will be trapped.\n\
3205 When exceptions are turned off, neither breakpoints nor single-stepping\n\
3208 /* Allow `set exc' despite conflict with `set exception-port'. */
3209 add_alias_cmd ("exc", "exceptions", class_run
, 1, &setlist
);
3210 add_cmd ("exceptions", no_class
, show_exceptions_cmd
, _("\
3211 Show whether exceptions in the inferior process will be trapped."),
3214 add_prefix_cmd ("task", no_class
, set_task_cmd
,
3215 _("Command prefix for setting task attributes."),
3216 &set_task_cmd_list
, "set task ", 0, &setlist
);
3217 add_prefix_cmd ("task", no_class
, show_task_cmd
,
3218 _("Command prefix for showing task attributes."),
3219 &show_task_cmd_list
, "show task ", 0, &showlist
);
3221 add_cmd ("pause", class_run
, set_task_pause_cmd
, _("\
3222 Set whether the task is suspended while gdb has control.\n\
3223 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3224 until the next time the program is continued.\n\
3225 When setting this to \"off\", \"set thread default pause on\" can be\n\
3226 used to pause individual threads by default instead."),
3227 &set_task_cmd_list
);
3228 add_cmd ("pause", no_class
, show_task_pause_cmd
,
3229 _("Show whether the task is suspended while gdb has control."),
3230 &show_task_cmd_list
);
3232 add_cmd ("detach-suspend-count", class_run
, set_task_detach_sc_cmd
,
3233 _("Set the suspend count will leave on the thread when detaching."),
3234 &set_task_cmd_list
);
3235 add_cmd ("detach-suspend-count", no_class
, show_task_detach_sc_cmd
,
3236 _("Show the suspend count will leave "
3237 "on the thread when detaching."),
3238 &show_task_cmd_list
);
3240 add_cmd ("exception-port", no_class
, set_task_exc_port_cmd
, _("\
3241 Set the task exception port to which we forward exceptions.\n\
3242 The argument should be the value of the send right in the task."),
3243 &set_task_cmd_list
);
3244 add_alias_cmd ("excp", "exception-port", no_class
, 1, &set_task_cmd_list
);
3245 add_alias_cmd ("exc-port", "exception-port", no_class
, 1,
3246 &set_task_cmd_list
);
3248 /* A convenient way of turning on all options require to noninvasively
3249 debug running tasks. */
3250 add_cmd ("noninvasive", no_class
, set_noninvasive_cmd
, _("\
3251 Set task options so that we interfere as little as possible.\n\
3252 This is the same as setting `task pause', `exceptions', and\n\
3253 `signals' to the opposite value."),
3256 /* Commands to show information about the task's ports. */
3257 add_cmd ("send-rights", class_info
, info_send_rights_cmd
,
3258 _("Show information about the task's send rights"),
3260 add_cmd ("receive-rights", class_info
, info_recv_rights_cmd
,
3261 _("Show information about the task's receive rights"),
3263 add_cmd ("port-rights", class_info
, info_port_rights_cmd
,
3264 _("Show information about the task's port rights"),
3266 add_cmd ("port-sets", class_info
, info_port_sets_cmd
,
3267 _("Show information about the task's port sets"),
3269 add_cmd ("dead-names", class_info
, info_dead_names_cmd
,
3270 _("Show information about the task's dead names"),
3272 add_info_alias ("ports", "port-rights", 1);
3273 add_info_alias ("port", "port-rights", 1);
3274 add_info_alias ("psets", "port-sets", 1);
3279 set_thread_pause_cmd (char *args
, int from_tty
)
3281 struct proc
*thread
= cur_thread ();
3282 int old_sc
= thread
->pause_sc
;
3284 thread
->pause_sc
= parse_bool_arg (args
, "set thread pause");
3285 if (old_sc
== 0 && thread
->pause_sc
!= 0 && thread
->inf
->pause_sc
== 0)
3286 /* If the task is currently unsuspended, immediately suspend it,
3287 otherwise wait until the next time it gets control. */
3288 inf_suspend (thread
->inf
);
3292 show_thread_pause_cmd (char *args
, int from_tty
)
3294 struct proc
*thread
= cur_thread ();
3295 int sc
= thread
->pause_sc
;
3297 check_empty (args
, "show task pause");
3298 printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n",
3299 proc_string (thread
),
3300 sc
? "is" : "isn't",
3301 !sc
&& thread
->inf
->pause_sc
? " (but the task is)" : "");
3305 set_thread_run_cmd (char *args
, int from_tty
)
3307 struct proc
*thread
= cur_thread ();
3309 thread
->run_sc
= parse_bool_arg (args
, "set thread run") ? 0 : 1;
3313 show_thread_run_cmd (char *args
, int from_tty
)
3315 struct proc
*thread
= cur_thread ();
3317 check_empty (args
, "show thread run");
3318 printf_unfiltered ("Thread %s %s allowed to run.",
3319 proc_string (thread
),
3320 thread
->run_sc
== 0 ? "is" : "isn't");
3324 set_thread_detach_sc_cmd (char *args
, int from_tty
)
3326 cur_thread ()->detach_sc
= parse_int_arg (args
,
3327 "set thread detach-suspend-count");
3331 show_thread_detach_sc_cmd (char *args
, int from_tty
)
3333 struct proc
*thread
= cur_thread ();
3335 check_empty (args
, "show thread detach-suspend-count");
3336 printf_unfiltered ("Thread %s will be left with a suspend count"
3337 " of %d when detaching.\n",
3338 proc_string (thread
),
3343 set_thread_exc_port_cmd (char *args
, int from_tty
)
3345 struct proc
*thread
= cur_thread ();
3348 error (_("No argument to \"set thread exception-port\" command."));
3349 steal_exc_port (thread
, parse_and_eval_address (args
));
3354 show_thread_cmd (char *args
, int from_tty
)
3356 struct proc
*thread
= cur_thread ();
3358 check_empty (args
, "show thread");
3359 show_thread_run_cmd (0, from_tty
);
3360 show_thread_pause_cmd (0, from_tty
);
3361 if (thread
->detach_sc
!= 0)
3362 show_thread_detach_sc_cmd (0, from_tty
);
3367 thread_takeover_sc_cmd (char *args
, int from_tty
)
3369 struct proc
*thread
= cur_thread ();
3371 thread_basic_info_data_t _info
;
3372 thread_basic_info_t info
= &_info
;
3373 mach_msg_type_number_t info_len
= THREAD_BASIC_INFO_COUNT
;
3375 thread_info (thread
->port
, THREAD_BASIC_INFO
, (int *) &info
, &info_len
);
3377 error (("%s."), safe_strerror (err
));
3378 thread
->sc
= info
->suspend_count
;
3380 printf_unfiltered ("Suspend count was %d.\n", thread
->sc
);
3382 vm_deallocate (mach_task_self (), (vm_address_t
) info
,
3383 info_len
* sizeof (int));
3388 add_thread_commands (void)
3390 add_prefix_cmd ("thread", no_class
, set_thread_cmd
,
3391 _("Command prefix for setting thread properties."),
3392 &set_thread_cmd_list
, "set thread ", 0, &setlist
);
3393 add_prefix_cmd ("default", no_class
, show_thread_cmd
,
3394 _("Command prefix for setting default thread properties."),
3395 &set_thread_default_cmd_list
, "set thread default ", 0,
3396 &set_thread_cmd_list
);
3397 add_prefix_cmd ("thread", no_class
, set_thread_default_cmd
,
3398 _("Command prefix for showing thread properties."),
3399 &show_thread_cmd_list
, "show thread ", 0, &showlist
);
3400 add_prefix_cmd ("default", no_class
, show_thread_default_cmd
,
3401 _("Command prefix for showing default thread properties."),
3402 &show_thread_default_cmd_list
, "show thread default ", 0,
3403 &show_thread_cmd_list
);
3405 add_cmd ("pause", class_run
, set_thread_pause_cmd
, _("\
3406 Set whether the current thread is suspended while gdb has control.\n\
3407 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3408 until the next time the program is continued. This property normally\n\
3409 has no effect because the whole task is suspended, however, that may\n\
3410 be disabled with \"set task pause off\".\n\
3411 The default value is \"off\"."),
3412 &set_thread_cmd_list
);
3413 add_cmd ("pause", no_class
, show_thread_pause_cmd
, _("\
3414 Show whether the current thread is suspended while gdb has control."),
3415 &show_thread_cmd_list
);
3417 add_cmd ("run", class_run
, set_thread_run_cmd
,
3418 _("Set whether the current thread is allowed to run."),
3419 &set_thread_cmd_list
);
3420 add_cmd ("run", no_class
, show_thread_run_cmd
,
3421 _("Show whether the current thread is allowed to run."),
3422 &show_thread_cmd_list
);
3424 add_cmd ("detach-suspend-count", class_run
, set_thread_detach_sc_cmd
, _("\
3425 Set the suspend count will leave on the thread when detaching.\n\
3426 Note that this is relative to suspend count when gdb noticed the thread;\n\
3427 use the `thread takeover-suspend-count' to force it to an absolute value."),
3428 &set_thread_cmd_list
);
3429 add_cmd ("detach-suspend-count", no_class
, show_thread_detach_sc_cmd
, _("\
3430 Show the suspend count will leave on the thread when detaching.\n\
3431 Note that this is relative to suspend count when gdb noticed the thread;\n\
3432 use the `thread takeover-suspend-count' to force it to an absolute value."),
3433 &show_thread_cmd_list
);
3435 add_cmd ("exception-port", no_class
, set_thread_exc_port_cmd
, _("\
3436 Set the thread exception port to which we forward exceptions.\n\
3437 This overrides the task exception port.\n\
3438 The argument should be the value of the send right in the task."),
3439 &set_thread_cmd_list
);
3440 add_alias_cmd ("excp", "exception-port", no_class
, 1, &set_thread_cmd_list
);
3441 add_alias_cmd ("exc-port", "exception-port", no_class
, 1,
3442 &set_thread_cmd_list
);
3444 add_cmd ("takeover-suspend-count", no_class
, thread_takeover_sc_cmd
, _("\
3445 Force the threads absolute suspend-count to be gdb's.\n\
3446 Prior to giving this command, gdb's thread suspend-counts are relative\n\
3447 to the thread's initial suspend-count when gdb notices the threads."),
3453 /* -Wmissing-prototypes */
3454 extern initialize_file_ftype _initialize_gnu_nat
;
3457 _initialize_gnu_nat (void)
3459 proc_server
= getproc ();
3461 add_task_commands ();
3462 add_thread_commands ();
3463 add_setshow_boolean_cmd ("gnu-nat", class_maintenance
,
3465 _("Set debugging output for the gnu backend."),
3466 _("Show debugging output for the gnu backend."),
3474 #ifdef FLUSH_INFERIOR_CACHE
3476 /* When over-writing code on some machines the I-Cache must be flushed
3477 explicitly, because it is not kept coherent by the lazy hardware.
3478 This definitely includes breakpoints, for instance, or else we
3479 end up looping in mysterious Bpt traps. */
3482 flush_inferior_icache (CORE_ADDR pc
, int amount
)
3484 vm_machine_attribute_val_t flush
= MATTR_VAL_ICACHE_FLUSH
;
3487 ret
= vm_machine_attribute (gnu_current_inf
->task
->port
,
3492 if (ret
!= KERN_SUCCESS
)
3493 warning (_("Error flushing inferior's cache : %s"), safe_strerror (ret
));
3495 #endif /* FLUSH_INFERIOR_CACHE */