1 /* Interface GDB to the GNU Hurd.
2 Copyright (C) 1992-2016 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/>. */
29 #include <sys/ptrace.h>
32 #include <mach_error.h>
33 #include <mach/exception.h>
34 #include <mach/message.h>
35 #include <mach/notify.h>
36 #include <mach/vm_attributes.h>
39 #include <hurd/interrupt.h>
41 #include <hurd/msg_request.h>
42 #include <hurd/process.h>
43 /* Defined in <hurd/process.h>, but we need forward declarations from
44 <hurd/process_request.h> as well. */
46 #include <hurd/process_request.h>
47 #include <hurd/signal.h>
48 #include <hurd/sigpreempt.h>
60 #include "gdbthread.h"
61 #include "gdb_obstack.h"
64 #include "inf-child.h"
66 #include "exc_request_S.h"
68 #include "process_reply_S.h"
69 #include "msg_reply_S.h"
70 #include "exc_request_U.h"
73 static process_t proc_server
= MACH_PORT_NULL
;
75 /* If we've sent a proc_wait_request to the proc server, the pid of the
76 process we asked about. We can only ever have one outstanding. */
77 int proc_wait_pid
= 0;
79 /* The number of wait requests we've sent, and expect replies from. */
80 int proc_waits_pending
= 0;
82 int gnu_debug_flag
= 0;
86 static struct inf
*make_inf ();
87 void inf_clear_wait (struct inf
*inf
);
88 void inf_cleanup (struct inf
*inf
);
89 void inf_startup (struct inf
*inf
, int pid
);
90 int inf_update_suspends (struct inf
*inf
);
91 void inf_set_pid (struct inf
*inf
, pid_t pid
);
92 void inf_validate_procs (struct inf
*inf
);
93 void inf_steal_exc_ports (struct inf
*inf
);
94 void inf_restore_exc_ports (struct inf
*inf
);
95 void inf_set_threads_resume_sc (struct inf
*inf
,
96 struct proc
*run_thread
,
98 int inf_set_threads_resume_sc_for_signal_thread (struct inf
*inf
);
99 void inf_suspend (struct inf
*inf
);
100 void inf_resume (struct inf
*inf
);
101 void inf_set_step_thread (struct inf
*inf
, struct proc
*proc
);
102 void inf_detach (struct inf
*inf
);
103 void inf_attach (struct inf
*inf
, int pid
);
104 void inf_signal (struct inf
*inf
, enum gdb_signal sig
);
105 void inf_continue (struct inf
*inf
);
107 #define inf_debug(_inf, msg, args...) \
108 do { struct inf *__inf = (_inf); \
109 debug ("{inf %d %s}: " msg, __inf->pid, \
110 host_address_to_string (__inf) , ##args); } while (0)
112 void proc_abort (struct proc
*proc
, int force
);
113 struct proc
*make_proc (struct inf
*inf
, mach_port_t port
, int tid
);
114 struct proc
*_proc_free (struct proc
*proc
);
115 int proc_update_sc (struct proc
*proc
);
116 error_t
proc_get_exception_port (struct proc
*proc
, mach_port_t
* port
);
117 error_t
proc_set_exception_port (struct proc
*proc
, mach_port_t port
);
118 static mach_port_t
_proc_get_exc_port (struct proc
*proc
);
119 void proc_steal_exc_port (struct proc
*proc
, mach_port_t exc_port
);
120 void proc_restore_exc_port (struct proc
*proc
);
121 int proc_trace (struct proc
*proc
, int set
);
123 /* Evaluate RPC_EXPR in a scope with the variables MSGPORT and REFPORT bound
124 to INF's msg port and task port respectively. If it has no msg port,
125 EIEIO is returned. INF must refer to a running process! */
126 #define INF_MSGPORT_RPC(inf, rpc_expr) \
127 HURD_MSGPORT_RPC (proc_getmsgport (proc_server, inf->pid, &msgport), \
128 (refport = inf->task->port, 0), 0, \
129 msgport ? (rpc_expr) : EIEIO)
131 /* Like INF_MSGPORT_RPC, but will also resume the signal thread to ensure
132 there's someone around to deal with the RPC (and resuspend things
133 afterwards). This effects INF's threads' resume_sc count. */
134 #define INF_RESUME_MSGPORT_RPC(inf, rpc_expr) \
135 (inf_set_threads_resume_sc_for_signal_thread (inf) \
138 __e = INF_MSGPORT_RPC (inf, rpc_expr); \
144 /* The state passed by an exception message. */
147 int exception
; /* The exception code. */
149 mach_port_t handler
; /* The real exception port to handle this. */
150 mach_port_t reply
; /* The reply port from the exception call. */
153 /* The results of the last wait an inf did. */
156 struct target_waitstatus status
; /* The status returned to gdb. */
157 struct exc_state exc
; /* The exception that caused us to return. */
158 struct proc
*thread
; /* The thread in question. */
159 int suppress
; /* Something trivial happened. */
162 /* The state of an inferior. */
165 /* Fields describing the current inferior. */
167 struct proc
*task
; /* The mach task. */
168 struct proc
*threads
; /* A linked list of all threads in TASK. */
170 /* True if THREADS needn't be validated by querying the task. We
171 assume that we and the task in question are the only ones
172 frobbing the thread list, so as long as we don't let any code
173 run, we don't have to worry about THREADS changing. */
174 int threads_up_to_date
;
176 pid_t pid
; /* The real system PID. */
178 struct inf_wait wait
; /* What to return from target_wait. */
180 /* One thread proc in INF may be in `single-stepping mode'. This
182 struct proc
*step_thread
;
184 /* The thread we think is the signal thread. */
185 struct proc
*signal_thread
;
187 mach_port_t event_port
; /* Where we receive various msgs. */
189 /* True if we think at least one thread in the inferior could currently be
191 unsigned int running
:1;
193 /* True if the process has stopped (in the proc server sense). Note that
194 since a proc server `stop' leaves the signal thread running, the inf can
195 be RUNNING && STOPPED... */
196 unsigned int stopped
:1;
198 /* True if the inferior has no message port. */
199 unsigned int nomsg
:1;
201 /* True if the inferior is traced. */
202 unsigned int traced
:1;
204 /* True if we shouldn't try waiting for the inferior, usually because we
205 can't for some reason. */
206 unsigned int no_wait
:1;
208 /* When starting a new inferior, we don't try to validate threads until all
209 the proper execs have been done, which this flag states we still
211 unsigned int pending_execs
:1;
213 /* Fields describing global state. */
215 /* The task suspend count used when gdb has control. This is normally 1 to
216 make things easier for us, but sometimes (like when attaching to vital
217 system servers) it may be desirable to let the task continue to run
218 (pausing individual threads as necessary). */
221 /* The task suspend count left when detaching from a task. */
224 /* The initial values used for the run_sc and pause_sc of newly discovered
225 threads -- see the definition of those fields in struct proc. */
226 int default_thread_run_sc
;
227 int default_thread_pause_sc
;
228 int default_thread_detach_sc
;
230 /* True if the process should be traced when started/attached. Newly
231 started processes *must* be traced at first to exec them properly, but
232 if this is false, tracing is turned off as soon it has done so. */
235 /* True if exceptions from the inferior process should be trapped. This
236 must be on to use breakpoints. */
242 __proc_pid (struct proc
*proc
)
244 return proc
->inf
->pid
;
248 /* Update PROC's real suspend count to match it's desired one. Returns true
249 if we think PROC is now in a runnable state. */
251 proc_update_sc (struct proc
*proc
)
255 int delta
= proc
->sc
- proc
->cur_sc
;
258 proc_debug (proc
, "sc: %d --> %d", proc
->cur_sc
, proc
->sc
);
260 if (proc
->sc
== 0 && proc
->state_changed
)
261 /* Since PROC may start running, we must write back any state changes. */
263 gdb_assert (proc_is_thread (proc
));
264 proc_debug (proc
, "storing back changed thread state");
265 err
= thread_set_state (proc
->port
, THREAD_STATE_FLAVOR
,
266 (thread_state_t
) &proc
->state
, THREAD_STATE_SIZE
);
268 proc
->state_changed
= 0;
273 while (delta
-- > 0 && !err
)
275 if (proc_is_task (proc
))
276 err
= task_suspend (proc
->port
);
278 err
= thread_suspend (proc
->port
);
283 while (delta
++ < 0 && !err
)
285 if (proc_is_task (proc
))
286 err
= task_resume (proc
->port
);
288 err
= thread_resume (proc
->port
);
292 proc
->cur_sc
= proc
->sc
;
294 /* If we got an error, then the task/thread has disappeared. */
295 running
= !err
&& proc
->sc
== 0;
297 proc_debug (proc
, "is %s", err
? "dead" : running
? "running" : "suspended");
299 proc_debug (proc
, "err = %s", safe_strerror (err
));
304 proc
->state_valid
= proc
->state_changed
= 0;
305 proc
->fetched_regs
= 0;
312 /* Thread_abort is called on PROC if needed. PROC must be a thread proc.
313 If PROC is deemed `precious', then nothing is done unless FORCE is true.
314 In particular, a thread is precious if it's running (in which case forcing
315 it includes suspending it first), or if it has an exception pending. */
317 proc_abort (struct proc
*proc
, int force
)
319 gdb_assert (proc_is_thread (proc
));
323 struct inf
*inf
= proc
->inf
;
324 int running
= (proc
->cur_sc
== 0 && inf
->task
->cur_sc
== 0);
326 if (running
&& force
)
329 inf_update_suspends (proc
->inf
);
331 warning (_("Stopped %s."), proc_string (proc
));
333 else if (proc
== inf
->wait
.thread
&& inf
->wait
.exc
.reply
&& !force
)
334 /* An exception is pending on PROC, which don't mess with. */
338 /* We only abort the thread if it's not actually running. */
340 thread_abort (proc
->port
);
341 proc_debug (proc
, "aborted");
345 proc_debug (proc
, "not aborting");
349 /* Make sure that the state field in PROC is up to date, and return a pointer
350 to it, or 0 if something is wrong. If WILL_MODIFY is true, makes sure
351 that the thread is stopped and aborted first, and sets the state_changed
352 field in PROC to true. */
354 proc_get_state (struct proc
*proc
, int will_modify
)
356 int was_aborted
= proc
->aborted
;
358 proc_debug (proc
, "updating state info%s",
359 will_modify
? " (with intention to modify)" : "");
361 proc_abort (proc
, will_modify
);
363 if (!was_aborted
&& proc
->aborted
)
364 /* PROC's state may have changed since we last fetched it. */
365 proc
->state_valid
= 0;
367 if (!proc
->state_valid
)
369 mach_msg_type_number_t state_size
= THREAD_STATE_SIZE
;
371 thread_get_state (proc
->port
, THREAD_STATE_FLAVOR
,
372 (thread_state_t
) &proc
->state
, &state_size
);
374 proc_debug (proc
, "getting thread state");
375 proc
->state_valid
= !err
;
378 if (proc
->state_valid
)
381 proc
->state_changed
= 1;
382 return (thread_state_t
) &proc
->state
;
389 /* Set PORT to PROC's exception port. */
391 proc_get_exception_port (struct proc
* proc
, mach_port_t
* port
)
393 if (proc_is_task (proc
))
394 return task_get_exception_port (proc
->port
, port
);
396 return thread_get_exception_port (proc
->port
, port
);
399 /* Set PROC's exception port to PORT. */
401 proc_set_exception_port (struct proc
* proc
, mach_port_t port
)
403 proc_debug (proc
, "setting exception port: %lu", port
);
404 if (proc_is_task (proc
))
405 return task_set_exception_port (proc
->port
, port
);
407 return thread_set_exception_port (proc
->port
, port
);
410 /* Get PROC's exception port, cleaning up a bit if proc has died. */
412 _proc_get_exc_port (struct proc
*proc
)
414 mach_port_t exc_port
;
415 error_t err
= proc_get_exception_port (proc
, &exc_port
);
418 /* PROC must be dead. */
421 mach_port_deallocate (mach_task_self (), proc
->exc_port
);
422 proc
->exc_port
= MACH_PORT_NULL
;
423 if (proc
->saved_exc_port
)
424 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
425 proc
->saved_exc_port
= MACH_PORT_NULL
;
431 /* Replace PROC's exception port with EXC_PORT, unless it's already
432 been done. Stash away any existing exception port so we can
435 proc_steal_exc_port (struct proc
*proc
, mach_port_t exc_port
)
437 mach_port_t cur_exc_port
= _proc_get_exc_port (proc
);
443 proc_debug (proc
, "inserting exception port: %lu", exc_port
);
445 if (cur_exc_port
!= exc_port
)
446 /* Put in our exception port. */
447 err
= proc_set_exception_port (proc
, exc_port
);
449 if (err
|| cur_exc_port
== proc
->exc_port
)
450 /* We previously set the exception port, and it's still set. So we
451 just keep the old saved port which is what the proc set. */
454 mach_port_deallocate (mach_task_self (), cur_exc_port
);
457 /* Keep a copy of PROC's old exception port so it can be restored. */
459 if (proc
->saved_exc_port
)
460 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
461 proc
->saved_exc_port
= cur_exc_port
;
464 proc_debug (proc
, "saved exception port: %lu", proc
->saved_exc_port
);
467 proc
->exc_port
= exc_port
;
469 warning (_("Error setting exception port for %s: %s"),
470 proc_string (proc
), safe_strerror (err
));
474 /* If we previously replaced PROC's exception port, put back what we
475 found there at the time, unless *our* exception port has since been
476 overwritten, in which case who knows what's going on. */
478 proc_restore_exc_port (struct proc
*proc
)
480 mach_port_t cur_exc_port
= _proc_get_exc_port (proc
);
486 proc_debug (proc
, "restoring real exception port");
488 if (proc
->exc_port
== cur_exc_port
)
489 /* Our's is still there. */
490 err
= proc_set_exception_port (proc
, proc
->saved_exc_port
);
492 if (proc
->saved_exc_port
)
493 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
494 proc
->saved_exc_port
= MACH_PORT_NULL
;
497 proc
->exc_port
= MACH_PORT_NULL
;
499 warning (_("Error setting exception port for %s: %s"),
500 proc_string (proc
), safe_strerror (err
));
505 /* Turns hardware tracing in PROC on or off when SET is true or false,
506 respectively. Returns true on success. */
508 proc_trace (struct proc
*proc
, int set
)
510 thread_state_t state
= proc_get_state (proc
, 1);
513 return 0; /* The thread must be dead. */
515 proc_debug (proc
, "tracing %s", set
? "on" : "off");
519 /* XXX We don't get the exception unless the thread has its own
520 exception port???? */
521 if (proc
->exc_port
== MACH_PORT_NULL
)
522 proc_steal_exc_port (proc
, proc
->inf
->event_port
);
523 THREAD_STATE_SET_TRACED (state
);
526 THREAD_STATE_CLEAR_TRACED (state
);
532 /* A variable from which to assign new TIDs. */
533 static int next_thread_id
= 1;
535 /* Returns a new proc structure with the given fields. Also adds a
536 notification for PORT becoming dead to be sent to INF's notify port. */
538 make_proc (struct inf
*inf
, mach_port_t port
, int tid
)
541 mach_port_t prev_port
= MACH_PORT_NULL
;
542 struct proc
*proc
= XNEW (struct proc
);
548 proc
->saved_exc_port
= MACH_PORT_NULL
;
549 proc
->exc_port
= MACH_PORT_NULL
;
554 /* Note that these are all the values for threads; the task simply uses the
555 corresponding field in INF directly. */
556 proc
->run_sc
= inf
->default_thread_run_sc
;
557 proc
->pause_sc
= inf
->default_thread_pause_sc
;
558 proc
->detach_sc
= inf
->default_thread_detach_sc
;
559 proc
->resume_sc
= proc
->run_sc
;
563 proc
->state_valid
= 0;
564 proc
->state_changed
= 0;
566 proc_debug (proc
, "is new");
568 /* Get notified when things die. */
570 mach_port_request_notification (mach_task_self (), port
,
571 MACH_NOTIFY_DEAD_NAME
, 1,
573 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
576 warning (_("Couldn't request notification for port %lu: %s"),
577 port
, safe_strerror (err
));
580 proc_debug (proc
, "notifications to: %lu", inf
->event_port
);
581 if (prev_port
!= MACH_PORT_NULL
)
582 mach_port_deallocate (mach_task_self (), prev_port
);
585 if (inf
->want_exceptions
)
587 if (proc_is_task (proc
))
588 /* Make the task exception port point to us. */
589 proc_steal_exc_port (proc
, inf
->event_port
);
591 /* Just clear thread exception ports -- they default to the
593 proc_steal_exc_port (proc
, MACH_PORT_NULL
);
599 /* Frees PROC and any resources it uses, and returns the value of PROC's
602 _proc_free (struct proc
*proc
)
604 struct inf
*inf
= proc
->inf
;
605 struct proc
*next
= proc
->next
;
607 proc_debug (proc
, "freeing...");
609 if (proc
== inf
->step_thread
)
610 /* Turn off single stepping. */
611 inf_set_step_thread (inf
, 0);
612 if (proc
== inf
->wait
.thread
)
613 inf_clear_wait (inf
);
614 if (proc
== inf
->signal_thread
)
615 inf
->signal_thread
= 0;
617 if (proc
->port
!= MACH_PORT_NULL
)
619 if (proc
->exc_port
!= MACH_PORT_NULL
)
620 /* Restore the original exception port. */
621 proc_restore_exc_port (proc
);
622 if (proc
->cur_sc
!= 0)
623 /* Resume the thread/task. */
626 proc_update_sc (proc
);
628 mach_port_deallocate (mach_task_self (), proc
->port
);
639 struct inf
*inf
= XNEW (struct inf
);
643 inf
->threads_up_to_date
= 0;
645 inf
->wait
.status
.kind
= TARGET_WAITKIND_SPURIOUS
;
646 inf
->wait
.thread
= 0;
647 inf
->wait
.exc
.handler
= MACH_PORT_NULL
;
648 inf
->wait
.exc
.reply
= MACH_PORT_NULL
;
649 inf
->step_thread
= 0;
650 inf
->signal_thread
= 0;
651 inf
->event_port
= MACH_PORT_NULL
;
657 inf
->pending_execs
= 0;
660 inf
->default_thread_run_sc
= 0;
661 inf
->default_thread_pause_sc
= 0;
662 inf
->default_thread_detach_sc
= 0;
663 inf
->want_signals
= 1; /* By default */
664 inf
->want_exceptions
= 1; /* By default */
669 /* Clear INF's target wait status. */
671 inf_clear_wait (struct inf
*inf
)
673 inf_debug (inf
, "clearing wait");
674 inf
->wait
.status
.kind
= TARGET_WAITKIND_SPURIOUS
;
675 inf
->wait
.thread
= 0;
676 inf
->wait
.suppress
= 0;
677 if (inf
->wait
.exc
.handler
!= MACH_PORT_NULL
)
679 mach_port_deallocate (mach_task_self (), inf
->wait
.exc
.handler
);
680 inf
->wait
.exc
.handler
= MACH_PORT_NULL
;
682 if (inf
->wait
.exc
.reply
!= MACH_PORT_NULL
)
684 mach_port_deallocate (mach_task_self (), inf
->wait
.exc
.reply
);
685 inf
->wait
.exc
.reply
= MACH_PORT_NULL
;
691 inf_cleanup (struct inf
*inf
)
693 inf_debug (inf
, "cleanup");
695 inf_clear_wait (inf
);
697 inf_set_pid (inf
, -1);
704 inf
->pending_execs
= 0;
708 mach_port_destroy (mach_task_self (), inf
->event_port
);
709 inf
->event_port
= MACH_PORT_NULL
;
714 inf_startup (struct inf
*inf
, int pid
)
718 inf_debug (inf
, "startup: pid = %d", pid
);
722 /* Make the port on which we receive all events. */
723 err
= mach_port_allocate (mach_task_self (),
724 MACH_PORT_RIGHT_RECEIVE
, &inf
->event_port
);
726 error (_("Error allocating event port: %s"), safe_strerror (err
));
728 /* Make a send right for it, so we can easily copy it for other people. */
729 mach_port_insert_right (mach_task_self (), inf
->event_port
,
730 inf
->event_port
, MACH_MSG_TYPE_MAKE_SEND
);
731 inf_set_pid (inf
, pid
);
735 /* Close current process, if any, and attach INF to process PORT. */
737 inf_set_pid (struct inf
*inf
, pid_t pid
)
740 struct proc
*task
= inf
->task
;
742 inf_debug (inf
, "setting pid: %d", pid
);
745 task_port
= MACH_PORT_NULL
;
748 error_t err
= proc_pid2task (proc_server
, pid
, &task_port
);
751 error (_("Error getting task for pid %d: %s"),
752 pid
, safe_strerror (err
));
755 inf_debug (inf
, "setting task: %lu", task_port
);
758 task_suspend (task_port
);
760 if (task
&& task
->port
!= task_port
)
763 inf_validate_procs (inf
); /* Trash all the threads. */
764 _proc_free (task
); /* And the task. */
767 if (task_port
!= MACH_PORT_NULL
)
769 inf
->task
= make_proc (inf
, task_port
, PROC_TID_TASK
);
770 inf
->threads_up_to_date
= 0;
777 /* Reflect task_suspend above. */
778 inf
->task
->sc
= inf
->task
->cur_sc
= 1;
785 /* Validates INF's stopped, nomsg and traced field from the actual
786 proc server state. Note that the traced field is only updated from
787 the proc server state if we do not have a message port. If we do
788 have a message port we'd better look at the tracemask itself. */
790 inf_validate_procinfo (struct inf
*inf
)
793 mach_msg_type_number_t noise_len
= 0;
795 mach_msg_type_number_t pi_len
= 0;
798 proc_getprocinfo (proc_server
, inf
->pid
, &info_flags
,
799 (procinfo_t
*) &pi
, &pi_len
, &noise
, &noise_len
);
803 inf
->stopped
= !!(pi
->state
& PI_STOPPED
);
804 inf
->nomsg
= !!(pi
->state
& PI_NOMSG
);
806 inf
->traced
= !!(pi
->state
& PI_TRACED
);
807 vm_deallocate (mach_task_self (), (vm_address_t
) pi
,
808 pi_len
* sizeof (*(procinfo_t
) 0));
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
,
849 pi_len
* sizeof (*(procinfo_t
) 0));
851 vm_deallocate (mach_task_self (), (vm_address_t
) noise
, noise_len
);
853 if (inf
->task
->cur_sc
< suspend_count
)
855 if (!query (_("Pid %d has an additional task suspend count of %d;"
856 " clear it? "), inf
->pid
,
857 suspend_count
- inf
->task
->cur_sc
))
858 error (_("Additional task suspend count left untouched."));
860 inf
->task
->cur_sc
= suspend_count
;
864 /* Turns tracing for INF on or off, depending on ON, unless it already
865 is. If INF is running, the resume_sc count of INF's threads will
866 be modified, and the signal thread will briefly be run to change
869 inf_set_traced (struct inf
*inf
, int on
)
871 if (on
== inf
->traced
)
874 if (inf
->task
&& !inf
->task
->dead
)
875 /* Make it take effect immediately. */
877 sigset_t mask
= on
? ~(sigset_t
) 0 : 0;
879 INF_RESUME_MSGPORT_RPC (inf
, msg_set_init_int (msgport
, refport
,
880 INIT_TRACEMASK
, mask
));
885 warning (_("Can't modify tracing state for pid %d: %s"),
886 inf
->pid
, "No signal thread");
890 warning (_("Can't modify tracing state for pid %d: %s"),
891 inf
->pid
, safe_strerror (err
));
900 /* Makes all the real suspend count deltas of all the procs in INF
901 match the desired values. Careful to always do thread/task suspend
902 counts in the safe order. Returns true if at least one thread is
903 thought to be running. */
905 inf_update_suspends (struct inf
*inf
)
907 struct proc
*task
= inf
->task
;
909 /* We don't have to update INF->threads even though we're iterating over it
910 because we'll change a thread only if it already has an existing proc
912 inf_debug (inf
, "updating suspend counts");
917 int task_running
= (task
->sc
== 0), thread_running
= 0;
919 if (task
->sc
> task
->cur_sc
)
920 /* The task is becoming _more_ suspended; do before any threads. */
921 task_running
= proc_update_sc (task
);
923 if (inf
->pending_execs
)
924 /* When we're waiting for an exec, things may be happening behind our
925 back, so be conservative. */
928 /* Do all the thread suspend counts. */
929 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
930 thread_running
|= proc_update_sc (thread
);
932 if (task
->sc
!= task
->cur_sc
)
933 /* We didn't do the task first, because we wanted to wait for the
934 threads; do it now. */
935 task_running
= proc_update_sc (task
);
937 inf_debug (inf
, "%srunning...",
938 (thread_running
&& task_running
) ? "" : "not ");
940 inf
->running
= thread_running
&& task_running
;
942 /* Once any thread has executed some code, we can't depend on the
943 threads list any more. */
945 inf
->threads_up_to_date
= 0;
954 /* Converts a GDB pid to a struct proc. */
956 inf_tid_to_thread (struct inf
*inf
, int tid
)
958 struct proc
*thread
= inf
->threads
;
961 if (thread
->tid
== tid
)
964 thread
= thread
->next
;
968 /* Converts a thread port to a struct proc. */
970 inf_port_to_thread (struct inf
*inf
, mach_port_t port
)
972 struct proc
*thread
= inf
->threads
;
975 if (thread
->port
== port
)
978 thread
= thread
->next
;
985 inf_threads (struct inf
*inf
, inf_threads_ftype
*f
, void *arg
)
989 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
994 /* Make INF's list of threads be consistent with reality of TASK. */
996 inf_validate_procs (struct inf
*inf
)
998 thread_array_t threads
;
999 mach_msg_type_number_t num_threads
, i
;
1000 struct proc
*task
= inf
->task
;
1002 /* If no threads are currently running, this function will guarantee that
1003 things are up to date. The exception is if there are zero threads --
1004 then it is almost certainly in an odd state, and probably some outside
1005 agent will create threads. */
1006 inf
->threads_up_to_date
= inf
->threads
? !inf
->running
: 0;
1010 error_t err
= task_threads (task
->port
, &threads
, &num_threads
);
1012 inf_debug (inf
, "fetching threads");
1014 /* TASK must be dead. */
1024 inf_debug (inf
, "no task");
1028 /* Make things normally linear. */
1029 mach_msg_type_number_t search_start
= 0;
1030 /* Which thread in PROCS corresponds to each task thread, & the task. */
1031 struct proc
*matched
[num_threads
+ 1];
1032 /* The last thread in INF->threads, so we can add to the end. */
1033 struct proc
*last
= 0;
1034 /* The current thread we're considering. */
1035 struct proc
*thread
= inf
->threads
;
1037 memset (matched
, 0, sizeof (matched
));
1041 mach_msg_type_number_t left
;
1043 for (i
= search_start
, left
= num_threads
; left
; i
++, left
--)
1045 if (i
>= num_threads
)
1046 i
-= num_threads
; /* I wrapped around. */
1047 if (thread
->port
== threads
[i
])
1048 /* We already know about this thread. */
1050 matched
[i
] = thread
;
1052 thread
= thread
->next
;
1060 proc_debug (thread
, "died!");
1061 thread
->port
= MACH_PORT_NULL
;
1062 thread
= _proc_free (thread
); /* THREAD is dead. */
1064 last
->next
= thread
;
1066 inf
->threads
= thread
;
1070 for (i
= 0; i
< num_threads
; i
++)
1073 /* Throw away the duplicate send right. */
1074 mach_port_deallocate (mach_task_self (), threads
[i
]);
1076 /* THREADS[I] is a thread we don't know about yet! */
1080 thread
= make_proc (inf
, threads
[i
], next_thread_id
++);
1082 last
->next
= thread
;
1084 inf
->threads
= thread
;
1086 proc_debug (thread
, "new thread: %lu", threads
[i
]);
1088 ptid
= ptid_build (inf
->pid
, thread
->tid
, 0);
1090 /* Tell GDB's generic thread code. */
1092 if (ptid_equal (inferior_ptid
, pid_to_ptid (inf
->pid
)))
1093 /* This is the first time we're hearing about thread
1094 ids, after a fork-child. */
1095 thread_change_ptid (inferior_ptid
, ptid
);
1096 else if (inf
->pending_execs
!= 0)
1097 /* This is a shell thread. */
1098 add_thread_silent (ptid
);
1104 vm_deallocate (mach_task_self (),
1105 (vm_address_t
) threads
, (num_threads
* sizeof (thread_t
)));
1110 /* Makes sure that INF's thread list is synced with the actual process. */
1112 inf_update_procs (struct inf
*inf
)
1116 if (!inf
->threads_up_to_date
)
1117 inf_validate_procs (inf
);
1121 /* Sets the resume_sc of each thread in inf. That of RUN_THREAD is set to 0,
1122 and others are set to their run_sc if RUN_OTHERS is true, and otherwise
1125 inf_set_threads_resume_sc (struct inf
*inf
,
1126 struct proc
*run_thread
, int run_others
)
1128 struct proc
*thread
;
1130 inf_update_procs (inf
);
1131 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1132 if (thread
== run_thread
)
1133 thread
->resume_sc
= 0;
1134 else if (run_others
)
1135 thread
->resume_sc
= thread
->run_sc
;
1137 thread
->resume_sc
= thread
->pause_sc
;
1141 /* Cause INF to continue execution immediately; individual threads may still
1142 be suspended (but their suspend counts will be updated). */
1144 inf_resume (struct inf
*inf
)
1146 struct proc
*thread
;
1148 inf_update_procs (inf
);
1150 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1151 thread
->sc
= thread
->resume_sc
;
1155 if (!inf
->pending_execs
)
1156 /* Try to make sure our task count is correct -- in the case where
1157 we're waiting for an exec though, things are too volatile, so just
1158 assume things will be reasonable (which they usually will be). */
1159 inf_validate_task_sc (inf
);
1163 inf_update_suspends (inf
);
1166 /* Cause INF to stop execution immediately; individual threads may still
1169 inf_suspend (struct inf
*inf
)
1171 struct proc
*thread
;
1173 inf_update_procs (inf
);
1175 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1176 thread
->sc
= thread
->pause_sc
;
1179 inf
->task
->sc
= inf
->pause_sc
;
1181 inf_update_suspends (inf
);
1185 /* INF has one thread PROC that is in single-stepping mode. This
1186 function changes it to be PROC, changing any old step_thread to be
1187 a normal one. A PROC of 0 clears any existing value. */
1189 inf_set_step_thread (struct inf
*inf
, struct proc
*thread
)
1191 gdb_assert (!thread
|| proc_is_thread (thread
));
1194 inf_debug (inf
, "setting step thread: %d/%d", inf
->pid
, thread
->tid
);
1196 inf_debug (inf
, "clearing step thread");
1198 if (inf
->step_thread
!= thread
)
1200 if (inf
->step_thread
&& inf
->step_thread
->port
!= MACH_PORT_NULL
)
1201 if (!proc_trace (inf
->step_thread
, 0))
1203 if (thread
&& proc_trace (thread
, 1))
1204 inf
->step_thread
= thread
;
1206 inf
->step_thread
= 0;
1211 /* Set up the thread resume_sc's so that only the signal thread is running
1212 (plus whatever other thread are set to always run). Returns true if we
1213 did so, or false if we can't find a signal thread. */
1215 inf_set_threads_resume_sc_for_signal_thread (struct inf
*inf
)
1217 if (inf
->signal_thread
)
1219 inf_set_threads_resume_sc (inf
, inf
->signal_thread
, 0);
1227 inf_update_signal_thread (struct inf
*inf
)
1229 /* XXX for now we assume that if there's a msgport, the 2nd thread is
1230 the signal thread. */
1231 inf
->signal_thread
= inf
->threads
? inf
->threads
->next
: 0;
1235 /* Detachs from INF's inferior task, letting it run once again... */
1237 inf_detach (struct inf
*inf
)
1239 struct proc
*task
= inf
->task
;
1241 inf_debug (inf
, "detaching...");
1243 inf_clear_wait (inf
);
1244 inf_set_step_thread (inf
, 0);
1248 struct proc
*thread
;
1250 inf_validate_procinfo (inf
);
1252 inf_set_traced (inf
, 0);
1258 inf_signal (inf
, GDB_SIGNAL_0
);
1261 proc_restore_exc_port (task
);
1262 task
->sc
= inf
->detach_sc
;
1264 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1266 proc_restore_exc_port (thread
);
1267 thread
->sc
= thread
->detach_sc
;
1270 inf_update_suspends (inf
);
1276 /* Attaches INF to the process with process id PID, returning it in a
1277 suspended state suitable for debugging. */
1279 inf_attach (struct inf
*inf
, int pid
)
1281 inf_debug (inf
, "attaching: %d", pid
);
1286 inf_startup (inf
, pid
);
1290 /* Makes sure that we've got our exception ports entrenched in the process. */
1292 inf_steal_exc_ports (struct inf
*inf
)
1294 struct proc
*thread
;
1296 inf_debug (inf
, "stealing exception ports");
1298 inf_set_step_thread (inf
, 0); /* The step thread is special. */
1300 proc_steal_exc_port (inf
->task
, inf
->event_port
);
1301 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1302 proc_steal_exc_port (thread
, MACH_PORT_NULL
);
1305 /* Makes sure the process has its own exception ports. */
1307 inf_restore_exc_ports (struct inf
*inf
)
1309 struct proc
*thread
;
1311 inf_debug (inf
, "restoring exception ports");
1313 inf_set_step_thread (inf
, 0); /* The step thread is special. */
1315 proc_restore_exc_port (inf
->task
);
1316 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1317 proc_restore_exc_port (thread
);
1321 /* Deliver signal SIG to INF. If INF is stopped, delivering a signal, even
1322 signal 0, will continue it. INF is assumed to be in a paused state, and
1323 the resume_sc's of INF's threads may be affected. */
1325 inf_signal (struct inf
*inf
, enum gdb_signal sig
)
1328 int host_sig
= gdb_signal_to_host (sig
);
1330 #define NAME gdb_signal_to_name (sig)
1332 if (host_sig
>= _NSIG
)
1333 /* A mach exception. Exceptions are encoded in the signal space by
1334 putting them after _NSIG; this assumes they're positive (and not
1335 extremely large)! */
1337 struct inf_wait
*w
= &inf
->wait
;
1339 if (w
->status
.kind
== TARGET_WAITKIND_STOPPED
1340 && w
->status
.value
.sig
== sig
1341 && w
->thread
&& !w
->thread
->aborted
)
1342 /* We're passing through the last exception we received. This is
1343 kind of bogus, because exceptions are per-thread whereas gdb
1344 treats signals as per-process. We just forward the exception to
1345 the correct handler, even it's not for the same thread as TID --
1346 i.e., we pretend it's global. */
1348 struct exc_state
*e
= &w
->exc
;
1350 inf_debug (inf
, "passing through exception:"
1351 " task = %lu, thread = %lu, exc = %d"
1352 ", code = %d, subcode = %d",
1353 w
->thread
->port
, inf
->task
->port
,
1354 e
->exception
, e
->code
, e
->subcode
);
1356 exception_raise_request (e
->handler
,
1357 e
->reply
, MACH_MSG_TYPE_MOVE_SEND_ONCE
,
1358 w
->thread
->port
, inf
->task
->port
,
1359 e
->exception
, e
->code
, e
->subcode
);
1362 error (_("Can't forward spontaneous exception (%s)."), NAME
);
1365 /* A Unix signal. */
1367 /* The process is stopped and expecting a signal. Just send off a
1368 request and let it get handled when we resume everything. */
1370 inf_debug (inf
, "sending %s to stopped process", NAME
);
1372 INF_MSGPORT_RPC (inf
,
1373 msg_sig_post_untraced_request (msgport
,
1375 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1379 /* Posting an untraced signal automatically continues it.
1380 We clear this here rather than when we get the reply
1381 because we'd rather assume it's not stopped when it
1382 actually is, than the reverse. */
1386 /* It's not expecting it. We have to let just the signal thread
1387 run, and wait for it to get into a reasonable state before we
1388 can continue the rest of the process. When we finally resume the
1389 process the signal we request will be the very first thing that
1392 inf_debug (inf
, "sending %s to unstopped process"
1393 " (so resuming signal thread)", NAME
);
1395 INF_RESUME_MSGPORT_RPC (inf
,
1396 msg_sig_post_untraced (msgport
, host_sig
,
1401 /* Can't do too much... */
1402 warning (_("Can't deliver signal %s: No signal thread."), NAME
);
1404 warning (_("Delivering signal %s: %s"), NAME
, safe_strerror (err
));
1410 /* Continue INF without delivering a signal. This is meant to be used
1411 when INF does not have a message port. */
1413 inf_continue (struct inf
*inf
)
1416 error_t err
= proc_pid2proc (proc_server
, inf
->pid
, &proc
);
1420 inf_debug (inf
, "continuing process");
1422 err
= proc_mark_cont (proc
);
1425 struct proc
*thread
;
1427 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1428 thread_resume (thread
->port
);
1435 warning (_("Can't continue process: %s"), safe_strerror (err
));
1439 /* The inferior used for all gdb target ops. */
1440 struct inf
*gnu_current_inf
= 0;
1442 /* The inferior being waited for by gnu_wait. Since GDB is decidely not
1443 multi-threaded, we don't bother to lock this. */
1444 struct inf
*waiting_inf
;
1446 /* Wait for something to happen in the inferior, returning what in STATUS. */
1448 gnu_wait (struct target_ops
*ops
,
1449 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
1453 mach_msg_header_t hdr
;
1454 mach_msg_type_t type
;
1458 struct proc
*thread
;
1459 struct inf
*inf
= gnu_current_inf
;
1461 extern int exc_server (mach_msg_header_t
*, mach_msg_header_t
*);
1462 extern int msg_reply_server (mach_msg_header_t
*, mach_msg_header_t
*);
1463 extern int notify_server (mach_msg_header_t
*, mach_msg_header_t
*);
1464 extern int process_reply_server (mach_msg_header_t
*, mach_msg_header_t
*);
1466 gdb_assert (inf
->task
);
1468 if (!inf
->threads
&& !inf
->pending_execs
)
1469 /* No threads! Assume that maybe some outside agency is frobbing our
1470 task, and really look for new threads. If we can't find any, just tell
1471 the user to try again later. */
1473 inf_validate_procs (inf
);
1474 if (!inf
->threads
&& !inf
->task
->dead
)
1475 error (_("There are no threads; try again later."));
1480 inf_debug (inf
, "waiting for: %s", target_pid_to_str (ptid
));
1483 if (proc_wait_pid
!= inf
->pid
&& !inf
->no_wait
)
1484 /* Always get information on events from the proc server. */
1486 inf_debug (inf
, "requesting wait on pid %d", inf
->pid
);
1489 /* The proc server is single-threaded, and only allows a single
1490 outstanding wait request, so we have to cancel the previous one. */
1492 inf_debug (inf
, "cancelling previous wait on pid %d", proc_wait_pid
);
1493 interrupt_operation (proc_server
, 0);
1497 proc_wait_request (proc_server
, inf
->event_port
, inf
->pid
, WUNTRACED
);
1499 warning (_("wait request failed: %s"), safe_strerror (err
));
1502 inf_debug (inf
, "waits pending: %d", proc_waits_pending
);
1503 proc_wait_pid
= inf
->pid
;
1504 /* Even if proc_waits_pending was > 0 before, we still won't
1505 get any other replies, because it was either from a
1506 different INF, or a different process attached to INF --
1507 and the event port, which is the wait reply port, changes
1508 when you switch processes. */
1509 proc_waits_pending
= 1;
1513 inf_clear_wait (inf
);
1515 /* What can happen? (1) Dead name notification; (2) Exceptions arrive;
1516 (3) wait reply from the proc server. */
1518 inf_debug (inf
, "waiting for an event...");
1519 err
= mach_msg (&msg
.hdr
, MACH_RCV_MSG
| MACH_RCV_INTERRUPT
,
1520 0, sizeof (struct msg
), inf
->event_port
,
1521 MACH_MSG_TIMEOUT_NONE
, MACH_PORT_NULL
);
1523 /* Re-suspend the task. */
1526 if (!inf
->task
&& inf
->pending_execs
)
1527 /* When doing an exec, it's possible that the old task wasn't reused
1528 (e.g., setuid execs). So if the task seems to have disappeared,
1529 attempt to refetch it, as the pid should still be the same. */
1530 inf_set_pid (inf
, inf
->pid
);
1532 if (err
== EMACH_RCV_INTERRUPTED
)
1533 inf_debug (inf
, "interrupted");
1535 error (_("Couldn't wait for an event: %s"), safe_strerror (err
));
1540 mach_msg_header_t hdr
;
1541 mach_msg_type_t err_type
;
1547 inf_debug (inf
, "event: msgid = %d", msg
.hdr
.msgh_id
);
1549 /* Handle what we got. */
1550 if (!notify_server (&msg
.hdr
, &reply
.hdr
)
1551 && !exc_server (&msg
.hdr
, &reply
.hdr
)
1552 && !process_reply_server (&msg
.hdr
, &reply
.hdr
)
1553 && !msg_reply_server (&msg
.hdr
, &reply
.hdr
))
1554 /* Whatever it is, it's something strange. */
1555 error (_("Got a strange event, msg id = %d."), msg
.hdr
.msgh_id
);
1558 error (_("Handling event, msgid = %d: %s"),
1559 msg
.hdr
.msgh_id
, safe_strerror (reply
.err
));
1562 if (inf
->pending_execs
)
1563 /* We're waiting for the inferior to finish execing. */
1565 struct inf_wait
*w
= &inf
->wait
;
1566 enum target_waitkind kind
= w
->status
.kind
;
1568 if (kind
== TARGET_WAITKIND_SPURIOUS
)
1569 /* Since gdb is actually counting the number of times the inferior
1570 stops, expecting one stop per exec, we only return major events
1574 inf_debug (inf
, "pending_execs, ignoring minor event");
1576 else if (kind
== TARGET_WAITKIND_STOPPED
1577 && w
->status
.value
.sig
== GDB_SIGNAL_TRAP
)
1578 /* Ah hah! A SIGTRAP from the inferior while starting up probably
1579 means we've succesfully completed an exec! */
1581 inf_debug (inf
, "one pending exec completed");
1583 else if (kind
== TARGET_WAITKIND_STOPPED
)
1584 /* It's possible that this signal is because of a crashed process
1585 being handled by the hurd crash server; in this case, the process
1586 will have an extra task suspend, which we need to know about.
1587 Since the code in inf_resume that normally checks for this is
1588 disabled while INF->pending_execs, we do the check here instead. */
1589 inf_validate_task_sc (inf
);
1592 if (inf
->wait
.suppress
)
1593 /* Some totally spurious event happened that we don't consider
1594 worth returning to gdb. Just keep waiting. */
1596 inf_debug (inf
, "suppressing return, rewaiting...");
1601 /* Pass back out our results. */
1602 memcpy (status
, &inf
->wait
.status
, sizeof (*status
));
1604 thread
= inf
->wait
.thread
;
1606 ptid
= ptid_build (inf
->pid
, thread
->tid
, 0);
1607 else if (ptid_equal (ptid
, minus_one_ptid
))
1608 thread
= inf_tid_to_thread (inf
, -1);
1610 thread
= inf_tid_to_thread (inf
, ptid_get_lwp (ptid
));
1612 if (!thread
|| thread
->port
== MACH_PORT_NULL
)
1614 /* TID is dead; try and find a new thread. */
1615 if (inf_update_procs (inf
) && inf
->threads
)
1616 ptid
= ptid_build (inf
->pid
, inf
->threads
->tid
, 0); /* The first
1620 ptid
= inferior_ptid
; /* let wait_for_inferior handle exit case */
1624 && !ptid_equal (ptid
, minus_one_ptid
)
1625 && status
->kind
!= TARGET_WAITKIND_SPURIOUS
1626 && inf
->pause_sc
== 0 && thread
->pause_sc
== 0)
1627 /* If something actually happened to THREAD, make sure we
1631 inf_update_suspends (inf
);
1634 inf_debug (inf
, "returning ptid = %s, status = %s (%d)",
1635 target_pid_to_str (ptid
),
1636 status
->kind
== TARGET_WAITKIND_EXITED
? "EXITED"
1637 : status
->kind
== TARGET_WAITKIND_STOPPED
? "STOPPED"
1638 : status
->kind
== TARGET_WAITKIND_SIGNALLED
? "SIGNALLED"
1639 : status
->kind
== TARGET_WAITKIND_LOADED
? "LOADED"
1640 : status
->kind
== TARGET_WAITKIND_SPURIOUS
? "SPURIOUS"
1642 status
->value
.integer
);
1648 /* The rpc handler called by exc_server. */
1650 S_exception_raise_request (mach_port_t port
, mach_port_t reply_port
,
1651 thread_t thread_port
, task_t task_port
,
1652 int exception
, int code
, int subcode
)
1654 struct inf
*inf
= waiting_inf
;
1655 struct proc
*thread
= inf_port_to_thread (inf
, thread_port
);
1657 inf_debug (waiting_inf
,
1658 "thread = %lu, task = %lu, exc = %d, code = %d, subcode = %d",
1659 thread_port
, task_port
, exception
, code
, subcode
);
1662 /* We don't know about thread? */
1664 inf_update_procs (inf
);
1665 thread
= inf_port_to_thread (inf
, thread_port
);
1667 /* Give up, the generating thread is gone. */
1671 mach_port_deallocate (mach_task_self (), thread_port
);
1672 mach_port_deallocate (mach_task_self (), task_port
);
1674 if (!thread
->aborted
)
1675 /* THREAD hasn't been aborted since this exception happened (abortion
1676 clears any exception state), so it must be real. */
1678 /* Store away the details; this will destroy any previous info. */
1679 inf
->wait
.thread
= thread
;
1681 inf
->wait
.status
.kind
= TARGET_WAITKIND_STOPPED
;
1683 if (exception
== EXC_BREAKPOINT
)
1684 /* GDB likes to get SIGTRAP for breakpoints. */
1686 inf
->wait
.status
.value
.sig
= GDB_SIGNAL_TRAP
;
1687 mach_port_deallocate (mach_task_self (), reply_port
);
1690 /* Record the exception so that we can forward it later. */
1692 if (thread
->exc_port
== port
)
1694 inf_debug (waiting_inf
, "Handler is thread exception port <%lu>",
1695 thread
->saved_exc_port
);
1696 inf
->wait
.exc
.handler
= thread
->saved_exc_port
;
1700 inf_debug (waiting_inf
, "Handler is task exception port <%lu>",
1701 inf
->task
->saved_exc_port
);
1702 inf
->wait
.exc
.handler
= inf
->task
->saved_exc_port
;
1703 gdb_assert (inf
->task
->exc_port
== port
);
1705 if (inf
->wait
.exc
.handler
!= MACH_PORT_NULL
)
1706 /* Add a reference to the exception handler. */
1707 mach_port_mod_refs (mach_task_self (),
1708 inf
->wait
.exc
.handler
, MACH_PORT_RIGHT_SEND
,
1711 inf
->wait
.exc
.exception
= exception
;
1712 inf
->wait
.exc
.code
= code
;
1713 inf
->wait
.exc
.subcode
= subcode
;
1714 inf
->wait
.exc
.reply
= reply_port
;
1716 /* Exceptions are encoded in the signal space by putting
1717 them after _NSIG; this assumes they're positive (and not
1718 extremely large)! */
1719 inf
->wait
.status
.value
.sig
=
1720 gdb_signal_from_host (_NSIG
+ exception
);
1724 /* A supppressed exception, which ignore. */
1726 inf
->wait
.suppress
= 1;
1727 mach_port_deallocate (mach_task_self (), reply_port
);
1734 /* Fill in INF's wait field after a task has died without giving us more
1735 detailed information. */
1737 inf_task_died_status (struct inf
*inf
)
1739 warning (_("Pid %d died with unknown exit status, using SIGKILL."),
1741 inf
->wait
.status
.kind
= TARGET_WAITKIND_SIGNALLED
;
1742 inf
->wait
.status
.value
.sig
= GDB_SIGNAL_KILL
;
1745 /* Notify server routines. The only real one is dead name notification. */
1747 do_mach_notify_dead_name (mach_port_t notify
, mach_port_t dead_port
)
1749 struct inf
*inf
= waiting_inf
;
1751 inf_debug (waiting_inf
, "port = %lu", dead_port
);
1753 if (inf
->task
&& inf
->task
->port
== dead_port
)
1755 proc_debug (inf
->task
, "is dead");
1756 inf
->task
->port
= MACH_PORT_NULL
;
1757 if (proc_wait_pid
== inf
->pid
)
1758 /* We have a wait outstanding on the process, which will return more
1759 detailed information, so delay until we get that. */
1760 inf
->wait
.suppress
= 1;
1762 /* We never waited for the process (maybe it wasn't a child), so just
1763 pretend it got a SIGKILL. */
1764 inf_task_died_status (inf
);
1768 struct proc
*thread
= inf_port_to_thread (inf
, dead_port
);
1772 proc_debug (thread
, "is dead");
1773 thread
->port
= MACH_PORT_NULL
;
1776 if (inf
->task
->dead
)
1777 /* Since the task is dead, its threads are dying with it. */
1778 inf
->wait
.suppress
= 1;
1781 mach_port_deallocate (mach_task_self (), dead_port
);
1782 inf
->threads_up_to_date
= 0; /* Just in case. */
1788 #define ILL_RPC(fun, ...) \
1789 extern kern_return_t fun (__VA_ARGS__); \
1790 kern_return_t fun (__VA_ARGS__) \
1792 warning (_("illegal rpc: %s"), #fun); \
1796 ILL_RPC (do_mach_notify_no_senders
,
1797 mach_port_t notify
, mach_port_mscount_t count
)
1798 ILL_RPC (do_mach_notify_port_deleted
,
1799 mach_port_t notify
, mach_port_t name
)
1800 ILL_RPC (do_mach_notify_msg_accepted
,
1801 mach_port_t notify
, mach_port_t name
)
1802 ILL_RPC (do_mach_notify_port_destroyed
,
1803 mach_port_t notify
, mach_port_t name
)
1804 ILL_RPC (do_mach_notify_send_once
,
1807 /* Process_reply server routines. We only use process_wait_reply. */
1810 S_proc_wait_reply (mach_port_t reply
, error_t err
,
1811 int status
, int sigcode
, rusage_t rusage
, pid_t pid
)
1813 struct inf
*inf
= waiting_inf
;
1815 inf_debug (inf
, "err = %s, pid = %d, status = 0x%x, sigcode = %d",
1816 err
? safe_strerror (err
) : "0", pid
, status
, sigcode
);
1818 if (err
&& proc_wait_pid
&& (!inf
->task
|| !inf
->task
->port
))
1819 /* Ack. The task has died, but the task-died notification code didn't
1820 tell anyone because it thought a more detailed reply from the
1821 procserver was forthcoming. However, we now learn that won't
1822 happen... So we have to act like the task just died, and this time,
1824 inf_task_died_status (inf
);
1826 if (--proc_waits_pending
== 0)
1827 /* PROC_WAIT_PID represents the most recent wait. We will always get
1828 replies in order because the proc server is single threaded. */
1831 inf_debug (inf
, "waits pending now: %d", proc_waits_pending
);
1837 warning (_("Can't wait for pid %d: %s"),
1838 inf
->pid
, safe_strerror (err
));
1841 /* Since we can't see the inferior's signals, don't trap them. */
1842 inf_set_traced (inf
, 0);
1845 else if (pid
== inf
->pid
)
1847 store_waitstatus (&inf
->wait
.status
, status
);
1848 if (inf
->wait
.status
.kind
== TARGET_WAITKIND_STOPPED
)
1849 /* The process has sent us a signal, and stopped itself in a sane
1850 state pending our actions. */
1852 inf_debug (inf
, "process has stopped itself");
1857 inf
->wait
.suppress
= 1; /* Something odd happened. Ignore. */
1862 ILL_RPC (S_proc_setmsgport_reply
,
1863 mach_port_t reply_port
, kern_return_t return_code
,
1864 mach_port_t oldmsgport
)
1865 ILL_RPC (S_proc_getmsgport_reply
,
1866 mach_port_t reply_port
, kern_return_t return_code
,
1867 mach_port_t msgports
)
1868 ILL_RPC (S_proc_pid2task_reply
,
1869 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t task
)
1870 ILL_RPC (S_proc_task2pid_reply
,
1871 mach_port_t reply_port
, kern_return_t return_code
, pid_t pid
)
1872 ILL_RPC (S_proc_task2proc_reply
,
1873 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t proc
)
1874 ILL_RPC (S_proc_proc2task_reply
,
1875 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t task
)
1876 ILL_RPC (S_proc_pid2proc_reply
,
1877 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t proc
)
1878 ILL_RPC (S_proc_getprocinfo_reply
,
1879 mach_port_t reply_port
, kern_return_t return_code
,
1880 int flags
, procinfo_t procinfo
, mach_msg_type_number_t procinfoCnt
,
1881 data_t threadwaits
, mach_msg_type_number_t threadwaitsCnt
)
1882 ILL_RPC (S_proc_getprocargs_reply
,
1883 mach_port_t reply_port
, kern_return_t return_code
,
1884 data_t procargs
, mach_msg_type_number_t procargsCnt
)
1885 ILL_RPC (S_proc_getprocenv_reply
,
1886 mach_port_t reply_port
, kern_return_t return_code
,
1887 data_t procenv
, mach_msg_type_number_t procenvCnt
)
1888 ILL_RPC (S_proc_getloginid_reply
,
1889 mach_port_t reply_port
, kern_return_t return_code
, pid_t login_id
)
1890 ILL_RPC (S_proc_getloginpids_reply
,
1891 mach_port_t reply_port
, kern_return_t return_code
,
1892 pidarray_t pids
, mach_msg_type_number_t pidsCnt
)
1893 ILL_RPC (S_proc_getlogin_reply
,
1894 mach_port_t reply_port
, kern_return_t return_code
, string_t logname
)
1895 ILL_RPC (S_proc_getsid_reply
,
1896 mach_port_t reply_port
, kern_return_t return_code
, pid_t sid
)
1897 ILL_RPC (S_proc_getsessionpgids_reply
,
1898 mach_port_t reply_port
, kern_return_t return_code
,
1899 pidarray_t pgidset
, mach_msg_type_number_t pgidsetCnt
)
1900 ILL_RPC (S_proc_getsessionpids_reply
,
1901 mach_port_t reply_port
, kern_return_t return_code
,
1902 pidarray_t pidset
, mach_msg_type_number_t pidsetCnt
)
1903 ILL_RPC (S_proc_getsidport_reply
,
1904 mach_port_t reply_port
, kern_return_t return_code
,
1905 mach_port_t sessport
)
1906 ILL_RPC (S_proc_getpgrp_reply
,
1907 mach_port_t reply_port
, kern_return_t return_code
, pid_t pgrp
)
1908 ILL_RPC (S_proc_getpgrppids_reply
,
1909 mach_port_t reply_port
, kern_return_t return_code
,
1910 pidarray_t pidset
, mach_msg_type_number_t pidsetCnt
)
1911 ILL_RPC (S_proc_get_tty_reply
,
1912 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t tty
)
1913 ILL_RPC (S_proc_getnports_reply
,
1914 mach_port_t reply_port
, kern_return_t return_code
,
1915 mach_msg_type_number_t nports
)
1916 ILL_RPC (S_proc_is_important_reply
,
1917 mach_port_t reply_port
, kern_return_t return_code
,
1918 boolean_t essential
)
1919 ILL_RPC (S_proc_get_code_reply
,
1920 mach_port_t reply_port
, kern_return_t return_code
,
1921 vm_address_t start_code
, vm_address_t end_code
)
1923 /* Msg_reply server routines. We only use msg_sig_post_untraced_reply. */
1926 S_msg_sig_post_untraced_reply (mach_port_t reply
, error_t err
)
1928 struct inf
*inf
= waiting_inf
;
1931 /* EBUSY is what we get when the crash server has grabbed control of the
1932 process and doesn't like what signal we tried to send it. Just act
1933 like the process stopped (using a signal of 0 should mean that the
1934 *next* time the user continues, it will pass signal 0, which the crash
1935 server should like). */
1937 inf
->wait
.status
.kind
= TARGET_WAITKIND_STOPPED
;
1938 inf
->wait
.status
.value
.sig
= GDB_SIGNAL_0
;
1941 warning (_("Signal delivery failed: %s"), safe_strerror (err
));
1944 /* We only get this reply when we've posted a signal to a process which we
1945 thought was stopped, and which we expected to continue after the signal.
1946 Given that the signal has failed for some reason, it's reasonable to
1947 assume it's still stopped. */
1950 inf
->wait
.suppress
= 1;
1955 ILL_RPC (S_msg_sig_post_reply
,
1956 mach_port_t reply
, error_t err
)
1958 /* Returns the number of messages queued for the receive right PORT. */
1959 static mach_port_msgcount_t
1960 port_msgs_queued (mach_port_t port
)
1962 struct mach_port_status status
;
1964 mach_port_get_receive_status (mach_task_self (), port
, &status
);
1969 return status
.mps_msgcount
;
1973 /* Resume execution of the inferior process.
1975 If STEP is nonzero, single-step it.
1976 If SIGNAL is nonzero, give it that signal.
1979 -1 true Single step the current thread allowing other threads to run.
1980 -1 false Continue the current thread allowing other threads to run.
1981 X true Single step the given thread, don't allow any others to run.
1982 X false Continue the given thread, do not allow any others to run.
1983 (Where X, of course, is anything except -1)
1985 Note that a resume may not `take' if there are pending exceptions/&c
1986 still unprocessed from the last resume we did (any given resume may result
1987 in multiple events returned by wait). */
1990 gnu_resume (struct target_ops
*ops
,
1991 ptid_t ptid
, int step
, enum gdb_signal sig
)
1993 struct proc
*step_thread
= 0;
1995 struct inf
*inf
= gnu_current_inf
;
1997 inf_debug (inf
, "ptid = %s, step = %d, sig = %d",
1998 target_pid_to_str (ptid
), step
, sig
);
2000 inf_validate_procinfo (inf
);
2002 if (sig
!= GDB_SIGNAL_0
|| inf
->stopped
)
2004 if (sig
== GDB_SIGNAL_0
&& inf
->nomsg
)
2007 inf_signal (inf
, sig
);
2009 else if (inf
->wait
.exc
.reply
!= MACH_PORT_NULL
)
2010 /* We received an exception to which we have chosen not to forward, so
2011 abort the faulting thread, which will perhaps retake it. */
2013 proc_abort (inf
->wait
.thread
, 1);
2014 warning (_("Aborting %s with unforwarded exception %s."),
2015 proc_string (inf
->wait
.thread
),
2016 gdb_signal_to_name (inf
->wait
.status
.value
.sig
));
2019 if (port_msgs_queued (inf
->event_port
))
2020 /* If there are still messages in our event queue, don't bother resuming
2021 the process, as we're just going to stop it right away anyway. */
2024 inf_update_procs (inf
);
2026 /* A specific PTID means `step only this process id'. */
2027 resume_all
= ptid_equal (ptid
, minus_one_ptid
);
2030 /* Allow all threads to run, except perhaps single-stepping one. */
2032 inf_debug (inf
, "running all threads; tid = %d",
2033 ptid_get_pid (inferior_ptid
));
2034 ptid
= inferior_ptid
; /* What to step. */
2035 inf_set_threads_resume_sc (inf
, 0, 1);
2038 /* Just allow a single thread to run. */
2040 struct proc
*thread
= inf_tid_to_thread (inf
, ptid_get_lwp (ptid
));
2043 error (_("Can't run single thread id %s: no such thread!"),
2044 target_pid_to_str (ptid
));
2045 inf_debug (inf
, "running one thread: %s", target_pid_to_str (ptid
));
2046 inf_set_threads_resume_sc (inf
, thread
, 0);
2051 step_thread
= inf_tid_to_thread (inf
, ptid_get_lwp (ptid
));
2053 warning (_("Can't step thread id %s: no such thread."),
2054 target_pid_to_str (ptid
));
2056 inf_debug (inf
, "stepping thread: %s", target_pid_to_str (ptid
));
2058 if (step_thread
!= inf
->step_thread
)
2059 inf_set_step_thread (inf
, step_thread
);
2061 inf_debug (inf
, "here we go...");
2067 gnu_kill_inferior (struct target_ops
*ops
)
2069 struct proc
*task
= gnu_current_inf
->task
;
2073 proc_debug (task
, "terminating...");
2074 task_terminate (task
->port
);
2075 inf_set_pid (gnu_current_inf
, -1);
2077 target_mourn_inferior (inferior_ptid
);
2080 /* Clean up after the inferior dies. */
2082 gnu_mourn_inferior (struct target_ops
*ops
)
2084 inf_debug (gnu_current_inf
, "rip");
2085 inf_detach (gnu_current_inf
);
2086 inf_child_mourn_inferior (ops
);
2090 /* Fork an inferior process, and start debugging it. */
2092 /* Set INFERIOR_PID to the first thread available in the child, if any. */
2094 inf_pick_first_thread (void)
2096 if (gnu_current_inf
->task
&& gnu_current_inf
->threads
)
2097 /* The first thread. */
2098 return gnu_current_inf
->threads
->tid
;
2100 /* What may be the next thread. */
2101 return next_thread_id
;
2107 if (!gnu_current_inf
)
2108 gnu_current_inf
= make_inf ();
2109 return gnu_current_inf
;
2113 gnu_ptrace_me (void)
2115 /* We're in the child; make this process stop as soon as it execs. */
2116 struct inf
*inf
= cur_inf ();
2117 inf_debug (inf
, "tracing self");
2118 if (ptrace (PTRACE_TRACEME
) != 0)
2119 error (_("ptrace (PTRACE_TRACEME) failed!"));
2123 gnu_create_inferior (struct target_ops
*ops
,
2124 char *exec_file
, char *allargs
, char **env
,
2127 struct inf
*inf
= cur_inf ();
2130 inf_debug (inf
, "creating inferior");
2132 pid
= fork_inferior (exec_file
, allargs
, env
, gnu_ptrace_me
,
2133 NULL
, NULL
, NULL
, NULL
);
2135 /* Attach to the now stopped child, which is actually a shell... */
2136 inf_debug (inf
, "attaching to child: %d", pid
);
2138 inf_attach (inf
, pid
);
2142 inf
->pending_execs
= 1;
2146 /* Now let the child run again, knowing that it will stop
2147 immediately because of the ptrace. */
2150 /* We now have thread info. */
2151 thread_change_ptid (inferior_ptid
,
2152 ptid_build (inf
->pid
, inf_pick_first_thread (), 0));
2154 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
2155 inf
->pending_execs
= 0;
2157 inf_validate_procinfo (inf
);
2158 inf_update_signal_thread (inf
);
2159 inf_set_traced (inf
, inf
->want_signals
);
2161 /* Execing the process will have trashed our exception ports; steal them
2162 back (or make sure they're restored if the user wants that). */
2163 if (inf
->want_exceptions
)
2164 inf_steal_exc_ports (inf
);
2166 inf_restore_exc_ports (inf
);
2170 /* Attach to process PID, then initialize for debugging it
2171 and wait for the trace-trap that results from attaching. */
2173 gnu_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
2177 struct inf
*inf
= cur_inf ();
2178 struct inferior
*inferior
;
2180 pid
= parse_pid_to_attach (args
);
2182 if (pid
== getpid ()) /* Trying to masturbate? */
2183 error (_("I refuse to debug myself!"));
2187 exec_file
= (char *) get_exec_file (0);
2190 printf_unfiltered ("Attaching to program `%s', pid %d\n",
2193 printf_unfiltered ("Attaching to pid %d\n", pid
);
2195 gdb_flush (gdb_stdout
);
2198 inf_debug (inf
, "attaching to pid: %d", pid
);
2200 inf_attach (inf
, pid
);
2204 inferior
= current_inferior ();
2205 inferior_appeared (inferior
, pid
);
2206 inferior
->attach_flag
= 1;
2208 inf_update_procs (inf
);
2210 inferior_ptid
= ptid_build (pid
, inf_pick_first_thread (), 0);
2212 /* We have to initialize the terminal settings now, since the code
2213 below might try to restore them. */
2214 target_terminal_init ();
2216 /* If the process was stopped before we attached, make it continue the next
2217 time the user does a continue. */
2218 inf_validate_procinfo (inf
);
2220 inf_update_signal_thread (inf
);
2221 inf_set_traced (inf
, inf
->want_signals
);
2223 #if 0 /* Do we need this? */
2224 renumber_threads (0); /* Give our threads reasonable names. */
2229 /* Take a program previously attached to and detaches it.
2230 The program resumes execution and will no longer stop
2231 on signals, etc. We'd better not have left any breakpoints
2232 in the program or it'll die when it hits one. For this
2233 to work, it may be necessary for the process to have been
2234 previously attached. It *might* work if the program was
2235 started via fork. */
2237 gnu_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
2243 char *exec_file
= get_exec_file (0);
2246 printf_unfiltered ("Detaching from program `%s' pid %d\n",
2247 exec_file
, gnu_current_inf
->pid
);
2249 printf_unfiltered ("Detaching from pid %d\n", gnu_current_inf
->pid
);
2250 gdb_flush (gdb_stdout
);
2253 pid
= gnu_current_inf
->pid
;
2255 inf_detach (gnu_current_inf
);
2257 inferior_ptid
= null_ptid
;
2258 detach_inferior (pid
);
2260 inf_child_maybe_unpush_target (ops
);
2264 gnu_terminal_init (struct target_ops
*self
)
2266 gdb_assert (gnu_current_inf
);
2267 child_terminal_init_with_pgrp (gnu_current_inf
->pid
);
2271 gnu_stop (struct target_ops
*self
, ptid_t ptid
)
2273 error (_("to_stop target function not implemented"));
2277 gnu_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2279 inf_update_procs (gnu_current_inf
);
2280 return !!inf_tid_to_thread (gnu_current_inf
,
2281 ptid_get_lwp (ptid
));
2285 /* Read inferior task's LEN bytes from ADDR and copy it to MYADDR in
2286 gdb's address space. Return 0 on failure; number of bytes read
2289 gnu_read_inferior (task_t task
, CORE_ADDR addr
, gdb_byte
*myaddr
, int length
)
2292 vm_address_t low_address
= (vm_address_t
) trunc_page (addr
);
2293 vm_size_t aligned_length
=
2294 (vm_size_t
) round_page (addr
+ length
) - low_address
;
2296 mach_msg_type_number_t copy_count
;
2298 /* Get memory from inferior with page aligned addresses. */
2299 err
= vm_read (task
, low_address
, aligned_length
, &copied
, ©_count
);
2303 err
= hurd_safe_copyin (myaddr
, (void *) (addr
- low_address
+ copied
),
2307 warning (_("Read from inferior faulted: %s"), safe_strerror (err
));
2311 err
= vm_deallocate (mach_task_self (), copied
, copy_count
);
2313 warning (_("gnu_read_inferior vm_deallocate failed: %s"),
2314 safe_strerror (err
));
2319 #define CHK_GOTO_OUT(str,ret) \
2320 do if (ret != KERN_SUCCESS) { errstr = #str; goto out; } while(0)
2322 struct vm_region_list
2324 struct vm_region_list
*next
;
2325 vm_prot_t protection
;
2330 struct obstack region_obstack
;
2332 /* Write gdb's LEN bytes from MYADDR and copy it to ADDR in inferior
2333 task's address space. */
2335 gnu_write_inferior (task_t task
, CORE_ADDR addr
,
2336 const gdb_byte
*myaddr
, int length
)
2339 vm_address_t low_address
= (vm_address_t
) trunc_page (addr
);
2340 vm_size_t aligned_length
=
2341 (vm_size_t
) round_page (addr
+ length
) - low_address
;
2343 mach_msg_type_number_t copy_count
;
2346 char *errstr
= "Bug in gnu_write_inferior";
2348 struct vm_region_list
*region_element
;
2349 struct vm_region_list
*region_head
= NULL
;
2351 /* Get memory from inferior with page aligned addresses. */
2352 err
= vm_read (task
,
2357 CHK_GOTO_OUT ("gnu_write_inferior vm_read failed", err
);
2361 err
= hurd_safe_copyout ((void *) (addr
- low_address
+ copied
),
2363 CHK_GOTO_OUT ("Write to inferior faulted", err
);
2365 obstack_init (®ion_obstack
);
2367 /* Do writes atomically.
2368 First check for holes and unwritable memory. */
2370 vm_size_t remaining_length
= aligned_length
;
2371 vm_address_t region_address
= low_address
;
2373 struct vm_region_list
*scan
;
2375 while (region_address
< low_address
+ aligned_length
)
2377 vm_prot_t protection
;
2378 vm_prot_t max_protection
;
2379 vm_inherit_t inheritance
;
2381 mach_port_t object_name
;
2383 vm_size_t region_length
= remaining_length
;
2384 vm_address_t old_address
= region_address
;
2386 err
= vm_region (task
,
2395 CHK_GOTO_OUT ("vm_region failed", err
);
2397 /* Check for holes in memory. */
2398 if (old_address
!= region_address
)
2400 warning (_("No memory at 0x%lx. Nothing written"),
2407 if (!(max_protection
& VM_PROT_WRITE
))
2409 warning (_("Memory at address 0x%lx is unwritable. "
2417 /* Chain the regions for later use. */
2418 region_element
= XOBNEW (®ion_obstack
, struct vm_region_list
);
2420 region_element
->protection
= protection
;
2421 region_element
->start
= region_address
;
2422 region_element
->length
= region_length
;
2424 /* Chain the regions along with protections. */
2425 region_element
->next
= region_head
;
2426 region_head
= region_element
;
2428 region_address
+= region_length
;
2429 remaining_length
= remaining_length
- region_length
;
2432 /* If things fail after this, we give up.
2433 Somebody is messing up inferior_task's mappings. */
2435 /* Enable writes to the chained vm regions. */
2436 for (scan
= region_head
; scan
; scan
= scan
->next
)
2438 if (!(scan
->protection
& VM_PROT_WRITE
))
2440 err
= vm_protect (task
,
2444 scan
->protection
| VM_PROT_WRITE
);
2445 CHK_GOTO_OUT ("vm_protect: enable write failed", err
);
2449 err
= vm_write (task
,
2453 CHK_GOTO_OUT ("vm_write failed", err
);
2455 /* Set up the original region protections, if they were changed. */
2456 for (scan
= region_head
; scan
; scan
= scan
->next
)
2458 if (!(scan
->protection
& VM_PROT_WRITE
))
2460 err
= vm_protect (task
,
2465 CHK_GOTO_OUT ("vm_protect: enable write failed", err
);
2473 obstack_free (®ion_obstack
, 0);
2475 (void) vm_deallocate (mach_task_self (),
2480 if (err
!= KERN_SUCCESS
)
2482 warning (_("%s: %s"), errstr
, mach_error_string (err
));
2491 /* Implement the to_xfer_partial target_ops method for
2492 TARGET_OBJECT_MEMORY. */
2494 static enum target_xfer_status
2495 gnu_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2496 CORE_ADDR memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2498 task_t task
= (gnu_current_inf
2499 ? (gnu_current_inf
->task
2500 ? gnu_current_inf
->task
->port
: 0)
2504 if (task
== MACH_PORT_NULL
)
2505 return TARGET_XFER_E_IO
;
2507 if (writebuf
!= NULL
)
2509 inf_debug (gnu_current_inf
, "writing %s[%s] <-- %s",
2510 paddress (target_gdbarch (), memaddr
), pulongest (len
),
2511 host_address_to_string (writebuf
));
2512 res
= gnu_write_inferior (task
, memaddr
, writebuf
, len
);
2516 inf_debug (gnu_current_inf
, "reading %s[%s] --> %s",
2517 paddress (target_gdbarch (), memaddr
), pulongest (len
),
2518 host_address_to_string (readbuf
));
2519 res
= gnu_read_inferior (task
, memaddr
, readbuf
, len
);
2521 gdb_assert (res
>= 0);
2523 return TARGET_XFER_E_IO
;
2526 *xfered_len
= (ULONGEST
) res
;
2527 return TARGET_XFER_OK
;
2531 /* Target to_xfer_partial implementation. */
2533 static enum target_xfer_status
2534 gnu_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2535 const char *annex
, gdb_byte
*readbuf
,
2536 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
2537 ULONGEST
*xfered_len
)
2541 case TARGET_OBJECT_MEMORY
:
2542 return gnu_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2544 return TARGET_XFER_E_IO
;
2548 /* Call FUNC on each memory region in the task. */
2550 gnu_find_memory_regions (struct target_ops
*self
,
2551 find_memory_region_ftype func
, void *data
)
2555 vm_address_t region_address
, last_region_address
, last_region_end
;
2556 vm_prot_t last_protection
;
2558 if (gnu_current_inf
== 0 || gnu_current_inf
->task
== 0)
2560 task
= gnu_current_inf
->task
->port
;
2561 if (task
== MACH_PORT_NULL
)
2564 region_address
= last_region_address
= last_region_end
= VM_MIN_ADDRESS
;
2565 last_protection
= VM_PROT_NONE
;
2566 while (region_address
< VM_MAX_ADDRESS
)
2568 vm_prot_t protection
;
2569 vm_prot_t max_protection
;
2570 vm_inherit_t inheritance
;
2572 mach_port_t object_name
;
2574 vm_size_t region_length
= VM_MAX_ADDRESS
- region_address
;
2575 vm_address_t old_address
= region_address
;
2577 err
= vm_region (task
,
2586 if (err
== KERN_NO_SPACE
)
2588 if (err
!= KERN_SUCCESS
)
2590 warning (_("vm_region failed: %s"), mach_error_string (err
));
2594 if (protection
== last_protection
&& region_address
== last_region_end
)
2595 /* This region is contiguous with and indistinguishable from
2596 the previous one, so we just extend that one. */
2597 last_region_end
= region_address
+= region_length
;
2600 /* This region is distinct from the last one we saw, so report
2601 that previous one. */
2602 if (last_protection
!= VM_PROT_NONE
)
2603 (*func
) (last_region_address
,
2604 last_region_end
- last_region_address
,
2605 last_protection
& VM_PROT_READ
,
2606 last_protection
& VM_PROT_WRITE
,
2607 last_protection
& VM_PROT_EXECUTE
,
2608 1, /* MODIFIED is unknown, pass it as true. */
2610 last_region_address
= region_address
;
2611 last_region_end
= region_address
+= region_length
;
2612 last_protection
= protection
;
2616 /* Report the final region. */
2617 if (last_region_end
> last_region_address
&& last_protection
!= VM_PROT_NONE
)
2618 (*func
) (last_region_address
, last_region_end
- last_region_address
,
2619 last_protection
& VM_PROT_READ
,
2620 last_protection
& VM_PROT_WRITE
,
2621 last_protection
& VM_PROT_EXECUTE
,
2622 1, /* MODIFIED is unknown, pass it as true. */
2629 /* Return printable description of proc. */
2631 proc_string (struct proc
*proc
)
2633 static char tid_str
[80];
2635 if (proc_is_task (proc
))
2636 xsnprintf (tid_str
, sizeof (tid_str
), "process %d", proc
->inf
->pid
);
2638 xsnprintf (tid_str
, sizeof (tid_str
), "Thread %d.%d",
2639 proc
->inf
->pid
, proc
->tid
);
2644 gnu_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2646 struct inf
*inf
= gnu_current_inf
;
2647 int tid
= ptid_get_lwp (ptid
);
2648 struct proc
*thread
= inf_tid_to_thread (inf
, tid
);
2651 return proc_string (thread
);
2654 static char tid_str
[80];
2656 xsnprintf (tid_str
, sizeof (tid_str
), "bogus thread id %d", tid
);
2662 /* Create a prototype generic GNU/Hurd target. The client can
2663 override it with local methods. */
2668 struct target_ops
*t
= inf_child_target ();
2670 t
->to_attach
= gnu_attach
;
2671 t
->to_attach_no_wait
= 1;
2672 t
->to_detach
= gnu_detach
;
2673 t
->to_resume
= gnu_resume
;
2674 t
->to_wait
= gnu_wait
;
2675 t
->to_xfer_partial
= gnu_xfer_partial
;
2676 t
->to_find_memory_regions
= gnu_find_memory_regions
;
2677 t
->to_terminal_init
= gnu_terminal_init
;
2678 t
->to_kill
= gnu_kill_inferior
;
2679 t
->to_create_inferior
= gnu_create_inferior
;
2680 t
->to_mourn_inferior
= gnu_mourn_inferior
;
2681 t
->to_thread_alive
= gnu_thread_alive
;
2682 t
->to_pid_to_str
= gnu_pid_to_str
;
2683 t
->to_stop
= gnu_stop
;
2689 /* User task commands. */
2691 static struct cmd_list_element
*set_task_cmd_list
= 0;
2692 static struct cmd_list_element
*show_task_cmd_list
= 0;
2693 /* User thread commands. */
2695 /* Commands with a prefix of `set/show thread'. */
2696 extern struct cmd_list_element
*thread_cmd_list
;
2697 struct cmd_list_element
*set_thread_cmd_list
= NULL
;
2698 struct cmd_list_element
*show_thread_cmd_list
= NULL
;
2700 /* Commands with a prefix of `set/show thread default'. */
2701 struct cmd_list_element
*set_thread_default_cmd_list
= NULL
;
2702 struct cmd_list_element
*show_thread_default_cmd_list
= NULL
;
2705 set_thread_cmd (char *args
, int from_tty
)
2707 printf_unfiltered ("\"set thread\" must be followed by the "
2708 "name of a thread property, or \"default\".\n");
2712 show_thread_cmd (char *args
, int from_tty
)
2714 printf_unfiltered ("\"show thread\" must be followed by the "
2715 "name of a thread property, or \"default\".\n");
2719 set_thread_default_cmd (char *args
, int from_tty
)
2721 printf_unfiltered ("\"set thread default\" must be followed "
2722 "by the name of a thread property.\n");
2726 show_thread_default_cmd (char *args
, int from_tty
)
2728 printf_unfiltered ("\"show thread default\" must be followed "
2729 "by the name of a thread property.\n");
2733 parse_int_arg (char *args
, char *cmd_prefix
)
2738 int val
= strtoul (args
, &arg_end
, 10);
2740 if (*args
&& *arg_end
== '\0')
2743 error (_("Illegal argument for \"%s\" command, should be an integer."),
2748 _parse_bool_arg (char *args
, char *t_val
, char *f_val
, char *cmd_prefix
)
2750 if (!args
|| strcmp (args
, t_val
) == 0)
2752 else if (strcmp (args
, f_val
) == 0)
2755 error (_("Illegal argument for \"%s\" command, "
2756 "should be \"%s\" or \"%s\"."),
2757 cmd_prefix
, t_val
, f_val
);
2760 #define parse_bool_arg(args, cmd_prefix) \
2761 _parse_bool_arg (args, "on", "off", cmd_prefix)
2764 check_empty (char *args
, char *cmd_prefix
)
2767 error (_("Garbage after \"%s\" command: `%s'"), cmd_prefix
, args
);
2770 /* Returns the alive thread named by INFERIOR_PID, or signals an error. */
2771 static struct proc
*
2774 struct inf
*inf
= cur_inf ();
2775 struct proc
*thread
= inf_tid_to_thread (inf
,
2776 ptid_get_lwp (inferior_ptid
));
2778 error (_("No current thread."));
2782 /* Returns the current inferior, but signals an error if it has no task. */
2786 struct inf
*inf
= cur_inf ();
2789 error (_("No current process."));
2795 set_task_pause_cmd (char *args
, int from_tty
)
2797 struct inf
*inf
= cur_inf ();
2798 int old_sc
= inf
->pause_sc
;
2800 inf
->pause_sc
= parse_bool_arg (args
, "set task pause");
2802 if (old_sc
== 0 && inf
->pause_sc
!= 0)
2803 /* If the task is currently unsuspended, immediately suspend it,
2804 otherwise wait until the next time it gets control. */
2809 show_task_pause_cmd (char *args
, int from_tty
)
2811 struct inf
*inf
= cur_inf ();
2813 check_empty (args
, "show task pause");
2814 printf_unfiltered ("The inferior task %s suspended while gdb has control.\n",
2816 ? (inf
->pause_sc
== 0 ? "isn't" : "is")
2817 : (inf
->pause_sc
== 0 ? "won't be" : "will be"));
2821 set_task_detach_sc_cmd (char *args
, int from_tty
)
2823 cur_inf ()->detach_sc
= parse_int_arg (args
,
2824 "set task detach-suspend-count");
2828 show_task_detach_sc_cmd (char *args
, int from_tty
)
2830 check_empty (args
, "show task detach-suspend-count");
2831 printf_unfiltered ("The inferior task will be left with a "
2832 "suspend count of %d when detaching.\n",
2833 cur_inf ()->detach_sc
);
2838 set_thread_default_pause_cmd (char *args
, int from_tty
)
2840 struct inf
*inf
= cur_inf ();
2842 inf
->default_thread_pause_sc
=
2843 parse_bool_arg (args
, "set thread default pause") ? 0 : 1;
2847 show_thread_default_pause_cmd (char *args
, int from_tty
)
2849 struct inf
*inf
= cur_inf ();
2850 int sc
= inf
->default_thread_pause_sc
;
2852 check_empty (args
, "show thread default pause");
2853 printf_unfiltered ("New threads %s suspended while gdb has control%s.\n",
2854 sc
? "are" : "aren't",
2855 !sc
&& inf
->pause_sc
? " (but the task is)" : "");
2859 set_thread_default_run_cmd (char *args
, int from_tty
)
2861 struct inf
*inf
= cur_inf ();
2863 inf
->default_thread_run_sc
=
2864 parse_bool_arg (args
, "set thread default run") ? 0 : 1;
2868 show_thread_default_run_cmd (char *args
, int from_tty
)
2870 struct inf
*inf
= cur_inf ();
2872 check_empty (args
, "show thread default run");
2873 printf_unfiltered ("New threads %s allowed to run.\n",
2874 inf
->default_thread_run_sc
== 0 ? "are" : "aren't");
2878 set_thread_default_detach_sc_cmd (char *args
, int from_tty
)
2880 cur_inf ()->default_thread_detach_sc
=
2881 parse_int_arg (args
, "set thread default detach-suspend-count");
2885 show_thread_default_detach_sc_cmd (char *args
, int from_tty
)
2887 check_empty (args
, "show thread default detach-suspend-count");
2888 printf_unfiltered ("New threads will get a detach-suspend-count of %d.\n",
2889 cur_inf ()->default_thread_detach_sc
);
2893 /* Steal a send right called NAME in the inferior task, and make it PROC's
2894 saved exception port. */
2896 steal_exc_port (struct proc
*proc
, mach_port_t name
)
2900 mach_msg_type_name_t port_type
;
2902 if (!proc
|| !proc
->inf
->task
)
2903 error (_("No inferior task."));
2905 err
= mach_port_extract_right (proc
->inf
->task
->port
,
2906 name
, MACH_MSG_TYPE_COPY_SEND
,
2909 error (_("Couldn't extract send right %lu from inferior: %s"),
2910 name
, safe_strerror (err
));
2912 if (proc
->saved_exc_port
)
2913 /* Get rid of our reference to the old one. */
2914 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
2916 proc
->saved_exc_port
= port
;
2918 if (!proc
->exc_port
)
2919 /* If PROC is a thread, we may not have set its exception port
2920 before. We can't use proc_steal_exc_port because it also sets
2923 proc
->exc_port
= proc
->inf
->event_port
;
2924 err
= proc_set_exception_port (proc
, proc
->exc_port
);
2925 error (_("Can't set exception port for %s: %s"),
2926 proc_string (proc
), safe_strerror (err
));
2931 set_task_exc_port_cmd (char *args
, int from_tty
)
2933 struct inf
*inf
= cur_inf ();
2936 error (_("No argument to \"set task exception-port\" command."));
2937 steal_exc_port (inf
->task
, parse_and_eval_address (args
));
2941 set_stopped_cmd (char *args
, int from_tty
)
2943 cur_inf ()->stopped
= _parse_bool_arg (args
, "yes", "no", "set stopped");
2947 show_stopped_cmd (char *args
, int from_tty
)
2949 struct inf
*inf
= active_inf ();
2951 check_empty (args
, "show stopped");
2952 printf_unfiltered ("The inferior process %s stopped.\n",
2953 inf
->stopped
? "is" : "isn't");
2957 set_sig_thread_cmd (char *args
, int from_tty
)
2959 struct inf
*inf
= cur_inf ();
2961 if (!args
|| (!isdigit (*args
) && strcmp (args
, "none") != 0))
2962 error (_("Illegal argument to \"set signal-thread\" command.\n"
2963 "Should be an integer thread ID, or `none'."));
2965 if (strcmp (args
, "none") == 0)
2966 inf
->signal_thread
= 0;
2969 ptid_t ptid
= global_thread_id_to_ptid (atoi (args
));
2971 if (ptid_equal (ptid
, minus_one_ptid
))
2972 error (_("Thread ID %s not known. "
2973 "Use the \"info threads\" command to\n"
2974 "see the IDs of currently known threads."), args
);
2975 inf
->signal_thread
= inf_tid_to_thread (inf
, ptid_get_lwp (ptid
));
2980 show_sig_thread_cmd (char *args
, int from_tty
)
2982 struct inf
*inf
= active_inf ();
2984 check_empty (args
, "show signal-thread");
2985 if (inf
->signal_thread
)
2986 printf_unfiltered ("The signal thread is %s.\n",
2987 proc_string (inf
->signal_thread
));
2989 printf_unfiltered ("There is no signal thread.\n");
2994 set_signals_cmd (char *args
, int from_tty
)
2996 struct inf
*inf
= cur_inf ();
2998 inf
->want_signals
= parse_bool_arg (args
, "set signals");
3000 if (inf
->task
&& inf
->want_signals
!= inf
->traced
)
3001 /* Make this take effect immediately in a running process. */
3002 inf_set_traced (inf
, inf
->want_signals
);
3006 show_signals_cmd (char *args
, int from_tty
)
3008 struct inf
*inf
= cur_inf ();
3010 check_empty (args
, "show signals");
3011 printf_unfiltered ("The inferior process's signals %s intercepted.\n",
3013 ? (inf
->traced
? "are" : "aren't")
3014 : (inf
->want_signals
? "will be" : "won't be"));
3018 set_exceptions_cmd (char *args
, int from_tty
)
3020 struct inf
*inf
= cur_inf ();
3021 int val
= parse_bool_arg (args
, "set exceptions");
3023 /* Make this take effect immediately in a running process. */
3026 inf
->want_exceptions
= val
;
3030 show_exceptions_cmd (char *args
, int from_tty
)
3032 struct inf
*inf
= cur_inf ();
3034 check_empty (args
, "show exceptions");
3035 printf_unfiltered ("Exceptions in the inferior %s trapped.\n",
3037 ? (inf
->want_exceptions
? "are" : "aren't")
3038 : (inf
->want_exceptions
? "will be" : "won't be"));
3043 set_task_cmd (char *args
, int from_tty
)
3045 printf_unfiltered ("\"set task\" must be followed by the name"
3046 " of a task property.\n");
3050 show_task_cmd (char *args
, int from_tty
)
3052 struct inf
*inf
= cur_inf ();
3054 check_empty (args
, "show task");
3056 show_signals_cmd (0, from_tty
);
3057 show_exceptions_cmd (0, from_tty
);
3058 show_task_pause_cmd (0, from_tty
);
3060 if (inf
->pause_sc
== 0)
3061 show_thread_default_pause_cmd (0, from_tty
);
3062 show_thread_default_run_cmd (0, from_tty
);
3066 show_stopped_cmd (0, from_tty
);
3067 show_sig_thread_cmd (0, from_tty
);
3070 if (inf
->detach_sc
!= 0)
3071 show_task_detach_sc_cmd (0, from_tty
);
3072 if (inf
->default_thread_detach_sc
!= 0)
3073 show_thread_default_detach_sc_cmd (0, from_tty
);
3078 set_noninvasive_cmd (char *args
, int from_tty
)
3080 /* Invert the sense of the arg for each component. */
3081 char *inv_args
= parse_bool_arg (args
, "set noninvasive") ? "off" : "on";
3083 set_task_pause_cmd (inv_args
, from_tty
);
3084 set_signals_cmd (inv_args
, from_tty
);
3085 set_exceptions_cmd (inv_args
, from_tty
);
3090 info_port_rights (const char *args
, mach_port_type_t only
)
3092 struct inf
*inf
= active_inf ();
3093 struct value
*vmark
= value_mark ();
3096 /* Explicit list of port rights. */
3100 struct value
*val
= parse_to_comma_and_eval (&args
);
3101 long right
= value_as_long (val
);
3103 print_port_info (right
, 0, inf
->task
->port
, PORTINFO_DETAILS
,
3107 error (_("%ld: %s."), right
, safe_strerror (err
));
3111 /* Print all of them. */
3114 print_task_ports_info (inf
->task
->port
, only
, PORTINFO_DETAILS
,
3117 error (_("%s."), safe_strerror (err
));
3120 value_free_to_mark (vmark
);
3124 info_send_rights_cmd (char *args
, int from_tty
)
3126 info_port_rights (args
, MACH_PORT_TYPE_SEND
);
3130 info_recv_rights_cmd (char *args
, int from_tty
)
3132 info_port_rights (args
, MACH_PORT_TYPE_RECEIVE
);
3136 info_port_sets_cmd (char *args
, int from_tty
)
3138 info_port_rights (args
, MACH_PORT_TYPE_PORT_SET
);
3142 info_dead_names_cmd (char *args
, int from_tty
)
3144 info_port_rights (args
, MACH_PORT_TYPE_DEAD_NAME
);
3148 info_port_rights_cmd (char *args
, int from_tty
)
3150 info_port_rights (args
, ~0);
3155 add_task_commands (void)
3157 add_cmd ("pause", class_run
, set_thread_default_pause_cmd
, _("\
3158 Set whether the new threads are suspended while gdb has control.\n\
3159 This property normally has no effect because the whole task is\n\
3160 suspended, however, that may be disabled with \"set task pause off\".\n\
3161 The default value is \"off\"."),
3162 &set_thread_default_cmd_list
);
3163 add_cmd ("pause", no_class
, show_thread_default_pause_cmd
, _("\
3164 Show whether new threads are suspended while gdb has control."),
3165 &show_thread_default_cmd_list
);
3167 add_cmd ("run", class_run
, set_thread_default_run_cmd
, _("\
3168 Set whether new threads are allowed to run (once gdb has noticed them)."),
3169 &set_thread_default_cmd_list
);
3170 add_cmd ("run", no_class
, show_thread_default_run_cmd
, _("\
3171 Show whether new threads are allowed to run (once gdb has noticed them)."),
3172 &show_thread_default_cmd_list
);
3174 add_cmd ("detach-suspend-count", class_run
, set_thread_default_detach_sc_cmd
,
3175 _("Set the default detach-suspend-count value for new threads."),
3176 &set_thread_default_cmd_list
);
3177 add_cmd ("detach-suspend-count", no_class
, show_thread_default_detach_sc_cmd
,
3178 _("Show the default detach-suspend-count value for new threads."),
3179 &show_thread_default_cmd_list
);
3181 add_cmd ("signals", class_run
, set_signals_cmd
, _("\
3182 Set whether the inferior process's signals will be intercepted.\n\
3183 Mach exceptions (such as breakpoint traps) are not affected."),
3185 add_alias_cmd ("sigs", "signals", class_run
, 1, &setlist
);
3186 add_cmd ("signals", no_class
, show_signals_cmd
, _("\
3187 Show whether the inferior process's signals will be intercepted."),
3189 add_alias_cmd ("sigs", "signals", no_class
, 1, &showlist
);
3191 add_cmd ("signal-thread", class_run
, set_sig_thread_cmd
, _("\
3192 Set the thread that gdb thinks is the libc signal thread.\n\
3193 This thread is run when delivering a signal to a non-stopped process."),
3195 add_alias_cmd ("sigthread", "signal-thread", class_run
, 1, &setlist
);
3196 add_cmd ("signal-thread", no_class
, show_sig_thread_cmd
, _("\
3197 Set the thread that gdb thinks is the libc signal thread."),
3199 add_alias_cmd ("sigthread", "signal-thread", no_class
, 1, &showlist
);
3201 add_cmd ("stopped", class_run
, set_stopped_cmd
, _("\
3202 Set whether gdb thinks the inferior process is stopped as with SIGSTOP.\n\
3203 Stopped process will be continued by sending them a signal."),
3205 add_cmd ("stopped", no_class
, show_stopped_cmd
, _("\
3206 Show whether gdb thinks the inferior process is stopped as with SIGSTOP."),
3209 add_cmd ("exceptions", class_run
, set_exceptions_cmd
, _("\
3210 Set whether exceptions in the inferior process will be trapped.\n\
3211 When exceptions are turned off, neither breakpoints nor single-stepping\n\
3214 /* Allow `set exc' despite conflict with `set exception-port'. */
3215 add_alias_cmd ("exc", "exceptions", class_run
, 1, &setlist
);
3216 add_cmd ("exceptions", no_class
, show_exceptions_cmd
, _("\
3217 Show whether exceptions in the inferior process will be trapped."),
3220 add_prefix_cmd ("task", no_class
, set_task_cmd
,
3221 _("Command prefix for setting task attributes."),
3222 &set_task_cmd_list
, "set task ", 0, &setlist
);
3223 add_prefix_cmd ("task", no_class
, show_task_cmd
,
3224 _("Command prefix for showing task attributes."),
3225 &show_task_cmd_list
, "show task ", 0, &showlist
);
3227 add_cmd ("pause", class_run
, set_task_pause_cmd
, _("\
3228 Set whether the task is suspended while gdb has control.\n\
3229 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3230 until the next time the program is continued.\n\
3231 When setting this to \"off\", \"set thread default pause on\" can be\n\
3232 used to pause individual threads by default instead."),
3233 &set_task_cmd_list
);
3234 add_cmd ("pause", no_class
, show_task_pause_cmd
,
3235 _("Show whether the task is suspended while gdb has control."),
3236 &show_task_cmd_list
);
3238 add_cmd ("detach-suspend-count", class_run
, set_task_detach_sc_cmd
,
3239 _("Set the suspend count will leave on the thread when detaching."),
3240 &set_task_cmd_list
);
3241 add_cmd ("detach-suspend-count", no_class
, show_task_detach_sc_cmd
,
3242 _("Show the suspend count will leave "
3243 "on the thread when detaching."),
3244 &show_task_cmd_list
);
3246 add_cmd ("exception-port", no_class
, set_task_exc_port_cmd
, _("\
3247 Set the task exception port to which we forward exceptions.\n\
3248 The argument should be the value of the send right in the task."),
3249 &set_task_cmd_list
);
3250 add_alias_cmd ("excp", "exception-port", no_class
, 1, &set_task_cmd_list
);
3251 add_alias_cmd ("exc-port", "exception-port", no_class
, 1,
3252 &set_task_cmd_list
);
3254 /* A convenient way of turning on all options require to noninvasively
3255 debug running tasks. */
3256 add_cmd ("noninvasive", no_class
, set_noninvasive_cmd
, _("\
3257 Set task options so that we interfere as little as possible.\n\
3258 This is the same as setting `task pause', `exceptions', and\n\
3259 `signals' to the opposite value."),
3262 /* Commands to show information about the task's ports. */
3263 add_info ("send-rights", info_send_rights_cmd
,
3264 _("Show information about the task's send rights"));
3265 add_info ("receive-rights", info_recv_rights_cmd
,
3266 _("Show information about the task's receive rights"));
3267 add_info ("port-rights", info_port_rights_cmd
,
3268 _("Show information about the task's port rights"));
3269 add_info ("port-sets", info_port_sets_cmd
,
3270 _("Show information about the task's port sets"));
3271 add_info ("dead-names", info_dead_names_cmd
,
3272 _("Show information about the task's dead names"));
3273 add_info_alias ("ports", "port-rights", 1);
3274 add_info_alias ("port", "port-rights", 1);
3275 add_info_alias ("psets", "port-sets", 1);
3280 set_thread_pause_cmd (char *args
, int from_tty
)
3282 struct proc
*thread
= cur_thread ();
3283 int old_sc
= thread
->pause_sc
;
3285 thread
->pause_sc
= parse_bool_arg (args
, "set thread pause");
3286 if (old_sc
== 0 && thread
->pause_sc
!= 0 && thread
->inf
->pause_sc
== 0)
3287 /* If the task is currently unsuspended, immediately suspend it,
3288 otherwise wait until the next time it gets control. */
3289 inf_suspend (thread
->inf
);
3293 show_thread_pause_cmd (char *args
, int from_tty
)
3295 struct proc
*thread
= cur_thread ();
3296 int sc
= thread
->pause_sc
;
3298 check_empty (args
, "show task pause");
3299 printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n",
3300 proc_string (thread
),
3301 sc
? "is" : "isn't",
3302 !sc
&& thread
->inf
->pause_sc
? " (but the task is)" : "");
3306 set_thread_run_cmd (char *args
, int from_tty
)
3308 struct proc
*thread
= cur_thread ();
3310 thread
->run_sc
= parse_bool_arg (args
, "set thread run") ? 0 : 1;
3314 show_thread_run_cmd (char *args
, int from_tty
)
3316 struct proc
*thread
= cur_thread ();
3318 check_empty (args
, "show thread run");
3319 printf_unfiltered ("Thread %s %s allowed to run.",
3320 proc_string (thread
),
3321 thread
->run_sc
== 0 ? "is" : "isn't");
3325 set_thread_detach_sc_cmd (char *args
, int from_tty
)
3327 cur_thread ()->detach_sc
= parse_int_arg (args
,
3328 "set thread detach-suspend-count");
3332 show_thread_detach_sc_cmd (char *args
, int from_tty
)
3334 struct proc
*thread
= cur_thread ();
3336 check_empty (args
, "show thread detach-suspend-count");
3337 printf_unfiltered ("Thread %s will be left with a suspend count"
3338 " of %d when detaching.\n",
3339 proc_string (thread
),
3344 set_thread_exc_port_cmd (char *args
, int from_tty
)
3346 struct proc
*thread
= cur_thread ();
3349 error (_("No argument to \"set thread exception-port\" command."));
3350 steal_exc_port (thread
, parse_and_eval_address (args
));
3355 show_thread_cmd (char *args
, int from_tty
)
3357 struct proc
*thread
= cur_thread ();
3359 check_empty (args
, "show thread");
3360 show_thread_run_cmd (0, from_tty
);
3361 show_thread_pause_cmd (0, from_tty
);
3362 if (thread
->detach_sc
!= 0)
3363 show_thread_detach_sc_cmd (0, from_tty
);
3368 thread_takeover_sc_cmd (char *args
, int from_tty
)
3370 struct proc
*thread
= cur_thread ();
3372 thread_basic_info_data_t _info
;
3373 thread_basic_info_t info
= &_info
;
3374 mach_msg_type_number_t info_len
= THREAD_BASIC_INFO_COUNT
;
3376 thread_info (thread
->port
, THREAD_BASIC_INFO
, (int *) &info
, &info_len
);
3378 error (("%s."), safe_strerror (err
));
3379 thread
->sc
= info
->suspend_count
;
3381 printf_unfiltered ("Suspend count was %d.\n", thread
->sc
);
3383 vm_deallocate (mach_task_self (), (vm_address_t
) info
,
3384 info_len
* sizeof (int));
3389 add_thread_commands (void)
3391 add_prefix_cmd ("thread", no_class
, set_thread_cmd
,
3392 _("Command prefix for setting thread properties."),
3393 &set_thread_cmd_list
, "set thread ", 0, &setlist
);
3394 add_prefix_cmd ("default", no_class
, show_thread_cmd
,
3395 _("Command prefix for setting default thread properties."),
3396 &set_thread_default_cmd_list
, "set thread default ", 0,
3397 &set_thread_cmd_list
);
3398 add_prefix_cmd ("thread", no_class
, set_thread_default_cmd
,
3399 _("Command prefix for showing thread properties."),
3400 &show_thread_cmd_list
, "show thread ", 0, &showlist
);
3401 add_prefix_cmd ("default", no_class
, show_thread_default_cmd
,
3402 _("Command prefix for showing default thread properties."),
3403 &show_thread_default_cmd_list
, "show thread default ", 0,
3404 &show_thread_cmd_list
);
3406 add_cmd ("pause", class_run
, set_thread_pause_cmd
, _("\
3407 Set whether the current thread is suspended while gdb has control.\n\
3408 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3409 until the next time the program is continued. This property normally\n\
3410 has no effect because the whole task is suspended, however, that may\n\
3411 be disabled with \"set task pause off\".\n\
3412 The default value is \"off\"."),
3413 &set_thread_cmd_list
);
3414 add_cmd ("pause", no_class
, show_thread_pause_cmd
, _("\
3415 Show whether the current thread is suspended while gdb has control."),
3416 &show_thread_cmd_list
);
3418 add_cmd ("run", class_run
, set_thread_run_cmd
,
3419 _("Set whether the current thread is allowed to run."),
3420 &set_thread_cmd_list
);
3421 add_cmd ("run", no_class
, show_thread_run_cmd
,
3422 _("Show whether the current thread is allowed to run."),
3423 &show_thread_cmd_list
);
3425 add_cmd ("detach-suspend-count", class_run
, set_thread_detach_sc_cmd
, _("\
3426 Set the suspend count will leave on the thread when detaching.\n\
3427 Note that this is relative to suspend count when gdb noticed the thread;\n\
3428 use the `thread takeover-suspend-count' to force it to an absolute value."),
3429 &set_thread_cmd_list
);
3430 add_cmd ("detach-suspend-count", no_class
, show_thread_detach_sc_cmd
, _("\
3431 Show the suspend count will leave on the thread when detaching.\n\
3432 Note that this is relative to suspend count when gdb noticed the thread;\n\
3433 use the `thread takeover-suspend-count' to force it to an absolute value."),
3434 &show_thread_cmd_list
);
3436 add_cmd ("exception-port", no_class
, set_thread_exc_port_cmd
, _("\
3437 Set the thread exception port to which we forward exceptions.\n\
3438 This overrides the task exception port.\n\
3439 The argument should be the value of the send right in the task."),
3440 &set_thread_cmd_list
);
3441 add_alias_cmd ("excp", "exception-port", no_class
, 1, &set_thread_cmd_list
);
3442 add_alias_cmd ("exc-port", "exception-port", no_class
, 1,
3443 &set_thread_cmd_list
);
3445 add_cmd ("takeover-suspend-count", no_class
, thread_takeover_sc_cmd
, _("\
3446 Force the threads absolute suspend-count to be gdb's.\n\
3447 Prior to giving this command, gdb's thread suspend-counts are relative\n\
3448 to the thread's initial suspend-count when gdb notices the threads."),
3454 /* -Wmissing-prototypes */
3455 extern initialize_file_ftype _initialize_gnu_nat
;
3458 _initialize_gnu_nat (void)
3460 proc_server
= getproc ();
3462 add_task_commands ();
3463 add_thread_commands ();
3464 add_setshow_boolean_cmd ("gnu-nat", class_maintenance
,
3466 _("Set debugging output for the gnu backend."),
3467 _("Show debugging output for the gnu backend."),
3475 #ifdef FLUSH_INFERIOR_CACHE
3477 /* When over-writing code on some machines the I-Cache must be flushed
3478 explicitly, because it is not kept coherent by the lazy hardware.
3479 This definitely includes breakpoints, for instance, or else we
3480 end up looping in mysterious Bpt traps. */
3483 flush_inferior_icache (CORE_ADDR pc
, int amount
)
3485 vm_machine_attribute_val_t flush
= MATTR_VAL_ICACHE_FLUSH
;
3488 ret
= vm_machine_attribute (gnu_current_inf
->task
->port
,
3493 if (ret
!= KERN_SUCCESS
)
3494 warning (_("Error flushing inferior's cache : %s"), safe_strerror (ret
));
3496 #endif /* FLUSH_INFERIOR_CACHE */