1 /* Interface GDB to the GNU Hurd.
2 Copyright (C) 1992-2020 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 "gdbsupport/gdb_wait.h"
70 #include "gdbthread.h"
71 #include "gdb_obstack.h"
72 #include "tid-parse.h"
73 #include "nat/fork-inferior.h"
75 #include "inf-child.h"
77 /* MIG stubs are not yet ready for C++ compilation. */
80 #include "exc_request_S.h"
82 #include "process_reply_S.h"
83 #include "msg_reply_S.h"
84 #include "exc_request_U.h"
88 struct gnu_nat_target
*gnu_target
;
90 static process_t proc_server
= MACH_PORT_NULL
;
92 /* If we've sent a proc_wait_request to the proc server, the pid of the
93 process we asked about. We can only ever have one outstanding. */
94 int proc_wait_pid
= 0;
96 /* The number of wait requests we've sent, and expect replies from. */
97 int proc_waits_pending
= 0;
99 bool gnu_debug_flag
= false;
103 static struct inf
*make_inf ();
104 void inf_clear_wait (struct inf
*inf
);
105 void inf_cleanup (struct inf
*inf
);
106 void inf_startup (struct inf
*inf
, int pid
);
107 int inf_update_suspends (struct inf
*inf
);
108 void inf_set_pid (struct inf
*inf
, pid_t pid
);
109 void inf_validate_procs (struct inf
*inf
);
110 void inf_steal_exc_ports (struct inf
*inf
);
111 void inf_restore_exc_ports (struct inf
*inf
);
112 void inf_set_threads_resume_sc (struct inf
*inf
,
113 struct proc
*run_thread
,
115 int inf_set_threads_resume_sc_for_signal_thread (struct inf
*inf
);
116 void inf_suspend (struct inf
*inf
);
117 void inf_resume (struct inf
*inf
);
118 void inf_set_step_thread (struct inf
*inf
, struct proc
*proc
);
119 void inf_detach (struct inf
*inf
);
120 void inf_attach (struct inf
*inf
, int pid
);
121 void inf_signal (struct inf
*inf
, enum gdb_signal sig
);
122 void inf_continue (struct inf
*inf
);
124 #define inf_debug(_inf, msg, args...) \
125 do { struct inf *__inf = (_inf); \
126 debug ("{inf %d %s}: " msg, __inf->pid, \
127 host_address_to_string (__inf) , ##args); } while (0)
129 void proc_abort (struct proc
*proc
, int force
);
130 struct proc
*make_proc (struct inf
*inf
, mach_port_t port
, int tid
);
131 struct proc
*_proc_free (struct proc
*proc
);
132 int proc_update_sc (struct proc
*proc
);
133 kern_return_t
proc_get_exception_port (struct proc
*proc
, mach_port_t
* port
);
134 kern_return_t
proc_set_exception_port (struct proc
*proc
, mach_port_t port
);
135 static mach_port_t
_proc_get_exc_port (struct proc
*proc
);
136 void proc_steal_exc_port (struct proc
*proc
, mach_port_t exc_port
);
137 void proc_restore_exc_port (struct proc
*proc
);
138 int proc_trace (struct proc
*proc
, int set
);
140 /* Evaluate RPC_EXPR in a scope with the variables MSGPORT and REFPORT bound
141 to INF's msg port and task port respectively. If it has no msg port,
142 EIEIO is returned. INF must refer to a running process! */
143 #define INF_MSGPORT_RPC(inf, rpc_expr) \
144 HURD_MSGPORT_RPC (proc_getmsgport (proc_server, inf->pid, &msgport), \
145 (refport = inf->task->port, 0), 0, \
146 msgport ? (rpc_expr) : EIEIO)
148 /* Like INF_MSGPORT_RPC, but will also resume the signal thread to ensure
149 there's someone around to deal with the RPC (and resuspend things
150 afterwards). This effects INF's threads' resume_sc count. */
151 #define INF_RESUME_MSGPORT_RPC(inf, rpc_expr) \
152 (inf_set_threads_resume_sc_for_signal_thread (inf) \
153 ? ({ kern_return_t __e; \
155 __e = INF_MSGPORT_RPC (inf, rpc_expr); \
161 /* The state passed by an exception message. */
164 int exception
; /* The exception code. */
166 mach_port_t handler
; /* The real exception port to handle this. */
167 mach_port_t reply
; /* The reply port from the exception call. */
170 /* The results of the last wait an inf did. */
173 struct target_waitstatus status
; /* The status returned to gdb. */
174 struct exc_state exc
; /* The exception that caused us to return. */
175 struct proc
*thread
; /* The thread in question. */
176 int suppress
; /* Something trivial happened. */
179 /* The state of an inferior. */
182 /* Fields describing the current inferior. */
184 struct proc
*task
; /* The mach task. */
185 struct proc
*threads
; /* A linked list of all threads in TASK. */
187 /* True if THREADS needn't be validated by querying the task. We
188 assume that we and the task in question are the only ones
189 frobbing the thread list, so as long as we don't let any code
190 run, we don't have to worry about THREADS changing. */
191 int threads_up_to_date
;
193 pid_t pid
; /* The real system PID. */
195 struct inf_wait wait
; /* What to return from target_wait. */
197 /* One thread proc in INF may be in `single-stepping mode'. This
199 struct proc
*step_thread
;
201 /* The thread we think is the signal thread. */
202 struct proc
*signal_thread
;
204 mach_port_t event_port
; /* Where we receive various msgs. */
206 /* True if we think at least one thread in the inferior could currently be
208 unsigned int running
:1;
210 /* True if the process has stopped (in the proc server sense). Note that
211 since a proc server `stop' leaves the signal thread running, the inf can
212 be RUNNING && STOPPED... */
213 unsigned int stopped
:1;
215 /* True if the inferior has no message port. */
216 unsigned int nomsg
:1;
218 /* True if the inferior is traced. */
219 unsigned int traced
:1;
221 /* True if we shouldn't try waiting for the inferior, usually because we
222 can't for some reason. */
223 unsigned int no_wait
:1;
225 /* When starting a new inferior, we don't try to validate threads until all
226 the proper execs have been done, which this flag states we still
228 unsigned int pending_execs
:1;
230 /* Fields describing global state. */
232 /* The task suspend count used when gdb has control. This is normally 1 to
233 make things easier for us, but sometimes (like when attaching to vital
234 system servers) it may be desirable to let the task continue to run
235 (pausing individual threads as necessary). */
238 /* The task suspend count left when detaching from a task. */
241 /* The initial values used for the run_sc and pause_sc of newly discovered
242 threads -- see the definition of those fields in struct proc. */
243 int default_thread_run_sc
;
244 int default_thread_pause_sc
;
245 int default_thread_detach_sc
;
247 /* True if the process should be traced when started/attached. Newly
248 started processes *must* be traced at first to exec them properly, but
249 if this is false, tracing is turned off as soon it has done so. */
252 /* True if exceptions from the inferior process should be trapped. This
253 must be on to use breakpoints. */
259 __proc_pid (struct proc
*proc
)
261 return proc
->inf
->pid
;
265 /* Update PROC's real suspend count to match it's desired one. Returns true
266 if we think PROC is now in a runnable state. */
268 proc_update_sc (struct proc
*proc
)
272 int delta
= proc
->sc
- proc
->cur_sc
;
275 proc_debug (proc
, "sc: %d --> %d", proc
->cur_sc
, proc
->sc
);
277 if (proc
->sc
== 0 && proc
->state_changed
)
278 /* Since PROC may start running, we must write back any state changes. */
280 gdb_assert (proc_is_thread (proc
));
281 proc_debug (proc
, "storing back changed thread state");
282 err
= thread_set_state (proc
->port
, THREAD_STATE_FLAVOR
,
283 (thread_state_t
) &proc
->state
, THREAD_STATE_SIZE
);
285 proc
->state_changed
= 0;
290 while (delta
-- > 0 && !err
)
292 if (proc_is_task (proc
))
293 err
= task_suspend (proc
->port
);
295 err
= thread_suspend (proc
->port
);
300 while (delta
++ < 0 && !err
)
302 if (proc_is_task (proc
))
303 err
= task_resume (proc
->port
);
305 err
= thread_resume (proc
->port
);
309 proc
->cur_sc
= proc
->sc
;
311 /* If we got an error, then the task/thread has disappeared. */
312 running
= !err
&& proc
->sc
== 0;
314 proc_debug (proc
, "is %s", err
? "dead" : running
? "running" : "suspended");
316 proc_debug (proc
, "err = %s", safe_strerror (err
));
321 proc
->state_valid
= proc
->state_changed
= 0;
322 proc
->fetched_regs
= 0;
329 /* Thread_abort is called on PROC if needed. PROC must be a thread proc.
330 If PROC is deemed `precious', then nothing is done unless FORCE is true.
331 In particular, a thread is precious if it's running (in which case forcing
332 it includes suspending it first), or if it has an exception pending. */
334 proc_abort (struct proc
*proc
, int force
)
336 gdb_assert (proc_is_thread (proc
));
340 struct inf
*inf
= proc
->inf
;
341 int running
= (proc
->cur_sc
== 0 && inf
->task
->cur_sc
== 0);
343 if (running
&& force
)
346 inf_update_suspends (proc
->inf
);
348 warning (_("Stopped %s."), proc_string (proc
));
350 else if (proc
== inf
->wait
.thread
&& inf
->wait
.exc
.reply
&& !force
)
351 /* An exception is pending on PROC, which don't mess with. */
355 /* We only abort the thread if it's not actually running. */
357 thread_abort (proc
->port
);
358 proc_debug (proc
, "aborted");
362 proc_debug (proc
, "not aborting");
366 /* Make sure that the state field in PROC is up to date, and return a pointer
367 to it, or 0 if something is wrong. If WILL_MODIFY is true, makes sure
368 that the thread is stopped and aborted first, and sets the state_changed
369 field in PROC to true. */
371 proc_get_state (struct proc
*proc
, int will_modify
)
373 int was_aborted
= proc
->aborted
;
375 proc_debug (proc
, "updating state info%s",
376 will_modify
? " (with intention to modify)" : "");
378 proc_abort (proc
, will_modify
);
380 if (!was_aborted
&& proc
->aborted
)
381 /* PROC's state may have changed since we last fetched it. */
382 proc
->state_valid
= 0;
384 if (!proc
->state_valid
)
386 mach_msg_type_number_t state_size
= THREAD_STATE_SIZE
;
388 thread_get_state (proc
->port
, THREAD_STATE_FLAVOR
,
389 (thread_state_t
) &proc
->state
, &state_size
);
391 proc_debug (proc
, "getting thread state");
392 proc
->state_valid
= !err
;
395 if (proc
->state_valid
)
398 proc
->state_changed
= 1;
399 return (thread_state_t
) &proc
->state
;
406 /* Set PORT to PROC's exception port. */
408 proc_get_exception_port (struct proc
* proc
, mach_port_t
* port
)
410 if (proc_is_task (proc
))
411 return task_get_exception_port (proc
->port
, port
);
413 return thread_get_exception_port (proc
->port
, port
);
416 /* Set PROC's exception port to PORT. */
418 proc_set_exception_port (struct proc
* proc
, mach_port_t port
)
420 proc_debug (proc
, "setting exception port: %lu", port
);
421 if (proc_is_task (proc
))
422 return task_set_exception_port (proc
->port
, port
);
424 return thread_set_exception_port (proc
->port
, port
);
427 /* Get PROC's exception port, cleaning up a bit if proc has died. */
429 _proc_get_exc_port (struct proc
*proc
)
431 mach_port_t exc_port
;
432 kern_return_t err
= proc_get_exception_port (proc
, &exc_port
);
435 /* PROC must be dead. */
438 mach_port_deallocate (mach_task_self (), proc
->exc_port
);
439 proc
->exc_port
= MACH_PORT_NULL
;
440 if (proc
->saved_exc_port
)
441 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
442 proc
->saved_exc_port
= MACH_PORT_NULL
;
448 /* Replace PROC's exception port with EXC_PORT, unless it's already
449 been done. Stash away any existing exception port so we can
452 proc_steal_exc_port (struct proc
*proc
, mach_port_t exc_port
)
454 mach_port_t cur_exc_port
= _proc_get_exc_port (proc
);
458 kern_return_t err
= 0;
460 proc_debug (proc
, "inserting exception port: %lu", exc_port
);
462 if (cur_exc_port
!= exc_port
)
463 /* Put in our exception port. */
464 err
= proc_set_exception_port (proc
, exc_port
);
466 if (err
|| cur_exc_port
== proc
->exc_port
)
467 /* We previously set the exception port, and it's still set. So we
468 just keep the old saved port which is what the proc set. */
471 mach_port_deallocate (mach_task_self (), cur_exc_port
);
474 /* Keep a copy of PROC's old exception port so it can be restored. */
476 if (proc
->saved_exc_port
)
477 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
478 proc
->saved_exc_port
= cur_exc_port
;
481 proc_debug (proc
, "saved exception port: %lu", proc
->saved_exc_port
);
484 proc
->exc_port
= exc_port
;
486 warning (_("Error setting exception port for %s: %s"),
487 proc_string (proc
), safe_strerror (err
));
491 /* If we previously replaced PROC's exception port, put back what we
492 found there at the time, unless *our* exception port has since been
493 overwritten, in which case who knows what's going on. */
495 proc_restore_exc_port (struct proc
*proc
)
497 mach_port_t cur_exc_port
= _proc_get_exc_port (proc
);
501 kern_return_t err
= 0;
503 proc_debug (proc
, "restoring real exception port");
505 if (proc
->exc_port
== cur_exc_port
)
506 /* Our's is still there. */
507 err
= proc_set_exception_port (proc
, proc
->saved_exc_port
);
509 if (proc
->saved_exc_port
)
510 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
511 proc
->saved_exc_port
= MACH_PORT_NULL
;
514 proc
->exc_port
= MACH_PORT_NULL
;
516 warning (_("Error setting exception port for %s: %s"),
517 proc_string (proc
), safe_strerror (err
));
522 /* Turns hardware tracing in PROC on or off when SET is true or false,
523 respectively. Returns true on success. */
525 proc_trace (struct proc
*proc
, int set
)
527 thread_state_t state
= proc_get_state (proc
, 1);
530 return 0; /* The thread must be dead. */
532 proc_debug (proc
, "tracing %s", set
? "on" : "off");
536 /* XXX We don't get the exception unless the thread has its own
537 exception port???? */
538 if (proc
->exc_port
== MACH_PORT_NULL
)
539 proc_steal_exc_port (proc
, proc
->inf
->event_port
);
540 THREAD_STATE_SET_TRACED (state
);
543 THREAD_STATE_CLEAR_TRACED (state
);
549 /* A variable from which to assign new TIDs. */
550 static int next_thread_id
= 1;
552 /* Returns a new proc structure with the given fields. Also adds a
553 notification for PORT becoming dead to be sent to INF's notify port. */
555 make_proc (struct inf
*inf
, mach_port_t port
, int tid
)
558 mach_port_t prev_port
= MACH_PORT_NULL
;
559 struct proc
*proc
= XNEW (struct proc
);
565 proc
->saved_exc_port
= MACH_PORT_NULL
;
566 proc
->exc_port
= MACH_PORT_NULL
;
571 /* Note that these are all the values for threads; the task simply uses the
572 corresponding field in INF directly. */
573 proc
->run_sc
= inf
->default_thread_run_sc
;
574 proc
->pause_sc
= inf
->default_thread_pause_sc
;
575 proc
->detach_sc
= inf
->default_thread_detach_sc
;
576 proc
->resume_sc
= proc
->run_sc
;
580 proc
->state_valid
= 0;
581 proc
->state_changed
= 0;
583 proc_debug (proc
, "is new");
585 /* Get notified when things die. */
587 mach_port_request_notification (mach_task_self (), port
,
588 MACH_NOTIFY_DEAD_NAME
, 1,
590 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
593 warning (_("Couldn't request notification for port %lu: %s"),
594 port
, safe_strerror (err
));
597 proc_debug (proc
, "notifications to: %lu", inf
->event_port
);
598 if (prev_port
!= MACH_PORT_NULL
)
599 mach_port_deallocate (mach_task_self (), prev_port
);
602 if (inf
->want_exceptions
)
604 if (proc_is_task (proc
))
605 /* Make the task exception port point to us. */
606 proc_steal_exc_port (proc
, inf
->event_port
);
608 /* Just clear thread exception ports -- they default to the
610 proc_steal_exc_port (proc
, MACH_PORT_NULL
);
616 /* Frees PROC and any resources it uses, and returns the value of PROC's
619 _proc_free (struct proc
*proc
)
621 struct inf
*inf
= proc
->inf
;
622 struct proc
*next
= proc
->next
;
624 proc_debug (proc
, "freeing...");
626 if (proc
== inf
->step_thread
)
627 /* Turn off single stepping. */
628 inf_set_step_thread (inf
, 0);
629 if (proc
== inf
->wait
.thread
)
630 inf_clear_wait (inf
);
631 if (proc
== inf
->signal_thread
)
632 inf
->signal_thread
= 0;
634 if (proc
->port
!= MACH_PORT_NULL
)
636 if (proc
->exc_port
!= MACH_PORT_NULL
)
637 /* Restore the original exception port. */
638 proc_restore_exc_port (proc
);
639 if (proc
->cur_sc
!= 0)
640 /* Resume the thread/task. */
643 proc_update_sc (proc
);
645 mach_port_deallocate (mach_task_self (), proc
->port
);
656 struct inf
*inf
= XNEW (struct inf
);
660 inf
->threads_up_to_date
= 0;
662 inf
->wait
.status
.kind
= TARGET_WAITKIND_SPURIOUS
;
663 inf
->wait
.thread
= 0;
664 inf
->wait
.exc
.handler
= MACH_PORT_NULL
;
665 inf
->wait
.exc
.reply
= MACH_PORT_NULL
;
666 inf
->step_thread
= 0;
667 inf
->signal_thread
= 0;
668 inf
->event_port
= MACH_PORT_NULL
;
674 inf
->pending_execs
= 0;
677 inf
->default_thread_run_sc
= 0;
678 inf
->default_thread_pause_sc
= 0;
679 inf
->default_thread_detach_sc
= 0;
680 inf
->want_signals
= 1; /* By default */
681 inf
->want_exceptions
= 1; /* By default */
686 /* Clear INF's target wait status. */
688 inf_clear_wait (struct inf
*inf
)
690 inf_debug (inf
, "clearing wait");
691 inf
->wait
.status
.kind
= TARGET_WAITKIND_SPURIOUS
;
692 inf
->wait
.thread
= 0;
693 inf
->wait
.suppress
= 0;
694 if (inf
->wait
.exc
.handler
!= MACH_PORT_NULL
)
696 mach_port_deallocate (mach_task_self (), inf
->wait
.exc
.handler
);
697 inf
->wait
.exc
.handler
= MACH_PORT_NULL
;
699 if (inf
->wait
.exc
.reply
!= MACH_PORT_NULL
)
701 mach_port_deallocate (mach_task_self (), inf
->wait
.exc
.reply
);
702 inf
->wait
.exc
.reply
= MACH_PORT_NULL
;
708 inf_cleanup (struct inf
*inf
)
710 inf_debug (inf
, "cleanup");
712 inf_clear_wait (inf
);
714 inf_set_pid (inf
, -1);
721 inf
->pending_execs
= 0;
725 mach_port_destroy (mach_task_self (), inf
->event_port
);
726 inf
->event_port
= MACH_PORT_NULL
;
731 inf_startup (struct inf
*inf
, int pid
)
735 inf_debug (inf
, "startup: pid = %d", pid
);
739 /* Make the port on which we receive all events. */
740 err
= mach_port_allocate (mach_task_self (),
741 MACH_PORT_RIGHT_RECEIVE
, &inf
->event_port
);
743 error (_("Error allocating event port: %s"), safe_strerror (err
));
745 /* Make a send right for it, so we can easily copy it for other people. */
746 mach_port_insert_right (mach_task_self (), inf
->event_port
,
747 inf
->event_port
, MACH_MSG_TYPE_MAKE_SEND
);
748 inf_set_pid (inf
, pid
);
752 /* Close current process, if any, and attach INF to process PORT. */
754 inf_set_pid (struct inf
*inf
, pid_t pid
)
757 struct proc
*task
= inf
->task
;
759 inf_debug (inf
, "setting pid: %d", pid
);
762 task_port
= MACH_PORT_NULL
;
765 kern_return_t err
= proc_pid2task (proc_server
, pid
, &task_port
);
768 error (_("Error getting task for pid %d: %s"),
769 pid
, safe_strerror (err
));
772 inf_debug (inf
, "setting task: %lu", task_port
);
775 task_suspend (task_port
);
777 if (task
&& task
->port
!= task_port
)
780 inf_validate_procs (inf
); /* Trash all the threads. */
781 _proc_free (task
); /* And the task. */
784 if (task_port
!= MACH_PORT_NULL
)
786 inf
->task
= make_proc (inf
, task_port
, PROC_TID_TASK
);
787 inf
->threads_up_to_date
= 0;
794 /* Reflect task_suspend above. */
795 inf
->task
->sc
= inf
->task
->cur_sc
= 1;
802 /* Validates INF's stopped, nomsg and traced field from the actual
803 proc server state. Note that the traced field is only updated from
804 the proc server state if we do not have a message port. If we do
805 have a message port we'd better look at the tracemask itself. */
807 inf_validate_procinfo (struct inf
*inf
)
810 mach_msg_type_number_t noise_len
= 0;
812 mach_msg_type_number_t pi_len
= 0;
815 proc_getprocinfo (proc_server
, inf
->pid
, &info_flags
,
816 (procinfo_t
*) &pi
, &pi_len
, &noise
, &noise_len
);
820 inf
->stopped
= !!(pi
->state
& PI_STOPPED
);
821 inf
->nomsg
= !!(pi
->state
& PI_NOMSG
);
823 inf
->traced
= !!(pi
->state
& PI_TRACED
);
824 vm_deallocate (mach_task_self (), (vm_address_t
) pi
,
825 pi_len
* sizeof (*(procinfo_t
) 0));
827 vm_deallocate (mach_task_self (), (vm_address_t
) noise
, noise_len
);
831 /* Validates INF's task suspend count. If it's higher than we expect,
832 verify with the user before `stealing' the extra count. */
834 inf_validate_task_sc (struct inf
*inf
)
837 mach_msg_type_number_t noise_len
= 0;
839 mach_msg_type_number_t pi_len
= 0;
840 int info_flags
= PI_FETCH_TASKINFO
;
841 int suspend_count
= -1;
845 err
= proc_getprocinfo (proc_server
, inf
->pid
, &info_flags
,
846 (procinfo_t
*) &pi
, &pi_len
, &noise
, &noise_len
);
849 inf
->task
->dead
= 1; /* oh well */
853 if (inf
->task
->cur_sc
< pi
->taskinfo
.suspend_count
&& suspend_count
== -1)
855 /* The proc server might have suspended the task while stopping
856 it. This happens when the task is handling a traced signal.
857 Refetch the suspend count. The proc server should be
858 finished stopping the task by now. */
859 suspend_count
= pi
->taskinfo
.suspend_count
;
863 suspend_count
= pi
->taskinfo
.suspend_count
;
865 vm_deallocate (mach_task_self (), (vm_address_t
) pi
,
866 pi_len
* sizeof (*(procinfo_t
) 0));
868 vm_deallocate (mach_task_self (), (vm_address_t
) noise
, noise_len
);
870 if (inf
->task
->cur_sc
< suspend_count
)
872 if (!query (_("Pid %d has an additional task suspend count of %d;"
873 " clear it? "), inf
->pid
,
874 suspend_count
- inf
->task
->cur_sc
))
875 error (_("Additional task suspend count left untouched."));
877 inf
->task
->cur_sc
= suspend_count
;
881 /* Turns tracing for INF on or off, depending on ON, unless it already
882 is. If INF is running, the resume_sc count of INF's threads will
883 be modified, and the signal thread will briefly be run to change
886 inf_set_traced (struct inf
*inf
, int on
)
888 if (on
== inf
->traced
)
891 if (inf
->task
&& !inf
->task
->dead
)
892 /* Make it take effect immediately. */
894 sigset_t mask
= on
? ~(sigset_t
) 0 : 0;
896 INF_RESUME_MSGPORT_RPC (inf
, msg_set_init_int (msgport
, refport
,
897 INIT_TRACEMASK
, mask
));
902 warning (_("Can't modify tracing state for pid %d: %s"),
903 inf
->pid
, "No signal thread");
907 warning (_("Can't modify tracing state for pid %d: %s"),
908 inf
->pid
, safe_strerror (err
));
917 /* Makes all the real suspend count deltas of all the procs in INF
918 match the desired values. Careful to always do thread/task suspend
919 counts in the safe order. Returns true if at least one thread is
920 thought to be running. */
922 inf_update_suspends (struct inf
*inf
)
924 struct proc
*task
= inf
->task
;
926 /* We don't have to update INF->threads even though we're iterating over it
927 because we'll change a thread only if it already has an existing proc
929 inf_debug (inf
, "updating suspend counts");
934 int task_running
= (task
->sc
== 0), thread_running
= 0;
936 if (task
->sc
> task
->cur_sc
)
937 /* The task is becoming _more_ suspended; do before any threads. */
938 task_running
= proc_update_sc (task
);
940 if (inf
->pending_execs
)
941 /* When we're waiting for an exec, things may be happening behind our
942 back, so be conservative. */
945 /* Do all the thread suspend counts. */
946 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
947 thread_running
|= proc_update_sc (thread
);
949 if (task
->sc
!= task
->cur_sc
)
950 /* We didn't do the task first, because we wanted to wait for the
951 threads; do it now. */
952 task_running
= proc_update_sc (task
);
954 inf_debug (inf
, "%srunning...",
955 (thread_running
&& task_running
) ? "" : "not ");
957 inf
->running
= thread_running
&& task_running
;
959 /* Once any thread has executed some code, we can't depend on the
960 threads list any more. */
962 inf
->threads_up_to_date
= 0;
971 /* Converts a GDB pid to a struct proc. */
973 inf_tid_to_thread (struct inf
*inf
, int tid
)
975 struct proc
*thread
= inf
->threads
;
978 if (thread
->tid
== tid
)
981 thread
= thread
->next
;
985 /* Converts a thread port to a struct proc. */
987 inf_port_to_thread (struct inf
*inf
, mach_port_t port
)
989 struct proc
*thread
= inf
->threads
;
992 if (thread
->port
== port
)
995 thread
= thread
->next
;
1002 inf_threads (struct inf
*inf
, inf_threads_ftype
*f
, void *arg
)
1004 struct proc
*thread
;
1006 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1011 /* Make INF's list of threads be consistent with reality of TASK. */
1013 inf_validate_procs (struct inf
*inf
)
1015 thread_array_t threads
;
1016 mach_msg_type_number_t num_threads
, i
;
1017 struct proc
*task
= inf
->task
;
1019 /* If no threads are currently running, this function will guarantee that
1020 things are up to date. The exception is if there are zero threads --
1021 then it is almost certainly in an odd state, and probably some outside
1022 agent will create threads. */
1023 inf
->threads_up_to_date
= inf
->threads
? !inf
->running
: 0;
1027 kern_return_t err
= task_threads (task
->port
, &threads
, &num_threads
);
1029 inf_debug (inf
, "fetching threads");
1031 /* TASK must be dead. */
1041 inf_debug (inf
, "no task");
1045 /* Make things normally linear. */
1046 mach_msg_type_number_t search_start
= 0;
1047 /* Which thread in PROCS corresponds to each task thread, & the task. */
1048 struct proc
*matched
[num_threads
+ 1];
1049 /* The last thread in INF->threads, so we can add to the end. */
1050 struct proc
*last
= 0;
1051 /* The current thread we're considering. */
1052 struct proc
*thread
= inf
->threads
;
1054 memset (matched
, 0, sizeof (matched
));
1058 mach_msg_type_number_t left
;
1060 for (i
= search_start
, left
= num_threads
; left
; i
++, left
--)
1062 if (i
>= num_threads
)
1063 i
-= num_threads
; /* I wrapped around. */
1064 if (thread
->port
== threads
[i
])
1065 /* We already know about this thread. */
1067 matched
[i
] = thread
;
1069 thread
= thread
->next
;
1077 proc_debug (thread
, "died!");
1078 thread
->port
= MACH_PORT_NULL
;
1079 thread
= _proc_free (thread
); /* THREAD is dead. */
1081 last
->next
= thread
;
1083 inf
->threads
= thread
;
1087 for (i
= 0; i
< num_threads
; i
++)
1090 /* Throw away the duplicate send right. */
1091 mach_port_deallocate (mach_task_self (), threads
[i
]);
1093 /* THREADS[I] is a thread we don't know about yet! */
1097 thread
= make_proc (inf
, threads
[i
], next_thread_id
++);
1099 last
->next
= thread
;
1101 inf
->threads
= thread
;
1103 proc_debug (thread
, "new thread: %lu", threads
[i
]);
1105 ptid
= ptid_t (inf
->pid
, thread
->tid
, 0);
1107 /* Tell GDB's generic thread code. */
1109 if (inferior_ptid
== ptid_t (inf
->pid
))
1110 /* This is the first time we're hearing about thread
1111 ids, after a fork-child. */
1112 thread_change_ptid (gnu_target
, inferior_ptid
, ptid
);
1113 else if (inf
->pending_execs
!= 0)
1114 /* This is a shell thread. */
1115 add_thread_silent (gnu_target
, ptid
);
1117 add_thread (gnu_target
, ptid
);
1121 vm_deallocate (mach_task_self (),
1122 (vm_address_t
) threads
, (num_threads
* sizeof (thread_t
)));
1127 /* Makes sure that INF's thread list is synced with the actual process. */
1129 inf_update_procs (struct inf
*inf
)
1133 if (!inf
->threads_up_to_date
)
1134 inf_validate_procs (inf
);
1138 /* Sets the resume_sc of each thread in inf. That of RUN_THREAD is set to 0,
1139 and others are set to their run_sc if RUN_OTHERS is true, and otherwise
1142 inf_set_threads_resume_sc (struct inf
*inf
,
1143 struct proc
*run_thread
, int run_others
)
1145 struct proc
*thread
;
1147 inf_update_procs (inf
);
1148 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1149 if (thread
== run_thread
)
1150 thread
->resume_sc
= 0;
1151 else if (run_others
)
1152 thread
->resume_sc
= thread
->run_sc
;
1154 thread
->resume_sc
= thread
->pause_sc
;
1158 /* Cause INF to continue execution immediately; individual threads may still
1159 be suspended (but their suspend counts will be updated). */
1161 inf_resume (struct inf
*inf
)
1163 struct proc
*thread
;
1165 inf_update_procs (inf
);
1167 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1168 thread
->sc
= thread
->resume_sc
;
1172 if (!inf
->pending_execs
)
1173 /* Try to make sure our task count is correct -- in the case where
1174 we're waiting for an exec though, things are too volatile, so just
1175 assume things will be reasonable (which they usually will be). */
1176 inf_validate_task_sc (inf
);
1180 inf_update_suspends (inf
);
1183 /* Cause INF to stop execution immediately; individual threads may still
1186 inf_suspend (struct inf
*inf
)
1188 struct proc
*thread
;
1190 inf_update_procs (inf
);
1192 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1193 thread
->sc
= thread
->pause_sc
;
1196 inf
->task
->sc
= inf
->pause_sc
;
1198 inf_update_suspends (inf
);
1202 /* INF has one thread PROC that is in single-stepping mode. This
1203 function changes it to be PROC, changing any old step_thread to be
1204 a normal one. A PROC of 0 clears any existing value. */
1206 inf_set_step_thread (struct inf
*inf
, struct proc
*thread
)
1208 gdb_assert (!thread
|| proc_is_thread (thread
));
1211 inf_debug (inf
, "setting step thread: %d/%d", inf
->pid
, thread
->tid
);
1213 inf_debug (inf
, "clearing step thread");
1215 if (inf
->step_thread
!= thread
)
1217 if (inf
->step_thread
&& inf
->step_thread
->port
!= MACH_PORT_NULL
)
1218 if (!proc_trace (inf
->step_thread
, 0))
1220 if (thread
&& proc_trace (thread
, 1))
1221 inf
->step_thread
= thread
;
1223 inf
->step_thread
= 0;
1228 /* Set up the thread resume_sc's so that only the signal thread is running
1229 (plus whatever other thread are set to always run). Returns true if we
1230 did so, or false if we can't find a signal thread. */
1232 inf_set_threads_resume_sc_for_signal_thread (struct inf
*inf
)
1234 if (inf
->signal_thread
)
1236 inf_set_threads_resume_sc (inf
, inf
->signal_thread
, 0);
1244 inf_update_signal_thread (struct inf
*inf
)
1246 /* XXX for now we assume that if there's a msgport, the 2nd thread is
1247 the signal thread. */
1248 inf
->signal_thread
= inf
->threads
? inf
->threads
->next
: 0;
1252 /* Detachs from INF's inferior task, letting it run once again... */
1254 inf_detach (struct inf
*inf
)
1256 struct proc
*task
= inf
->task
;
1258 inf_debug (inf
, "detaching...");
1260 inf_clear_wait (inf
);
1261 inf_set_step_thread (inf
, 0);
1265 struct proc
*thread
;
1267 inf_validate_procinfo (inf
);
1269 inf_set_traced (inf
, 0);
1275 inf_signal (inf
, GDB_SIGNAL_0
);
1278 proc_restore_exc_port (task
);
1279 task
->sc
= inf
->detach_sc
;
1281 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1283 proc_restore_exc_port (thread
);
1284 thread
->sc
= thread
->detach_sc
;
1287 inf_update_suspends (inf
);
1293 /* Attaches INF to the process with process id PID, returning it in a
1294 suspended state suitable for debugging. */
1296 inf_attach (struct inf
*inf
, int pid
)
1298 inf_debug (inf
, "attaching: %d", pid
);
1303 inf_startup (inf
, pid
);
1307 /* Makes sure that we've got our exception ports entrenched in the process. */
1309 inf_steal_exc_ports (struct inf
*inf
)
1311 struct proc
*thread
;
1313 inf_debug (inf
, "stealing exception ports");
1315 inf_set_step_thread (inf
, 0); /* The step thread is special. */
1317 proc_steal_exc_port (inf
->task
, inf
->event_port
);
1318 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1319 proc_steal_exc_port (thread
, MACH_PORT_NULL
);
1322 /* Makes sure the process has its own exception ports. */
1324 inf_restore_exc_ports (struct inf
*inf
)
1326 struct proc
*thread
;
1328 inf_debug (inf
, "restoring exception ports");
1330 inf_set_step_thread (inf
, 0); /* The step thread is special. */
1332 proc_restore_exc_port (inf
->task
);
1333 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1334 proc_restore_exc_port (thread
);
1338 /* Deliver signal SIG to INF. If INF is stopped, delivering a signal, even
1339 signal 0, will continue it. INF is assumed to be in a paused state, and
1340 the resume_sc's of INF's threads may be affected. */
1342 inf_signal (struct inf
*inf
, enum gdb_signal sig
)
1344 kern_return_t err
= 0;
1345 int host_sig
= gdb_signal_to_host (sig
);
1347 #define NAME gdb_signal_to_name (sig)
1349 if (host_sig
>= _NSIG
)
1350 /* A mach exception. Exceptions are encoded in the signal space by
1351 putting them after _NSIG; this assumes they're positive (and not
1352 extremely large)! */
1354 struct inf_wait
*w
= &inf
->wait
;
1356 if (w
->status
.kind
== TARGET_WAITKIND_STOPPED
1357 && w
->status
.value
.sig
== sig
1358 && w
->thread
&& !w
->thread
->aborted
)
1359 /* We're passing through the last exception we received. This is
1360 kind of bogus, because exceptions are per-thread whereas gdb
1361 treats signals as per-process. We just forward the exception to
1362 the correct handler, even it's not for the same thread as TID --
1363 i.e., we pretend it's global. */
1365 struct exc_state
*e
= &w
->exc
;
1367 inf_debug (inf
, "passing through exception:"
1368 " task = %lu, thread = %lu, exc = %d"
1369 ", code = %d, subcode = %d",
1370 w
->thread
->port
, inf
->task
->port
,
1371 e
->exception
, e
->code
, e
->subcode
);
1373 exception_raise_request (e
->handler
,
1374 e
->reply
, MACH_MSG_TYPE_MOVE_SEND_ONCE
,
1375 w
->thread
->port
, inf
->task
->port
,
1376 e
->exception
, e
->code
, e
->subcode
);
1379 error (_("Can't forward spontaneous exception (%s)."), NAME
);
1382 /* A Unix signal. */
1384 /* The process is stopped and expecting a signal. Just send off a
1385 request and let it get handled when we resume everything. */
1387 inf_debug (inf
, "sending %s to stopped process", NAME
);
1389 INF_MSGPORT_RPC (inf
,
1390 msg_sig_post_untraced_request (msgport
,
1392 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1396 /* Posting an untraced signal automatically continues it.
1397 We clear this here rather than when we get the reply
1398 because we'd rather assume it's not stopped when it
1399 actually is, than the reverse. */
1403 /* It's not expecting it. We have to let just the signal thread
1404 run, and wait for it to get into a reasonable state before we
1405 can continue the rest of the process. When we finally resume the
1406 process the signal we request will be the very first thing that
1409 inf_debug (inf
, "sending %s to unstopped process"
1410 " (so resuming signal thread)", NAME
);
1412 INF_RESUME_MSGPORT_RPC (inf
,
1413 msg_sig_post_untraced (msgport
, host_sig
,
1418 /* Can't do too much... */
1419 warning (_("Can't deliver signal %s: No signal thread."), NAME
);
1421 warning (_("Delivering signal %s: %s"), NAME
, safe_strerror (err
));
1427 /* Continue INF without delivering a signal. This is meant to be used
1428 when INF does not have a message port. */
1430 inf_continue (struct inf
*inf
)
1433 kern_return_t err
= proc_pid2proc (proc_server
, inf
->pid
, &proc
);
1437 inf_debug (inf
, "continuing process");
1439 err
= proc_mark_cont (proc
);
1442 struct proc
*thread
;
1444 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1445 thread_resume (thread
->port
);
1452 warning (_("Can't continue process: %s"), safe_strerror (err
));
1456 /* The inferior used for all gdb target ops. */
1457 struct inf
*gnu_current_inf
= 0;
1459 /* The inferior being waited for by gnu_wait. Since GDB is decidely not
1460 multi-threaded, we don't bother to lock this. */
1461 struct inf
*waiting_inf
;
1463 /* MIG stubs are not yet ready for C++ compilation. */
1464 extern "C" int exc_server (mach_msg_header_t
*, mach_msg_header_t
*);
1465 extern "C" int msg_reply_server (mach_msg_header_t
*, mach_msg_header_t
*);
1466 extern "C" int notify_server (mach_msg_header_t
*, mach_msg_header_t
*);
1467 extern "C" int process_reply_server (mach_msg_header_t
*, mach_msg_header_t
*);
1469 /* Wait for something to happen in the inferior, returning what in STATUS. */
1472 gnu_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
1477 mach_msg_header_t hdr
;
1478 mach_msg_type_t type
;
1482 struct proc
*thread
;
1483 struct inf
*inf
= gnu_current_inf
;
1485 gdb_assert (inf
->task
);
1487 if (!inf
->threads
&& !inf
->pending_execs
)
1488 /* No threads! Assume that maybe some outside agency is frobbing our
1489 task, and really look for new threads. If we can't find any, just tell
1490 the user to try again later. */
1492 inf_validate_procs (inf
);
1493 if (!inf
->threads
&& !inf
->task
->dead
)
1494 error (_("There are no threads; try again later."));
1499 inf_debug (inf
, "waiting for: %s", target_pid_to_str (ptid
).c_str ());
1502 if (proc_wait_pid
!= inf
->pid
&& !inf
->no_wait
)
1503 /* Always get information on events from the proc server. */
1505 inf_debug (inf
, "requesting wait on pid %d", inf
->pid
);
1508 /* The proc server is single-threaded, and only allows a single
1509 outstanding wait request, so we have to cancel the previous one. */
1511 inf_debug (inf
, "cancelling previous wait on pid %d", proc_wait_pid
);
1512 interrupt_operation (proc_server
, 0);
1516 proc_wait_request (proc_server
, inf
->event_port
, inf
->pid
, WUNTRACED
);
1518 warning (_("wait request failed: %s"), safe_strerror (err
));
1521 inf_debug (inf
, "waits pending: %d", proc_waits_pending
);
1522 proc_wait_pid
= inf
->pid
;
1523 /* Even if proc_waits_pending was > 0 before, we still won't
1524 get any other replies, because it was either from a
1525 different INF, or a different process attached to INF --
1526 and the event port, which is the wait reply port, changes
1527 when you switch processes. */
1528 proc_waits_pending
= 1;
1532 inf_clear_wait (inf
);
1534 /* What can happen? (1) Dead name notification; (2) Exceptions arrive;
1535 (3) wait reply from the proc server. */
1537 inf_debug (inf
, "waiting for an event...");
1538 err
= mach_msg (&msg
.hdr
, MACH_RCV_MSG
| MACH_RCV_INTERRUPT
,
1539 0, sizeof (struct msg
), inf
->event_port
,
1540 MACH_MSG_TIMEOUT_NONE
, MACH_PORT_NULL
);
1542 /* Re-suspend the task. */
1545 if (!inf
->task
&& inf
->pending_execs
)
1546 /* When doing an exec, it's possible that the old task wasn't reused
1547 (e.g., setuid execs). So if the task seems to have disappeared,
1548 attempt to refetch it, as the pid should still be the same. */
1549 inf_set_pid (inf
, inf
->pid
);
1551 if (err
== EMACH_RCV_INTERRUPTED
)
1552 inf_debug (inf
, "interrupted");
1554 error (_("Couldn't wait for an event: %s"), safe_strerror (err
));
1559 mach_msg_header_t hdr
;
1560 mach_msg_type_t err_type
;
1566 inf_debug (inf
, "event: msgid = %d", msg
.hdr
.msgh_id
);
1568 /* Handle what we got. */
1569 if (!notify_server (&msg
.hdr
, &reply
.hdr
)
1570 && !exc_server (&msg
.hdr
, &reply
.hdr
)
1571 && !process_reply_server (&msg
.hdr
, &reply
.hdr
)
1572 && !msg_reply_server (&msg
.hdr
, &reply
.hdr
))
1573 /* Whatever it is, it's something strange. */
1574 error (_("Got a strange event, msg id = %d."), msg
.hdr
.msgh_id
);
1577 error (_("Handling event, msgid = %d: %s"),
1578 msg
.hdr
.msgh_id
, safe_strerror (reply
.err
));
1581 if (inf
->pending_execs
)
1582 /* We're waiting for the inferior to finish execing. */
1584 struct inf_wait
*w
= &inf
->wait
;
1585 enum target_waitkind kind
= w
->status
.kind
;
1587 if (kind
== TARGET_WAITKIND_SPURIOUS
)
1588 /* Since gdb is actually counting the number of times the inferior
1589 stops, expecting one stop per exec, we only return major events
1593 inf_debug (inf
, "pending_execs, ignoring minor event");
1595 else if (kind
== TARGET_WAITKIND_STOPPED
1596 && w
->status
.value
.sig
== GDB_SIGNAL_TRAP
)
1597 /* Ah hah! A SIGTRAP from the inferior while starting up probably
1598 means we've succesfully completed an exec! */
1600 inf_debug (inf
, "one pending exec completed");
1602 else if (kind
== TARGET_WAITKIND_STOPPED
)
1603 /* It's possible that this signal is because of a crashed process
1604 being handled by the hurd crash server; in this case, the process
1605 will have an extra task suspend, which we need to know about.
1606 Since the code in inf_resume that normally checks for this is
1607 disabled while INF->pending_execs, we do the check here instead. */
1608 inf_validate_task_sc (inf
);
1611 if (inf
->wait
.suppress
)
1612 /* Some totally spurious event happened that we don't consider
1613 worth returning to gdb. Just keep waiting. */
1615 inf_debug (inf
, "suppressing return, rewaiting...");
1620 /* Pass back out our results. */
1621 memcpy (status
, &inf
->wait
.status
, sizeof (*status
));
1623 thread
= inf
->wait
.thread
;
1625 ptid
= ptid_t (inf
->pid
, thread
->tid
, 0);
1626 else if (ptid
== minus_one_ptid
)
1627 thread
= inf_tid_to_thread (inf
, -1);
1629 thread
= inf_tid_to_thread (inf
, ptid
.lwp ());
1631 if (!thread
|| thread
->port
== MACH_PORT_NULL
)
1633 /* TID is dead; try and find a new thread. */
1634 if (inf_update_procs (inf
) && inf
->threads
)
1635 ptid
= ptid_t (inf
->pid
, inf
->threads
->tid
, 0); /* The first
1639 ptid
= inferior_ptid
; /* let wait_for_inferior handle exit case */
1643 && ptid
!= minus_one_ptid
1644 && status
->kind
!= TARGET_WAITKIND_SPURIOUS
1645 && inf
->pause_sc
== 0 && thread
->pause_sc
== 0)
1646 /* If something actually happened to THREAD, make sure we
1650 inf_update_suspends (inf
);
1653 inf_debug (inf
, "returning ptid = %s, %s",
1654 target_pid_to_str (ptid
).c_str (),
1655 target_waitstatus_to_string (status
).c_str ());
1661 /* The rpc handler called by exc_server. */
1663 S_exception_raise_request (mach_port_t port
, mach_port_t reply_port
,
1664 thread_t thread_port
, task_t task_port
,
1665 int exception
, int code
, int subcode
)
1667 struct inf
*inf
= waiting_inf
;
1668 struct proc
*thread
= inf_port_to_thread (inf
, thread_port
);
1670 inf_debug (waiting_inf
,
1671 "thread = %lu, task = %lu, exc = %d, code = %d, subcode = %d",
1672 thread_port
, task_port
, exception
, code
, subcode
);
1675 /* We don't know about thread? */
1677 inf_update_procs (inf
);
1678 thread
= inf_port_to_thread (inf
, thread_port
);
1680 /* Give up, the generating thread is gone. */
1684 mach_port_deallocate (mach_task_self (), thread_port
);
1685 mach_port_deallocate (mach_task_self (), task_port
);
1687 if (!thread
->aborted
)
1688 /* THREAD hasn't been aborted since this exception happened (abortion
1689 clears any exception state), so it must be real. */
1691 /* Store away the details; this will destroy any previous info. */
1692 inf
->wait
.thread
= thread
;
1694 inf
->wait
.status
.kind
= TARGET_WAITKIND_STOPPED
;
1696 if (exception
== EXC_BREAKPOINT
)
1697 /* GDB likes to get SIGTRAP for breakpoints. */
1699 inf
->wait
.status
.value
.sig
= GDB_SIGNAL_TRAP
;
1700 mach_port_deallocate (mach_task_self (), reply_port
);
1703 /* Record the exception so that we can forward it later. */
1705 if (thread
->exc_port
== port
)
1707 inf_debug (waiting_inf
, "Handler is thread exception port <%lu>",
1708 thread
->saved_exc_port
);
1709 inf
->wait
.exc
.handler
= thread
->saved_exc_port
;
1713 inf_debug (waiting_inf
, "Handler is task exception port <%lu>",
1714 inf
->task
->saved_exc_port
);
1715 inf
->wait
.exc
.handler
= inf
->task
->saved_exc_port
;
1716 gdb_assert (inf
->task
->exc_port
== port
);
1718 if (inf
->wait
.exc
.handler
!= MACH_PORT_NULL
)
1719 /* Add a reference to the exception handler. */
1720 mach_port_mod_refs (mach_task_self (),
1721 inf
->wait
.exc
.handler
, MACH_PORT_RIGHT_SEND
,
1724 inf
->wait
.exc
.exception
= exception
;
1725 inf
->wait
.exc
.code
= code
;
1726 inf
->wait
.exc
.subcode
= subcode
;
1727 inf
->wait
.exc
.reply
= reply_port
;
1729 /* Exceptions are encoded in the signal space by putting
1730 them after _NSIG; this assumes they're positive (and not
1731 extremely large)! */
1732 inf
->wait
.status
.value
.sig
=
1733 gdb_signal_from_host (_NSIG
+ exception
);
1737 /* A suppressed exception, which ignore. */
1739 inf
->wait
.suppress
= 1;
1740 mach_port_deallocate (mach_task_self (), reply_port
);
1747 /* Fill in INF's wait field after a task has died without giving us more
1748 detailed information. */
1750 inf_task_died_status (struct inf
*inf
)
1752 warning (_("Pid %d died with unknown exit status, using SIGKILL."),
1754 inf
->wait
.status
.kind
= TARGET_WAITKIND_SIGNALLED
;
1755 inf
->wait
.status
.value
.sig
= GDB_SIGNAL_KILL
;
1758 /* Notify server routines. The only real one is dead name notification. */
1760 do_mach_notify_dead_name (mach_port_t notify
, mach_port_t dead_port
)
1762 struct inf
*inf
= waiting_inf
;
1764 inf_debug (waiting_inf
, "port = %lu", dead_port
);
1766 if (inf
->task
&& inf
->task
->port
== dead_port
)
1768 proc_debug (inf
->task
, "is dead");
1769 inf
->task
->port
= MACH_PORT_NULL
;
1770 if (proc_wait_pid
== inf
->pid
)
1771 /* We have a wait outstanding on the process, which will return more
1772 detailed information, so delay until we get that. */
1773 inf
->wait
.suppress
= 1;
1775 /* We never waited for the process (maybe it wasn't a child), so just
1776 pretend it got a SIGKILL. */
1777 inf_task_died_status (inf
);
1781 struct proc
*thread
= inf_port_to_thread (inf
, dead_port
);
1785 proc_debug (thread
, "is dead");
1786 thread
->port
= MACH_PORT_NULL
;
1789 if (inf
->task
->dead
)
1790 /* Since the task is dead, its threads are dying with it. */
1791 inf
->wait
.suppress
= 1;
1794 mach_port_deallocate (mach_task_self (), dead_port
);
1795 inf
->threads_up_to_date
= 0; /* Just in case. */
1801 #define ILL_RPC(fun, ...) \
1802 extern kern_return_t fun (__VA_ARGS__); \
1803 kern_return_t fun (__VA_ARGS__) \
1805 warning (_("illegal rpc: %s"), #fun); \
1809 ILL_RPC (do_mach_notify_no_senders
,
1810 mach_port_t notify
, mach_port_mscount_t count
)
1811 ILL_RPC (do_mach_notify_port_deleted
,
1812 mach_port_t notify
, mach_port_t name
)
1813 ILL_RPC (do_mach_notify_msg_accepted
,
1814 mach_port_t notify
, mach_port_t name
)
1815 ILL_RPC (do_mach_notify_port_destroyed
,
1816 mach_port_t notify
, mach_port_t name
)
1817 ILL_RPC (do_mach_notify_send_once
,
1820 /* Process_reply server routines. We only use process_wait_reply. */
1823 S_proc_wait_reply (mach_port_t reply
, kern_return_t err
,
1824 int status
, int sigcode
, rusage_t rusage
, pid_t pid
)
1826 struct inf
*inf
= waiting_inf
;
1828 inf_debug (inf
, "err = %s, pid = %d, status = 0x%x, sigcode = %d",
1829 err
? safe_strerror (err
) : "0", pid
, status
, sigcode
);
1831 if (err
&& proc_wait_pid
&& (!inf
->task
|| !inf
->task
->port
))
1832 /* Ack. The task has died, but the task-died notification code didn't
1833 tell anyone because it thought a more detailed reply from the
1834 procserver was forthcoming. However, we now learn that won't
1835 happen... So we have to act like the task just died, and this time,
1837 inf_task_died_status (inf
);
1839 if (--proc_waits_pending
== 0)
1840 /* PROC_WAIT_PID represents the most recent wait. We will always get
1841 replies in order because the proc server is single threaded. */
1844 inf_debug (inf
, "waits pending now: %d", proc_waits_pending
);
1850 warning (_("Can't wait for pid %d: %s"),
1851 inf
->pid
, safe_strerror (err
));
1854 /* Since we can't see the inferior's signals, don't trap them. */
1855 inf_set_traced (inf
, 0);
1858 else if (pid
== inf
->pid
)
1860 store_waitstatus (&inf
->wait
.status
, status
);
1861 if (inf
->wait
.status
.kind
== TARGET_WAITKIND_STOPPED
)
1862 /* The process has sent us a signal, and stopped itself in a sane
1863 state pending our actions. */
1865 inf_debug (inf
, "process has stopped itself");
1870 inf
->wait
.suppress
= 1; /* Something odd happened. Ignore. */
1875 ILL_RPC (S_proc_setmsgport_reply
,
1876 mach_port_t reply_port
, kern_return_t return_code
,
1877 mach_port_t oldmsgport
)
1878 ILL_RPC (S_proc_getmsgport_reply
,
1879 mach_port_t reply_port
, kern_return_t return_code
,
1880 mach_port_t msgports
, mach_msg_type_name_t msgportsPoly
)
1881 ILL_RPC (S_proc_pid2task_reply
,
1882 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t task
)
1883 ILL_RPC (S_proc_task2pid_reply
,
1884 mach_port_t reply_port
, kern_return_t return_code
, pid_t pid
)
1885 ILL_RPC (S_proc_task2proc_reply
,
1886 mach_port_t reply_port
, kern_return_t return_code
,
1887 mach_port_t proc
, mach_msg_type_name_t procPoly
)
1888 ILL_RPC (S_proc_proc2task_reply
,
1889 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t task
)
1890 ILL_RPC (S_proc_pid2proc_reply
,
1891 mach_port_t reply_port
, kern_return_t return_code
,
1892 mach_port_t proc
, mach_msg_type_name_t procPoly
)
1893 ILL_RPC (S_proc_getprocinfo_reply
,
1894 mach_port_t reply_port
, kern_return_t return_code
,
1895 int flags
, procinfo_t procinfo
, mach_msg_type_number_t procinfoCnt
,
1896 data_t threadwaits
, mach_msg_type_number_t threadwaitsCnt
)
1897 ILL_RPC (S_proc_getprocargs_reply
,
1898 mach_port_t reply_port
, kern_return_t return_code
,
1899 data_t procargs
, mach_msg_type_number_t procargsCnt
)
1900 ILL_RPC (S_proc_getprocenv_reply
,
1901 mach_port_t reply_port
, kern_return_t return_code
,
1902 data_t procenv
, mach_msg_type_number_t procenvCnt
)
1903 ILL_RPC (S_proc_getloginid_reply
,
1904 mach_port_t reply_port
, kern_return_t return_code
, pid_t login_id
)
1905 ILL_RPC (S_proc_getloginpids_reply
,
1906 mach_port_t reply_port
, kern_return_t return_code
,
1907 pidarray_t pids
, mach_msg_type_number_t pidsCnt
)
1908 ILL_RPC (S_proc_getlogin_reply
,
1909 mach_port_t reply_port
, kern_return_t return_code
, string_t logname
)
1910 ILL_RPC (S_proc_getsid_reply
,
1911 mach_port_t reply_port
, kern_return_t return_code
, pid_t sid
)
1912 ILL_RPC (S_proc_getsessionpgids_reply
,
1913 mach_port_t reply_port
, kern_return_t return_code
,
1914 pidarray_t pgidset
, mach_msg_type_number_t pgidsetCnt
)
1915 ILL_RPC (S_proc_getsessionpids_reply
,
1916 mach_port_t reply_port
, kern_return_t return_code
,
1917 pidarray_t pidset
, mach_msg_type_number_t pidsetCnt
)
1918 ILL_RPC (S_proc_getsidport_reply
,
1919 mach_port_t reply_port
, kern_return_t return_code
,
1920 mach_port_t sessport
)
1921 ILL_RPC (S_proc_getpgrp_reply
,
1922 mach_port_t reply_port
, kern_return_t return_code
, pid_t pgrp
)
1923 ILL_RPC (S_proc_getpgrppids_reply
,
1924 mach_port_t reply_port
, kern_return_t return_code
,
1925 pidarray_t pidset
, mach_msg_type_number_t pidsetCnt
)
1926 ILL_RPC (S_proc_get_tty_reply
,
1927 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t tty
)
1928 ILL_RPC (S_proc_getnports_reply
,
1929 mach_port_t reply_port
, kern_return_t return_code
,
1930 mach_msg_type_number_t nports
)
1931 ILL_RPC (S_proc_is_important_reply
,
1932 mach_port_t reply_port
, kern_return_t return_code
,
1933 boolean_t essential
)
1934 ILL_RPC (S_proc_get_code_reply
,
1935 mach_port_t reply_port
, kern_return_t return_code
,
1936 vm_address_t start_code
, vm_address_t end_code
)
1938 /* Msg_reply server routines. We only use msg_sig_post_untraced_reply. */
1941 S_msg_sig_post_untraced_reply (mach_port_t reply
, kern_return_t err
)
1943 struct inf
*inf
= waiting_inf
;
1946 /* EBUSY is what we get when the crash server has grabbed control of the
1947 process and doesn't like what signal we tried to send it. Just act
1948 like the process stopped (using a signal of 0 should mean that the
1949 *next* time the user continues, it will pass signal 0, which the crash
1950 server should like). */
1952 inf
->wait
.status
.kind
= TARGET_WAITKIND_STOPPED
;
1953 inf
->wait
.status
.value
.sig
= GDB_SIGNAL_0
;
1956 warning (_("Signal delivery failed: %s"), safe_strerror (err
));
1959 /* We only get this reply when we've posted a signal to a process which we
1960 thought was stopped, and which we expected to continue after the signal.
1961 Given that the signal has failed for some reason, it's reasonable to
1962 assume it's still stopped. */
1965 inf
->wait
.suppress
= 1;
1970 ILL_RPC (S_msg_sig_post_reply
,
1971 mach_port_t reply
, kern_return_t err
)
1973 /* Returns the number of messages queued for the receive right PORT. */
1974 static mach_port_msgcount_t
1975 port_msgs_queued (mach_port_t port
)
1977 struct mach_port_status status
;
1979 mach_port_get_receive_status (mach_task_self (), port
, &status
);
1984 return status
.mps_msgcount
;
1988 /* Resume execution of the inferior process.
1990 If STEP is nonzero, single-step it.
1991 If SIGNAL is nonzero, give it that signal.
1994 -1 true Single step the current thread allowing other threads to run.
1995 -1 false Continue the current thread allowing other threads to run.
1996 X true Single step the given thread, don't allow any others to run.
1997 X false Continue the given thread, do not allow any others to run.
1998 (Where X, of course, is anything except -1)
2000 Note that a resume may not `take' if there are pending exceptions/&c
2001 still unprocessed from the last resume we did (any given resume may result
2002 in multiple events returned by wait). */
2005 gnu_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
2007 struct proc
*step_thread
= 0;
2009 struct inf
*inf
= gnu_current_inf
;
2011 inf_debug (inf
, "ptid = %s, step = %d, sig = %d",
2012 target_pid_to_str (ptid
).c_str (), step
, sig
);
2014 inf_validate_procinfo (inf
);
2016 if (sig
!= GDB_SIGNAL_0
|| inf
->stopped
)
2018 if (sig
== GDB_SIGNAL_0
&& inf
->nomsg
)
2021 inf_signal (inf
, sig
);
2023 else if (inf
->wait
.exc
.reply
!= MACH_PORT_NULL
)
2024 /* We received an exception to which we have chosen not to forward, so
2025 abort the faulting thread, which will perhaps retake it. */
2027 proc_abort (inf
->wait
.thread
, 1);
2028 warning (_("Aborting %s with unforwarded exception %s."),
2029 proc_string (inf
->wait
.thread
),
2030 gdb_signal_to_name (inf
->wait
.status
.value
.sig
));
2033 if (port_msgs_queued (inf
->event_port
))
2034 /* If there are still messages in our event queue, don't bother resuming
2035 the process, as we're just going to stop it right away anyway. */
2038 inf_update_procs (inf
);
2040 /* A specific PTID means `step only this process id'. */
2041 resume_all
= ptid
== minus_one_ptid
;
2044 /* Allow all threads to run, except perhaps single-stepping one. */
2046 inf_debug (inf
, "running all threads; tid = %d",
2047 inferior_ptid
.pid ());
2048 ptid
= inferior_ptid
; /* What to step. */
2049 inf_set_threads_resume_sc (inf
, 0, 1);
2052 /* Just allow a single thread to run. */
2054 struct proc
*thread
= inf_tid_to_thread (inf
, ptid
.lwp ());
2057 error (_("Can't run single thread id %s: no such thread!"),
2058 target_pid_to_str (ptid
).c_str ());
2059 inf_debug (inf
, "running one thread: %s",
2060 target_pid_to_str (ptid
).c_str ());
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
).c_str ());
2071 inf_debug (inf
, "stepping thread: %s",
2072 target_pid_to_str (ptid
).c_str ());
2074 if (step_thread
!= inf
->step_thread
)
2075 inf_set_step_thread (inf
, step_thread
);
2077 inf_debug (inf
, "here we go...");
2083 gnu_nat_target::kill ()
2085 struct proc
*task
= gnu_current_inf
->task
;
2089 proc_debug (task
, "terminating...");
2090 task_terminate (task
->port
);
2091 inf_set_pid (gnu_current_inf
, -1);
2093 target_mourn_inferior (inferior_ptid
);
2096 /* Clean up after the inferior dies. */
2098 gnu_nat_target::mourn_inferior ()
2100 inf_debug (gnu_current_inf
, "rip");
2101 inf_detach (gnu_current_inf
);
2102 inf_child_target::mourn_inferior ();
2106 /* Fork an inferior process, and start debugging it. */
2108 /* Set INFERIOR_PID to the first thread available in the child, if any. */
2110 inf_pick_first_thread (void)
2112 if (gnu_current_inf
->task
&& gnu_current_inf
->threads
)
2113 /* The first thread. */
2114 return gnu_current_inf
->threads
->tid
;
2116 /* What may be the next thread. */
2117 return next_thread_id
;
2123 if (!gnu_current_inf
)
2124 gnu_current_inf
= make_inf ();
2125 return gnu_current_inf
;
2129 gnu_ptrace_me (void)
2131 /* We're in the child; make this process stop as soon as it execs. */
2132 struct inf
*inf
= cur_inf ();
2133 inf_debug (inf
, "tracing self");
2134 if (ptrace (PTRACE_TRACEME
) != 0)
2135 trace_start_error_with_name ("ptrace");
2139 gnu_nat_target::create_inferior (const char *exec_file
,
2140 const std::string
&allargs
,
2144 struct inf
*inf
= cur_inf ();
2147 inf_debug (inf
, "creating inferior");
2149 if (!target_is_pushed (this))
2152 pid
= fork_inferior (exec_file
, allargs
, env
, gnu_ptrace_me
,
2153 NULL
, NULL
, NULL
, NULL
);
2155 /* We have something that executes now. We'll be running through
2156 the shell at this point (if startup-with-shell is true), but the
2157 pid shouldn't change. */
2158 add_thread_silent (gnu_target
, ptid_t (pid
));
2160 /* Attach to the now stopped child, which is actually a shell... */
2161 inf_debug (inf
, "attaching to child: %d", pid
);
2163 inf_attach (inf
, pid
);
2165 inf
->pending_execs
= 1;
2169 /* Now let the child run again, knowing that it will stop
2170 immediately because of the ptrace. */
2173 /* We now have thread info. */
2174 thread_change_ptid (gnu_target
, inferior_ptid
,
2175 ptid_t (inf
->pid
, inf_pick_first_thread (), 0));
2177 gdb_startup_inferior (pid
, START_INFERIOR_TRAPS_EXPECTED
);
2179 inf
->pending_execs
= 0;
2180 /* Get rid of the old shell threads. */
2183 inf_validate_procinfo (inf
);
2184 inf_update_signal_thread (inf
);
2185 inf_set_traced (inf
, inf
->want_signals
);
2187 /* Execing the process will have trashed our exception ports; steal them
2188 back (or make sure they're restored if the user wants that). */
2189 if (inf
->want_exceptions
)
2190 inf_steal_exc_ports (inf
);
2192 inf_restore_exc_ports (inf
);
2196 /* Attach to process PID, then initialize for debugging it
2197 and wait for the trace-trap that results from attaching. */
2199 gnu_nat_target::attach (const char *args
, int from_tty
)
2202 struct inf
*inf
= cur_inf ();
2203 struct inferior
*inferior
;
2205 pid
= parse_pid_to_attach (args
);
2207 if (pid
== getpid ()) /* Trying to masturbate? */
2208 error (_("I refuse to debug myself!"));
2212 const char *exec_file
= get_exec_file (0);
2215 printf_unfiltered ("Attaching to program `%s', pid %d\n",
2218 printf_unfiltered ("Attaching to pid %d\n", pid
);
2221 inf_debug (inf
, "attaching to pid: %d", pid
);
2223 inf_attach (inf
, pid
);
2227 inferior
= current_inferior ();
2228 inferior_appeared (inferior
, pid
);
2229 inferior
->attach_flag
= 1;
2231 inf_update_procs (inf
);
2233 inferior_ptid
= ptid_t (pid
, inf_pick_first_thread (), 0);
2235 /* We have to initialize the terminal settings now, since the code
2236 below might try to restore them. */
2237 target_terminal::init ();
2239 /* If the process was stopped before we attached, make it continue the next
2240 time the user does a continue. */
2241 inf_validate_procinfo (inf
);
2243 inf_update_signal_thread (inf
);
2244 inf_set_traced (inf
, inf
->want_signals
);
2246 #if 0 /* Do we need this? */
2247 renumber_threads (0); /* Give our threads reasonable names. */
2252 /* Take a program previously attached to and detaches it.
2253 The program resumes execution and will no longer stop
2254 on signals, etc. We'd better not have left any breakpoints
2255 in the program or it'll die when it hits one. For this
2256 to work, it may be necessary for the process to have been
2257 previously attached. It *might* work if the program was
2258 started via fork. */
2260 gnu_nat_target::detach (inferior
*inf
, int from_tty
)
2266 const char *exec_file
= get_exec_file (0);
2269 printf_unfiltered ("Detaching from program `%s' pid %d\n",
2270 exec_file
, gnu_current_inf
->pid
);
2272 printf_unfiltered ("Detaching from pid %d\n", gnu_current_inf
->pid
);
2275 pid
= gnu_current_inf
->pid
;
2277 inf_detach (gnu_current_inf
);
2279 inferior_ptid
= null_ptid
;
2280 detach_inferior (find_inferior_pid (gnu_target
, pid
));
2282 maybe_unpush_target ();
2287 gnu_nat_target::stop (ptid_t ptid
)
2289 error (_("stop target function not implemented"));
2293 gnu_nat_target::thread_alive (ptid_t ptid
)
2295 inf_update_procs (gnu_current_inf
);
2296 return !!inf_tid_to_thread (gnu_current_inf
,
2301 /* Read inferior task's LEN bytes from ADDR and copy it to MYADDR in
2302 gdb's address space. Return 0 on failure; number of bytes read
2305 gnu_read_inferior (task_t task
, CORE_ADDR addr
, gdb_byte
*myaddr
, int length
)
2308 vm_address_t low_address
= (vm_address_t
) trunc_page (addr
);
2309 vm_size_t aligned_length
=
2310 (vm_size_t
) round_page (addr
+ length
) - low_address
;
2312 mach_msg_type_number_t copy_count
;
2314 /* Get memory from inferior with page aligned addresses. */
2315 err
= vm_read (task
, low_address
, aligned_length
, &copied
, ©_count
);
2319 err
= hurd_safe_copyin (myaddr
, (void *) (addr
- low_address
+ copied
),
2323 warning (_("Read from inferior faulted: %s"), safe_strerror (err
));
2327 err
= vm_deallocate (mach_task_self (), copied
, copy_count
);
2329 warning (_("gnu_read_inferior vm_deallocate failed: %s"),
2330 safe_strerror (err
));
2335 #define CHK_GOTO_OUT(str,ret) \
2336 do if (ret != KERN_SUCCESS) { errstr = #str; goto out; } while(0)
2338 struct vm_region_list
2340 struct vm_region_list
*next
;
2341 vm_prot_t protection
;
2346 struct obstack region_obstack
;
2348 /* Write gdb's LEN bytes from MYADDR and copy it to ADDR in inferior
2349 task's address space. */
2351 gnu_write_inferior (task_t task
, CORE_ADDR addr
,
2352 const gdb_byte
*myaddr
, int length
)
2355 vm_address_t low_address
= (vm_address_t
) trunc_page (addr
);
2356 vm_size_t aligned_length
=
2357 (vm_size_t
) round_page (addr
+ length
) - low_address
;
2359 mach_msg_type_number_t copy_count
;
2362 const char *errstr
= "Bug in gnu_write_inferior";
2364 struct vm_region_list
*region_element
;
2365 struct vm_region_list
*region_head
= NULL
;
2367 /* Get memory from inferior with page aligned addresses. */
2368 err
= vm_read (task
,
2373 CHK_GOTO_OUT ("gnu_write_inferior vm_read failed", err
);
2377 err
= hurd_safe_copyout ((void *) (addr
- low_address
+ copied
),
2379 CHK_GOTO_OUT ("Write to inferior faulted", err
);
2381 obstack_init (®ion_obstack
);
2383 /* Do writes atomically.
2384 First check for holes and unwritable memory. */
2386 vm_size_t remaining_length
= aligned_length
;
2387 vm_address_t region_address
= low_address
;
2389 struct vm_region_list
*scan
;
2391 while (region_address
< low_address
+ aligned_length
)
2393 vm_prot_t protection
;
2394 vm_prot_t max_protection
;
2395 vm_inherit_t inheritance
;
2397 mach_port_t object_name
;
2399 vm_size_t region_length
= remaining_length
;
2400 vm_address_t old_address
= region_address
;
2402 err
= vm_region (task
,
2411 CHK_GOTO_OUT ("vm_region failed", err
);
2413 /* Check for holes in memory. */
2414 if (old_address
!= region_address
)
2416 warning (_("No memory at 0x%lx. Nothing written"),
2423 if (!(max_protection
& VM_PROT_WRITE
))
2425 warning (_("Memory at address 0x%lx is unwritable. "
2433 /* Chain the regions for later use. */
2434 region_element
= XOBNEW (®ion_obstack
, struct vm_region_list
);
2436 region_element
->protection
= protection
;
2437 region_element
->start
= region_address
;
2438 region_element
->length
= region_length
;
2440 /* Chain the regions along with protections. */
2441 region_element
->next
= region_head
;
2442 region_head
= region_element
;
2444 region_address
+= region_length
;
2445 remaining_length
= remaining_length
- region_length
;
2448 /* If things fail after this, we give up.
2449 Somebody is messing up inferior_task's mappings. */
2451 /* Enable writes to the chained vm regions. */
2452 for (scan
= region_head
; scan
; scan
= scan
->next
)
2454 if (!(scan
->protection
& VM_PROT_WRITE
))
2456 err
= vm_protect (task
,
2460 scan
->protection
| VM_PROT_WRITE
);
2461 CHK_GOTO_OUT ("vm_protect: enable write failed", err
);
2465 err
= vm_write (task
,
2469 CHK_GOTO_OUT ("vm_write failed", err
);
2471 /* Set up the original region protections, if they were changed. */
2472 for (scan
= region_head
; scan
; scan
= scan
->next
)
2474 if (!(scan
->protection
& VM_PROT_WRITE
))
2476 err
= vm_protect (task
,
2481 CHK_GOTO_OUT ("vm_protect: enable write failed", err
);
2489 obstack_free (®ion_obstack
, 0);
2491 (void) vm_deallocate (mach_task_self (),
2496 if (err
!= KERN_SUCCESS
)
2498 warning (_("%s: %s"), errstr
, mach_error_string (err
));
2507 /* Implement the to_xfer_partial target_ops method for
2508 TARGET_OBJECT_MEMORY. */
2510 static enum target_xfer_status
2511 gnu_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2512 CORE_ADDR memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2514 task_t task
= (gnu_current_inf
2515 ? (gnu_current_inf
->task
2516 ? gnu_current_inf
->task
->port
: 0)
2520 if (task
== MACH_PORT_NULL
)
2521 return TARGET_XFER_E_IO
;
2523 if (writebuf
!= NULL
)
2525 inf_debug (gnu_current_inf
, "writing %s[%s] <-- %s",
2526 paddress (target_gdbarch (), memaddr
), pulongest (len
),
2527 host_address_to_string (writebuf
));
2528 res
= gnu_write_inferior (task
, memaddr
, writebuf
, len
);
2532 inf_debug (gnu_current_inf
, "reading %s[%s] --> %s",
2533 paddress (target_gdbarch (), memaddr
), pulongest (len
),
2534 host_address_to_string (readbuf
));
2535 res
= gnu_read_inferior (task
, memaddr
, readbuf
, len
);
2537 gdb_assert (res
>= 0);
2539 return TARGET_XFER_E_IO
;
2542 *xfered_len
= (ULONGEST
) res
;
2543 return TARGET_XFER_OK
;
2547 /* GNU does not have auxv, but we can at least fake the AT_ENTRY entry for PIE
2549 static enum target_xfer_status
2550 gnu_xfer_auxv (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2551 CORE_ADDR memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2553 task_t task
= (gnu_current_inf
2554 ? (gnu_current_inf
->task
2555 ? gnu_current_inf
->task
->port
: 0)
2560 ElfW(auxv_t
) auxv
[2];
2562 if (task
== MACH_PORT_NULL
)
2563 return TARGET_XFER_E_IO
;
2564 if (writebuf
!= NULL
)
2565 return TARGET_XFER_E_IO
;
2567 if (memaddr
== sizeof (auxv
))
2568 return TARGET_XFER_EOF
;
2569 if (memaddr
> sizeof (auxv
))
2570 return TARGET_XFER_E_IO
;
2572 err
= proc_task2proc (proc_server
, task
, &proc
);
2574 return TARGET_XFER_E_IO
;
2576 /* Get entry from proc server. */
2577 err
= proc_get_entry (proc
, &entry
);
2579 return TARGET_XFER_E_IO
;
2581 /* Fake auxv entry. */
2582 auxv
[0].a_type
= AT_ENTRY
;
2583 auxv
[0].a_un
.a_val
= entry
;
2584 auxv
[1].a_type
= AT_NULL
;
2585 auxv
[1].a_un
.a_val
= 0;
2587 inf_debug (gnu_current_inf
, "reading auxv %s[%s] --> %s",
2588 paddress (target_gdbarch (), memaddr
), pulongest (len
),
2589 host_address_to_string (readbuf
));
2591 if (memaddr
+ len
> sizeof (auxv
))
2592 len
= sizeof (auxv
) - memaddr
;
2594 memcpy (readbuf
, (gdb_byte
*) &auxv
+ memaddr
, len
);
2597 return TARGET_XFER_OK
;
2600 /* Target to_xfer_partial implementation. */
2602 enum target_xfer_status
2603 gnu_nat_target::xfer_partial (enum target_object object
,
2604 const char *annex
, gdb_byte
*readbuf
,
2605 const gdb_byte
*writebuf
, ULONGEST offset
,
2606 ULONGEST len
, ULONGEST
*xfered_len
)
2610 case TARGET_OBJECT_MEMORY
:
2611 return gnu_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2612 case TARGET_OBJECT_AUXV
:
2613 return gnu_xfer_auxv (readbuf
, writebuf
, offset
, len
, xfered_len
);
2615 return TARGET_XFER_E_IO
;
2619 /* Call FUNC on each memory region in the task. */
2622 gnu_nat_target::find_memory_regions (find_memory_region_ftype func
,
2627 vm_address_t region_address
, last_region_address
, last_region_end
;
2628 vm_prot_t last_protection
;
2630 if (gnu_current_inf
== 0 || gnu_current_inf
->task
== 0)
2632 task
= gnu_current_inf
->task
->port
;
2633 if (task
== MACH_PORT_NULL
)
2636 region_address
= last_region_address
= last_region_end
= VM_MIN_ADDRESS
;
2637 last_protection
= VM_PROT_NONE
;
2638 while (region_address
< VM_MAX_ADDRESS
)
2640 vm_prot_t protection
;
2641 vm_prot_t max_protection
;
2642 vm_inherit_t inheritance
;
2644 mach_port_t object_name
;
2646 vm_size_t region_length
= VM_MAX_ADDRESS
- region_address
;
2648 err
= vm_region (task
,
2657 if (err
== KERN_NO_SPACE
)
2659 if (err
!= KERN_SUCCESS
)
2661 warning (_("vm_region failed: %s"), mach_error_string (err
));
2665 if (protection
== last_protection
&& region_address
== last_region_end
)
2666 /* This region is contiguous with and indistinguishable from
2667 the previous one, so we just extend that one. */
2668 last_region_end
= region_address
+= region_length
;
2671 /* This region is distinct from the last one we saw, so report
2672 that previous one. */
2673 if (last_protection
!= VM_PROT_NONE
)
2674 (*func
) (last_region_address
,
2675 last_region_end
- last_region_address
,
2676 last_protection
& VM_PROT_READ
,
2677 last_protection
& VM_PROT_WRITE
,
2678 last_protection
& VM_PROT_EXECUTE
,
2679 1, /* MODIFIED is unknown, pass it as true. */
2681 last_region_address
= region_address
;
2682 last_region_end
= region_address
+= region_length
;
2683 last_protection
= protection
;
2687 /* Report the final region. */
2688 if (last_region_end
> last_region_address
&& last_protection
!= VM_PROT_NONE
)
2689 (*func
) (last_region_address
, last_region_end
- last_region_address
,
2690 last_protection
& VM_PROT_READ
,
2691 last_protection
& VM_PROT_WRITE
,
2692 last_protection
& VM_PROT_EXECUTE
,
2693 1, /* MODIFIED is unknown, pass it as true. */
2700 /* Return printable description of proc. */
2702 proc_string (struct proc
*proc
)
2704 static char tid_str
[80];
2706 if (proc_is_task (proc
))
2707 xsnprintf (tid_str
, sizeof (tid_str
), "process %d", proc
->inf
->pid
);
2709 xsnprintf (tid_str
, sizeof (tid_str
), "Thread %d.%d",
2710 proc
->inf
->pid
, proc
->tid
);
2715 gnu_nat_target::pid_to_str (ptid_t ptid
)
2717 struct inf
*inf
= gnu_current_inf
;
2718 int tid
= ptid
.lwp ();
2719 struct proc
*thread
= inf_tid_to_thread (inf
, tid
);
2722 return proc_string (thread
);
2724 return string_printf ("bogus thread id %d", tid
);
2728 /* User task commands. */
2730 static struct cmd_list_element
*set_task_cmd_list
= 0;
2731 static struct cmd_list_element
*show_task_cmd_list
= 0;
2732 /* User thread commands. */
2734 /* Commands with a prefix of `set/show thread'. */
2735 extern struct cmd_list_element
*thread_cmd_list
;
2736 struct cmd_list_element
*set_thread_cmd_list
= NULL
;
2737 struct cmd_list_element
*show_thread_cmd_list
= NULL
;
2739 /* Commands with a prefix of `set/show thread default'. */
2740 struct cmd_list_element
*set_thread_default_cmd_list
= NULL
;
2741 struct cmd_list_element
*show_thread_default_cmd_list
= NULL
;
2744 set_thread_cmd (const char *args
, int from_tty
)
2746 printf_unfiltered ("\"set thread\" must be followed by the "
2747 "name of a thread property, or \"default\".\n");
2751 show_thread_cmd (const char *args
, int from_tty
)
2753 printf_unfiltered ("\"show thread\" must be followed by the "
2754 "name of a thread property, or \"default\".\n");
2758 set_thread_default_cmd (const char *args
, int from_tty
)
2760 printf_unfiltered ("\"set thread default\" must be followed "
2761 "by the name of a thread property.\n");
2765 show_thread_default_cmd (const char *args
, int from_tty
)
2767 printf_unfiltered ("\"show thread default\" must be followed "
2768 "by the name of a thread property.\n");
2772 parse_int_arg (const char *args
, const char *cmd_prefix
)
2777 int val
= strtoul (args
, &arg_end
, 10);
2779 if (*args
&& *arg_end
== '\0')
2782 error (_("Illegal argument for \"%s\" command, should be an integer."),
2787 _parse_bool_arg (const char *args
, const char *t_val
, const char *f_val
,
2788 const char *cmd_prefix
)
2790 if (!args
|| strcmp (args
, t_val
) == 0)
2792 else if (strcmp (args
, f_val
) == 0)
2795 error (_("Illegal argument for \"%s\" command, "
2796 "should be \"%s\" or \"%s\"."),
2797 cmd_prefix
, t_val
, f_val
);
2800 #define parse_bool_arg(args, cmd_prefix) \
2801 _parse_bool_arg (args, "on", "off", cmd_prefix)
2804 check_empty (const char *args
, const char *cmd_prefix
)
2807 error (_("Garbage after \"%s\" command: `%s'"), cmd_prefix
, args
);
2810 /* Returns the alive thread named by INFERIOR_PID, or signals an error. */
2811 static struct proc
*
2814 struct inf
*inf
= cur_inf ();
2815 struct proc
*thread
= inf_tid_to_thread (inf
,
2816 inferior_ptid
.lwp ());
2818 error (_("No current thread."));
2822 /* Returns the current inferior, but signals an error if it has no task. */
2826 struct inf
*inf
= cur_inf ();
2829 error (_("No current process."));
2835 set_task_pause_cmd (int arg
, int from_tty
)
2837 struct inf
*inf
= cur_inf ();
2838 int old_sc
= inf
->pause_sc
;
2840 inf
->pause_sc
= arg
;
2842 if (old_sc
== 0 && inf
->pause_sc
!= 0)
2843 /* If the task is currently unsuspended, immediately suspend it,
2844 otherwise wait until the next time it gets control. */
2849 set_task_pause_cmd (const char *args
, int from_tty
)
2851 set_task_pause_cmd (parse_bool_arg (args
, "set task pause"), from_tty
);
2855 show_task_pause_cmd (const char *args
, int from_tty
)
2857 struct inf
*inf
= cur_inf ();
2859 check_empty (args
, "show task pause");
2860 printf_unfiltered ("The inferior task %s suspended while gdb has control.\n",
2862 ? (inf
->pause_sc
== 0 ? "isn't" : "is")
2863 : (inf
->pause_sc
== 0 ? "won't be" : "will be"));
2867 set_task_detach_sc_cmd (const char *args
, int from_tty
)
2869 cur_inf ()->detach_sc
= parse_int_arg (args
,
2870 "set task detach-suspend-count");
2874 show_task_detach_sc_cmd (const char *args
, int from_tty
)
2876 check_empty (args
, "show task detach-suspend-count");
2877 printf_unfiltered ("The inferior task will be left with a "
2878 "suspend count of %d when detaching.\n",
2879 cur_inf ()->detach_sc
);
2884 set_thread_default_pause_cmd (const char *args
, int from_tty
)
2886 struct inf
*inf
= cur_inf ();
2888 inf
->default_thread_pause_sc
=
2889 parse_bool_arg (args
, "set thread default pause") ? 0 : 1;
2893 show_thread_default_pause_cmd (const char *args
, int from_tty
)
2895 struct inf
*inf
= cur_inf ();
2896 int sc
= inf
->default_thread_pause_sc
;
2898 check_empty (args
, "show thread default pause");
2899 printf_unfiltered ("New threads %s suspended while gdb has control%s.\n",
2900 sc
? "are" : "aren't",
2901 !sc
&& inf
->pause_sc
? " (but the task is)" : "");
2905 set_thread_default_run_cmd (const char *args
, int from_tty
)
2907 struct inf
*inf
= cur_inf ();
2909 inf
->default_thread_run_sc
=
2910 parse_bool_arg (args
, "set thread default run") ? 0 : 1;
2914 show_thread_default_run_cmd (const char *args
, int from_tty
)
2916 struct inf
*inf
= cur_inf ();
2918 check_empty (args
, "show thread default run");
2919 printf_unfiltered ("New threads %s allowed to run.\n",
2920 inf
->default_thread_run_sc
== 0 ? "are" : "aren't");
2924 set_thread_default_detach_sc_cmd (const char *args
, int from_tty
)
2926 cur_inf ()->default_thread_detach_sc
=
2927 parse_int_arg (args
, "set thread default detach-suspend-count");
2931 show_thread_default_detach_sc_cmd (const char *args
, int from_tty
)
2933 check_empty (args
, "show thread default detach-suspend-count");
2934 printf_unfiltered ("New threads will get a detach-suspend-count of %d.\n",
2935 cur_inf ()->default_thread_detach_sc
);
2939 /* Steal a send right called NAME in the inferior task, and make it PROC's
2940 saved exception port. */
2942 steal_exc_port (struct proc
*proc
, mach_port_t name
)
2946 mach_msg_type_name_t port_type
;
2948 if (!proc
|| !proc
->inf
->task
)
2949 error (_("No inferior task."));
2951 err
= mach_port_extract_right (proc
->inf
->task
->port
,
2952 name
, MACH_MSG_TYPE_COPY_SEND
,
2955 error (_("Couldn't extract send right %lu from inferior: %s"),
2956 name
, safe_strerror (err
));
2958 if (proc
->saved_exc_port
)
2959 /* Get rid of our reference to the old one. */
2960 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
2962 proc
->saved_exc_port
= port
;
2964 if (!proc
->exc_port
)
2965 /* If PROC is a thread, we may not have set its exception port
2966 before. We can't use proc_steal_exc_port because it also sets
2969 proc
->exc_port
= proc
->inf
->event_port
;
2970 err
= proc_set_exception_port (proc
, proc
->exc_port
);
2971 error (_("Can't set exception port for %s: %s"),
2972 proc_string (proc
), safe_strerror (err
));
2977 set_task_exc_port_cmd (const char *args
, int from_tty
)
2979 struct inf
*inf
= cur_inf ();
2982 error (_("No argument to \"set task exception-port\" command."));
2983 steal_exc_port (inf
->task
, parse_and_eval_address (args
));
2987 set_stopped_cmd (const char *args
, int from_tty
)
2989 cur_inf ()->stopped
= _parse_bool_arg (args
, "yes", "no", "set stopped");
2993 show_stopped_cmd (const char *args
, int from_tty
)
2995 struct inf
*inf
= active_inf ();
2997 check_empty (args
, "show stopped");
2998 printf_unfiltered ("The inferior process %s stopped.\n",
2999 inf
->stopped
? "is" : "isn't");
3003 set_sig_thread_cmd (const char *args
, int from_tty
)
3005 struct inf
*inf
= cur_inf ();
3007 if (!args
|| (!isdigit (*args
) && strcmp (args
, "none") != 0))
3008 error (_("Illegal argument to \"set signal-thread\" command.\n"
3009 "Should be a thread ID, or \"none\"."));
3011 if (strcmp (args
, "none") == 0)
3012 inf
->signal_thread
= 0;
3015 struct thread_info
*tp
= parse_thread_id (args
, NULL
);
3016 inf
->signal_thread
= inf_tid_to_thread (inf
, tp
->ptid
.lwp ());
3021 show_sig_thread_cmd (const char *args
, int from_tty
)
3023 struct inf
*inf
= active_inf ();
3025 check_empty (args
, "show signal-thread");
3026 if (inf
->signal_thread
)
3027 printf_unfiltered ("The signal thread is %s.\n",
3028 proc_string (inf
->signal_thread
));
3030 printf_unfiltered ("There is no signal thread.\n");
3035 set_signals_cmd (int arg
, int from_tty
)
3037 struct inf
*inf
= cur_inf ();
3039 inf
->want_signals
= arg
;
3041 if (inf
->task
&& inf
->want_signals
!= inf
->traced
)
3042 /* Make this take effect immediately in a running process. */
3043 inf_set_traced (inf
, inf
->want_signals
);
3047 set_signals_cmd (const char *args
, int from_tty
)
3049 set_signals_cmd(parse_bool_arg (args
, "set signals"), from_tty
);
3053 show_signals_cmd (const char *args
, int from_tty
)
3055 struct inf
*inf
= cur_inf ();
3057 check_empty (args
, "show signals");
3058 printf_unfiltered ("The inferior process's signals %s intercepted.\n",
3060 ? (inf
->traced
? "are" : "aren't")
3061 : (inf
->want_signals
? "will be" : "won't be"));
3065 set_exceptions_cmd (int arg
, int from_tty
)
3067 struct inf
*inf
= cur_inf ();
3069 /* Make this take effect immediately in a running process. */
3072 inf
->want_exceptions
= arg
;
3076 set_exceptions_cmd (const char *args
, int from_tty
)
3078 set_exceptions_cmd (parse_bool_arg (args
, "set exceptions"), from_tty
);
3082 show_exceptions_cmd (const char *args
, int from_tty
)
3084 struct inf
*inf
= cur_inf ();
3086 check_empty (args
, "show exceptions");
3087 printf_unfiltered ("Exceptions in the inferior %s trapped.\n",
3089 ? (inf
->want_exceptions
? "are" : "aren't")
3090 : (inf
->want_exceptions
? "will be" : "won't be"));
3095 set_task_cmd (const char *args
, int from_tty
)
3097 printf_unfiltered ("\"set task\" must be followed by the name"
3098 " of a task property.\n");
3102 show_task_cmd (const char *args
, int from_tty
)
3104 struct inf
*inf
= cur_inf ();
3106 check_empty (args
, "show task");
3108 show_signals_cmd (0, from_tty
);
3109 show_exceptions_cmd (0, from_tty
);
3110 show_task_pause_cmd (0, from_tty
);
3112 if (inf
->pause_sc
== 0)
3113 show_thread_default_pause_cmd (0, from_tty
);
3114 show_thread_default_run_cmd (0, from_tty
);
3118 show_stopped_cmd (0, from_tty
);
3119 show_sig_thread_cmd (0, from_tty
);
3122 if (inf
->detach_sc
!= 0)
3123 show_task_detach_sc_cmd (0, from_tty
);
3124 if (inf
->default_thread_detach_sc
!= 0)
3125 show_thread_default_detach_sc_cmd (0, from_tty
);
3130 set_noninvasive_cmd (const char *args
, int from_tty
)
3132 /* Invert the sense of the arg for each component. */
3133 int inv_arg
= parse_bool_arg (args
, "set noninvasive") ? 0 : 1;
3135 set_task_pause_cmd (inv_arg
, from_tty
);
3136 set_signals_cmd (inv_arg
, from_tty
);
3137 set_exceptions_cmd (inv_arg
, from_tty
);
3142 info_port_rights (const char *args
, mach_port_type_t only
)
3144 struct inf
*inf
= active_inf ();
3145 struct value
*vmark
= value_mark ();
3148 /* Explicit list of port rights. */
3152 struct value
*val
= parse_to_comma_and_eval (&args
);
3153 long right
= value_as_long (val
);
3155 print_port_info (right
, 0, inf
->task
->port
, PORTINFO_DETAILS
,
3159 error (_("%ld: %s."), right
, safe_strerror (err
));
3163 /* Print all of them. */
3166 print_task_ports_info (inf
->task
->port
, only
, PORTINFO_DETAILS
,
3169 error (_("%s."), safe_strerror (err
));
3172 value_free_to_mark (vmark
);
3176 info_send_rights_cmd (const char *args
, int from_tty
)
3178 info_port_rights (args
, MACH_PORT_TYPE_SEND
);
3182 info_recv_rights_cmd (const char *args
, int from_tty
)
3184 info_port_rights (args
, MACH_PORT_TYPE_RECEIVE
);
3188 info_port_sets_cmd (const char *args
, int from_tty
)
3190 info_port_rights (args
, MACH_PORT_TYPE_PORT_SET
);
3194 info_dead_names_cmd (const char *args
, int from_tty
)
3196 info_port_rights (args
, MACH_PORT_TYPE_DEAD_NAME
);
3200 info_port_rights_cmd (const char *args
, int from_tty
)
3202 info_port_rights (args
, ~0);
3207 add_task_commands (void)
3209 add_cmd ("pause", class_run
, set_thread_default_pause_cmd
, _("\
3210 Set whether the new threads are suspended while gdb has control.\n\
3211 This property normally has no effect because the whole task is\n\
3212 suspended, however, that may be disabled with \"set task pause off\".\n\
3213 The default value is \"off\"."),
3214 &set_thread_default_cmd_list
);
3215 add_cmd ("pause", no_class
, show_thread_default_pause_cmd
, _("\
3216 Show whether new threads are suspended while gdb has control."),
3217 &show_thread_default_cmd_list
);
3219 add_cmd ("run", class_run
, set_thread_default_run_cmd
, _("\
3220 Set whether new threads are allowed to run (once gdb has noticed them)."),
3221 &set_thread_default_cmd_list
);
3222 add_cmd ("run", no_class
, show_thread_default_run_cmd
, _("\
3223 Show whether new threads are allowed to run (once gdb has noticed them)."),
3224 &show_thread_default_cmd_list
);
3226 add_cmd ("detach-suspend-count", class_run
, set_thread_default_detach_sc_cmd
,
3227 _("Set the default detach-suspend-count value for new threads."),
3228 &set_thread_default_cmd_list
);
3229 add_cmd ("detach-suspend-count", no_class
, show_thread_default_detach_sc_cmd
,
3230 _("Show the default detach-suspend-count value for new threads."),
3231 &show_thread_default_cmd_list
);
3233 add_cmd ("signals", class_run
, set_signals_cmd
, _("\
3234 Set whether the inferior process's signals will be intercepted.\n\
3235 Mach exceptions (such as breakpoint traps) are not affected."),
3237 add_alias_cmd ("sigs", "signals", class_run
, 1, &setlist
);
3238 add_cmd ("signals", no_class
, show_signals_cmd
, _("\
3239 Show whether the inferior process's signals will be intercepted."),
3241 add_alias_cmd ("sigs", "signals", no_class
, 1, &showlist
);
3243 add_cmd ("signal-thread", class_run
, set_sig_thread_cmd
, _("\
3244 Set the thread that gdb thinks is the libc signal thread.\n\
3245 This thread is run when delivering a signal to a non-stopped process."),
3247 add_alias_cmd ("sigthread", "signal-thread", class_run
, 1, &setlist
);
3248 add_cmd ("signal-thread", no_class
, show_sig_thread_cmd
, _("\
3249 Set the thread that gdb thinks is the libc signal thread."),
3251 add_alias_cmd ("sigthread", "signal-thread", no_class
, 1, &showlist
);
3253 add_cmd ("stopped", class_run
, set_stopped_cmd
, _("\
3254 Set whether gdb thinks the inferior process is stopped as with SIGSTOP.\n\
3255 Stopped process will be continued by sending them a signal."),
3257 add_cmd ("stopped", no_class
, show_stopped_cmd
, _("\
3258 Show whether gdb thinks the inferior process is stopped as with SIGSTOP."),
3261 add_cmd ("exceptions", class_run
, set_exceptions_cmd
, _("\
3262 Set whether exceptions in the inferior process will be trapped.\n\
3263 When exceptions are turned off, neither breakpoints nor single-stepping\n\
3266 /* Allow `set exc' despite conflict with `set exception-port'. */
3267 add_alias_cmd ("exc", "exceptions", class_run
, 1, &setlist
);
3268 add_cmd ("exceptions", no_class
, show_exceptions_cmd
, _("\
3269 Show whether exceptions in the inferior process will be trapped."),
3272 add_prefix_cmd ("task", no_class
, set_task_cmd
,
3273 _("Command prefix for setting task attributes."),
3274 &set_task_cmd_list
, "set task ", 0, &setlist
);
3275 add_prefix_cmd ("task", no_class
, show_task_cmd
,
3276 _("Command prefix for showing task attributes."),
3277 &show_task_cmd_list
, "show task ", 0, &showlist
);
3279 add_cmd ("pause", class_run
, set_task_pause_cmd
, _("\
3280 Set whether the task is suspended while gdb has control.\n\
3281 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3282 until the next time the program is continued.\n\
3283 When setting this to \"off\", \"set thread default pause on\" can be\n\
3284 used to pause individual threads by default instead."),
3285 &set_task_cmd_list
);
3286 add_cmd ("pause", no_class
, show_task_pause_cmd
,
3287 _("Show whether the task is suspended while gdb has control."),
3288 &show_task_cmd_list
);
3290 add_cmd ("detach-suspend-count", class_run
, set_task_detach_sc_cmd
,
3291 _("Set the suspend count will leave on the thread when detaching."),
3292 &set_task_cmd_list
);
3293 add_cmd ("detach-suspend-count", no_class
, show_task_detach_sc_cmd
,
3294 _("Show the suspend count will leave "
3295 "on the thread when detaching."),
3296 &show_task_cmd_list
);
3298 add_cmd ("exception-port", no_class
, set_task_exc_port_cmd
, _("\
3299 Set the task exception port to which we forward exceptions.\n\
3300 The argument should be the value of the send right in the task."),
3301 &set_task_cmd_list
);
3302 add_alias_cmd ("excp", "exception-port", no_class
, 1, &set_task_cmd_list
);
3303 add_alias_cmd ("exc-port", "exception-port", no_class
, 1,
3304 &set_task_cmd_list
);
3306 /* A convenient way of turning on all options require to noninvasively
3307 debug running tasks. */
3308 add_cmd ("noninvasive", no_class
, set_noninvasive_cmd
, _("\
3309 Set task options so that we interfere as little as possible.\n\
3310 This is the same as setting `task pause', `exceptions', and\n\
3311 `signals' to the opposite value."),
3314 /* Commands to show information about the task's ports. */
3315 add_info ("send-rights", info_send_rights_cmd
,
3316 _("Show information about the task's send rights."));
3317 add_info ("receive-rights", info_recv_rights_cmd
,
3318 _("Show information about the task's receive rights."));
3319 add_info ("port-rights", info_port_rights_cmd
,
3320 _("Show information about the task's port rights."));
3321 add_info ("port-sets", info_port_sets_cmd
,
3322 _("Show information about the task's port sets."));
3323 add_info ("dead-names", info_dead_names_cmd
,
3324 _("Show information about the task's dead names."));
3325 add_info_alias ("ports", "port-rights", 1);
3326 add_info_alias ("port", "port-rights", 1);
3327 add_info_alias ("psets", "port-sets", 1);
3332 set_thread_pause_cmd (const char *args
, int from_tty
)
3334 struct proc
*thread
= cur_thread ();
3335 int old_sc
= thread
->pause_sc
;
3337 thread
->pause_sc
= parse_bool_arg (args
, "set thread pause");
3338 if (old_sc
== 0 && thread
->pause_sc
!= 0 && thread
->inf
->pause_sc
== 0)
3339 /* If the task is currently unsuspended, immediately suspend it,
3340 otherwise wait until the next time it gets control. */
3341 inf_suspend (thread
->inf
);
3345 show_thread_pause_cmd (const char *args
, int from_tty
)
3347 struct proc
*thread
= cur_thread ();
3348 int sc
= thread
->pause_sc
;
3350 check_empty (args
, "show task pause");
3351 printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n",
3352 proc_string (thread
),
3353 sc
? "is" : "isn't",
3354 !sc
&& thread
->inf
->pause_sc
? " (but the task is)" : "");
3358 set_thread_run_cmd (const char *args
, int from_tty
)
3360 struct proc
*thread
= cur_thread ();
3362 thread
->run_sc
= parse_bool_arg (args
, "set thread run") ? 0 : 1;
3366 show_thread_run_cmd (const char *args
, int from_tty
)
3368 struct proc
*thread
= cur_thread ();
3370 check_empty (args
, "show thread run");
3371 printf_unfiltered ("Thread %s %s allowed to run.",
3372 proc_string (thread
),
3373 thread
->run_sc
== 0 ? "is" : "isn't");
3377 set_thread_detach_sc_cmd (const char *args
, int from_tty
)
3379 cur_thread ()->detach_sc
= parse_int_arg (args
,
3380 "set thread detach-suspend-count");
3384 show_thread_detach_sc_cmd (const char *args
, int from_tty
)
3386 struct proc
*thread
= cur_thread ();
3388 check_empty (args
, "show thread detach-suspend-count");
3389 printf_unfiltered ("Thread %s will be left with a suspend count"
3390 " of %d when detaching.\n",
3391 proc_string (thread
),
3396 set_thread_exc_port_cmd (const char *args
, int from_tty
)
3398 struct proc
*thread
= cur_thread ();
3401 error (_("No argument to \"set thread exception-port\" command."));
3402 steal_exc_port (thread
, parse_and_eval_address (args
));
3407 show_thread_cmd (char *args
, int from_tty
)
3409 struct proc
*thread
= cur_thread ();
3411 check_empty (args
, "show thread");
3412 show_thread_run_cmd (0, from_tty
);
3413 show_thread_pause_cmd (0, from_tty
);
3414 if (thread
->detach_sc
!= 0)
3415 show_thread_detach_sc_cmd (0, from_tty
);
3420 thread_takeover_sc_cmd (const char *args
, int from_tty
)
3422 struct proc
*thread
= cur_thread ();
3424 thread_basic_info_data_t _info
;
3425 thread_basic_info_t info
= &_info
;
3426 mach_msg_type_number_t info_len
= THREAD_BASIC_INFO_COUNT
;
3428 = mach_thread_info (thread
->port
, THREAD_BASIC_INFO
,
3429 (int *) &info
, &info_len
);
3431 error (("%s."), safe_strerror (err
));
3432 thread
->sc
= info
->suspend_count
;
3434 printf_unfiltered ("Suspend count was %d.\n", thread
->sc
);
3436 vm_deallocate (mach_task_self (), (vm_address_t
) info
,
3437 info_len
* sizeof (int));
3442 add_thread_commands (void)
3444 add_prefix_cmd ("thread", no_class
, set_thread_cmd
,
3445 _("Command prefix for setting thread properties."),
3446 &set_thread_cmd_list
, "set thread ", 0, &setlist
);
3447 add_prefix_cmd ("default", no_class
, show_thread_cmd
,
3448 _("Command prefix for setting default thread properties."),
3449 &set_thread_default_cmd_list
, "set thread default ", 0,
3450 &set_thread_cmd_list
);
3451 add_prefix_cmd ("thread", no_class
, set_thread_default_cmd
,
3452 _("Command prefix for showing thread properties."),
3453 &show_thread_cmd_list
, "show thread ", 0, &showlist
);
3454 add_prefix_cmd ("default", no_class
, show_thread_default_cmd
,
3455 _("Command prefix for showing default thread properties."),
3456 &show_thread_default_cmd_list
, "show thread default ", 0,
3457 &show_thread_cmd_list
);
3459 add_cmd ("pause", class_run
, set_thread_pause_cmd
, _("\
3460 Set whether the current thread is suspended while gdb has control.\n\
3461 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3462 until the next time the program is continued. This property normally\n\
3463 has no effect because the whole task is suspended, however, that may\n\
3464 be disabled with \"set task pause off\".\n\
3465 The default value is \"off\"."),
3466 &set_thread_cmd_list
);
3467 add_cmd ("pause", no_class
, show_thread_pause_cmd
, _("\
3468 Show whether the current thread is suspended while gdb has control."),
3469 &show_thread_cmd_list
);
3471 add_cmd ("run", class_run
, set_thread_run_cmd
,
3472 _("Set whether the current thread is allowed to run."),
3473 &set_thread_cmd_list
);
3474 add_cmd ("run", no_class
, show_thread_run_cmd
,
3475 _("Show whether the current thread is allowed to run."),
3476 &show_thread_cmd_list
);
3478 add_cmd ("detach-suspend-count", class_run
, set_thread_detach_sc_cmd
, _("\
3479 Set the suspend count will leave on the thread when detaching.\n\
3480 Note that this is relative to suspend count when gdb noticed the thread;\n\
3481 use the `thread takeover-suspend-count' to force it to an absolute value."),
3482 &set_thread_cmd_list
);
3483 add_cmd ("detach-suspend-count", no_class
, show_thread_detach_sc_cmd
, _("\
3484 Show the suspend count will leave on the thread when detaching.\n\
3485 Note that this is relative to suspend count when gdb noticed the thread;\n\
3486 use the `thread takeover-suspend-count' to force it to an absolute value."),
3487 &show_thread_cmd_list
);
3489 add_cmd ("exception-port", no_class
, set_thread_exc_port_cmd
, _("\
3490 Set the thread exception port to which we forward exceptions.\n\
3491 This overrides the task exception port.\n\
3492 The argument should be the value of the send right in the task."),
3493 &set_thread_cmd_list
);
3494 add_alias_cmd ("excp", "exception-port", no_class
, 1, &set_thread_cmd_list
);
3495 add_alias_cmd ("exc-port", "exception-port", no_class
, 1,
3496 &set_thread_cmd_list
);
3498 add_cmd ("takeover-suspend-count", no_class
, thread_takeover_sc_cmd
, _("\
3499 Force the threads absolute suspend-count to be gdb's.\n\
3500 Prior to giving this command, gdb's thread suspend-counts are relative\n\
3501 to the thread's initial suspend-count when gdb notices the threads."),
3505 void _initialize_gnu_nat ();
3507 _initialize_gnu_nat ()
3509 proc_server
= getproc ();
3511 add_task_commands ();
3512 add_thread_commands ();
3513 add_setshow_boolean_cmd ("gnu-nat", class_maintenance
,
3515 _("Set debugging output for the gnu backend."),
3516 _("Show debugging output for the gnu backend."),
3524 #ifdef FLUSH_INFERIOR_CACHE
3526 /* When over-writing code on some machines the I-Cache must be flushed
3527 explicitly, because it is not kept coherent by the lazy hardware.
3528 This definitely includes breakpoints, for instance, or else we
3529 end up looping in mysterious Bpt traps. */
3532 flush_inferior_icache (CORE_ADDR pc
, int amount
)
3534 vm_machine_attribute_val_t flush
= MATTR_VAL_ICACHE_FLUSH
;
3537 ret
= vm_machine_attribute (gnu_current_inf
->task
->port
,
3542 if (ret
!= KERN_SUCCESS
)
3543 warning (_("Error flushing inferior's cache : %s"), safe_strerror (ret
));
3545 #endif /* FLUSH_INFERIOR_CACHE */