1 /* Interface GDB to the GNU Hurd.
2 Copyright (C) 1992-2019 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/>. */
23 /* Include this first, to pick up the <mach.h> 'thread_info' diversion. */
26 /* Mach/Hurd headers are not yet ready for C++ compilation. */
30 #include <mach_error.h>
31 #include <mach/exception.h>
32 #include <mach/message.h>
33 #include <mach/notify.h>
34 #include <mach/vm_attributes.h>
37 #include <hurd/interrupt.h>
39 #include <hurd/msg_request.h>
40 #include <hurd/process.h>
41 /* Defined in <hurd/process.h>, but we need forward declarations from
42 <hurd/process_request.h> as well. */
44 #include <hurd/process_request.h>
45 #include <hurd/signal.h>
46 #include <hurd/sigpreempt.h>
57 #include <sys/ptrace.h>
66 #include "common/gdb_wait.h"
69 #include "gdbthread.h"
70 #include "gdb_obstack.h"
71 #include "tid-parse.h"
72 #include "nat/fork-inferior.h"
74 #include "inf-child.h"
76 /* MIG stubs are not yet ready for C++ compilation. */
79 #include "exc_request_S.h"
81 #include "process_reply_S.h"
82 #include "msg_reply_S.h"
83 #include "exc_request_U.h"
87 static process_t proc_server
= MACH_PORT_NULL
;
89 /* If we've sent a proc_wait_request to the proc server, the pid of the
90 process we asked about. We can only ever have one outstanding. */
91 int proc_wait_pid
= 0;
93 /* The number of wait requests we've sent, and expect replies from. */
94 int proc_waits_pending
= 0;
96 int gnu_debug_flag
= 0;
100 static struct inf
*make_inf ();
101 void inf_clear_wait (struct inf
*inf
);
102 void inf_cleanup (struct inf
*inf
);
103 void inf_startup (struct inf
*inf
, int pid
);
104 int inf_update_suspends (struct inf
*inf
);
105 void inf_set_pid (struct inf
*inf
, pid_t pid
);
106 void inf_validate_procs (struct inf
*inf
);
107 void inf_steal_exc_ports (struct inf
*inf
);
108 void inf_restore_exc_ports (struct inf
*inf
);
109 void inf_set_threads_resume_sc (struct inf
*inf
,
110 struct proc
*run_thread
,
112 int inf_set_threads_resume_sc_for_signal_thread (struct inf
*inf
);
113 void inf_suspend (struct inf
*inf
);
114 void inf_resume (struct inf
*inf
);
115 void inf_set_step_thread (struct inf
*inf
, struct proc
*proc
);
116 void inf_detach (struct inf
*inf
);
117 void inf_attach (struct inf
*inf
, int pid
);
118 void inf_signal (struct inf
*inf
, enum gdb_signal sig
);
119 void inf_continue (struct inf
*inf
);
121 #define inf_debug(_inf, msg, args...) \
122 do { struct inf *__inf = (_inf); \
123 debug ("{inf %d %s}: " msg, __inf->pid, \
124 host_address_to_string (__inf) , ##args); } while (0)
126 void proc_abort (struct proc
*proc
, int force
);
127 struct proc
*make_proc (struct inf
*inf
, mach_port_t port
, int tid
);
128 struct proc
*_proc_free (struct proc
*proc
);
129 int proc_update_sc (struct proc
*proc
);
130 kern_return_t
proc_get_exception_port (struct proc
*proc
, mach_port_t
* port
);
131 kern_return_t
proc_set_exception_port (struct proc
*proc
, mach_port_t port
);
132 static mach_port_t
_proc_get_exc_port (struct proc
*proc
);
133 void proc_steal_exc_port (struct proc
*proc
, mach_port_t exc_port
);
134 void proc_restore_exc_port (struct proc
*proc
);
135 int proc_trace (struct proc
*proc
, int set
);
137 /* Evaluate RPC_EXPR in a scope with the variables MSGPORT and REFPORT bound
138 to INF's msg port and task port respectively. If it has no msg port,
139 EIEIO is returned. INF must refer to a running process! */
140 #define INF_MSGPORT_RPC(inf, rpc_expr) \
141 HURD_MSGPORT_RPC (proc_getmsgport (proc_server, inf->pid, &msgport), \
142 (refport = inf->task->port, 0), 0, \
143 msgport ? (rpc_expr) : EIEIO)
145 /* Like INF_MSGPORT_RPC, but will also resume the signal thread to ensure
146 there's someone around to deal with the RPC (and resuspend things
147 afterwards). This effects INF's threads' resume_sc count. */
148 #define INF_RESUME_MSGPORT_RPC(inf, rpc_expr) \
149 (inf_set_threads_resume_sc_for_signal_thread (inf) \
150 ? ({ kern_return_t __e; \
152 __e = INF_MSGPORT_RPC (inf, rpc_expr); \
158 /* The state passed by an exception message. */
161 int exception
; /* The exception code. */
163 mach_port_t handler
; /* The real exception port to handle this. */
164 mach_port_t reply
; /* The reply port from the exception call. */
167 /* The results of the last wait an inf did. */
170 struct target_waitstatus status
; /* The status returned to gdb. */
171 struct exc_state exc
; /* The exception that caused us to return. */
172 struct proc
*thread
; /* The thread in question. */
173 int suppress
; /* Something trivial happened. */
176 /* The state of an inferior. */
179 /* Fields describing the current inferior. */
181 struct proc
*task
; /* The mach task. */
182 struct proc
*threads
; /* A linked list of all threads in TASK. */
184 /* True if THREADS needn't be validated by querying the task. We
185 assume that we and the task in question are the only ones
186 frobbing the thread list, so as long as we don't let any code
187 run, we don't have to worry about THREADS changing. */
188 int threads_up_to_date
;
190 pid_t pid
; /* The real system PID. */
192 struct inf_wait wait
; /* What to return from target_wait. */
194 /* One thread proc in INF may be in `single-stepping mode'. This
196 struct proc
*step_thread
;
198 /* The thread we think is the signal thread. */
199 struct proc
*signal_thread
;
201 mach_port_t event_port
; /* Where we receive various msgs. */
203 /* True if we think at least one thread in the inferior could currently be
205 unsigned int running
:1;
207 /* True if the process has stopped (in the proc server sense). Note that
208 since a proc server `stop' leaves the signal thread running, the inf can
209 be RUNNING && STOPPED... */
210 unsigned int stopped
:1;
212 /* True if the inferior has no message port. */
213 unsigned int nomsg
:1;
215 /* True if the inferior is traced. */
216 unsigned int traced
:1;
218 /* True if we shouldn't try waiting for the inferior, usually because we
219 can't for some reason. */
220 unsigned int no_wait
:1;
222 /* When starting a new inferior, we don't try to validate threads until all
223 the proper execs have been done, which this flag states we still
225 unsigned int pending_execs
:1;
227 /* Fields describing global state. */
229 /* The task suspend count used when gdb has control. This is normally 1 to
230 make things easier for us, but sometimes (like when attaching to vital
231 system servers) it may be desirable to let the task continue to run
232 (pausing individual threads as necessary). */
235 /* The task suspend count left when detaching from a task. */
238 /* The initial values used for the run_sc and pause_sc of newly discovered
239 threads -- see the definition of those fields in struct proc. */
240 int default_thread_run_sc
;
241 int default_thread_pause_sc
;
242 int default_thread_detach_sc
;
244 /* True if the process should be traced when started/attached. Newly
245 started processes *must* be traced at first to exec them properly, but
246 if this is false, tracing is turned off as soon it has done so. */
249 /* True if exceptions from the inferior process should be trapped. This
250 must be on to use breakpoints. */
256 __proc_pid (struct proc
*proc
)
258 return proc
->inf
->pid
;
262 /* Update PROC's real suspend count to match it's desired one. Returns true
263 if we think PROC is now in a runnable state. */
265 proc_update_sc (struct proc
*proc
)
269 int delta
= proc
->sc
- proc
->cur_sc
;
272 proc_debug (proc
, "sc: %d --> %d", proc
->cur_sc
, proc
->sc
);
274 if (proc
->sc
== 0 && proc
->state_changed
)
275 /* Since PROC may start running, we must write back any state changes. */
277 gdb_assert (proc_is_thread (proc
));
278 proc_debug (proc
, "storing back changed thread state");
279 err
= thread_set_state (proc
->port
, THREAD_STATE_FLAVOR
,
280 (thread_state_t
) &proc
->state
, THREAD_STATE_SIZE
);
282 proc
->state_changed
= 0;
287 while (delta
-- > 0 && !err
)
289 if (proc_is_task (proc
))
290 err
= task_suspend (proc
->port
);
292 err
= thread_suspend (proc
->port
);
297 while (delta
++ < 0 && !err
)
299 if (proc_is_task (proc
))
300 err
= task_resume (proc
->port
);
302 err
= thread_resume (proc
->port
);
306 proc
->cur_sc
= proc
->sc
;
308 /* If we got an error, then the task/thread has disappeared. */
309 running
= !err
&& proc
->sc
== 0;
311 proc_debug (proc
, "is %s", err
? "dead" : running
? "running" : "suspended");
313 proc_debug (proc
, "err = %s", safe_strerror (err
));
318 proc
->state_valid
= proc
->state_changed
= 0;
319 proc
->fetched_regs
= 0;
326 /* Thread_abort is called on PROC if needed. PROC must be a thread proc.
327 If PROC is deemed `precious', then nothing is done unless FORCE is true.
328 In particular, a thread is precious if it's running (in which case forcing
329 it includes suspending it first), or if it has an exception pending. */
331 proc_abort (struct proc
*proc
, int force
)
333 gdb_assert (proc_is_thread (proc
));
337 struct inf
*inf
= proc
->inf
;
338 int running
= (proc
->cur_sc
== 0 && inf
->task
->cur_sc
== 0);
340 if (running
&& force
)
343 inf_update_suspends (proc
->inf
);
345 warning (_("Stopped %s."), proc_string (proc
));
347 else if (proc
== inf
->wait
.thread
&& inf
->wait
.exc
.reply
&& !force
)
348 /* An exception is pending on PROC, which don't mess with. */
352 /* We only abort the thread if it's not actually running. */
354 thread_abort (proc
->port
);
355 proc_debug (proc
, "aborted");
359 proc_debug (proc
, "not aborting");
363 /* Make sure that the state field in PROC is up to date, and return a pointer
364 to it, or 0 if something is wrong. If WILL_MODIFY is true, makes sure
365 that the thread is stopped and aborted first, and sets the state_changed
366 field in PROC to true. */
368 proc_get_state (struct proc
*proc
, int will_modify
)
370 int was_aborted
= proc
->aborted
;
372 proc_debug (proc
, "updating state info%s",
373 will_modify
? " (with intention to modify)" : "");
375 proc_abort (proc
, will_modify
);
377 if (!was_aborted
&& proc
->aborted
)
378 /* PROC's state may have changed since we last fetched it. */
379 proc
->state_valid
= 0;
381 if (!proc
->state_valid
)
383 mach_msg_type_number_t state_size
= THREAD_STATE_SIZE
;
385 thread_get_state (proc
->port
, THREAD_STATE_FLAVOR
,
386 (thread_state_t
) &proc
->state
, &state_size
);
388 proc_debug (proc
, "getting thread state");
389 proc
->state_valid
= !err
;
392 if (proc
->state_valid
)
395 proc
->state_changed
= 1;
396 return (thread_state_t
) &proc
->state
;
403 /* Set PORT to PROC's exception port. */
405 proc_get_exception_port (struct proc
* proc
, mach_port_t
* port
)
407 if (proc_is_task (proc
))
408 return task_get_exception_port (proc
->port
, port
);
410 return thread_get_exception_port (proc
->port
, port
);
413 /* Set PROC's exception port to PORT. */
415 proc_set_exception_port (struct proc
* proc
, mach_port_t port
)
417 proc_debug (proc
, "setting exception port: %lu", port
);
418 if (proc_is_task (proc
))
419 return task_set_exception_port (proc
->port
, port
);
421 return thread_set_exception_port (proc
->port
, port
);
424 /* Get PROC's exception port, cleaning up a bit if proc has died. */
426 _proc_get_exc_port (struct proc
*proc
)
428 mach_port_t exc_port
;
429 kern_return_t err
= proc_get_exception_port (proc
, &exc_port
);
432 /* PROC must be dead. */
435 mach_port_deallocate (mach_task_self (), proc
->exc_port
);
436 proc
->exc_port
= MACH_PORT_NULL
;
437 if (proc
->saved_exc_port
)
438 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
439 proc
->saved_exc_port
= MACH_PORT_NULL
;
445 /* Replace PROC's exception port with EXC_PORT, unless it's already
446 been done. Stash away any existing exception port so we can
449 proc_steal_exc_port (struct proc
*proc
, mach_port_t exc_port
)
451 mach_port_t cur_exc_port
= _proc_get_exc_port (proc
);
455 kern_return_t err
= 0;
457 proc_debug (proc
, "inserting exception port: %lu", exc_port
);
459 if (cur_exc_port
!= exc_port
)
460 /* Put in our exception port. */
461 err
= proc_set_exception_port (proc
, exc_port
);
463 if (err
|| cur_exc_port
== proc
->exc_port
)
464 /* We previously set the exception port, and it's still set. So we
465 just keep the old saved port which is what the proc set. */
468 mach_port_deallocate (mach_task_self (), cur_exc_port
);
471 /* Keep a copy of PROC's old exception port so it can be restored. */
473 if (proc
->saved_exc_port
)
474 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
475 proc
->saved_exc_port
= cur_exc_port
;
478 proc_debug (proc
, "saved exception port: %lu", proc
->saved_exc_port
);
481 proc
->exc_port
= exc_port
;
483 warning (_("Error setting exception port for %s: %s"),
484 proc_string (proc
), safe_strerror (err
));
488 /* If we previously replaced PROC's exception port, put back what we
489 found there at the time, unless *our* exception port has since been
490 overwritten, in which case who knows what's going on. */
492 proc_restore_exc_port (struct proc
*proc
)
494 mach_port_t cur_exc_port
= _proc_get_exc_port (proc
);
498 kern_return_t err
= 0;
500 proc_debug (proc
, "restoring real exception port");
502 if (proc
->exc_port
== cur_exc_port
)
503 /* Our's is still there. */
504 err
= proc_set_exception_port (proc
, proc
->saved_exc_port
);
506 if (proc
->saved_exc_port
)
507 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
508 proc
->saved_exc_port
= MACH_PORT_NULL
;
511 proc
->exc_port
= MACH_PORT_NULL
;
513 warning (_("Error setting exception port for %s: %s"),
514 proc_string (proc
), safe_strerror (err
));
519 /* Turns hardware tracing in PROC on or off when SET is true or false,
520 respectively. Returns true on success. */
522 proc_trace (struct proc
*proc
, int set
)
524 thread_state_t state
= proc_get_state (proc
, 1);
527 return 0; /* The thread must be dead. */
529 proc_debug (proc
, "tracing %s", set
? "on" : "off");
533 /* XXX We don't get the exception unless the thread has its own
534 exception port???? */
535 if (proc
->exc_port
== MACH_PORT_NULL
)
536 proc_steal_exc_port (proc
, proc
->inf
->event_port
);
537 THREAD_STATE_SET_TRACED (state
);
540 THREAD_STATE_CLEAR_TRACED (state
);
546 /* A variable from which to assign new TIDs. */
547 static int next_thread_id
= 1;
549 /* Returns a new proc structure with the given fields. Also adds a
550 notification for PORT becoming dead to be sent to INF's notify port. */
552 make_proc (struct inf
*inf
, mach_port_t port
, int tid
)
555 mach_port_t prev_port
= MACH_PORT_NULL
;
556 struct proc
*proc
= XNEW (struct proc
);
562 proc
->saved_exc_port
= MACH_PORT_NULL
;
563 proc
->exc_port
= MACH_PORT_NULL
;
568 /* Note that these are all the values for threads; the task simply uses the
569 corresponding field in INF directly. */
570 proc
->run_sc
= inf
->default_thread_run_sc
;
571 proc
->pause_sc
= inf
->default_thread_pause_sc
;
572 proc
->detach_sc
= inf
->default_thread_detach_sc
;
573 proc
->resume_sc
= proc
->run_sc
;
577 proc
->state_valid
= 0;
578 proc
->state_changed
= 0;
580 proc_debug (proc
, "is new");
582 /* Get notified when things die. */
584 mach_port_request_notification (mach_task_self (), port
,
585 MACH_NOTIFY_DEAD_NAME
, 1,
587 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
590 warning (_("Couldn't request notification for port %lu: %s"),
591 port
, safe_strerror (err
));
594 proc_debug (proc
, "notifications to: %lu", inf
->event_port
);
595 if (prev_port
!= MACH_PORT_NULL
)
596 mach_port_deallocate (mach_task_self (), prev_port
);
599 if (inf
->want_exceptions
)
601 if (proc_is_task (proc
))
602 /* Make the task exception port point to us. */
603 proc_steal_exc_port (proc
, inf
->event_port
);
605 /* Just clear thread exception ports -- they default to the
607 proc_steal_exc_port (proc
, MACH_PORT_NULL
);
613 /* Frees PROC and any resources it uses, and returns the value of PROC's
616 _proc_free (struct proc
*proc
)
618 struct inf
*inf
= proc
->inf
;
619 struct proc
*next
= proc
->next
;
621 proc_debug (proc
, "freeing...");
623 if (proc
== inf
->step_thread
)
624 /* Turn off single stepping. */
625 inf_set_step_thread (inf
, 0);
626 if (proc
== inf
->wait
.thread
)
627 inf_clear_wait (inf
);
628 if (proc
== inf
->signal_thread
)
629 inf
->signal_thread
= 0;
631 if (proc
->port
!= MACH_PORT_NULL
)
633 if (proc
->exc_port
!= MACH_PORT_NULL
)
634 /* Restore the original exception port. */
635 proc_restore_exc_port (proc
);
636 if (proc
->cur_sc
!= 0)
637 /* Resume the thread/task. */
640 proc_update_sc (proc
);
642 mach_port_deallocate (mach_task_self (), proc
->port
);
653 struct inf
*inf
= XNEW (struct inf
);
657 inf
->threads_up_to_date
= 0;
659 inf
->wait
.status
.kind
= TARGET_WAITKIND_SPURIOUS
;
660 inf
->wait
.thread
= 0;
661 inf
->wait
.exc
.handler
= MACH_PORT_NULL
;
662 inf
->wait
.exc
.reply
= MACH_PORT_NULL
;
663 inf
->step_thread
= 0;
664 inf
->signal_thread
= 0;
665 inf
->event_port
= MACH_PORT_NULL
;
671 inf
->pending_execs
= 0;
674 inf
->default_thread_run_sc
= 0;
675 inf
->default_thread_pause_sc
= 0;
676 inf
->default_thread_detach_sc
= 0;
677 inf
->want_signals
= 1; /* By default */
678 inf
->want_exceptions
= 1; /* By default */
683 /* Clear INF's target wait status. */
685 inf_clear_wait (struct inf
*inf
)
687 inf_debug (inf
, "clearing wait");
688 inf
->wait
.status
.kind
= TARGET_WAITKIND_SPURIOUS
;
689 inf
->wait
.thread
= 0;
690 inf
->wait
.suppress
= 0;
691 if (inf
->wait
.exc
.handler
!= MACH_PORT_NULL
)
693 mach_port_deallocate (mach_task_self (), inf
->wait
.exc
.handler
);
694 inf
->wait
.exc
.handler
= MACH_PORT_NULL
;
696 if (inf
->wait
.exc
.reply
!= MACH_PORT_NULL
)
698 mach_port_deallocate (mach_task_self (), inf
->wait
.exc
.reply
);
699 inf
->wait
.exc
.reply
= MACH_PORT_NULL
;
705 inf_cleanup (struct inf
*inf
)
707 inf_debug (inf
, "cleanup");
709 inf_clear_wait (inf
);
711 inf_set_pid (inf
, -1);
718 inf
->pending_execs
= 0;
722 mach_port_destroy (mach_task_self (), inf
->event_port
);
723 inf
->event_port
= MACH_PORT_NULL
;
728 inf_startup (struct inf
*inf
, int pid
)
732 inf_debug (inf
, "startup: pid = %d", pid
);
736 /* Make the port on which we receive all events. */
737 err
= mach_port_allocate (mach_task_self (),
738 MACH_PORT_RIGHT_RECEIVE
, &inf
->event_port
);
740 error (_("Error allocating event port: %s"), safe_strerror (err
));
742 /* Make a send right for it, so we can easily copy it for other people. */
743 mach_port_insert_right (mach_task_self (), inf
->event_port
,
744 inf
->event_port
, MACH_MSG_TYPE_MAKE_SEND
);
745 inf_set_pid (inf
, pid
);
749 /* Close current process, if any, and attach INF to process PORT. */
751 inf_set_pid (struct inf
*inf
, pid_t pid
)
754 struct proc
*task
= inf
->task
;
756 inf_debug (inf
, "setting pid: %d", pid
);
759 task_port
= MACH_PORT_NULL
;
762 kern_return_t err
= proc_pid2task (proc_server
, pid
, &task_port
);
765 error (_("Error getting task for pid %d: %s"),
766 pid
, safe_strerror (err
));
769 inf_debug (inf
, "setting task: %lu", task_port
);
772 task_suspend (task_port
);
774 if (task
&& task
->port
!= task_port
)
777 inf_validate_procs (inf
); /* Trash all the threads. */
778 _proc_free (task
); /* And the task. */
781 if (task_port
!= MACH_PORT_NULL
)
783 inf
->task
= make_proc (inf
, task_port
, PROC_TID_TASK
);
784 inf
->threads_up_to_date
= 0;
791 /* Reflect task_suspend above. */
792 inf
->task
->sc
= inf
->task
->cur_sc
= 1;
799 /* Validates INF's stopped, nomsg and traced field from the actual
800 proc server state. Note that the traced field is only updated from
801 the proc server state if we do not have a message port. If we do
802 have a message port we'd better look at the tracemask itself. */
804 inf_validate_procinfo (struct inf
*inf
)
807 mach_msg_type_number_t noise_len
= 0;
809 mach_msg_type_number_t pi_len
= 0;
812 proc_getprocinfo (proc_server
, inf
->pid
, &info_flags
,
813 (procinfo_t
*) &pi
, &pi_len
, &noise
, &noise_len
);
817 inf
->stopped
= !!(pi
->state
& PI_STOPPED
);
818 inf
->nomsg
= !!(pi
->state
& PI_NOMSG
);
820 inf
->traced
= !!(pi
->state
& PI_TRACED
);
821 vm_deallocate (mach_task_self (), (vm_address_t
) pi
,
822 pi_len
* sizeof (*(procinfo_t
) 0));
824 vm_deallocate (mach_task_self (), (vm_address_t
) noise
, noise_len
);
828 /* Validates INF's task suspend count. If it's higher than we expect,
829 verify with the user before `stealing' the extra count. */
831 inf_validate_task_sc (struct inf
*inf
)
834 mach_msg_type_number_t noise_len
= 0;
836 mach_msg_type_number_t pi_len
= 0;
837 int info_flags
= PI_FETCH_TASKINFO
;
838 int suspend_count
= -1;
842 err
= proc_getprocinfo (proc_server
, inf
->pid
, &info_flags
,
843 (procinfo_t
*) &pi
, &pi_len
, &noise
, &noise_len
);
846 inf
->task
->dead
= 1; /* oh well */
850 if (inf
->task
->cur_sc
< pi
->taskinfo
.suspend_count
&& suspend_count
== -1)
852 /* The proc server might have suspended the task while stopping
853 it. This happens when the task is handling a traced signal.
854 Refetch the suspend count. The proc server should be
855 finished stopping the task by now. */
856 suspend_count
= pi
->taskinfo
.suspend_count
;
860 suspend_count
= pi
->taskinfo
.suspend_count
;
862 vm_deallocate (mach_task_self (), (vm_address_t
) pi
,
863 pi_len
* sizeof (*(procinfo_t
) 0));
865 vm_deallocate (mach_task_self (), (vm_address_t
) noise
, noise_len
);
867 if (inf
->task
->cur_sc
< suspend_count
)
869 if (!query (_("Pid %d has an additional task suspend count of %d;"
870 " clear it? "), inf
->pid
,
871 suspend_count
- inf
->task
->cur_sc
))
872 error (_("Additional task suspend count left untouched."));
874 inf
->task
->cur_sc
= suspend_count
;
878 /* Turns tracing for INF on or off, depending on ON, unless it already
879 is. If INF is running, the resume_sc count of INF's threads will
880 be modified, and the signal thread will briefly be run to change
883 inf_set_traced (struct inf
*inf
, int on
)
885 if (on
== inf
->traced
)
888 if (inf
->task
&& !inf
->task
->dead
)
889 /* Make it take effect immediately. */
891 sigset_t mask
= on
? ~(sigset_t
) 0 : 0;
893 INF_RESUME_MSGPORT_RPC (inf
, msg_set_init_int (msgport
, refport
,
894 INIT_TRACEMASK
, mask
));
899 warning (_("Can't modify tracing state for pid %d: %s"),
900 inf
->pid
, "No signal thread");
904 warning (_("Can't modify tracing state for pid %d: %s"),
905 inf
->pid
, safe_strerror (err
));
914 /* Makes all the real suspend count deltas of all the procs in INF
915 match the desired values. Careful to always do thread/task suspend
916 counts in the safe order. Returns true if at least one thread is
917 thought to be running. */
919 inf_update_suspends (struct inf
*inf
)
921 struct proc
*task
= inf
->task
;
923 /* We don't have to update INF->threads even though we're iterating over it
924 because we'll change a thread only if it already has an existing proc
926 inf_debug (inf
, "updating suspend counts");
931 int task_running
= (task
->sc
== 0), thread_running
= 0;
933 if (task
->sc
> task
->cur_sc
)
934 /* The task is becoming _more_ suspended; do before any threads. */
935 task_running
= proc_update_sc (task
);
937 if (inf
->pending_execs
)
938 /* When we're waiting for an exec, things may be happening behind our
939 back, so be conservative. */
942 /* Do all the thread suspend counts. */
943 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
944 thread_running
|= proc_update_sc (thread
);
946 if (task
->sc
!= task
->cur_sc
)
947 /* We didn't do the task first, because we wanted to wait for the
948 threads; do it now. */
949 task_running
= proc_update_sc (task
);
951 inf_debug (inf
, "%srunning...",
952 (thread_running
&& task_running
) ? "" : "not ");
954 inf
->running
= thread_running
&& task_running
;
956 /* Once any thread has executed some code, we can't depend on the
957 threads list any more. */
959 inf
->threads_up_to_date
= 0;
968 /* Converts a GDB pid to a struct proc. */
970 inf_tid_to_thread (struct inf
*inf
, int tid
)
972 struct proc
*thread
= inf
->threads
;
975 if (thread
->tid
== tid
)
978 thread
= thread
->next
;
982 /* Converts a thread port to a struct proc. */
984 inf_port_to_thread (struct inf
*inf
, mach_port_t port
)
986 struct proc
*thread
= inf
->threads
;
989 if (thread
->port
== port
)
992 thread
= thread
->next
;
999 inf_threads (struct inf
*inf
, inf_threads_ftype
*f
, void *arg
)
1001 struct proc
*thread
;
1003 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1008 /* Make INF's list of threads be consistent with reality of TASK. */
1010 inf_validate_procs (struct inf
*inf
)
1012 thread_array_t threads
;
1013 mach_msg_type_number_t num_threads
, i
;
1014 struct proc
*task
= inf
->task
;
1016 /* If no threads are currently running, this function will guarantee that
1017 things are up to date. The exception is if there are zero threads --
1018 then it is almost certainly in an odd state, and probably some outside
1019 agent will create threads. */
1020 inf
->threads_up_to_date
= inf
->threads
? !inf
->running
: 0;
1024 kern_return_t err
= task_threads (task
->port
, &threads
, &num_threads
);
1026 inf_debug (inf
, "fetching threads");
1028 /* TASK must be dead. */
1038 inf_debug (inf
, "no task");
1042 /* Make things normally linear. */
1043 mach_msg_type_number_t search_start
= 0;
1044 /* Which thread in PROCS corresponds to each task thread, & the task. */
1045 struct proc
*matched
[num_threads
+ 1];
1046 /* The last thread in INF->threads, so we can add to the end. */
1047 struct proc
*last
= 0;
1048 /* The current thread we're considering. */
1049 struct proc
*thread
= inf
->threads
;
1051 memset (matched
, 0, sizeof (matched
));
1055 mach_msg_type_number_t left
;
1057 for (i
= search_start
, left
= num_threads
; left
; i
++, left
--)
1059 if (i
>= num_threads
)
1060 i
-= num_threads
; /* I wrapped around. */
1061 if (thread
->port
== threads
[i
])
1062 /* We already know about this thread. */
1064 matched
[i
] = thread
;
1066 thread
= thread
->next
;
1074 proc_debug (thread
, "died!");
1075 thread
->port
= MACH_PORT_NULL
;
1076 thread
= _proc_free (thread
); /* THREAD is dead. */
1078 last
->next
= thread
;
1080 inf
->threads
= thread
;
1084 for (i
= 0; i
< num_threads
; i
++)
1087 /* Throw away the duplicate send right. */
1088 mach_port_deallocate (mach_task_self (), threads
[i
]);
1090 /* THREADS[I] is a thread we don't know about yet! */
1094 thread
= make_proc (inf
, threads
[i
], next_thread_id
++);
1096 last
->next
= thread
;
1098 inf
->threads
= thread
;
1100 proc_debug (thread
, "new thread: %lu", threads
[i
]);
1102 ptid
= ptid_t (inf
->pid
, thread
->tid
, 0);
1104 /* Tell GDB's generic thread code. */
1106 if (inferior_ptid
== ptid_t (inf
->pid
))
1107 /* This is the first time we're hearing about thread
1108 ids, after a fork-child. */
1109 thread_change_ptid (inferior_ptid
, ptid
);
1110 else if (inf
->pending_execs
!= 0)
1111 /* This is a shell thread. */
1112 add_thread_silent (ptid
);
1118 vm_deallocate (mach_task_self (),
1119 (vm_address_t
) threads
, (num_threads
* sizeof (thread_t
)));
1124 /* Makes sure that INF's thread list is synced with the actual process. */
1126 inf_update_procs (struct inf
*inf
)
1130 if (!inf
->threads_up_to_date
)
1131 inf_validate_procs (inf
);
1135 /* Sets the resume_sc of each thread in inf. That of RUN_THREAD is set to 0,
1136 and others are set to their run_sc if RUN_OTHERS is true, and otherwise
1139 inf_set_threads_resume_sc (struct inf
*inf
,
1140 struct proc
*run_thread
, int run_others
)
1142 struct proc
*thread
;
1144 inf_update_procs (inf
);
1145 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1146 if (thread
== run_thread
)
1147 thread
->resume_sc
= 0;
1148 else if (run_others
)
1149 thread
->resume_sc
= thread
->run_sc
;
1151 thread
->resume_sc
= thread
->pause_sc
;
1155 /* Cause INF to continue execution immediately; individual threads may still
1156 be suspended (but their suspend counts will be updated). */
1158 inf_resume (struct inf
*inf
)
1160 struct proc
*thread
;
1162 inf_update_procs (inf
);
1164 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1165 thread
->sc
= thread
->resume_sc
;
1169 if (!inf
->pending_execs
)
1170 /* Try to make sure our task count is correct -- in the case where
1171 we're waiting for an exec though, things are too volatile, so just
1172 assume things will be reasonable (which they usually will be). */
1173 inf_validate_task_sc (inf
);
1177 inf_update_suspends (inf
);
1180 /* Cause INF to stop execution immediately; individual threads may still
1183 inf_suspend (struct inf
*inf
)
1185 struct proc
*thread
;
1187 inf_update_procs (inf
);
1189 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1190 thread
->sc
= thread
->pause_sc
;
1193 inf
->task
->sc
= inf
->pause_sc
;
1195 inf_update_suspends (inf
);
1199 /* INF has one thread PROC that is in single-stepping mode. This
1200 function changes it to be PROC, changing any old step_thread to be
1201 a normal one. A PROC of 0 clears any existing value. */
1203 inf_set_step_thread (struct inf
*inf
, struct proc
*thread
)
1205 gdb_assert (!thread
|| proc_is_thread (thread
));
1208 inf_debug (inf
, "setting step thread: %d/%d", inf
->pid
, thread
->tid
);
1210 inf_debug (inf
, "clearing step thread");
1212 if (inf
->step_thread
!= thread
)
1214 if (inf
->step_thread
&& inf
->step_thread
->port
!= MACH_PORT_NULL
)
1215 if (!proc_trace (inf
->step_thread
, 0))
1217 if (thread
&& proc_trace (thread
, 1))
1218 inf
->step_thread
= thread
;
1220 inf
->step_thread
= 0;
1225 /* Set up the thread resume_sc's so that only the signal thread is running
1226 (plus whatever other thread are set to always run). Returns true if we
1227 did so, or false if we can't find a signal thread. */
1229 inf_set_threads_resume_sc_for_signal_thread (struct inf
*inf
)
1231 if (inf
->signal_thread
)
1233 inf_set_threads_resume_sc (inf
, inf
->signal_thread
, 0);
1241 inf_update_signal_thread (struct inf
*inf
)
1243 /* XXX for now we assume that if there's a msgport, the 2nd thread is
1244 the signal thread. */
1245 inf
->signal_thread
= inf
->threads
? inf
->threads
->next
: 0;
1249 /* Detachs from INF's inferior task, letting it run once again... */
1251 inf_detach (struct inf
*inf
)
1253 struct proc
*task
= inf
->task
;
1255 inf_debug (inf
, "detaching...");
1257 inf_clear_wait (inf
);
1258 inf_set_step_thread (inf
, 0);
1262 struct proc
*thread
;
1264 inf_validate_procinfo (inf
);
1266 inf_set_traced (inf
, 0);
1272 inf_signal (inf
, GDB_SIGNAL_0
);
1275 proc_restore_exc_port (task
);
1276 task
->sc
= inf
->detach_sc
;
1278 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1280 proc_restore_exc_port (thread
);
1281 thread
->sc
= thread
->detach_sc
;
1284 inf_update_suspends (inf
);
1290 /* Attaches INF to the process with process id PID, returning it in a
1291 suspended state suitable for debugging. */
1293 inf_attach (struct inf
*inf
, int pid
)
1295 inf_debug (inf
, "attaching: %d", pid
);
1300 inf_startup (inf
, pid
);
1304 /* Makes sure that we've got our exception ports entrenched in the process. */
1306 inf_steal_exc_ports (struct inf
*inf
)
1308 struct proc
*thread
;
1310 inf_debug (inf
, "stealing exception ports");
1312 inf_set_step_thread (inf
, 0); /* The step thread is special. */
1314 proc_steal_exc_port (inf
->task
, inf
->event_port
);
1315 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1316 proc_steal_exc_port (thread
, MACH_PORT_NULL
);
1319 /* Makes sure the process has its own exception ports. */
1321 inf_restore_exc_ports (struct inf
*inf
)
1323 struct proc
*thread
;
1325 inf_debug (inf
, "restoring exception ports");
1327 inf_set_step_thread (inf
, 0); /* The step thread is special. */
1329 proc_restore_exc_port (inf
->task
);
1330 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1331 proc_restore_exc_port (thread
);
1335 /* Deliver signal SIG to INF. If INF is stopped, delivering a signal, even
1336 signal 0, will continue it. INF is assumed to be in a paused state, and
1337 the resume_sc's of INF's threads may be affected. */
1339 inf_signal (struct inf
*inf
, enum gdb_signal sig
)
1341 kern_return_t err
= 0;
1342 int host_sig
= gdb_signal_to_host (sig
);
1344 #define NAME gdb_signal_to_name (sig)
1346 if (host_sig
>= _NSIG
)
1347 /* A mach exception. Exceptions are encoded in the signal space by
1348 putting them after _NSIG; this assumes they're positive (and not
1349 extremely large)! */
1351 struct inf_wait
*w
= &inf
->wait
;
1353 if (w
->status
.kind
== TARGET_WAITKIND_STOPPED
1354 && w
->status
.value
.sig
== sig
1355 && w
->thread
&& !w
->thread
->aborted
)
1356 /* We're passing through the last exception we received. This is
1357 kind of bogus, because exceptions are per-thread whereas gdb
1358 treats signals as per-process. We just forward the exception to
1359 the correct handler, even it's not for the same thread as TID --
1360 i.e., we pretend it's global. */
1362 struct exc_state
*e
= &w
->exc
;
1364 inf_debug (inf
, "passing through exception:"
1365 " task = %lu, thread = %lu, exc = %d"
1366 ", code = %d, subcode = %d",
1367 w
->thread
->port
, inf
->task
->port
,
1368 e
->exception
, e
->code
, e
->subcode
);
1370 exception_raise_request (e
->handler
,
1371 e
->reply
, MACH_MSG_TYPE_MOVE_SEND_ONCE
,
1372 w
->thread
->port
, inf
->task
->port
,
1373 e
->exception
, e
->code
, e
->subcode
);
1376 error (_("Can't forward spontaneous exception (%s)."), NAME
);
1379 /* A Unix signal. */
1381 /* The process is stopped and expecting a signal. Just send off a
1382 request and let it get handled when we resume everything. */
1384 inf_debug (inf
, "sending %s to stopped process", NAME
);
1386 INF_MSGPORT_RPC (inf
,
1387 msg_sig_post_untraced_request (msgport
,
1389 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1393 /* Posting an untraced signal automatically continues it.
1394 We clear this here rather than when we get the reply
1395 because we'd rather assume it's not stopped when it
1396 actually is, than the reverse. */
1400 /* It's not expecting it. We have to let just the signal thread
1401 run, and wait for it to get into a reasonable state before we
1402 can continue the rest of the process. When we finally resume the
1403 process the signal we request will be the very first thing that
1406 inf_debug (inf
, "sending %s to unstopped process"
1407 " (so resuming signal thread)", NAME
);
1409 INF_RESUME_MSGPORT_RPC (inf
,
1410 msg_sig_post_untraced (msgport
, host_sig
,
1415 /* Can't do too much... */
1416 warning (_("Can't deliver signal %s: No signal thread."), NAME
);
1418 warning (_("Delivering signal %s: %s"), NAME
, safe_strerror (err
));
1424 /* Continue INF without delivering a signal. This is meant to be used
1425 when INF does not have a message port. */
1427 inf_continue (struct inf
*inf
)
1430 kern_return_t err
= proc_pid2proc (proc_server
, inf
->pid
, &proc
);
1434 inf_debug (inf
, "continuing process");
1436 err
= proc_mark_cont (proc
);
1439 struct proc
*thread
;
1441 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1442 thread_resume (thread
->port
);
1449 warning (_("Can't continue process: %s"), safe_strerror (err
));
1453 /* The inferior used for all gdb target ops. */
1454 struct inf
*gnu_current_inf
= 0;
1456 /* The inferior being waited for by gnu_wait. Since GDB is decidely not
1457 multi-threaded, we don't bother to lock this. */
1458 struct inf
*waiting_inf
;
1460 /* MIG stubs are not yet ready for C++ compilation. */
1461 extern "C" int exc_server (mach_msg_header_t
*, mach_msg_header_t
*);
1462 extern "C" int msg_reply_server (mach_msg_header_t
*, mach_msg_header_t
*);
1463 extern "C" int notify_server (mach_msg_header_t
*, mach_msg_header_t
*);
1464 extern "C" int process_reply_server (mach_msg_header_t
*, mach_msg_header_t
*);
1466 /* Wait for something to happen in the inferior, returning what in STATUS. */
1469 gnu_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
1474 mach_msg_header_t hdr
;
1475 mach_msg_type_t type
;
1479 struct proc
*thread
;
1480 struct inf
*inf
= gnu_current_inf
;
1482 gdb_assert (inf
->task
);
1484 if (!inf
->threads
&& !inf
->pending_execs
)
1485 /* No threads! Assume that maybe some outside agency is frobbing our
1486 task, and really look for new threads. If we can't find any, just tell
1487 the user to try again later. */
1489 inf_validate_procs (inf
);
1490 if (!inf
->threads
&& !inf
->task
->dead
)
1491 error (_("There are no threads; try again later."));
1496 inf_debug (inf
, "waiting for: %s", target_pid_to_str (ptid
));
1499 if (proc_wait_pid
!= inf
->pid
&& !inf
->no_wait
)
1500 /* Always get information on events from the proc server. */
1502 inf_debug (inf
, "requesting wait on pid %d", inf
->pid
);
1505 /* The proc server is single-threaded, and only allows a single
1506 outstanding wait request, so we have to cancel the previous one. */
1508 inf_debug (inf
, "cancelling previous wait on pid %d", proc_wait_pid
);
1509 interrupt_operation (proc_server
, 0);
1513 proc_wait_request (proc_server
, inf
->event_port
, inf
->pid
, WUNTRACED
);
1515 warning (_("wait request failed: %s"), safe_strerror (err
));
1518 inf_debug (inf
, "waits pending: %d", proc_waits_pending
);
1519 proc_wait_pid
= inf
->pid
;
1520 /* Even if proc_waits_pending was > 0 before, we still won't
1521 get any other replies, because it was either from a
1522 different INF, or a different process attached to INF --
1523 and the event port, which is the wait reply port, changes
1524 when you switch processes. */
1525 proc_waits_pending
= 1;
1529 inf_clear_wait (inf
);
1531 /* What can happen? (1) Dead name notification; (2) Exceptions arrive;
1532 (3) wait reply from the proc server. */
1534 inf_debug (inf
, "waiting for an event...");
1535 err
= mach_msg (&msg
.hdr
, MACH_RCV_MSG
| MACH_RCV_INTERRUPT
,
1536 0, sizeof (struct msg
), inf
->event_port
,
1537 MACH_MSG_TIMEOUT_NONE
, MACH_PORT_NULL
);
1539 /* Re-suspend the task. */
1542 if (!inf
->task
&& inf
->pending_execs
)
1543 /* When doing an exec, it's possible that the old task wasn't reused
1544 (e.g., setuid execs). So if the task seems to have disappeared,
1545 attempt to refetch it, as the pid should still be the same. */
1546 inf_set_pid (inf
, inf
->pid
);
1548 if (err
== EMACH_RCV_INTERRUPTED
)
1549 inf_debug (inf
, "interrupted");
1551 error (_("Couldn't wait for an event: %s"), safe_strerror (err
));
1556 mach_msg_header_t hdr
;
1557 mach_msg_type_t err_type
;
1563 inf_debug (inf
, "event: msgid = %d", msg
.hdr
.msgh_id
);
1565 /* Handle what we got. */
1566 if (!notify_server (&msg
.hdr
, &reply
.hdr
)
1567 && !exc_server (&msg
.hdr
, &reply
.hdr
)
1568 && !process_reply_server (&msg
.hdr
, &reply
.hdr
)
1569 && !msg_reply_server (&msg
.hdr
, &reply
.hdr
))
1570 /* Whatever it is, it's something strange. */
1571 error (_("Got a strange event, msg id = %d."), msg
.hdr
.msgh_id
);
1574 error (_("Handling event, msgid = %d: %s"),
1575 msg
.hdr
.msgh_id
, safe_strerror (reply
.err
));
1578 if (inf
->pending_execs
)
1579 /* We're waiting for the inferior to finish execing. */
1581 struct inf_wait
*w
= &inf
->wait
;
1582 enum target_waitkind kind
= w
->status
.kind
;
1584 if (kind
== TARGET_WAITKIND_SPURIOUS
)
1585 /* Since gdb is actually counting the number of times the inferior
1586 stops, expecting one stop per exec, we only return major events
1590 inf_debug (inf
, "pending_execs, ignoring minor event");
1592 else if (kind
== TARGET_WAITKIND_STOPPED
1593 && w
->status
.value
.sig
== GDB_SIGNAL_TRAP
)
1594 /* Ah hah! A SIGTRAP from the inferior while starting up probably
1595 means we've succesfully completed an exec! */
1597 inf_debug (inf
, "one pending exec completed");
1599 else if (kind
== TARGET_WAITKIND_STOPPED
)
1600 /* It's possible that this signal is because of a crashed process
1601 being handled by the hurd crash server; in this case, the process
1602 will have an extra task suspend, which we need to know about.
1603 Since the code in inf_resume that normally checks for this is
1604 disabled while INF->pending_execs, we do the check here instead. */
1605 inf_validate_task_sc (inf
);
1608 if (inf
->wait
.suppress
)
1609 /* Some totally spurious event happened that we don't consider
1610 worth returning to gdb. Just keep waiting. */
1612 inf_debug (inf
, "suppressing return, rewaiting...");
1617 /* Pass back out our results. */
1618 memcpy (status
, &inf
->wait
.status
, sizeof (*status
));
1620 thread
= inf
->wait
.thread
;
1622 ptid
= ptid_t (inf
->pid
, thread
->tid
, 0);
1623 else if (ptid
== minus_one_ptid
)
1624 thread
= inf_tid_to_thread (inf
, -1);
1626 thread
= inf_tid_to_thread (inf
, ptid
.lwp ());
1628 if (!thread
|| thread
->port
== MACH_PORT_NULL
)
1630 /* TID is dead; try and find a new thread. */
1631 if (inf_update_procs (inf
) && inf
->threads
)
1632 ptid
= ptid_t (inf
->pid
, inf
->threads
->tid
, 0); /* The first
1636 ptid
= inferior_ptid
; /* let wait_for_inferior handle exit case */
1640 && ptid
!= minus_one_ptid
1641 && status
->kind
!= TARGET_WAITKIND_SPURIOUS
1642 && inf
->pause_sc
== 0 && thread
->pause_sc
== 0)
1643 /* If something actually happened to THREAD, make sure we
1647 inf_update_suspends (inf
);
1650 inf_debug (inf
, "returning ptid = %s, status = %s (%d)",
1651 target_pid_to_str (ptid
),
1652 status
->kind
== TARGET_WAITKIND_EXITED
? "EXITED"
1653 : status
->kind
== TARGET_WAITKIND_STOPPED
? "STOPPED"
1654 : status
->kind
== TARGET_WAITKIND_SIGNALLED
? "SIGNALLED"
1655 : status
->kind
== TARGET_WAITKIND_LOADED
? "LOADED"
1656 : status
->kind
== TARGET_WAITKIND_SPURIOUS
? "SPURIOUS"
1658 status
->value
.integer
);
1664 /* The rpc handler called by exc_server. */
1666 S_exception_raise_request (mach_port_t port
, mach_port_t reply_port
,
1667 thread_t thread_port
, task_t task_port
,
1668 int exception
, int code
, int subcode
)
1670 struct inf
*inf
= waiting_inf
;
1671 struct proc
*thread
= inf_port_to_thread (inf
, thread_port
);
1673 inf_debug (waiting_inf
,
1674 "thread = %lu, task = %lu, exc = %d, code = %d, subcode = %d",
1675 thread_port
, task_port
, exception
, code
, subcode
);
1678 /* We don't know about thread? */
1680 inf_update_procs (inf
);
1681 thread
= inf_port_to_thread (inf
, thread_port
);
1683 /* Give up, the generating thread is gone. */
1687 mach_port_deallocate (mach_task_self (), thread_port
);
1688 mach_port_deallocate (mach_task_self (), task_port
);
1690 if (!thread
->aborted
)
1691 /* THREAD hasn't been aborted since this exception happened (abortion
1692 clears any exception state), so it must be real. */
1694 /* Store away the details; this will destroy any previous info. */
1695 inf
->wait
.thread
= thread
;
1697 inf
->wait
.status
.kind
= TARGET_WAITKIND_STOPPED
;
1699 if (exception
== EXC_BREAKPOINT
)
1700 /* GDB likes to get SIGTRAP for breakpoints. */
1702 inf
->wait
.status
.value
.sig
= GDB_SIGNAL_TRAP
;
1703 mach_port_deallocate (mach_task_self (), reply_port
);
1706 /* Record the exception so that we can forward it later. */
1708 if (thread
->exc_port
== port
)
1710 inf_debug (waiting_inf
, "Handler is thread exception port <%lu>",
1711 thread
->saved_exc_port
);
1712 inf
->wait
.exc
.handler
= thread
->saved_exc_port
;
1716 inf_debug (waiting_inf
, "Handler is task exception port <%lu>",
1717 inf
->task
->saved_exc_port
);
1718 inf
->wait
.exc
.handler
= inf
->task
->saved_exc_port
;
1719 gdb_assert (inf
->task
->exc_port
== port
);
1721 if (inf
->wait
.exc
.handler
!= MACH_PORT_NULL
)
1722 /* Add a reference to the exception handler. */
1723 mach_port_mod_refs (mach_task_self (),
1724 inf
->wait
.exc
.handler
, MACH_PORT_RIGHT_SEND
,
1727 inf
->wait
.exc
.exception
= exception
;
1728 inf
->wait
.exc
.code
= code
;
1729 inf
->wait
.exc
.subcode
= subcode
;
1730 inf
->wait
.exc
.reply
= reply_port
;
1732 /* Exceptions are encoded in the signal space by putting
1733 them after _NSIG; this assumes they're positive (and not
1734 extremely large)! */
1735 inf
->wait
.status
.value
.sig
=
1736 gdb_signal_from_host (_NSIG
+ exception
);
1740 /* A supppressed exception, which ignore. */
1742 inf
->wait
.suppress
= 1;
1743 mach_port_deallocate (mach_task_self (), reply_port
);
1750 /* Fill in INF's wait field after a task has died without giving us more
1751 detailed information. */
1753 inf_task_died_status (struct inf
*inf
)
1755 warning (_("Pid %d died with unknown exit status, using SIGKILL."),
1757 inf
->wait
.status
.kind
= TARGET_WAITKIND_SIGNALLED
;
1758 inf
->wait
.status
.value
.sig
= GDB_SIGNAL_KILL
;
1761 /* Notify server routines. The only real one is dead name notification. */
1763 do_mach_notify_dead_name (mach_port_t notify
, mach_port_t dead_port
)
1765 struct inf
*inf
= waiting_inf
;
1767 inf_debug (waiting_inf
, "port = %lu", dead_port
);
1769 if (inf
->task
&& inf
->task
->port
== dead_port
)
1771 proc_debug (inf
->task
, "is dead");
1772 inf
->task
->port
= MACH_PORT_NULL
;
1773 if (proc_wait_pid
== inf
->pid
)
1774 /* We have a wait outstanding on the process, which will return more
1775 detailed information, so delay until we get that. */
1776 inf
->wait
.suppress
= 1;
1778 /* We never waited for the process (maybe it wasn't a child), so just
1779 pretend it got a SIGKILL. */
1780 inf_task_died_status (inf
);
1784 struct proc
*thread
= inf_port_to_thread (inf
, dead_port
);
1788 proc_debug (thread
, "is dead");
1789 thread
->port
= MACH_PORT_NULL
;
1792 if (inf
->task
->dead
)
1793 /* Since the task is dead, its threads are dying with it. */
1794 inf
->wait
.suppress
= 1;
1797 mach_port_deallocate (mach_task_self (), dead_port
);
1798 inf
->threads_up_to_date
= 0; /* Just in case. */
1804 #define ILL_RPC(fun, ...) \
1805 extern kern_return_t fun (__VA_ARGS__); \
1806 kern_return_t fun (__VA_ARGS__) \
1808 warning (_("illegal rpc: %s"), #fun); \
1812 ILL_RPC (do_mach_notify_no_senders
,
1813 mach_port_t notify
, mach_port_mscount_t count
)
1814 ILL_RPC (do_mach_notify_port_deleted
,
1815 mach_port_t notify
, mach_port_t name
)
1816 ILL_RPC (do_mach_notify_msg_accepted
,
1817 mach_port_t notify
, mach_port_t name
)
1818 ILL_RPC (do_mach_notify_port_destroyed
,
1819 mach_port_t notify
, mach_port_t name
)
1820 ILL_RPC (do_mach_notify_send_once
,
1823 /* Process_reply server routines. We only use process_wait_reply. */
1826 S_proc_wait_reply (mach_port_t reply
, kern_return_t err
,
1827 int status
, int sigcode
, rusage_t rusage
, pid_t pid
)
1829 struct inf
*inf
= waiting_inf
;
1831 inf_debug (inf
, "err = %s, pid = %d, status = 0x%x, sigcode = %d",
1832 err
? safe_strerror (err
) : "0", pid
, status
, sigcode
);
1834 if (err
&& proc_wait_pid
&& (!inf
->task
|| !inf
->task
->port
))
1835 /* Ack. The task has died, but the task-died notification code didn't
1836 tell anyone because it thought a more detailed reply from the
1837 procserver was forthcoming. However, we now learn that won't
1838 happen... So we have to act like the task just died, and this time,
1840 inf_task_died_status (inf
);
1842 if (--proc_waits_pending
== 0)
1843 /* PROC_WAIT_PID represents the most recent wait. We will always get
1844 replies in order because the proc server is single threaded. */
1847 inf_debug (inf
, "waits pending now: %d", proc_waits_pending
);
1853 warning (_("Can't wait for pid %d: %s"),
1854 inf
->pid
, safe_strerror (err
));
1857 /* Since we can't see the inferior's signals, don't trap them. */
1858 inf_set_traced (inf
, 0);
1861 else if (pid
== inf
->pid
)
1863 store_waitstatus (&inf
->wait
.status
, status
);
1864 if (inf
->wait
.status
.kind
== TARGET_WAITKIND_STOPPED
)
1865 /* The process has sent us a signal, and stopped itself in a sane
1866 state pending our actions. */
1868 inf_debug (inf
, "process has stopped itself");
1873 inf
->wait
.suppress
= 1; /* Something odd happened. Ignore. */
1878 ILL_RPC (S_proc_setmsgport_reply
,
1879 mach_port_t reply_port
, kern_return_t return_code
,
1880 mach_port_t oldmsgport
)
1881 ILL_RPC (S_proc_getmsgport_reply
,
1882 mach_port_t reply_port
, kern_return_t return_code
,
1883 mach_port_t msgports
)
1884 ILL_RPC (S_proc_pid2task_reply
,
1885 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t task
)
1886 ILL_RPC (S_proc_task2pid_reply
,
1887 mach_port_t reply_port
, kern_return_t return_code
, pid_t pid
)
1888 ILL_RPC (S_proc_task2proc_reply
,
1889 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t proc
)
1890 ILL_RPC (S_proc_proc2task_reply
,
1891 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t task
)
1892 ILL_RPC (S_proc_pid2proc_reply
,
1893 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t proc
)
1894 ILL_RPC (S_proc_getprocinfo_reply
,
1895 mach_port_t reply_port
, kern_return_t return_code
,
1896 int flags
, procinfo_t procinfo
, mach_msg_type_number_t procinfoCnt
,
1897 data_t threadwaits
, mach_msg_type_number_t threadwaitsCnt
)
1898 ILL_RPC (S_proc_getprocargs_reply
,
1899 mach_port_t reply_port
, kern_return_t return_code
,
1900 data_t procargs
, mach_msg_type_number_t procargsCnt
)
1901 ILL_RPC (S_proc_getprocenv_reply
,
1902 mach_port_t reply_port
, kern_return_t return_code
,
1903 data_t procenv
, mach_msg_type_number_t procenvCnt
)
1904 ILL_RPC (S_proc_getloginid_reply
,
1905 mach_port_t reply_port
, kern_return_t return_code
, pid_t login_id
)
1906 ILL_RPC (S_proc_getloginpids_reply
,
1907 mach_port_t reply_port
, kern_return_t return_code
,
1908 pidarray_t pids
, mach_msg_type_number_t pidsCnt
)
1909 ILL_RPC (S_proc_getlogin_reply
,
1910 mach_port_t reply_port
, kern_return_t return_code
, string_t logname
)
1911 ILL_RPC (S_proc_getsid_reply
,
1912 mach_port_t reply_port
, kern_return_t return_code
, pid_t sid
)
1913 ILL_RPC (S_proc_getsessionpgids_reply
,
1914 mach_port_t reply_port
, kern_return_t return_code
,
1915 pidarray_t pgidset
, mach_msg_type_number_t pgidsetCnt
)
1916 ILL_RPC (S_proc_getsessionpids_reply
,
1917 mach_port_t reply_port
, kern_return_t return_code
,
1918 pidarray_t pidset
, mach_msg_type_number_t pidsetCnt
)
1919 ILL_RPC (S_proc_getsidport_reply
,
1920 mach_port_t reply_port
, kern_return_t return_code
,
1921 mach_port_t sessport
)
1922 ILL_RPC (S_proc_getpgrp_reply
,
1923 mach_port_t reply_port
, kern_return_t return_code
, pid_t pgrp
)
1924 ILL_RPC (S_proc_getpgrppids_reply
,
1925 mach_port_t reply_port
, kern_return_t return_code
,
1926 pidarray_t pidset
, mach_msg_type_number_t pidsetCnt
)
1927 ILL_RPC (S_proc_get_tty_reply
,
1928 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t tty
)
1929 ILL_RPC (S_proc_getnports_reply
,
1930 mach_port_t reply_port
, kern_return_t return_code
,
1931 mach_msg_type_number_t nports
)
1932 ILL_RPC (S_proc_is_important_reply
,
1933 mach_port_t reply_port
, kern_return_t return_code
,
1934 boolean_t essential
)
1935 ILL_RPC (S_proc_get_code_reply
,
1936 mach_port_t reply_port
, kern_return_t return_code
,
1937 vm_address_t start_code
, vm_address_t end_code
)
1939 /* Msg_reply server routines. We only use msg_sig_post_untraced_reply. */
1942 S_msg_sig_post_untraced_reply (mach_port_t reply
, kern_return_t err
)
1944 struct inf
*inf
= waiting_inf
;
1947 /* EBUSY is what we get when the crash server has grabbed control of the
1948 process and doesn't like what signal we tried to send it. Just act
1949 like the process stopped (using a signal of 0 should mean that the
1950 *next* time the user continues, it will pass signal 0, which the crash
1951 server should like). */
1953 inf
->wait
.status
.kind
= TARGET_WAITKIND_STOPPED
;
1954 inf
->wait
.status
.value
.sig
= GDB_SIGNAL_0
;
1957 warning (_("Signal delivery failed: %s"), safe_strerror (err
));
1960 /* We only get this reply when we've posted a signal to a process which we
1961 thought was stopped, and which we expected to continue after the signal.
1962 Given that the signal has failed for some reason, it's reasonable to
1963 assume it's still stopped. */
1966 inf
->wait
.suppress
= 1;
1971 ILL_RPC (S_msg_sig_post_reply
,
1972 mach_port_t reply
, kern_return_t err
)
1974 /* Returns the number of messages queued for the receive right PORT. */
1975 static mach_port_msgcount_t
1976 port_msgs_queued (mach_port_t port
)
1978 struct mach_port_status status
;
1980 mach_port_get_receive_status (mach_task_self (), port
, &status
);
1985 return status
.mps_msgcount
;
1989 /* Resume execution of the inferior process.
1991 If STEP is nonzero, single-step it.
1992 If SIGNAL is nonzero, give it that signal.
1995 -1 true Single step the current thread allowing other threads to run.
1996 -1 false Continue the current thread allowing other threads to run.
1997 X true Single step the given thread, don't allow any others to run.
1998 X false Continue the given thread, do not allow any others to run.
1999 (Where X, of course, is anything except -1)
2001 Note that a resume may not `take' if there are pending exceptions/&c
2002 still unprocessed from the last resume we did (any given resume may result
2003 in multiple events returned by wait). */
2006 gnu_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
2008 struct proc
*step_thread
= 0;
2010 struct inf
*inf
= gnu_current_inf
;
2012 inf_debug (inf
, "ptid = %s, step = %d, sig = %d",
2013 target_pid_to_str (ptid
), step
, sig
);
2015 inf_validate_procinfo (inf
);
2017 if (sig
!= GDB_SIGNAL_0
|| inf
->stopped
)
2019 if (sig
== GDB_SIGNAL_0
&& inf
->nomsg
)
2022 inf_signal (inf
, sig
);
2024 else if (inf
->wait
.exc
.reply
!= MACH_PORT_NULL
)
2025 /* We received an exception to which we have chosen not to forward, so
2026 abort the faulting thread, which will perhaps retake it. */
2028 proc_abort (inf
->wait
.thread
, 1);
2029 warning (_("Aborting %s with unforwarded exception %s."),
2030 proc_string (inf
->wait
.thread
),
2031 gdb_signal_to_name (inf
->wait
.status
.value
.sig
));
2034 if (port_msgs_queued (inf
->event_port
))
2035 /* If there are still messages in our event queue, don't bother resuming
2036 the process, as we're just going to stop it right away anyway. */
2039 inf_update_procs (inf
);
2041 /* A specific PTID means `step only this process id'. */
2042 resume_all
= ptid
== minus_one_ptid
;
2045 /* Allow all threads to run, except perhaps single-stepping one. */
2047 inf_debug (inf
, "running all threads; tid = %d",
2048 inferior_ptid
.pid ());
2049 ptid
= inferior_ptid
; /* What to step. */
2050 inf_set_threads_resume_sc (inf
, 0, 1);
2053 /* Just allow a single thread to run. */
2055 struct proc
*thread
= inf_tid_to_thread (inf
, ptid
.lwp ());
2058 error (_("Can't run single thread id %s: no such thread!"),
2059 target_pid_to_str (ptid
));
2060 inf_debug (inf
, "running one thread: %s", target_pid_to_str (ptid
));
2061 inf_set_threads_resume_sc (inf
, thread
, 0);
2066 step_thread
= inf_tid_to_thread (inf
, ptid
.lwp ());
2068 warning (_("Can't step thread id %s: no such thread."),
2069 target_pid_to_str (ptid
));
2071 inf_debug (inf
, "stepping thread: %s", target_pid_to_str (ptid
));
2073 if (step_thread
!= inf
->step_thread
)
2074 inf_set_step_thread (inf
, step_thread
);
2076 inf_debug (inf
, "here we go...");
2082 gnu_nat_target::kill ()
2084 struct proc
*task
= gnu_current_inf
->task
;
2088 proc_debug (task
, "terminating...");
2089 task_terminate (task
->port
);
2090 inf_set_pid (gnu_current_inf
, -1);
2092 target_mourn_inferior (inferior_ptid
);
2095 /* Clean up after the inferior dies. */
2097 gnu_nat_target::mourn_inferior ()
2099 inf_debug (gnu_current_inf
, "rip");
2100 inf_detach (gnu_current_inf
);
2101 inf_child_target::mourn_inferior ();
2105 /* Fork an inferior process, and start debugging it. */
2107 /* Set INFERIOR_PID to the first thread available in the child, if any. */
2109 inf_pick_first_thread (void)
2111 if (gnu_current_inf
->task
&& gnu_current_inf
->threads
)
2112 /* The first thread. */
2113 return gnu_current_inf
->threads
->tid
;
2115 /* What may be the next thread. */
2116 return next_thread_id
;
2122 if (!gnu_current_inf
)
2123 gnu_current_inf
= make_inf ();
2124 return gnu_current_inf
;
2128 gnu_ptrace_me (void)
2130 /* We're in the child; make this process stop as soon as it execs. */
2131 struct inf
*inf
= cur_inf ();
2132 inf_debug (inf
, "tracing self");
2133 if (ptrace (PTRACE_TRACEME
) != 0)
2134 trace_start_error_with_name ("ptrace");
2138 gnu_nat_target::create_inferior (const char *exec_file
,
2139 const std::string
&allargs
,
2143 struct inf
*inf
= cur_inf ();
2146 inf_debug (inf
, "creating inferior");
2148 pid
= fork_inferior (exec_file
, allargs
, env
, gnu_ptrace_me
,
2149 NULL
, NULL
, NULL
, NULL
);
2151 /* We have something that executes now. We'll be running through
2152 the shell at this point (if startup-with-shell is true), but the
2153 pid shouldn't change. */
2154 add_thread_silent (ptid_t (pid
));
2156 /* Attach to the now stopped child, which is actually a shell... */
2157 inf_debug (inf
, "attaching to child: %d", pid
);
2159 inf_attach (inf
, pid
);
2163 inf
->pending_execs
= 1;
2167 /* Now let the child run again, knowing that it will stop
2168 immediately because of the ptrace. */
2171 /* We now have thread info. */
2172 thread_change_ptid (inferior_ptid
,
2173 ptid_t (inf
->pid
, inf_pick_first_thread (), 0));
2175 gdb_startup_inferior (pid
, START_INFERIOR_TRAPS_EXPECTED
);
2177 inf
->pending_execs
= 0;
2178 /* Get rid of the old shell threads. */
2181 inf_validate_procinfo (inf
);
2182 inf_update_signal_thread (inf
);
2183 inf_set_traced (inf
, inf
->want_signals
);
2185 /* Execing the process will have trashed our exception ports; steal them
2186 back (or make sure they're restored if the user wants that). */
2187 if (inf
->want_exceptions
)
2188 inf_steal_exc_ports (inf
);
2190 inf_restore_exc_ports (inf
);
2194 /* Attach to process PID, then initialize for debugging it
2195 and wait for the trace-trap that results from attaching. */
2197 gnu_nat_target::attach (const char *args
, int from_tty
)
2201 struct inf
*inf
= cur_inf ();
2202 struct inferior
*inferior
;
2204 pid
= parse_pid_to_attach (args
);
2206 if (pid
== getpid ()) /* Trying to masturbate? */
2207 error (_("I refuse to debug myself!"));
2211 exec_file
= (char *) get_exec_file (0);
2214 printf_unfiltered ("Attaching to program `%s', pid %d\n",
2217 printf_unfiltered ("Attaching to pid %d\n", pid
);
2219 gdb_flush (gdb_stdout
);
2222 inf_debug (inf
, "attaching to pid: %d", pid
);
2224 inf_attach (inf
, pid
);
2228 inferior
= current_inferior ();
2229 inferior_appeared (inferior
, pid
);
2230 inferior
->attach_flag
= 1;
2232 inf_update_procs (inf
);
2234 inferior_ptid
= ptid_t (pid
, inf_pick_first_thread (), 0);
2236 /* We have to initialize the terminal settings now, since the code
2237 below might try to restore them. */
2238 target_terminal::init ();
2240 /* If the process was stopped before we attached, make it continue the next
2241 time the user does a continue. */
2242 inf_validate_procinfo (inf
);
2244 inf_update_signal_thread (inf
);
2245 inf_set_traced (inf
, inf
->want_signals
);
2247 #if 0 /* Do we need this? */
2248 renumber_threads (0); /* Give our threads reasonable names. */
2253 /* Take a program previously attached to and detaches it.
2254 The program resumes execution and will no longer stop
2255 on signals, etc. We'd better not have left any breakpoints
2256 in the program or it'll die when it hits one. For this
2257 to work, it may be necessary for the process to have been
2258 previously attached. It *might* work if the program was
2259 started via fork. */
2261 gnu_nat_target::detach (inferior
*inf
, int from_tty
)
2267 char *exec_file
= get_exec_file (0);
2270 printf_unfiltered ("Detaching from program `%s' pid %d\n",
2271 exec_file
, gnu_current_inf
->pid
);
2273 printf_unfiltered ("Detaching from pid %d\n", gnu_current_inf
->pid
);
2274 gdb_flush (gdb_stdout
);
2277 pid
= gnu_current_inf
->pid
;
2279 inf_detach (gnu_current_inf
);
2281 inferior_ptid
= null_ptid
;
2282 detach_inferior (find_inferior_pid (pid
));
2284 maybe_unpush_target ();
2289 gnu_nat_target::stop (ptid_t ptid
)
2291 error (_("stop target function not implemented"));
2295 gnu_nat_target::thread_alive (ptid_t ptid
)
2297 inf_update_procs (gnu_current_inf
);
2298 return !!inf_tid_to_thread (gnu_current_inf
,
2303 /* Read inferior task's LEN bytes from ADDR and copy it to MYADDR in
2304 gdb's address space. Return 0 on failure; number of bytes read
2307 gnu_read_inferior (task_t task
, CORE_ADDR addr
, gdb_byte
*myaddr
, int length
)
2310 vm_address_t low_address
= (vm_address_t
) trunc_page (addr
);
2311 vm_size_t aligned_length
=
2312 (vm_size_t
) round_page (addr
+ length
) - low_address
;
2314 mach_msg_type_number_t copy_count
;
2316 /* Get memory from inferior with page aligned addresses. */
2317 err
= vm_read (task
, low_address
, aligned_length
, &copied
, ©_count
);
2321 err
= hurd_safe_copyin (myaddr
, (void *) (addr
- low_address
+ copied
),
2325 warning (_("Read from inferior faulted: %s"), safe_strerror (err
));
2329 err
= vm_deallocate (mach_task_self (), copied
, copy_count
);
2331 warning (_("gnu_read_inferior vm_deallocate failed: %s"),
2332 safe_strerror (err
));
2337 #define CHK_GOTO_OUT(str,ret) \
2338 do if (ret != KERN_SUCCESS) { errstr = #str; goto out; } while(0)
2340 struct vm_region_list
2342 struct vm_region_list
*next
;
2343 vm_prot_t protection
;
2348 struct obstack region_obstack
;
2350 /* Write gdb's LEN bytes from MYADDR and copy it to ADDR in inferior
2351 task's address space. */
2353 gnu_write_inferior (task_t task
, CORE_ADDR addr
,
2354 const gdb_byte
*myaddr
, int length
)
2357 vm_address_t low_address
= (vm_address_t
) trunc_page (addr
);
2358 vm_size_t aligned_length
=
2359 (vm_size_t
) round_page (addr
+ length
) - low_address
;
2361 mach_msg_type_number_t copy_count
;
2364 const char *errstr
= "Bug in gnu_write_inferior";
2366 struct vm_region_list
*region_element
;
2367 struct vm_region_list
*region_head
= NULL
;
2369 /* Get memory from inferior with page aligned addresses. */
2370 err
= vm_read (task
,
2375 CHK_GOTO_OUT ("gnu_write_inferior vm_read failed", err
);
2379 err
= hurd_safe_copyout ((void *) (addr
- low_address
+ copied
),
2381 CHK_GOTO_OUT ("Write to inferior faulted", err
);
2383 obstack_init (®ion_obstack
);
2385 /* Do writes atomically.
2386 First check for holes and unwritable memory. */
2388 vm_size_t remaining_length
= aligned_length
;
2389 vm_address_t region_address
= low_address
;
2391 struct vm_region_list
*scan
;
2393 while (region_address
< low_address
+ aligned_length
)
2395 vm_prot_t protection
;
2396 vm_prot_t max_protection
;
2397 vm_inherit_t inheritance
;
2399 mach_port_t object_name
;
2401 vm_size_t region_length
= remaining_length
;
2402 vm_address_t old_address
= region_address
;
2404 err
= vm_region (task
,
2413 CHK_GOTO_OUT ("vm_region failed", err
);
2415 /* Check for holes in memory. */
2416 if (old_address
!= region_address
)
2418 warning (_("No memory at 0x%lx. Nothing written"),
2425 if (!(max_protection
& VM_PROT_WRITE
))
2427 warning (_("Memory at address 0x%lx is unwritable. "
2435 /* Chain the regions for later use. */
2436 region_element
= XOBNEW (®ion_obstack
, struct vm_region_list
);
2438 region_element
->protection
= protection
;
2439 region_element
->start
= region_address
;
2440 region_element
->length
= region_length
;
2442 /* Chain the regions along with protections. */
2443 region_element
->next
= region_head
;
2444 region_head
= region_element
;
2446 region_address
+= region_length
;
2447 remaining_length
= remaining_length
- region_length
;
2450 /* If things fail after this, we give up.
2451 Somebody is messing up inferior_task's mappings. */
2453 /* Enable writes to the chained vm regions. */
2454 for (scan
= region_head
; scan
; scan
= scan
->next
)
2456 if (!(scan
->protection
& VM_PROT_WRITE
))
2458 err
= vm_protect (task
,
2462 scan
->protection
| VM_PROT_WRITE
);
2463 CHK_GOTO_OUT ("vm_protect: enable write failed", err
);
2467 err
= vm_write (task
,
2471 CHK_GOTO_OUT ("vm_write failed", err
);
2473 /* Set up the original region protections, if they were changed. */
2474 for (scan
= region_head
; scan
; scan
= scan
->next
)
2476 if (!(scan
->protection
& VM_PROT_WRITE
))
2478 err
= vm_protect (task
,
2483 CHK_GOTO_OUT ("vm_protect: enable write failed", err
);
2491 obstack_free (®ion_obstack
, 0);
2493 (void) vm_deallocate (mach_task_self (),
2498 if (err
!= KERN_SUCCESS
)
2500 warning (_("%s: %s"), errstr
, mach_error_string (err
));
2509 /* Implement the to_xfer_partial target_ops method for
2510 TARGET_OBJECT_MEMORY. */
2512 static enum target_xfer_status
2513 gnu_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2514 CORE_ADDR memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2516 task_t task
= (gnu_current_inf
2517 ? (gnu_current_inf
->task
2518 ? gnu_current_inf
->task
->port
: 0)
2522 if (task
== MACH_PORT_NULL
)
2523 return TARGET_XFER_E_IO
;
2525 if (writebuf
!= NULL
)
2527 inf_debug (gnu_current_inf
, "writing %s[%s] <-- %s",
2528 paddress (target_gdbarch (), memaddr
), pulongest (len
),
2529 host_address_to_string (writebuf
));
2530 res
= gnu_write_inferior (task
, memaddr
, writebuf
, len
);
2534 inf_debug (gnu_current_inf
, "reading %s[%s] --> %s",
2535 paddress (target_gdbarch (), memaddr
), pulongest (len
),
2536 host_address_to_string (readbuf
));
2537 res
= gnu_read_inferior (task
, memaddr
, readbuf
, len
);
2539 gdb_assert (res
>= 0);
2541 return TARGET_XFER_E_IO
;
2544 *xfered_len
= (ULONGEST
) res
;
2545 return TARGET_XFER_OK
;
2549 /* GNU does not have auxv, but we can at least fake the AT_ENTRY entry for PIE
2551 static enum target_xfer_status
2552 gnu_xfer_auxv (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2553 CORE_ADDR memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2555 task_t task
= (gnu_current_inf
2556 ? (gnu_current_inf
->task
2557 ? gnu_current_inf
->task
->port
: 0)
2563 ElfW(auxv_t
) auxv
[2];
2565 if (task
== MACH_PORT_NULL
)
2566 return TARGET_XFER_E_IO
;
2567 if (writebuf
!= NULL
)
2568 return TARGET_XFER_E_IO
;
2570 if (memaddr
== sizeof (auxv
))
2571 return TARGET_XFER_EOF
;
2572 if (memaddr
> sizeof (auxv
))
2573 return TARGET_XFER_E_IO
;
2575 err
= proc_task2proc (proc_server
, task
, &proc
);
2577 return TARGET_XFER_E_IO
;
2579 /* Get entry from proc server. */
2580 err
= proc_get_entry (proc
, &entry
);
2582 return TARGET_XFER_E_IO
;
2584 /* Fake auxv entry. */
2585 auxv
[0].a_type
= AT_ENTRY
;
2586 auxv
[0].a_un
.a_val
= entry
;
2587 auxv
[1].a_type
= AT_NULL
;
2588 auxv
[1].a_un
.a_val
= 0;
2590 inf_debug (gnu_current_inf
, "reading auxv %s[%s] --> %s",
2591 paddress (target_gdbarch (), memaddr
), pulongest (len
),
2592 host_address_to_string (readbuf
));
2594 if (memaddr
+ len
> sizeof (auxv
))
2595 len
= sizeof (auxv
) - memaddr
;
2597 memcpy (readbuf
, (gdb_byte
*) &auxv
+ memaddr
, len
);
2600 return TARGET_XFER_OK
;
2603 /* Target to_xfer_partial implementation. */
2605 enum target_xfer_status
2606 gnu_nat_target::xfer_partial (enum target_object object
,
2607 const char *annex
, gdb_byte
*readbuf
,
2608 const gdb_byte
*writebuf
, ULONGEST offset
,
2609 ULONGEST len
, ULONGEST
*xfered_len
)
2613 case TARGET_OBJECT_MEMORY
:
2614 return gnu_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2615 case TARGET_OBJECT_AUXV
:
2616 return gnu_xfer_auxv (readbuf
, writebuf
, offset
, len
, xfered_len
);
2618 return TARGET_XFER_E_IO
;
2622 /* Call FUNC on each memory region in the task. */
2625 gnu_nat_target::find_memory_regions (find_memory_region_ftype func
,
2630 vm_address_t region_address
, last_region_address
, last_region_end
;
2631 vm_prot_t last_protection
;
2633 if (gnu_current_inf
== 0 || gnu_current_inf
->task
== 0)
2635 task
= gnu_current_inf
->task
->port
;
2636 if (task
== MACH_PORT_NULL
)
2639 region_address
= last_region_address
= last_region_end
= VM_MIN_ADDRESS
;
2640 last_protection
= VM_PROT_NONE
;
2641 while (region_address
< VM_MAX_ADDRESS
)
2643 vm_prot_t protection
;
2644 vm_prot_t max_protection
;
2645 vm_inherit_t inheritance
;
2647 mach_port_t object_name
;
2649 vm_size_t region_length
= VM_MAX_ADDRESS
- region_address
;
2650 vm_address_t old_address
= region_address
;
2652 err
= vm_region (task
,
2661 if (err
== KERN_NO_SPACE
)
2663 if (err
!= KERN_SUCCESS
)
2665 warning (_("vm_region failed: %s"), mach_error_string (err
));
2669 if (protection
== last_protection
&& region_address
== last_region_end
)
2670 /* This region is contiguous with and indistinguishable from
2671 the previous one, so we just extend that one. */
2672 last_region_end
= region_address
+= region_length
;
2675 /* This region is distinct from the last one we saw, so report
2676 that previous one. */
2677 if (last_protection
!= VM_PROT_NONE
)
2678 (*func
) (last_region_address
,
2679 last_region_end
- last_region_address
,
2680 last_protection
& VM_PROT_READ
,
2681 last_protection
& VM_PROT_WRITE
,
2682 last_protection
& VM_PROT_EXECUTE
,
2683 1, /* MODIFIED is unknown, pass it as true. */
2685 last_region_address
= region_address
;
2686 last_region_end
= region_address
+= region_length
;
2687 last_protection
= protection
;
2691 /* Report the final region. */
2692 if (last_region_end
> last_region_address
&& last_protection
!= VM_PROT_NONE
)
2693 (*func
) (last_region_address
, last_region_end
- last_region_address
,
2694 last_protection
& VM_PROT_READ
,
2695 last_protection
& VM_PROT_WRITE
,
2696 last_protection
& VM_PROT_EXECUTE
,
2697 1, /* MODIFIED is unknown, pass it as true. */
2704 /* Return printable description of proc. */
2706 proc_string (struct proc
*proc
)
2708 static char tid_str
[80];
2710 if (proc_is_task (proc
))
2711 xsnprintf (tid_str
, sizeof (tid_str
), "process %d", proc
->inf
->pid
);
2713 xsnprintf (tid_str
, sizeof (tid_str
), "Thread %d.%d",
2714 proc
->inf
->pid
, proc
->tid
);
2719 gnu_nat_target::pid_to_str (ptid_t ptid
)
2721 struct inf
*inf
= gnu_current_inf
;
2722 int tid
= ptid
.lwp ();
2723 struct proc
*thread
= inf_tid_to_thread (inf
, tid
);
2726 return proc_string (thread
);
2729 static char tid_str
[80];
2731 xsnprintf (tid_str
, sizeof (tid_str
), "bogus thread id %d", tid
);
2737 /* User task commands. */
2739 static struct cmd_list_element
*set_task_cmd_list
= 0;
2740 static struct cmd_list_element
*show_task_cmd_list
= 0;
2741 /* User thread commands. */
2743 /* Commands with a prefix of `set/show thread'. */
2744 extern struct cmd_list_element
*thread_cmd_list
;
2745 struct cmd_list_element
*set_thread_cmd_list
= NULL
;
2746 struct cmd_list_element
*show_thread_cmd_list
= NULL
;
2748 /* Commands with a prefix of `set/show thread default'. */
2749 struct cmd_list_element
*set_thread_default_cmd_list
= NULL
;
2750 struct cmd_list_element
*show_thread_default_cmd_list
= NULL
;
2753 set_thread_cmd (const char *args
, int from_tty
)
2755 printf_unfiltered ("\"set thread\" must be followed by the "
2756 "name of a thread property, or \"default\".\n");
2760 show_thread_cmd (const char *args
, int from_tty
)
2762 printf_unfiltered ("\"show thread\" must be followed by the "
2763 "name of a thread property, or \"default\".\n");
2767 set_thread_default_cmd (const char *args
, int from_tty
)
2769 printf_unfiltered ("\"set thread default\" must be followed "
2770 "by the name of a thread property.\n");
2774 show_thread_default_cmd (const char *args
, int from_tty
)
2776 printf_unfiltered ("\"show thread default\" must be followed "
2777 "by the name of a thread property.\n");
2781 parse_int_arg (const char *args
, const char *cmd_prefix
)
2786 int val
= strtoul (args
, &arg_end
, 10);
2788 if (*args
&& *arg_end
== '\0')
2791 error (_("Illegal argument for \"%s\" command, should be an integer."),
2796 _parse_bool_arg (const char *args
, const char *t_val
, const char *f_val
,
2797 const char *cmd_prefix
)
2799 if (!args
|| strcmp (args
, t_val
) == 0)
2801 else if (strcmp (args
, f_val
) == 0)
2804 error (_("Illegal argument for \"%s\" command, "
2805 "should be \"%s\" or \"%s\"."),
2806 cmd_prefix
, t_val
, f_val
);
2809 #define parse_bool_arg(args, cmd_prefix) \
2810 _parse_bool_arg (args, "on", "off", cmd_prefix)
2813 check_empty (const char *args
, const char *cmd_prefix
)
2816 error (_("Garbage after \"%s\" command: `%s'"), cmd_prefix
, args
);
2819 /* Returns the alive thread named by INFERIOR_PID, or signals an error. */
2820 static struct proc
*
2823 struct inf
*inf
= cur_inf ();
2824 struct proc
*thread
= inf_tid_to_thread (inf
,
2825 inferior_ptid
.lwp ());
2827 error (_("No current thread."));
2831 /* Returns the current inferior, but signals an error if it has no task. */
2835 struct inf
*inf
= cur_inf ();
2838 error (_("No current process."));
2844 set_task_pause_cmd (int arg
, int from_tty
)
2846 struct inf
*inf
= cur_inf ();
2847 int old_sc
= inf
->pause_sc
;
2849 inf
->pause_sc
= arg
;
2851 if (old_sc
== 0 && inf
->pause_sc
!= 0)
2852 /* If the task is currently unsuspended, immediately suspend it,
2853 otherwise wait until the next time it gets control. */
2858 set_task_pause_cmd (const char *args
, int from_tty
)
2860 set_task_pause_cmd (parse_bool_arg (args
, "set task pause"), from_tty
);
2864 show_task_pause_cmd (const char *args
, int from_tty
)
2866 struct inf
*inf
= cur_inf ();
2868 check_empty (args
, "show task pause");
2869 printf_unfiltered ("The inferior task %s suspended while gdb has control.\n",
2871 ? (inf
->pause_sc
== 0 ? "isn't" : "is")
2872 : (inf
->pause_sc
== 0 ? "won't be" : "will be"));
2876 set_task_detach_sc_cmd (const char *args
, int from_tty
)
2878 cur_inf ()->detach_sc
= parse_int_arg (args
,
2879 "set task detach-suspend-count");
2883 show_task_detach_sc_cmd (const char *args
, int from_tty
)
2885 check_empty (args
, "show task detach-suspend-count");
2886 printf_unfiltered ("The inferior task will be left with a "
2887 "suspend count of %d when detaching.\n",
2888 cur_inf ()->detach_sc
);
2893 set_thread_default_pause_cmd (const char *args
, int from_tty
)
2895 struct inf
*inf
= cur_inf ();
2897 inf
->default_thread_pause_sc
=
2898 parse_bool_arg (args
, "set thread default pause") ? 0 : 1;
2902 show_thread_default_pause_cmd (const char *args
, int from_tty
)
2904 struct inf
*inf
= cur_inf ();
2905 int sc
= inf
->default_thread_pause_sc
;
2907 check_empty (args
, "show thread default pause");
2908 printf_unfiltered ("New threads %s suspended while gdb has control%s.\n",
2909 sc
? "are" : "aren't",
2910 !sc
&& inf
->pause_sc
? " (but the task is)" : "");
2914 set_thread_default_run_cmd (const char *args
, int from_tty
)
2916 struct inf
*inf
= cur_inf ();
2918 inf
->default_thread_run_sc
=
2919 parse_bool_arg (args
, "set thread default run") ? 0 : 1;
2923 show_thread_default_run_cmd (const char *args
, int from_tty
)
2925 struct inf
*inf
= cur_inf ();
2927 check_empty (args
, "show thread default run");
2928 printf_unfiltered ("New threads %s allowed to run.\n",
2929 inf
->default_thread_run_sc
== 0 ? "are" : "aren't");
2933 set_thread_default_detach_sc_cmd (const char *args
, int from_tty
)
2935 cur_inf ()->default_thread_detach_sc
=
2936 parse_int_arg (args
, "set thread default detach-suspend-count");
2940 show_thread_default_detach_sc_cmd (const char *args
, int from_tty
)
2942 check_empty (args
, "show thread default detach-suspend-count");
2943 printf_unfiltered ("New threads will get a detach-suspend-count of %d.\n",
2944 cur_inf ()->default_thread_detach_sc
);
2948 /* Steal a send right called NAME in the inferior task, and make it PROC's
2949 saved exception port. */
2951 steal_exc_port (struct proc
*proc
, mach_port_t name
)
2955 mach_msg_type_name_t port_type
;
2957 if (!proc
|| !proc
->inf
->task
)
2958 error (_("No inferior task."));
2960 err
= mach_port_extract_right (proc
->inf
->task
->port
,
2961 name
, MACH_MSG_TYPE_COPY_SEND
,
2964 error (_("Couldn't extract send right %lu from inferior: %s"),
2965 name
, safe_strerror (err
));
2967 if (proc
->saved_exc_port
)
2968 /* Get rid of our reference to the old one. */
2969 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
2971 proc
->saved_exc_port
= port
;
2973 if (!proc
->exc_port
)
2974 /* If PROC is a thread, we may not have set its exception port
2975 before. We can't use proc_steal_exc_port because it also sets
2978 proc
->exc_port
= proc
->inf
->event_port
;
2979 err
= proc_set_exception_port (proc
, proc
->exc_port
);
2980 error (_("Can't set exception port for %s: %s"),
2981 proc_string (proc
), safe_strerror (err
));
2986 set_task_exc_port_cmd (const char *args
, int from_tty
)
2988 struct inf
*inf
= cur_inf ();
2991 error (_("No argument to \"set task exception-port\" command."));
2992 steal_exc_port (inf
->task
, parse_and_eval_address (args
));
2996 set_stopped_cmd (const char *args
, int from_tty
)
2998 cur_inf ()->stopped
= _parse_bool_arg (args
, "yes", "no", "set stopped");
3002 show_stopped_cmd (const char *args
, int from_tty
)
3004 struct inf
*inf
= active_inf ();
3006 check_empty (args
, "show stopped");
3007 printf_unfiltered ("The inferior process %s stopped.\n",
3008 inf
->stopped
? "is" : "isn't");
3012 set_sig_thread_cmd (const char *args
, int from_tty
)
3014 struct inf
*inf
= cur_inf ();
3016 if (!args
|| (!isdigit (*args
) && strcmp (args
, "none") != 0))
3017 error (_("Illegal argument to \"set signal-thread\" command.\n"
3018 "Should be a thread ID, or \"none\"."));
3020 if (strcmp (args
, "none") == 0)
3021 inf
->signal_thread
= 0;
3024 struct thread_info
*tp
= parse_thread_id (args
, NULL
);
3025 inf
->signal_thread
= inf_tid_to_thread (inf
, tp
->ptid
.lwp ());
3030 show_sig_thread_cmd (const char *args
, int from_tty
)
3032 struct inf
*inf
= active_inf ();
3034 check_empty (args
, "show signal-thread");
3035 if (inf
->signal_thread
)
3036 printf_unfiltered ("The signal thread is %s.\n",
3037 proc_string (inf
->signal_thread
));
3039 printf_unfiltered ("There is no signal thread.\n");
3044 set_signals_cmd (int arg
, int from_tty
)
3046 struct inf
*inf
= cur_inf ();
3048 inf
->want_signals
= arg
;
3050 if (inf
->task
&& inf
->want_signals
!= inf
->traced
)
3051 /* Make this take effect immediately in a running process. */
3052 inf_set_traced (inf
, inf
->want_signals
);
3056 set_signals_cmd (const char *args
, int from_tty
)
3058 set_signals_cmd(parse_bool_arg (args
, "set signals"), from_tty
);
3062 show_signals_cmd (const char *args
, int from_tty
)
3064 struct inf
*inf
= cur_inf ();
3066 check_empty (args
, "show signals");
3067 printf_unfiltered ("The inferior process's signals %s intercepted.\n",
3069 ? (inf
->traced
? "are" : "aren't")
3070 : (inf
->want_signals
? "will be" : "won't be"));
3074 set_exceptions_cmd (int arg
, int from_tty
)
3076 struct inf
*inf
= cur_inf ();
3078 /* Make this take effect immediately in a running process. */
3081 inf
->want_exceptions
= arg
;
3085 set_exceptions_cmd (const char *args
, int from_tty
)
3087 set_exceptions_cmd (parse_bool_arg (args
, "set exceptions"), from_tty
);
3091 show_exceptions_cmd (const char *args
, int from_tty
)
3093 struct inf
*inf
= cur_inf ();
3095 check_empty (args
, "show exceptions");
3096 printf_unfiltered ("Exceptions in the inferior %s trapped.\n",
3098 ? (inf
->want_exceptions
? "are" : "aren't")
3099 : (inf
->want_exceptions
? "will be" : "won't be"));
3104 set_task_cmd (const char *args
, int from_tty
)
3106 printf_unfiltered ("\"set task\" must be followed by the name"
3107 " of a task property.\n");
3111 show_task_cmd (const char *args
, int from_tty
)
3113 struct inf
*inf
= cur_inf ();
3115 check_empty (args
, "show task");
3117 show_signals_cmd (0, from_tty
);
3118 show_exceptions_cmd (0, from_tty
);
3119 show_task_pause_cmd (0, from_tty
);
3121 if (inf
->pause_sc
== 0)
3122 show_thread_default_pause_cmd (0, from_tty
);
3123 show_thread_default_run_cmd (0, from_tty
);
3127 show_stopped_cmd (0, from_tty
);
3128 show_sig_thread_cmd (0, from_tty
);
3131 if (inf
->detach_sc
!= 0)
3132 show_task_detach_sc_cmd (0, from_tty
);
3133 if (inf
->default_thread_detach_sc
!= 0)
3134 show_thread_default_detach_sc_cmd (0, from_tty
);
3139 set_noninvasive_cmd (const char *args
, int from_tty
)
3141 /* Invert the sense of the arg for each component. */
3142 int inv_arg
= parse_bool_arg (args
, "set noninvasive") ? 0 : 1;
3144 set_task_pause_cmd (inv_arg
, from_tty
);
3145 set_signals_cmd (inv_arg
, from_tty
);
3146 set_exceptions_cmd (inv_arg
, from_tty
);
3151 info_port_rights (const char *args
, mach_port_type_t only
)
3153 struct inf
*inf
= active_inf ();
3154 struct value
*vmark
= value_mark ();
3157 /* Explicit list of port rights. */
3161 struct value
*val
= parse_to_comma_and_eval (&args
);
3162 long right
= value_as_long (val
);
3164 print_port_info (right
, 0, inf
->task
->port
, PORTINFO_DETAILS
,
3168 error (_("%ld: %s."), right
, safe_strerror (err
));
3172 /* Print all of them. */
3175 print_task_ports_info (inf
->task
->port
, only
, PORTINFO_DETAILS
,
3178 error (_("%s."), safe_strerror (err
));
3181 value_free_to_mark (vmark
);
3185 info_send_rights_cmd (const char *args
, int from_tty
)
3187 info_port_rights (args
, MACH_PORT_TYPE_SEND
);
3191 info_recv_rights_cmd (const char *args
, int from_tty
)
3193 info_port_rights (args
, MACH_PORT_TYPE_RECEIVE
);
3197 info_port_sets_cmd (const char *args
, int from_tty
)
3199 info_port_rights (args
, MACH_PORT_TYPE_PORT_SET
);
3203 info_dead_names_cmd (const char *args
, int from_tty
)
3205 info_port_rights (args
, MACH_PORT_TYPE_DEAD_NAME
);
3209 info_port_rights_cmd (const char *args
, int from_tty
)
3211 info_port_rights (args
, ~0);
3216 add_task_commands (void)
3218 add_cmd ("pause", class_run
, set_thread_default_pause_cmd
, _("\
3219 Set whether the new threads are suspended while gdb has control.\n\
3220 This property normally has no effect because the whole task is\n\
3221 suspended, however, that may be disabled with \"set task pause off\".\n\
3222 The default value is \"off\"."),
3223 &set_thread_default_cmd_list
);
3224 add_cmd ("pause", no_class
, show_thread_default_pause_cmd
, _("\
3225 Show whether new threads are suspended while gdb has control."),
3226 &show_thread_default_cmd_list
);
3228 add_cmd ("run", class_run
, set_thread_default_run_cmd
, _("\
3229 Set whether new threads are allowed to run (once gdb has noticed them)."),
3230 &set_thread_default_cmd_list
);
3231 add_cmd ("run", no_class
, show_thread_default_run_cmd
, _("\
3232 Show whether new threads are allowed to run (once gdb has noticed them)."),
3233 &show_thread_default_cmd_list
);
3235 add_cmd ("detach-suspend-count", class_run
, set_thread_default_detach_sc_cmd
,
3236 _("Set the default detach-suspend-count value for new threads."),
3237 &set_thread_default_cmd_list
);
3238 add_cmd ("detach-suspend-count", no_class
, show_thread_default_detach_sc_cmd
,
3239 _("Show the default detach-suspend-count value for new threads."),
3240 &show_thread_default_cmd_list
);
3242 add_cmd ("signals", class_run
, set_signals_cmd
, _("\
3243 Set whether the inferior process's signals will be intercepted.\n\
3244 Mach exceptions (such as breakpoint traps) are not affected."),
3246 add_alias_cmd ("sigs", "signals", class_run
, 1, &setlist
);
3247 add_cmd ("signals", no_class
, show_signals_cmd
, _("\
3248 Show whether the inferior process's signals will be intercepted."),
3250 add_alias_cmd ("sigs", "signals", no_class
, 1, &showlist
);
3252 add_cmd ("signal-thread", class_run
, set_sig_thread_cmd
, _("\
3253 Set the thread that gdb thinks is the libc signal thread.\n\
3254 This thread is run when delivering a signal to a non-stopped process."),
3256 add_alias_cmd ("sigthread", "signal-thread", class_run
, 1, &setlist
);
3257 add_cmd ("signal-thread", no_class
, show_sig_thread_cmd
, _("\
3258 Set the thread that gdb thinks is the libc signal thread."),
3260 add_alias_cmd ("sigthread", "signal-thread", no_class
, 1, &showlist
);
3262 add_cmd ("stopped", class_run
, set_stopped_cmd
, _("\
3263 Set whether gdb thinks the inferior process is stopped as with SIGSTOP.\n\
3264 Stopped process will be continued by sending them a signal."),
3266 add_cmd ("stopped", no_class
, show_stopped_cmd
, _("\
3267 Show whether gdb thinks the inferior process is stopped as with SIGSTOP."),
3270 add_cmd ("exceptions", class_run
, set_exceptions_cmd
, _("\
3271 Set whether exceptions in the inferior process will be trapped.\n\
3272 When exceptions are turned off, neither breakpoints nor single-stepping\n\
3275 /* Allow `set exc' despite conflict with `set exception-port'. */
3276 add_alias_cmd ("exc", "exceptions", class_run
, 1, &setlist
);
3277 add_cmd ("exceptions", no_class
, show_exceptions_cmd
, _("\
3278 Show whether exceptions in the inferior process will be trapped."),
3281 add_prefix_cmd ("task", no_class
, set_task_cmd
,
3282 _("Command prefix for setting task attributes."),
3283 &set_task_cmd_list
, "set task ", 0, &setlist
);
3284 add_prefix_cmd ("task", no_class
, show_task_cmd
,
3285 _("Command prefix for showing task attributes."),
3286 &show_task_cmd_list
, "show task ", 0, &showlist
);
3288 add_cmd ("pause", class_run
, set_task_pause_cmd
, _("\
3289 Set whether the task is suspended while gdb has control.\n\
3290 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3291 until the next time the program is continued.\n\
3292 When setting this to \"off\", \"set thread default pause on\" can be\n\
3293 used to pause individual threads by default instead."),
3294 &set_task_cmd_list
);
3295 add_cmd ("pause", no_class
, show_task_pause_cmd
,
3296 _("Show whether the task is suspended while gdb has control."),
3297 &show_task_cmd_list
);
3299 add_cmd ("detach-suspend-count", class_run
, set_task_detach_sc_cmd
,
3300 _("Set the suspend count will leave on the thread when detaching."),
3301 &set_task_cmd_list
);
3302 add_cmd ("detach-suspend-count", no_class
, show_task_detach_sc_cmd
,
3303 _("Show the suspend count will leave "
3304 "on the thread when detaching."),
3305 &show_task_cmd_list
);
3307 add_cmd ("exception-port", no_class
, set_task_exc_port_cmd
, _("\
3308 Set the task exception port to which we forward exceptions.\n\
3309 The argument should be the value of the send right in the task."),
3310 &set_task_cmd_list
);
3311 add_alias_cmd ("excp", "exception-port", no_class
, 1, &set_task_cmd_list
);
3312 add_alias_cmd ("exc-port", "exception-port", no_class
, 1,
3313 &set_task_cmd_list
);
3315 /* A convenient way of turning on all options require to noninvasively
3316 debug running tasks. */
3317 add_cmd ("noninvasive", no_class
, set_noninvasive_cmd
, _("\
3318 Set task options so that we interfere as little as possible.\n\
3319 This is the same as setting `task pause', `exceptions', and\n\
3320 `signals' to the opposite value."),
3323 /* Commands to show information about the task's ports. */
3324 add_info ("send-rights", info_send_rights_cmd
,
3325 _("Show information about the task's send rights"));
3326 add_info ("receive-rights", info_recv_rights_cmd
,
3327 _("Show information about the task's receive rights"));
3328 add_info ("port-rights", info_port_rights_cmd
,
3329 _("Show information about the task's port rights"));
3330 add_info ("port-sets", info_port_sets_cmd
,
3331 _("Show information about the task's port sets"));
3332 add_info ("dead-names", info_dead_names_cmd
,
3333 _("Show information about the task's dead names"));
3334 add_info_alias ("ports", "port-rights", 1);
3335 add_info_alias ("port", "port-rights", 1);
3336 add_info_alias ("psets", "port-sets", 1);
3341 set_thread_pause_cmd (const char *args
, int from_tty
)
3343 struct proc
*thread
= cur_thread ();
3344 int old_sc
= thread
->pause_sc
;
3346 thread
->pause_sc
= parse_bool_arg (args
, "set thread pause");
3347 if (old_sc
== 0 && thread
->pause_sc
!= 0 && thread
->inf
->pause_sc
== 0)
3348 /* If the task is currently unsuspended, immediately suspend it,
3349 otherwise wait until the next time it gets control. */
3350 inf_suspend (thread
->inf
);
3354 show_thread_pause_cmd (const char *args
, int from_tty
)
3356 struct proc
*thread
= cur_thread ();
3357 int sc
= thread
->pause_sc
;
3359 check_empty (args
, "show task pause");
3360 printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n",
3361 proc_string (thread
),
3362 sc
? "is" : "isn't",
3363 !sc
&& thread
->inf
->pause_sc
? " (but the task is)" : "");
3367 set_thread_run_cmd (const char *args
, int from_tty
)
3369 struct proc
*thread
= cur_thread ();
3371 thread
->run_sc
= parse_bool_arg (args
, "set thread run") ? 0 : 1;
3375 show_thread_run_cmd (const char *args
, int from_tty
)
3377 struct proc
*thread
= cur_thread ();
3379 check_empty (args
, "show thread run");
3380 printf_unfiltered ("Thread %s %s allowed to run.",
3381 proc_string (thread
),
3382 thread
->run_sc
== 0 ? "is" : "isn't");
3386 set_thread_detach_sc_cmd (const char *args
, int from_tty
)
3388 cur_thread ()->detach_sc
= parse_int_arg (args
,
3389 "set thread detach-suspend-count");
3393 show_thread_detach_sc_cmd (const char *args
, int from_tty
)
3395 struct proc
*thread
= cur_thread ();
3397 check_empty (args
, "show thread detach-suspend-count");
3398 printf_unfiltered ("Thread %s will be left with a suspend count"
3399 " of %d when detaching.\n",
3400 proc_string (thread
),
3405 set_thread_exc_port_cmd (const char *args
, int from_tty
)
3407 struct proc
*thread
= cur_thread ();
3410 error (_("No argument to \"set thread exception-port\" command."));
3411 steal_exc_port (thread
, parse_and_eval_address (args
));
3416 show_thread_cmd (char *args
, int from_tty
)
3418 struct proc
*thread
= cur_thread ();
3420 check_empty (args
, "show thread");
3421 show_thread_run_cmd (0, from_tty
);
3422 show_thread_pause_cmd (0, from_tty
);
3423 if (thread
->detach_sc
!= 0)
3424 show_thread_detach_sc_cmd (0, from_tty
);
3429 thread_takeover_sc_cmd (const char *args
, int from_tty
)
3431 struct proc
*thread
= cur_thread ();
3433 thread_basic_info_data_t _info
;
3434 thread_basic_info_t info
= &_info
;
3435 mach_msg_type_number_t info_len
= THREAD_BASIC_INFO_COUNT
;
3437 = mach_thread_info (thread
->port
, THREAD_BASIC_INFO
,
3438 (int *) &info
, &info_len
);
3440 error (("%s."), safe_strerror (err
));
3441 thread
->sc
= info
->suspend_count
;
3443 printf_unfiltered ("Suspend count was %d.\n", thread
->sc
);
3445 vm_deallocate (mach_task_self (), (vm_address_t
) info
,
3446 info_len
* sizeof (int));
3451 add_thread_commands (void)
3453 add_prefix_cmd ("thread", no_class
, set_thread_cmd
,
3454 _("Command prefix for setting thread properties."),
3455 &set_thread_cmd_list
, "set thread ", 0, &setlist
);
3456 add_prefix_cmd ("default", no_class
, show_thread_cmd
,
3457 _("Command prefix for setting default thread properties."),
3458 &set_thread_default_cmd_list
, "set thread default ", 0,
3459 &set_thread_cmd_list
);
3460 add_prefix_cmd ("thread", no_class
, set_thread_default_cmd
,
3461 _("Command prefix for showing thread properties."),
3462 &show_thread_cmd_list
, "show thread ", 0, &showlist
);
3463 add_prefix_cmd ("default", no_class
, show_thread_default_cmd
,
3464 _("Command prefix for showing default thread properties."),
3465 &show_thread_default_cmd_list
, "show thread default ", 0,
3466 &show_thread_cmd_list
);
3468 add_cmd ("pause", class_run
, set_thread_pause_cmd
, _("\
3469 Set whether the current thread is suspended while gdb has control.\n\
3470 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3471 until the next time the program is continued. This property normally\n\
3472 has no effect because the whole task is suspended, however, that may\n\
3473 be disabled with \"set task pause off\".\n\
3474 The default value is \"off\"."),
3475 &set_thread_cmd_list
);
3476 add_cmd ("pause", no_class
, show_thread_pause_cmd
, _("\
3477 Show whether the current thread is suspended while gdb has control."),
3478 &show_thread_cmd_list
);
3480 add_cmd ("run", class_run
, set_thread_run_cmd
,
3481 _("Set whether the current thread is allowed to run."),
3482 &set_thread_cmd_list
);
3483 add_cmd ("run", no_class
, show_thread_run_cmd
,
3484 _("Show whether the current thread is allowed to run."),
3485 &show_thread_cmd_list
);
3487 add_cmd ("detach-suspend-count", class_run
, set_thread_detach_sc_cmd
, _("\
3488 Set the suspend count will leave on the thread when detaching.\n\
3489 Note that this is relative to suspend count when gdb noticed the thread;\n\
3490 use the `thread takeover-suspend-count' to force it to an absolute value."),
3491 &set_thread_cmd_list
);
3492 add_cmd ("detach-suspend-count", no_class
, show_thread_detach_sc_cmd
, _("\
3493 Show the suspend count will leave on the thread when detaching.\n\
3494 Note that this is relative to suspend count when gdb noticed the thread;\n\
3495 use the `thread takeover-suspend-count' to force it to an absolute value."),
3496 &show_thread_cmd_list
);
3498 add_cmd ("exception-port", no_class
, set_thread_exc_port_cmd
, _("\
3499 Set the thread exception port to which we forward exceptions.\n\
3500 This overrides the task exception port.\n\
3501 The argument should be the value of the send right in the task."),
3502 &set_thread_cmd_list
);
3503 add_alias_cmd ("excp", "exception-port", no_class
, 1, &set_thread_cmd_list
);
3504 add_alias_cmd ("exc-port", "exception-port", no_class
, 1,
3505 &set_thread_cmd_list
);
3507 add_cmd ("takeover-suspend-count", no_class
, thread_takeover_sc_cmd
, _("\
3508 Force the threads absolute suspend-count to be gdb's.\n\
3509 Prior to giving this command, gdb's thread suspend-counts are relative\n\
3510 to the thread's initial suspend-count when gdb notices the threads."),
3515 _initialize_gnu_nat (void)
3517 proc_server
= getproc ();
3519 add_task_commands ();
3520 add_thread_commands ();
3521 add_setshow_boolean_cmd ("gnu-nat", class_maintenance
,
3523 _("Set debugging output for the gnu backend."),
3524 _("Show debugging output for the gnu backend."),
3532 #ifdef FLUSH_INFERIOR_CACHE
3534 /* When over-writing code on some machines the I-Cache must be flushed
3535 explicitly, because it is not kept coherent by the lazy hardware.
3536 This definitely includes breakpoints, for instance, or else we
3537 end up looping in mysterious Bpt traps. */
3540 flush_inferior_icache (CORE_ADDR pc
, int amount
)
3542 vm_machine_attribute_val_t flush
= MATTR_VAL_ICACHE_FLUSH
;
3545 ret
= vm_machine_attribute (gnu_current_inf
->task
->port
,
3550 if (ret
!= KERN_SUCCESS
)
3551 warning (_("Error flushing inferior's cache : %s"), safe_strerror (ret
));
3553 #endif /* FLUSH_INFERIOR_CACHE */