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"
87 #include "gnu-nat-mig.h"
90 struct gnu_nat_target
*gnu_target
;
92 static process_t proc_server
= MACH_PORT_NULL
;
94 /* If we've sent a proc_wait_request to the proc server, the pid of the
95 process we asked about. We can only ever have one outstanding. */
96 int proc_wait_pid
= 0;
98 /* The number of wait requests we've sent, and expect replies from. */
99 int proc_waits_pending
= 0;
101 bool gnu_debug_flag
= false;
105 static struct inf
*make_inf ();
107 #define inf_debug(_inf, msg, args...) \
108 do { struct inf *__inf = (_inf); \
109 debug ("{inf %d %s}: " msg, __inf->pid, \
110 host_address_to_string (__inf) , ##args); } while (0)
112 /* Evaluate RPC_EXPR in a scope with the variables MSGPORT and REFPORT bound
113 to INF's msg port and task port respectively. If it has no msg port,
114 EIEIO is returned. INF must refer to a running process! */
115 #define INF_MSGPORT_RPC(inf, rpc_expr) \
116 HURD_MSGPORT_RPC (proc_getmsgport (proc_server, inf->pid, &msgport), \
117 (refport = inf->task->port, 0), 0, \
118 msgport ? (rpc_expr) : EIEIO)
120 /* Like INF_MSGPORT_RPC, but will also resume the signal thread to ensure
121 there's someone around to deal with the RPC (and resuspend things
122 afterwards). This effects INF's threads' resume_sc count. */
123 #define INF_RESUME_MSGPORT_RPC(inf, rpc_expr) \
124 (inf_set_threads_resume_sc_for_signal_thread (inf) \
125 ? ({ kern_return_t __e; \
127 __e = INF_MSGPORT_RPC (inf, rpc_expr); \
133 /* The state passed by an exception message. */
136 int exception
; /* The exception code. */
138 mach_port_t handler
; /* The real exception port to handle this. */
139 mach_port_t reply
; /* The reply port from the exception call. */
142 /* The results of the last wait an inf did. */
145 struct target_waitstatus status
; /* The status returned to gdb. */
146 struct exc_state exc
; /* The exception that caused us to return. */
147 struct proc
*thread
; /* The thread in question. */
148 int suppress
; /* Something trivial happened. */
151 /* The state of an inferior. */
154 /* Fields describing the current inferior. */
156 struct proc
*task
; /* The mach task. */
157 struct proc
*threads
; /* A linked list of all threads in TASK. */
159 /* True if THREADS needn't be validated by querying the task. We
160 assume that we and the task in question are the only ones
161 frobbing the thread list, so as long as we don't let any code
162 run, we don't have to worry about THREADS changing. */
163 int threads_up_to_date
;
165 pid_t pid
; /* The real system PID. */
167 struct inf_wait wait
; /* What to return from target_wait. */
169 /* One thread proc in INF may be in `single-stepping mode'. This
171 struct proc
*step_thread
;
173 /* The thread we think is the signal thread. */
174 struct proc
*signal_thread
;
176 mach_port_t event_port
; /* Where we receive various msgs. */
178 /* True if we think at least one thread in the inferior could currently be
180 unsigned int running
:1;
182 /* True if the process has stopped (in the proc server sense). Note that
183 since a proc server `stop' leaves the signal thread running, the inf can
184 be RUNNING && STOPPED... */
185 unsigned int stopped
:1;
187 /* True if the inferior has no message port. */
188 unsigned int nomsg
:1;
190 /* True if the inferior is traced. */
191 unsigned int traced
:1;
193 /* True if we shouldn't try waiting for the inferior, usually because we
194 can't for some reason. */
195 unsigned int no_wait
:1;
197 /* When starting a new inferior, we don't try to validate threads until all
198 the proper execs have been done, which this flag states we still
200 unsigned int pending_execs
:1;
202 /* Fields describing global state. */
204 /* The task suspend count used when gdb has control. This is normally 1 to
205 make things easier for us, but sometimes (like when attaching to vital
206 system servers) it may be desirable to let the task continue to run
207 (pausing individual threads as necessary). */
210 /* The task suspend count left when detaching from a task. */
213 /* The initial values used for the run_sc and pause_sc of newly discovered
214 threads -- see the definition of those fields in struct proc. */
215 int default_thread_run_sc
;
216 int default_thread_pause_sc
;
217 int default_thread_detach_sc
;
219 /* True if the process should be traced when started/attached. Newly
220 started processes *must* be traced at first to exec them properly, but
221 if this is false, tracing is turned off as soon it has done so. */
224 /* True if exceptions from the inferior process should be trapped. This
225 must be on to use breakpoints. */
231 __proc_pid (struct proc
*proc
)
233 return proc
->inf
->pid
;
237 /* Update PROC's real suspend count to match it's desired one. Returns true
238 if we think PROC is now in a runnable state. */
240 gnu_nat_target::proc_update_sc (struct proc
*proc
)
244 int delta
= proc
->sc
- proc
->cur_sc
;
247 proc_debug (proc
, "sc: %d --> %d", proc
->cur_sc
, proc
->sc
);
249 if (proc
->sc
== 0 && proc
->state_changed
)
250 /* Since PROC may start running, we must write back any state changes. */
252 gdb_assert (proc_is_thread (proc
));
253 proc_debug (proc
, "storing back changed thread state");
254 err
= thread_set_state (proc
->port
, THREAD_STATE_FLAVOR
,
255 (thread_state_t
) &proc
->state
, THREAD_STATE_SIZE
);
257 proc
->state_changed
= 0;
262 while (delta
-- > 0 && !err
)
264 if (proc_is_task (proc
))
265 err
= task_suspend (proc
->port
);
267 err
= thread_suspend (proc
->port
);
272 while (delta
++ < 0 && !err
)
274 if (proc_is_task (proc
))
275 err
= task_resume (proc
->port
);
277 err
= thread_resume (proc
->port
);
281 proc
->cur_sc
= proc
->sc
;
283 /* If we got an error, then the task/thread has disappeared. */
284 running
= !err
&& proc
->sc
== 0;
286 proc_debug (proc
, "is %s", err
? "dead" : running
? "running" : "suspended");
288 proc_debug (proc
, "err = %s", safe_strerror (err
));
293 proc
->state_valid
= proc
->state_changed
= 0;
294 proc
->fetched_regs
= 0;
301 /* Thread_abort is called on PROC if needed. PROC must be a thread proc.
302 If PROC is deemed `precious', then nothing is done unless FORCE is true.
303 In particular, a thread is precious if it's running (in which case forcing
304 it includes suspending it first), or if it has an exception pending. */
306 gnu_nat_target::proc_abort (struct proc
*proc
, int force
)
308 gdb_assert (proc_is_thread (proc
));
312 struct inf
*inf
= proc
->inf
;
313 int running
= (proc
->cur_sc
== 0 && inf
->task
->cur_sc
== 0);
315 if (running
&& force
)
318 inf_update_suspends (proc
->inf
);
320 warning (_("Stopped %s."), proc_string (proc
));
322 else if (proc
== inf
->wait
.thread
&& inf
->wait
.exc
.reply
&& !force
)
323 /* An exception is pending on PROC, which don't mess with. */
327 /* We only abort the thread if it's not actually running. */
329 thread_abort (proc
->port
);
330 proc_debug (proc
, "aborted");
334 proc_debug (proc
, "not aborting");
338 /* Make sure that the state field in PROC is up to date, and return a pointer
339 to it, or 0 if something is wrong. If WILL_MODIFY is true, makes sure
340 that the thread is stopped and aborted first, and sets the state_changed
341 field in PROC to true. */
343 gnu_nat_target::proc_get_state (struct proc
*proc
, int will_modify
)
345 int was_aborted
= proc
->aborted
;
347 proc_debug (proc
, "updating state info%s",
348 will_modify
? " (with intention to modify)" : "");
350 proc_abort (proc
, will_modify
);
352 if (!was_aborted
&& proc
->aborted
)
353 /* PROC's state may have changed since we last fetched it. */
354 proc
->state_valid
= 0;
356 if (!proc
->state_valid
)
358 mach_msg_type_number_t state_size
= THREAD_STATE_SIZE
;
360 thread_get_state (proc
->port
, THREAD_STATE_FLAVOR
,
361 (thread_state_t
) &proc
->state
, &state_size
);
363 proc_debug (proc
, "getting thread state");
364 proc
->state_valid
= !err
;
367 if (proc
->state_valid
)
370 proc
->state_changed
= 1;
371 return (thread_state_t
) &proc
->state
;
378 /* Set PORT to PROC's exception port. */
380 gnu_nat_target::proc_get_exception_port (struct proc
* proc
, mach_port_t
* port
)
382 if (proc_is_task (proc
))
383 return task_get_exception_port (proc
->port
, port
);
385 return thread_get_exception_port (proc
->port
, port
);
388 /* Set PROC's exception port to PORT. */
390 gnu_nat_target::proc_set_exception_port (struct proc
* proc
, mach_port_t port
)
392 proc_debug (proc
, "setting exception port: %lu", port
);
393 if (proc_is_task (proc
))
394 return task_set_exception_port (proc
->port
, port
);
396 return thread_set_exception_port (proc
->port
, port
);
399 /* Get PROC's exception port, cleaning up a bit if proc has died. */
401 gnu_nat_target::_proc_get_exc_port (struct proc
*proc
)
403 mach_port_t exc_port
;
404 kern_return_t err
= proc_get_exception_port (proc
, &exc_port
);
407 /* PROC must be dead. */
410 mach_port_deallocate (mach_task_self (), proc
->exc_port
);
411 proc
->exc_port
= MACH_PORT_NULL
;
412 if (proc
->saved_exc_port
)
413 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
414 proc
->saved_exc_port
= MACH_PORT_NULL
;
420 /* Replace PROC's exception port with EXC_PORT, unless it's already
421 been done. Stash away any existing exception port so we can
424 gnu_nat_target::proc_steal_exc_port (struct proc
*proc
, mach_port_t exc_port
)
426 mach_port_t cur_exc_port
= _proc_get_exc_port (proc
);
430 kern_return_t err
= 0;
432 proc_debug (proc
, "inserting exception port: %lu", exc_port
);
434 if (cur_exc_port
!= exc_port
)
435 /* Put in our exception port. */
436 err
= proc_set_exception_port (proc
, exc_port
);
438 if (err
|| cur_exc_port
== proc
->exc_port
)
439 /* We previously set the exception port, and it's still set. So we
440 just keep the old saved port which is what the proc set. */
443 mach_port_deallocate (mach_task_self (), cur_exc_port
);
446 /* Keep a copy of PROC's old exception port so it can be restored. */
448 if (proc
->saved_exc_port
)
449 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
450 proc
->saved_exc_port
= cur_exc_port
;
453 proc_debug (proc
, "saved exception port: %lu", proc
->saved_exc_port
);
456 proc
->exc_port
= exc_port
;
458 warning (_("Error setting exception port for %s: %s"),
459 proc_string (proc
), safe_strerror (err
));
463 /* If we previously replaced PROC's exception port, put back what we
464 found there at the time, unless *our* exception port has since been
465 overwritten, in which case who knows what's going on. */
467 gnu_nat_target::proc_restore_exc_port (struct proc
*proc
)
469 mach_port_t cur_exc_port
= _proc_get_exc_port (proc
);
473 kern_return_t err
= 0;
475 proc_debug (proc
, "restoring real exception port");
477 if (proc
->exc_port
== cur_exc_port
)
478 /* Our's is still there. */
479 err
= proc_set_exception_port (proc
, proc
->saved_exc_port
);
481 if (proc
->saved_exc_port
)
482 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
483 proc
->saved_exc_port
= MACH_PORT_NULL
;
486 proc
->exc_port
= MACH_PORT_NULL
;
488 warning (_("Error setting exception port for %s: %s"),
489 proc_string (proc
), safe_strerror (err
));
494 /* Turns hardware tracing in PROC on or off when SET is true or false,
495 respectively. Returns true on success. */
497 gnu_nat_target::proc_trace (struct proc
*proc
, int set
)
499 thread_state_t state
= proc_get_state (proc
, 1);
502 return 0; /* The thread must be dead. */
504 proc_debug (proc
, "tracing %s", set
? "on" : "off");
508 /* XXX We don't get the exception unless the thread has its own
509 exception port???? */
510 if (proc
->exc_port
== MACH_PORT_NULL
)
511 proc_steal_exc_port (proc
, proc
->inf
->event_port
);
512 THREAD_STATE_SET_TRACED (state
);
515 THREAD_STATE_CLEAR_TRACED (state
);
521 /* A variable from which to assign new TIDs. */
522 static int next_thread_id
= 1;
524 /* Returns a new proc structure with the given fields. Also adds a
525 notification for PORT becoming dead to be sent to INF's notify port. */
527 gnu_nat_target::make_proc (struct inf
*inf
, mach_port_t port
, int tid
)
530 mach_port_t prev_port
= MACH_PORT_NULL
;
531 struct proc
*proc
= XNEW (struct proc
);
537 proc
->saved_exc_port
= MACH_PORT_NULL
;
538 proc
->exc_port
= MACH_PORT_NULL
;
543 /* Note that these are all the values for threads; the task simply uses the
544 corresponding field in INF directly. */
545 proc
->run_sc
= inf
->default_thread_run_sc
;
546 proc
->pause_sc
= inf
->default_thread_pause_sc
;
547 proc
->detach_sc
= inf
->default_thread_detach_sc
;
548 proc
->resume_sc
= proc
->run_sc
;
552 proc
->state_valid
= 0;
553 proc
->state_changed
= 0;
555 proc_debug (proc
, "is new");
557 /* Get notified when things die. */
559 mach_port_request_notification (mach_task_self (), port
,
560 MACH_NOTIFY_DEAD_NAME
, 1,
562 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
565 warning (_("Couldn't request notification for port %lu: %s"),
566 port
, safe_strerror (err
));
569 proc_debug (proc
, "notifications to: %lu", inf
->event_port
);
570 if (prev_port
!= MACH_PORT_NULL
)
571 mach_port_deallocate (mach_task_self (), prev_port
);
574 if (inf
->want_exceptions
)
576 if (proc_is_task (proc
))
577 /* Make the task exception port point to us. */
578 proc_steal_exc_port (proc
, inf
->event_port
);
580 /* Just clear thread exception ports -- they default to the
582 proc_steal_exc_port (proc
, MACH_PORT_NULL
);
588 /* Frees PROC and any resources it uses, and returns the value of PROC's
591 gnu_nat_target::_proc_free (struct proc
*proc
)
593 struct inf
*inf
= proc
->inf
;
594 struct proc
*next
= proc
->next
;
596 proc_debug (proc
, "freeing...");
598 if (proc
== inf
->step_thread
)
599 /* Turn off single stepping. */
600 inf_set_step_thread (inf
, 0);
601 if (proc
== inf
->wait
.thread
)
602 inf_clear_wait (inf
);
603 if (proc
== inf
->signal_thread
)
604 inf
->signal_thread
= 0;
606 if (proc
->port
!= MACH_PORT_NULL
)
608 if (proc
->exc_port
!= MACH_PORT_NULL
)
609 /* Restore the original exception port. */
610 proc_restore_exc_port (proc
);
611 if (proc
->cur_sc
!= 0)
612 /* Resume the thread/task. */
615 proc_update_sc (proc
);
617 mach_port_deallocate (mach_task_self (), proc
->port
);
628 struct inf
*inf
= XNEW (struct inf
);
632 inf
->threads_up_to_date
= 0;
634 inf
->wait
.status
.kind
= TARGET_WAITKIND_SPURIOUS
;
635 inf
->wait
.thread
= 0;
636 inf
->wait
.exc
.handler
= MACH_PORT_NULL
;
637 inf
->wait
.exc
.reply
= MACH_PORT_NULL
;
638 inf
->step_thread
= 0;
639 inf
->signal_thread
= 0;
640 inf
->event_port
= MACH_PORT_NULL
;
646 inf
->pending_execs
= 0;
649 inf
->default_thread_run_sc
= 0;
650 inf
->default_thread_pause_sc
= 0;
651 inf
->default_thread_detach_sc
= 0;
652 inf
->want_signals
= 1; /* By default */
653 inf
->want_exceptions
= 1; /* By default */
658 /* Clear INF's target wait status. */
660 gnu_nat_target::inf_clear_wait (struct inf
*inf
)
662 inf_debug (inf
, "clearing wait");
663 inf
->wait
.status
.kind
= TARGET_WAITKIND_SPURIOUS
;
664 inf
->wait
.thread
= 0;
665 inf
->wait
.suppress
= 0;
666 if (inf
->wait
.exc
.handler
!= MACH_PORT_NULL
)
668 mach_port_deallocate (mach_task_self (), inf
->wait
.exc
.handler
);
669 inf
->wait
.exc
.handler
= MACH_PORT_NULL
;
671 if (inf
->wait
.exc
.reply
!= MACH_PORT_NULL
)
673 mach_port_deallocate (mach_task_self (), inf
->wait
.exc
.reply
);
674 inf
->wait
.exc
.reply
= MACH_PORT_NULL
;
680 gnu_nat_target::inf_cleanup (struct inf
*inf
)
682 inf_debug (inf
, "cleanup");
684 inf_clear_wait (inf
);
686 inf_set_pid (inf
, -1);
693 inf
->pending_execs
= 0;
697 mach_port_destroy (mach_task_self (), inf
->event_port
);
698 inf
->event_port
= MACH_PORT_NULL
;
703 gnu_nat_target::inf_startup (struct inf
*inf
, int pid
)
707 inf_debug (inf
, "startup: pid = %d", pid
);
711 /* Make the port on which we receive all events. */
712 err
= mach_port_allocate (mach_task_self (),
713 MACH_PORT_RIGHT_RECEIVE
, &inf
->event_port
);
715 error (_("Error allocating event port: %s"), safe_strerror (err
));
717 /* Make a send right for it, so we can easily copy it for other people. */
718 mach_port_insert_right (mach_task_self (), inf
->event_port
,
719 inf
->event_port
, MACH_MSG_TYPE_MAKE_SEND
);
720 inf_set_pid (inf
, pid
);
724 /* Close current process, if any, and attach INF to process PORT. */
726 gnu_nat_target::inf_set_pid (struct inf
*inf
, pid_t pid
)
729 struct proc
*task
= inf
->task
;
731 inf_debug (inf
, "setting pid: %d", pid
);
734 task_port
= MACH_PORT_NULL
;
737 kern_return_t err
= proc_pid2task (proc_server
, pid
, &task_port
);
740 error (_("Error getting task for pid %d: %s"),
741 pid
, safe_strerror (err
));
744 inf_debug (inf
, "setting task: %lu", task_port
);
747 task_suspend (task_port
);
749 if (task
&& task
->port
!= task_port
)
752 inf_validate_procs (inf
); /* Trash all the threads. */
753 _proc_free (task
); /* And the task. */
756 if (task_port
!= MACH_PORT_NULL
)
758 inf
->task
= make_proc (inf
, task_port
, PROC_TID_TASK
);
759 inf
->threads_up_to_date
= 0;
766 /* Reflect task_suspend above. */
767 inf
->task
->sc
= inf
->task
->cur_sc
= 1;
774 /* Validates INF's stopped, nomsg and traced field from the actual
775 proc server state. Note that the traced field is only updated from
776 the proc server state if we do not have a message port. If we do
777 have a message port we'd better look at the tracemask itself. */
779 gnu_nat_target::inf_validate_procinfo (struct inf
*inf
)
782 mach_msg_type_number_t noise_len
= 0;
784 mach_msg_type_number_t pi_len
= 0;
787 proc_getprocinfo (proc_server
, inf
->pid
, &info_flags
,
788 (procinfo_t
*) &pi
, &pi_len
, &noise
, &noise_len
);
792 inf
->stopped
= !!(pi
->state
& PI_STOPPED
);
793 inf
->nomsg
= !!(pi
->state
& PI_NOMSG
);
795 inf
->traced
= !!(pi
->state
& PI_TRACED
);
796 vm_deallocate (mach_task_self (), (vm_address_t
) pi
,
797 pi_len
* sizeof (*(procinfo_t
) 0));
799 vm_deallocate (mach_task_self (), (vm_address_t
) noise
, noise_len
);
803 /* Validates INF's task suspend count. If it's higher than we expect,
804 verify with the user before `stealing' the extra count. */
806 gnu_nat_target::inf_validate_task_sc (struct inf
*inf
)
809 mach_msg_type_number_t noise_len
= 0;
811 mach_msg_type_number_t pi_len
= 0;
812 int info_flags
= PI_FETCH_TASKINFO
;
813 int suspend_count
= -1;
817 err
= proc_getprocinfo (proc_server
, inf
->pid
, &info_flags
,
818 (procinfo_t
*) &pi
, &pi_len
, &noise
, &noise_len
);
821 inf
->task
->dead
= 1; /* oh well */
825 if (inf
->task
->cur_sc
< pi
->taskinfo
.suspend_count
&& suspend_count
== -1)
827 /* The proc server might have suspended the task while stopping
828 it. This happens when the task is handling a traced signal.
829 Refetch the suspend count. The proc server should be
830 finished stopping the task by now. */
831 suspend_count
= pi
->taskinfo
.suspend_count
;
835 suspend_count
= pi
->taskinfo
.suspend_count
;
837 vm_deallocate (mach_task_self (), (vm_address_t
) pi
,
838 pi_len
* sizeof (*(procinfo_t
) 0));
840 vm_deallocate (mach_task_self (), (vm_address_t
) noise
, noise_len
);
842 if (inf
->task
->cur_sc
< suspend_count
)
844 if (!query (_("Pid %d has an additional task suspend count of %d;"
845 " clear it? "), inf
->pid
,
846 suspend_count
- inf
->task
->cur_sc
))
847 error (_("Additional task suspend count left untouched."));
849 inf
->task
->cur_sc
= suspend_count
;
853 /* Turns tracing for INF on or off, depending on ON, unless it already
854 is. If INF is running, the resume_sc count of INF's threads will
855 be modified, and the signal thread will briefly be run to change
858 gnu_nat_target::inf_set_traced (struct inf
*inf
, int on
)
860 if (on
== inf
->traced
)
863 if (inf
->task
&& !inf
->task
->dead
)
864 /* Make it take effect immediately. */
866 sigset_t mask
= on
? ~(sigset_t
) 0 : 0;
868 INF_RESUME_MSGPORT_RPC (inf
, msg_set_init_int (msgport
, refport
,
869 INIT_TRACEMASK
, mask
));
874 warning (_("Can't modify tracing state for pid %d: %s"),
875 inf
->pid
, "No signal thread");
879 warning (_("Can't modify tracing state for pid %d: %s"),
880 inf
->pid
, safe_strerror (err
));
889 /* Makes all the real suspend count deltas of all the procs in INF
890 match the desired values. Careful to always do thread/task suspend
891 counts in the safe order. Returns true if at least one thread is
892 thought to be running. */
894 gnu_nat_target::inf_update_suspends (struct inf
*inf
)
896 struct proc
*task
= inf
->task
;
898 /* We don't have to update INF->threads even though we're iterating over it
899 because we'll change a thread only if it already has an existing proc
901 inf_debug (inf
, "updating suspend counts");
906 int task_running
= (task
->sc
== 0), thread_running
= 0;
908 if (task
->sc
> task
->cur_sc
)
909 /* The task is becoming _more_ suspended; do before any threads. */
910 task_running
= proc_update_sc (task
);
912 if (inf
->pending_execs
)
913 /* When we're waiting for an exec, things may be happening behind our
914 back, so be conservative. */
917 /* Do all the thread suspend counts. */
918 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
919 thread_running
|= proc_update_sc (thread
);
921 if (task
->sc
!= task
->cur_sc
)
922 /* We didn't do the task first, because we wanted to wait for the
923 threads; do it now. */
924 task_running
= proc_update_sc (task
);
926 inf_debug (inf
, "%srunning...",
927 (thread_running
&& task_running
) ? "" : "not ");
929 inf
->running
= thread_running
&& task_running
;
931 /* Once any thread has executed some code, we can't depend on the
932 threads list any more. */
934 inf
->threads_up_to_date
= 0;
943 /* Converts a GDB pid to a struct proc. */
945 inf_tid_to_thread (struct inf
*inf
, int tid
)
947 struct proc
*thread
= inf
->threads
;
950 if (thread
->tid
== tid
)
953 thread
= thread
->next
;
957 /* Converts a thread port to a struct proc. */
959 inf_port_to_thread (struct inf
*inf
, mach_port_t port
)
961 struct proc
*thread
= inf
->threads
;
964 if (thread
->port
== port
)
967 thread
= thread
->next
;
974 inf_threads (struct inf
*inf
, inf_threads_ftype
*f
, void *arg
)
978 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
983 /* Make INF's list of threads be consistent with reality of TASK. */
985 gnu_nat_target::inf_validate_procs (struct inf
*inf
)
987 thread_array_t threads
;
988 mach_msg_type_number_t num_threads
, i
;
989 struct proc
*task
= inf
->task
;
991 /* If no threads are currently running, this function will guarantee that
992 things are up to date. The exception is if there are zero threads --
993 then it is almost certainly in an odd state, and probably some outside
994 agent will create threads. */
995 inf
->threads_up_to_date
= inf
->threads
? !inf
->running
: 0;
999 kern_return_t err
= task_threads (task
->port
, &threads
, &num_threads
);
1001 inf_debug (inf
, "fetching threads");
1003 /* TASK must be dead. */
1013 inf_debug (inf
, "no task");
1017 /* Make things normally linear. */
1018 mach_msg_type_number_t search_start
= 0;
1019 /* Which thread in PROCS corresponds to each task thread, & the task. */
1020 struct proc
*matched
[num_threads
+ 1];
1021 /* The last thread in INF->threads, so we can add to the end. */
1022 struct proc
*last
= 0;
1023 /* The current thread we're considering. */
1024 struct proc
*thread
= inf
->threads
;
1026 memset (matched
, 0, sizeof (matched
));
1030 mach_msg_type_number_t left
;
1032 for (i
= search_start
, left
= num_threads
; left
; i
++, left
--)
1034 if (i
>= num_threads
)
1035 i
-= num_threads
; /* I wrapped around. */
1036 if (thread
->port
== threads
[i
])
1037 /* We already know about this thread. */
1039 matched
[i
] = thread
;
1041 thread
= thread
->next
;
1049 proc_debug (thread
, "died!");
1050 thread
->port
= MACH_PORT_NULL
;
1051 thread
= _proc_free (thread
); /* THREAD is dead. */
1053 last
->next
= thread
;
1055 inf
->threads
= thread
;
1059 for (i
= 0; i
< num_threads
; i
++)
1062 /* Throw away the duplicate send right. */
1063 mach_port_deallocate (mach_task_self (), threads
[i
]);
1065 /* THREADS[I] is a thread we don't know about yet! */
1069 thread
= make_proc (inf
, threads
[i
], next_thread_id
++);
1071 last
->next
= thread
;
1073 inf
->threads
= thread
;
1075 proc_debug (thread
, "new thread: %lu", threads
[i
]);
1077 ptid
= ptid_t (inf
->pid
, thread
->tid
, 0);
1079 /* Tell GDB's generic thread code. */
1081 if (inferior_ptid
== ptid_t (inf
->pid
))
1082 /* This is the first time we're hearing about thread
1083 ids, after a fork-child. */
1084 thread_change_ptid (this, inferior_ptid
, ptid
);
1085 else if (inf
->pending_execs
!= 0)
1086 /* This is a shell thread. */
1087 add_thread_silent (this, ptid
);
1089 add_thread (this, ptid
);
1093 vm_deallocate (mach_task_self (),
1094 (vm_address_t
) threads
, (num_threads
* sizeof (thread_t
)));
1099 /* Makes sure that INF's thread list is synced with the actual process. */
1101 inf_update_procs (struct inf
*inf
)
1105 if (!inf
->threads_up_to_date
)
1106 gnu_target
->inf_validate_procs (inf
);
1110 /* Sets the resume_sc of each thread in inf. That of RUN_THREAD is set to 0,
1111 and others are set to their run_sc if RUN_OTHERS is true, and otherwise
1114 gnu_nat_target::inf_set_threads_resume_sc (struct inf
*inf
,
1115 struct proc
*run_thread
, int run_others
)
1117 struct proc
*thread
;
1119 inf_update_procs (inf
);
1120 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1121 if (thread
== run_thread
)
1122 thread
->resume_sc
= 0;
1123 else if (run_others
)
1124 thread
->resume_sc
= thread
->run_sc
;
1126 thread
->resume_sc
= thread
->pause_sc
;
1130 /* Cause INF to continue execution immediately; individual threads may still
1131 be suspended (but their suspend counts will be updated). */
1133 gnu_nat_target::inf_resume (struct inf
*inf
)
1135 struct proc
*thread
;
1137 inf_update_procs (inf
);
1139 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1140 thread
->sc
= thread
->resume_sc
;
1144 if (!inf
->pending_execs
)
1145 /* Try to make sure our task count is correct -- in the case where
1146 we're waiting for an exec though, things are too volatile, so just
1147 assume things will be reasonable (which they usually will be). */
1148 inf_validate_task_sc (inf
);
1152 inf_update_suspends (inf
);
1155 /* Cause INF to stop execution immediately; individual threads may still
1158 gnu_nat_target::inf_suspend (struct inf
*inf
)
1160 struct proc
*thread
;
1162 inf_update_procs (inf
);
1164 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1165 thread
->sc
= thread
->pause_sc
;
1168 inf
->task
->sc
= inf
->pause_sc
;
1170 inf_update_suspends (inf
);
1174 /* INF has one thread PROC that is in single-stepping mode. This
1175 function changes it to be PROC, changing any old step_thread to be
1176 a normal one. A PROC of 0 clears any existing value. */
1178 gnu_nat_target::inf_set_step_thread (struct inf
*inf
, struct proc
*thread
)
1180 gdb_assert (!thread
|| proc_is_thread (thread
));
1183 inf_debug (inf
, "setting step thread: %d/%d", inf
->pid
, thread
->tid
);
1185 inf_debug (inf
, "clearing step thread");
1187 if (inf
->step_thread
!= thread
)
1189 if (inf
->step_thread
&& inf
->step_thread
->port
!= MACH_PORT_NULL
)
1190 if (!proc_trace (inf
->step_thread
, 0))
1192 if (thread
&& proc_trace (thread
, 1))
1193 inf
->step_thread
= thread
;
1195 inf
->step_thread
= 0;
1200 /* Set up the thread resume_sc's so that only the signal thread is running
1201 (plus whatever other thread are set to always run). Returns true if we
1202 did so, or false if we can't find a signal thread. */
1204 gnu_nat_target::inf_set_threads_resume_sc_for_signal_thread (struct inf
*inf
)
1206 if (inf
->signal_thread
)
1208 inf_set_threads_resume_sc (inf
, inf
->signal_thread
, 0);
1216 inf_update_signal_thread (struct inf
*inf
)
1218 /* XXX for now we assume that if there's a msgport, the 2nd thread is
1219 the signal thread. */
1220 inf
->signal_thread
= inf
->threads
? inf
->threads
->next
: 0;
1224 /* Detachs from INF's inferior task, letting it run once again... */
1226 gnu_nat_target::inf_detach (struct inf
*inf
)
1228 struct proc
*task
= inf
->task
;
1230 inf_debug (inf
, "detaching...");
1232 inf_clear_wait (inf
);
1233 inf_set_step_thread (inf
, 0);
1237 struct proc
*thread
;
1239 inf_validate_procinfo (inf
);
1241 inf_set_traced (inf
, 0);
1247 inf_signal (inf
, GDB_SIGNAL_0
);
1250 proc_restore_exc_port (task
);
1251 task
->sc
= inf
->detach_sc
;
1253 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1255 proc_restore_exc_port (thread
);
1256 thread
->sc
= thread
->detach_sc
;
1259 inf_update_suspends (inf
);
1265 /* Attaches INF to the process with process id PID, returning it in a
1266 suspended state suitable for debugging. */
1268 gnu_nat_target::inf_attach (struct inf
*inf
, int pid
)
1270 inf_debug (inf
, "attaching: %d", pid
);
1275 inf_startup (inf
, pid
);
1279 /* Makes sure that we've got our exception ports entrenched in the process. */
1281 gnu_nat_target::inf_steal_exc_ports (struct inf
*inf
)
1283 struct proc
*thread
;
1285 inf_debug (inf
, "stealing exception ports");
1287 inf_set_step_thread (inf
, 0); /* The step thread is special. */
1289 proc_steal_exc_port (inf
->task
, inf
->event_port
);
1290 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1291 proc_steal_exc_port (thread
, MACH_PORT_NULL
);
1294 /* Makes sure the process has its own exception ports. */
1296 gnu_nat_target::inf_restore_exc_ports (struct inf
*inf
)
1298 struct proc
*thread
;
1300 inf_debug (inf
, "restoring exception ports");
1302 inf_set_step_thread (inf
, 0); /* The step thread is special. */
1304 proc_restore_exc_port (inf
->task
);
1305 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1306 proc_restore_exc_port (thread
);
1310 /* Deliver signal SIG to INF. If INF is stopped, delivering a signal, even
1311 signal 0, will continue it. INF is assumed to be in a paused state, and
1312 the resume_sc's of INF's threads may be affected. */
1314 gnu_nat_target::inf_signal (struct inf
*inf
, enum gdb_signal sig
)
1316 kern_return_t err
= 0;
1317 int host_sig
= gdb_signal_to_host (sig
);
1319 #define NAME gdb_signal_to_name (sig)
1321 if (host_sig
>= _NSIG
)
1322 /* A mach exception. Exceptions are encoded in the signal space by
1323 putting them after _NSIG; this assumes they're positive (and not
1324 extremely large)! */
1326 struct inf_wait
*w
= &inf
->wait
;
1328 if (w
->status
.kind
== TARGET_WAITKIND_STOPPED
1329 && w
->status
.value
.sig
== sig
1330 && w
->thread
&& !w
->thread
->aborted
)
1331 /* We're passing through the last exception we received. This is
1332 kind of bogus, because exceptions are per-thread whereas gdb
1333 treats signals as per-process. We just forward the exception to
1334 the correct handler, even it's not for the same thread as TID --
1335 i.e., we pretend it's global. */
1337 struct exc_state
*e
= &w
->exc
;
1339 inf_debug (inf
, "passing through exception:"
1340 " task = %lu, thread = %lu, exc = %d"
1341 ", code = %d, subcode = %d",
1342 w
->thread
->port
, inf
->task
->port
,
1343 e
->exception
, e
->code
, e
->subcode
);
1345 exception_raise_request (e
->handler
,
1346 e
->reply
, MACH_MSG_TYPE_MOVE_SEND_ONCE
,
1347 w
->thread
->port
, inf
->task
->port
,
1348 e
->exception
, e
->code
, e
->subcode
);
1351 error (_("Can't forward spontaneous exception (%s)."), NAME
);
1354 /* A Unix signal. */
1356 /* The process is stopped and expecting a signal. Just send off a
1357 request and let it get handled when we resume everything. */
1359 inf_debug (inf
, "sending %s to stopped process", NAME
);
1361 INF_MSGPORT_RPC (inf
,
1362 msg_sig_post_untraced_request (msgport
,
1364 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1368 /* Posting an untraced signal automatically continues it.
1369 We clear this here rather than when we get the reply
1370 because we'd rather assume it's not stopped when it
1371 actually is, than the reverse. */
1375 /* It's not expecting it. We have to let just the signal thread
1376 run, and wait for it to get into a reasonable state before we
1377 can continue the rest of the process. When we finally resume the
1378 process the signal we request will be the very first thing that
1381 inf_debug (inf
, "sending %s to unstopped process"
1382 " (so resuming signal thread)", NAME
);
1384 INF_RESUME_MSGPORT_RPC (inf
,
1385 msg_sig_post_untraced (msgport
, host_sig
,
1390 /* Can't do too much... */
1391 warning (_("Can't deliver signal %s: No signal thread."), NAME
);
1393 warning (_("Delivering signal %s: %s"), NAME
, safe_strerror (err
));
1399 /* Continue INF without delivering a signal. This is meant to be used
1400 when INF does not have a message port. */
1402 gnu_nat_target::inf_continue (struct inf
*inf
)
1405 kern_return_t err
= proc_pid2proc (proc_server
, inf
->pid
, &proc
);
1409 inf_debug (inf
, "continuing process");
1411 err
= proc_mark_cont (proc
);
1414 struct proc
*thread
;
1416 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1417 thread_resume (thread
->port
);
1424 warning (_("Can't continue process: %s"), safe_strerror (err
));
1428 /* The inferior used for all gdb target ops. */
1429 struct inf
*gnu_current_inf
= 0;
1431 /* The inferior being waited for by gnu_wait. Since GDB is decidely not
1432 multi-threaded, we don't bother to lock this. */
1433 static struct inf
*waiting_inf
;
1435 /* Wait for something to happen in the inferior, returning what in STATUS. */
1438 gnu_nat_target::wait (ptid_t ptid
, struct target_waitstatus
*status
,
1443 mach_msg_header_t hdr
;
1444 mach_msg_type_t type
;
1448 struct proc
*thread
;
1449 struct inf
*inf
= gnu_current_inf
;
1451 gdb_assert (inf
->task
);
1453 if (!inf
->threads
&& !inf
->pending_execs
)
1454 /* No threads! Assume that maybe some outside agency is frobbing our
1455 task, and really look for new threads. If we can't find any, just tell
1456 the user to try again later. */
1458 inf_validate_procs (inf
);
1459 if (!inf
->threads
&& !inf
->task
->dead
)
1460 error (_("There are no threads; try again later."));
1465 inf_debug (inf
, "waiting for: %s", target_pid_to_str (ptid
).c_str ());
1468 if (proc_wait_pid
!= inf
->pid
&& !inf
->no_wait
)
1469 /* Always get information on events from the proc server. */
1471 inf_debug (inf
, "requesting wait on pid %d", inf
->pid
);
1474 /* The proc server is single-threaded, and only allows a single
1475 outstanding wait request, so we have to cancel the previous one. */
1477 inf_debug (inf
, "cancelling previous wait on pid %d", proc_wait_pid
);
1478 interrupt_operation (proc_server
, 0);
1482 proc_wait_request (proc_server
, inf
->event_port
, inf
->pid
, WUNTRACED
);
1484 warning (_("wait request failed: %s"), safe_strerror (err
));
1487 inf_debug (inf
, "waits pending: %d", proc_waits_pending
);
1488 proc_wait_pid
= inf
->pid
;
1489 /* Even if proc_waits_pending was > 0 before, we still won't
1490 get any other replies, because it was either from a
1491 different INF, or a different process attached to INF --
1492 and the event port, which is the wait reply port, changes
1493 when you switch processes. */
1494 proc_waits_pending
= 1;
1498 inf_clear_wait (inf
);
1500 /* What can happen? (1) Dead name notification; (2) Exceptions arrive;
1501 (3) wait reply from the proc server. */
1503 inf_debug (inf
, "waiting for an event...");
1504 err
= mach_msg (&msg
.hdr
, MACH_RCV_MSG
| MACH_RCV_INTERRUPT
,
1505 0, sizeof (struct msg
), inf
->event_port
,
1506 MACH_MSG_TIMEOUT_NONE
, MACH_PORT_NULL
);
1508 /* Re-suspend the task. */
1511 if (!inf
->task
&& inf
->pending_execs
)
1512 /* When doing an exec, it's possible that the old task wasn't reused
1513 (e.g., setuid execs). So if the task seems to have disappeared,
1514 attempt to refetch it, as the pid should still be the same. */
1515 inf_set_pid (inf
, inf
->pid
);
1517 if (err
== EMACH_RCV_INTERRUPTED
)
1518 inf_debug (inf
, "interrupted");
1520 error (_("Couldn't wait for an event: %s"), safe_strerror (err
));
1525 mach_msg_header_t hdr
;
1526 mach_msg_type_t err_type
;
1532 inf_debug (inf
, "event: msgid = %d", msg
.hdr
.msgh_id
);
1534 /* Handle what we got. */
1535 if (!notify_server (&msg
.hdr
, &reply
.hdr
)
1536 && !exc_server (&msg
.hdr
, &reply
.hdr
)
1537 && !process_reply_server (&msg
.hdr
, &reply
.hdr
)
1538 && !msg_reply_server (&msg
.hdr
, &reply
.hdr
))
1539 /* Whatever it is, it's something strange. */
1540 error (_("Got a strange event, msg id = %d."), msg
.hdr
.msgh_id
);
1543 error (_("Handling event, msgid = %d: %s"),
1544 msg
.hdr
.msgh_id
, safe_strerror (reply
.err
));
1547 if (inf
->pending_execs
)
1548 /* We're waiting for the inferior to finish execing. */
1550 struct inf_wait
*w
= &inf
->wait
;
1551 enum target_waitkind kind
= w
->status
.kind
;
1553 if (kind
== TARGET_WAITKIND_SPURIOUS
)
1554 /* Since gdb is actually counting the number of times the inferior
1555 stops, expecting one stop per exec, we only return major events
1559 inf_debug (inf
, "pending_execs, ignoring minor event");
1561 else if (kind
== TARGET_WAITKIND_STOPPED
1562 && w
->status
.value
.sig
== GDB_SIGNAL_TRAP
)
1563 /* Ah hah! A SIGTRAP from the inferior while starting up probably
1564 means we've succesfully completed an exec! */
1566 inf_debug (inf
, "one pending exec completed");
1568 else if (kind
== TARGET_WAITKIND_STOPPED
)
1569 /* It's possible that this signal is because of a crashed process
1570 being handled by the hurd crash server; in this case, the process
1571 will have an extra task suspend, which we need to know about.
1572 Since the code in inf_resume that normally checks for this is
1573 disabled while INF->pending_execs, we do the check here instead. */
1574 inf_validate_task_sc (inf
);
1577 if (inf
->wait
.suppress
)
1578 /* Some totally spurious event happened that we don't consider
1579 worth returning to gdb. Just keep waiting. */
1581 inf_debug (inf
, "suppressing return, rewaiting...");
1586 /* Pass back out our results. */
1587 memcpy (status
, &inf
->wait
.status
, sizeof (*status
));
1589 thread
= inf
->wait
.thread
;
1591 ptid
= ptid_t (inf
->pid
, thread
->tid
, 0);
1592 else if (ptid
== minus_one_ptid
)
1593 thread
= inf_tid_to_thread (inf
, -1);
1595 thread
= inf_tid_to_thread (inf
, ptid
.lwp ());
1597 if (!thread
|| thread
->port
== MACH_PORT_NULL
)
1599 /* TID is dead; try and find a new thread. */
1600 if (inf_update_procs (inf
) && inf
->threads
)
1601 ptid
= ptid_t (inf
->pid
, inf
->threads
->tid
, 0); /* The first
1605 ptid
= inferior_ptid
; /* let wait_for_inferior handle exit case */
1609 && ptid
!= minus_one_ptid
1610 && status
->kind
!= TARGET_WAITKIND_SPURIOUS
1611 && inf
->pause_sc
== 0 && thread
->pause_sc
== 0)
1612 /* If something actually happened to THREAD, make sure we
1616 inf_update_suspends (inf
);
1619 inf_debug (inf
, "returning ptid = %s, %s",
1620 target_pid_to_str (ptid
).c_str (),
1621 target_waitstatus_to_string (status
).c_str ());
1627 /* The rpc handler called by exc_server. */
1629 S_exception_raise_request (mach_port_t port
, mach_port_t reply_port
,
1630 thread_t thread_port
, task_t task_port
,
1631 int exception
, int code
, int subcode
)
1633 struct inf
*inf
= waiting_inf
;
1634 struct proc
*thread
= inf_port_to_thread (inf
, thread_port
);
1636 inf_debug (waiting_inf
,
1637 "thread = %lu, task = %lu, exc = %d, code = %d, subcode = %d",
1638 thread_port
, task_port
, exception
, code
, subcode
);
1641 /* We don't know about thread? */
1643 inf_update_procs (inf
);
1644 thread
= inf_port_to_thread (inf
, thread_port
);
1646 /* Give up, the generating thread is gone. */
1650 mach_port_deallocate (mach_task_self (), thread_port
);
1651 mach_port_deallocate (mach_task_self (), task_port
);
1653 if (!thread
->aborted
)
1654 /* THREAD hasn't been aborted since this exception happened (abortion
1655 clears any exception state), so it must be real. */
1657 /* Store away the details; this will destroy any previous info. */
1658 inf
->wait
.thread
= thread
;
1660 inf
->wait
.status
.kind
= TARGET_WAITKIND_STOPPED
;
1662 if (exception
== EXC_BREAKPOINT
)
1663 /* GDB likes to get SIGTRAP for breakpoints. */
1665 inf
->wait
.status
.value
.sig
= GDB_SIGNAL_TRAP
;
1666 mach_port_deallocate (mach_task_self (), reply_port
);
1669 /* Record the exception so that we can forward it later. */
1671 if (thread
->exc_port
== port
)
1673 inf_debug (waiting_inf
, "Handler is thread exception port <%lu>",
1674 thread
->saved_exc_port
);
1675 inf
->wait
.exc
.handler
= thread
->saved_exc_port
;
1679 inf_debug (waiting_inf
, "Handler is task exception port <%lu>",
1680 inf
->task
->saved_exc_port
);
1681 inf
->wait
.exc
.handler
= inf
->task
->saved_exc_port
;
1682 gdb_assert (inf
->task
->exc_port
== port
);
1684 if (inf
->wait
.exc
.handler
!= MACH_PORT_NULL
)
1685 /* Add a reference to the exception handler. */
1686 mach_port_mod_refs (mach_task_self (),
1687 inf
->wait
.exc
.handler
, MACH_PORT_RIGHT_SEND
,
1690 inf
->wait
.exc
.exception
= exception
;
1691 inf
->wait
.exc
.code
= code
;
1692 inf
->wait
.exc
.subcode
= subcode
;
1693 inf
->wait
.exc
.reply
= reply_port
;
1695 /* Exceptions are encoded in the signal space by putting
1696 them after _NSIG; this assumes they're positive (and not
1697 extremely large)! */
1698 inf
->wait
.status
.value
.sig
=
1699 gdb_signal_from_host (_NSIG
+ exception
);
1703 /* A suppressed exception, which ignore. */
1705 inf
->wait
.suppress
= 1;
1706 mach_port_deallocate (mach_task_self (), reply_port
);
1713 /* Fill in INF's wait field after a task has died without giving us more
1714 detailed information. */
1716 inf_task_died_status (struct inf
*inf
)
1718 warning (_("Pid %d died with unknown exit status, using SIGKILL."),
1720 inf
->wait
.status
.kind
= TARGET_WAITKIND_SIGNALLED
;
1721 inf
->wait
.status
.value
.sig
= GDB_SIGNAL_KILL
;
1724 /* Notify server routines. The only real one is dead name notification. */
1726 do_mach_notify_dead_name (mach_port_t notify
, mach_port_t dead_port
)
1728 struct inf
*inf
= waiting_inf
;
1730 inf_debug (waiting_inf
, "port = %lu", dead_port
);
1732 if (inf
->task
&& inf
->task
->port
== dead_port
)
1734 proc_debug (inf
->task
, "is dead");
1735 inf
->task
->port
= MACH_PORT_NULL
;
1736 if (proc_wait_pid
== inf
->pid
)
1737 /* We have a wait outstanding on the process, which will return more
1738 detailed information, so delay until we get that. */
1739 inf
->wait
.suppress
= 1;
1741 /* We never waited for the process (maybe it wasn't a child), so just
1742 pretend it got a SIGKILL. */
1743 inf_task_died_status (inf
);
1747 struct proc
*thread
= inf_port_to_thread (inf
, dead_port
);
1751 proc_debug (thread
, "is dead");
1752 thread
->port
= MACH_PORT_NULL
;
1755 if (inf
->task
->dead
)
1756 /* Since the task is dead, its threads are dying with it. */
1757 inf
->wait
.suppress
= 1;
1760 mach_port_deallocate (mach_task_self (), dead_port
);
1761 inf
->threads_up_to_date
= 0; /* Just in case. */
1767 #define ILL_RPC(fun, ...) \
1768 extern kern_return_t fun (__VA_ARGS__); \
1769 kern_return_t fun (__VA_ARGS__) \
1771 warning (_("illegal rpc: %s"), #fun); \
1775 ILL_RPC (do_mach_notify_no_senders
,
1776 mach_port_t notify
, mach_port_mscount_t count
)
1777 ILL_RPC (do_mach_notify_port_deleted
,
1778 mach_port_t notify
, mach_port_t name
)
1779 ILL_RPC (do_mach_notify_msg_accepted
,
1780 mach_port_t notify
, mach_port_t name
)
1781 ILL_RPC (do_mach_notify_port_destroyed
,
1782 mach_port_t notify
, mach_port_t name
)
1783 ILL_RPC (do_mach_notify_send_once
,
1786 /* Process_reply server routines. We only use process_wait_reply. */
1789 S_proc_wait_reply (mach_port_t reply
, kern_return_t err
,
1790 int status
, int sigcode
, rusage_t rusage
, pid_t pid
)
1792 struct inf
*inf
= waiting_inf
;
1794 inf_debug (inf
, "err = %s, pid = %d, status = 0x%x, sigcode = %d",
1795 err
? safe_strerror (err
) : "0", pid
, status
, sigcode
);
1797 if (err
&& proc_wait_pid
&& (!inf
->task
|| !inf
->task
->port
))
1798 /* Ack. The task has died, but the task-died notification code didn't
1799 tell anyone because it thought a more detailed reply from the
1800 procserver was forthcoming. However, we now learn that won't
1801 happen... So we have to act like the task just died, and this time,
1803 inf_task_died_status (inf
);
1805 if (--proc_waits_pending
== 0)
1806 /* PROC_WAIT_PID represents the most recent wait. We will always get
1807 replies in order because the proc server is single threaded. */
1810 inf_debug (inf
, "waits pending now: %d", proc_waits_pending
);
1816 warning (_("Can't wait for pid %d: %s"),
1817 inf
->pid
, safe_strerror (err
));
1820 /* Since we can't see the inferior's signals, don't trap them. */
1821 gnu_target
->inf_set_traced (inf
, 0);
1824 else if (pid
== inf
->pid
)
1826 store_waitstatus (&inf
->wait
.status
, status
);
1827 if (inf
->wait
.status
.kind
== TARGET_WAITKIND_STOPPED
)
1828 /* The process has sent us a signal, and stopped itself in a sane
1829 state pending our actions. */
1831 inf_debug (inf
, "process has stopped itself");
1836 inf
->wait
.suppress
= 1; /* Something odd happened. Ignore. */
1841 ILL_RPC (S_proc_setmsgport_reply
,
1842 mach_port_t reply_port
, kern_return_t return_code
,
1843 mach_port_t oldmsgport
)
1844 ILL_RPC (S_proc_getmsgport_reply
,
1845 mach_port_t reply_port
, kern_return_t return_code
,
1846 mach_port_t msgports
, mach_msg_type_name_t msgportsPoly
)
1847 ILL_RPC (S_proc_pid2task_reply
,
1848 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t task
)
1849 ILL_RPC (S_proc_task2pid_reply
,
1850 mach_port_t reply_port
, kern_return_t return_code
, pid_t pid
)
1851 ILL_RPC (S_proc_task2proc_reply
,
1852 mach_port_t reply_port
, kern_return_t return_code
,
1853 mach_port_t proc
, mach_msg_type_name_t procPoly
)
1854 ILL_RPC (S_proc_proc2task_reply
,
1855 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t task
)
1856 ILL_RPC (S_proc_pid2proc_reply
,
1857 mach_port_t reply_port
, kern_return_t return_code
,
1858 mach_port_t proc
, mach_msg_type_name_t procPoly
)
1859 ILL_RPC (S_proc_getprocinfo_reply
,
1860 mach_port_t reply_port
, kern_return_t return_code
,
1861 int flags
, procinfo_t procinfo
, mach_msg_type_number_t procinfoCnt
,
1862 data_t threadwaits
, mach_msg_type_number_t threadwaitsCnt
)
1863 ILL_RPC (S_proc_getprocargs_reply
,
1864 mach_port_t reply_port
, kern_return_t return_code
,
1865 data_t procargs
, mach_msg_type_number_t procargsCnt
)
1866 ILL_RPC (S_proc_getprocenv_reply
,
1867 mach_port_t reply_port
, kern_return_t return_code
,
1868 data_t procenv
, mach_msg_type_number_t procenvCnt
)
1869 ILL_RPC (S_proc_getloginid_reply
,
1870 mach_port_t reply_port
, kern_return_t return_code
, pid_t login_id
)
1871 ILL_RPC (S_proc_getloginpids_reply
,
1872 mach_port_t reply_port
, kern_return_t return_code
,
1873 pidarray_t pids
, mach_msg_type_number_t pidsCnt
)
1874 ILL_RPC (S_proc_getlogin_reply
,
1875 mach_port_t reply_port
, kern_return_t return_code
, string_t logname
)
1876 ILL_RPC (S_proc_getsid_reply
,
1877 mach_port_t reply_port
, kern_return_t return_code
, pid_t sid
)
1878 ILL_RPC (S_proc_getsessionpgids_reply
,
1879 mach_port_t reply_port
, kern_return_t return_code
,
1880 pidarray_t pgidset
, mach_msg_type_number_t pgidsetCnt
)
1881 ILL_RPC (S_proc_getsessionpids_reply
,
1882 mach_port_t reply_port
, kern_return_t return_code
,
1883 pidarray_t pidset
, mach_msg_type_number_t pidsetCnt
)
1884 ILL_RPC (S_proc_getsidport_reply
,
1885 mach_port_t reply_port
, kern_return_t return_code
,
1886 mach_port_t sessport
)
1887 ILL_RPC (S_proc_getpgrp_reply
,
1888 mach_port_t reply_port
, kern_return_t return_code
, pid_t pgrp
)
1889 ILL_RPC (S_proc_getpgrppids_reply
,
1890 mach_port_t reply_port
, kern_return_t return_code
,
1891 pidarray_t pidset
, mach_msg_type_number_t pidsetCnt
)
1892 ILL_RPC (S_proc_get_tty_reply
,
1893 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t tty
)
1894 ILL_RPC (S_proc_getnports_reply
,
1895 mach_port_t reply_port
, kern_return_t return_code
,
1896 mach_msg_type_number_t nports
)
1897 ILL_RPC (S_proc_is_important_reply
,
1898 mach_port_t reply_port
, kern_return_t return_code
,
1899 boolean_t essential
)
1900 ILL_RPC (S_proc_get_code_reply
,
1901 mach_port_t reply_port
, kern_return_t return_code
,
1902 vm_address_t start_code
, vm_address_t end_code
)
1904 /* Msg_reply server routines. We only use msg_sig_post_untraced_reply. */
1907 S_msg_sig_post_untraced_reply (mach_port_t reply
, kern_return_t err
)
1909 struct inf
*inf
= waiting_inf
;
1912 /* EBUSY is what we get when the crash server has grabbed control of the
1913 process and doesn't like what signal we tried to send it. Just act
1914 like the process stopped (using a signal of 0 should mean that the
1915 *next* time the user continues, it will pass signal 0, which the crash
1916 server should like). */
1918 inf
->wait
.status
.kind
= TARGET_WAITKIND_STOPPED
;
1919 inf
->wait
.status
.value
.sig
= GDB_SIGNAL_0
;
1922 warning (_("Signal delivery failed: %s"), safe_strerror (err
));
1925 /* We only get this reply when we've posted a signal to a process which we
1926 thought was stopped, and which we expected to continue after the signal.
1927 Given that the signal has failed for some reason, it's reasonable to
1928 assume it's still stopped. */
1931 inf
->wait
.suppress
= 1;
1936 ILL_RPC (S_msg_sig_post_reply
,
1937 mach_port_t reply
, kern_return_t err
)
1939 /* Returns the number of messages queued for the receive right PORT. */
1940 static mach_port_msgcount_t
1941 port_msgs_queued (mach_port_t port
)
1943 struct mach_port_status status
;
1945 mach_port_get_receive_status (mach_task_self (), port
, &status
);
1950 return status
.mps_msgcount
;
1954 /* Resume execution of the inferior process.
1956 If STEP is nonzero, single-step it.
1957 If SIGNAL is nonzero, give it that signal.
1960 -1 true Single step the current thread allowing other threads to run.
1961 -1 false Continue the current thread allowing other threads to run.
1962 X true Single step the given thread, don't allow any others to run.
1963 X false Continue the given thread, do not allow any others to run.
1964 (Where X, of course, is anything except -1)
1966 Note that a resume may not `take' if there are pending exceptions/&c
1967 still unprocessed from the last resume we did (any given resume may result
1968 in multiple events returned by wait). */
1971 gnu_nat_target::resume (ptid_t ptid
, int step
, enum gdb_signal sig
)
1973 struct proc
*step_thread
= 0;
1975 struct inf
*inf
= gnu_current_inf
;
1977 inf_debug (inf
, "ptid = %s, step = %d, sig = %d",
1978 target_pid_to_str (ptid
).c_str (), step
, sig
);
1980 inf_validate_procinfo (inf
);
1982 if (sig
!= GDB_SIGNAL_0
|| inf
->stopped
)
1984 if (sig
== GDB_SIGNAL_0
&& inf
->nomsg
)
1987 inf_signal (inf
, sig
);
1989 else if (inf
->wait
.exc
.reply
!= MACH_PORT_NULL
)
1990 /* We received an exception to which we have chosen not to forward, so
1991 abort the faulting thread, which will perhaps retake it. */
1993 proc_abort (inf
->wait
.thread
, 1);
1994 warning (_("Aborting %s with unforwarded exception %s."),
1995 proc_string (inf
->wait
.thread
),
1996 gdb_signal_to_name (inf
->wait
.status
.value
.sig
));
1999 if (port_msgs_queued (inf
->event_port
))
2000 /* If there are still messages in our event queue, don't bother resuming
2001 the process, as we're just going to stop it right away anyway. */
2004 inf_update_procs (inf
);
2006 /* A specific PTID means `step only this process id'. */
2007 resume_all
= ptid
== minus_one_ptid
;
2010 /* Allow all threads to run, except perhaps single-stepping one. */
2012 inf_debug (inf
, "running all threads; tid = %d",
2013 inferior_ptid
.pid ());
2014 ptid
= inferior_ptid
; /* What to step. */
2015 inf_set_threads_resume_sc (inf
, 0, 1);
2018 /* Just allow a single thread to run. */
2020 struct proc
*thread
= inf_tid_to_thread (inf
, ptid
.lwp ());
2023 error (_("Can't run single thread id %s: no such thread!"),
2024 target_pid_to_str (ptid
).c_str ());
2025 inf_debug (inf
, "running one thread: %s",
2026 target_pid_to_str (ptid
).c_str ());
2027 inf_set_threads_resume_sc (inf
, thread
, 0);
2032 step_thread
= inf_tid_to_thread (inf
, ptid
.lwp ());
2034 warning (_("Can't step thread id %s: no such thread."),
2035 target_pid_to_str (ptid
).c_str ());
2037 inf_debug (inf
, "stepping thread: %s",
2038 target_pid_to_str (ptid
).c_str ());
2040 if (step_thread
!= inf
->step_thread
)
2041 inf_set_step_thread (inf
, step_thread
);
2043 inf_debug (inf
, "here we go...");
2049 gnu_nat_target::kill ()
2051 struct proc
*task
= gnu_current_inf
->task
;
2055 proc_debug (task
, "terminating...");
2056 task_terminate (task
->port
);
2057 inf_set_pid (gnu_current_inf
, -1);
2059 target_mourn_inferior (inferior_ptid
);
2062 /* Clean up after the inferior dies. */
2064 gnu_nat_target::mourn_inferior ()
2066 inf_debug (gnu_current_inf
, "rip");
2067 inf_detach (gnu_current_inf
);
2068 inf_child_target::mourn_inferior ();
2072 /* Fork an inferior process, and start debugging it. */
2074 /* Set INFERIOR_PID to the first thread available in the child, if any. */
2076 inf_pick_first_thread (void)
2078 if (gnu_current_inf
->task
&& gnu_current_inf
->threads
)
2079 /* The first thread. */
2080 return gnu_current_inf
->threads
->tid
;
2082 /* What may be the next thread. */
2083 return next_thread_id
;
2089 if (!gnu_current_inf
)
2090 gnu_current_inf
= make_inf ();
2091 return gnu_current_inf
;
2095 gnu_ptrace_me (void)
2097 /* We're in the child; make this process stop as soon as it execs. */
2098 struct inf
*inf
= cur_inf ();
2099 inf_debug (inf
, "tracing self");
2100 if (ptrace (PTRACE_TRACEME
) != 0)
2101 trace_start_error_with_name ("ptrace");
2105 gnu_nat_target::create_inferior (const char *exec_file
,
2106 const std::string
&allargs
,
2110 struct inf
*inf
= cur_inf ();
2113 inf_debug (inf
, "creating inferior");
2115 if (!target_is_pushed (this))
2118 pid
= fork_inferior (exec_file
, allargs
, env
, gnu_ptrace_me
,
2119 NULL
, NULL
, NULL
, NULL
);
2121 /* We have something that executes now. We'll be running through
2122 the shell at this point (if startup-with-shell is true), but the
2123 pid shouldn't change. */
2124 add_thread_silent (this, ptid_t (pid
));
2126 /* Attach to the now stopped child, which is actually a shell... */
2127 inf_debug (inf
, "attaching to child: %d", pid
);
2129 inf_attach (inf
, pid
);
2131 inf
->pending_execs
= 1;
2135 /* Now let the child run again, knowing that it will stop
2136 immediately because of the ptrace. */
2139 /* We now have thread info. */
2140 thread_change_ptid (this, inferior_ptid
,
2141 ptid_t (inf
->pid
, inf_pick_first_thread (), 0));
2143 gdb_startup_inferior (pid
, START_INFERIOR_TRAPS_EXPECTED
);
2145 inf
->pending_execs
= 0;
2146 /* Get rid of the old shell threads. */
2149 inf_validate_procinfo (inf
);
2150 inf_update_signal_thread (inf
);
2151 inf_set_traced (inf
, inf
->want_signals
);
2153 /* Execing the process will have trashed our exception ports; steal them
2154 back (or make sure they're restored if the user wants that). */
2155 if (inf
->want_exceptions
)
2156 inf_steal_exc_ports (inf
);
2158 inf_restore_exc_ports (inf
);
2162 /* Attach to process PID, then initialize for debugging it
2163 and wait for the trace-trap that results from attaching. */
2165 gnu_nat_target::attach (const char *args
, int from_tty
)
2168 struct inf
*inf
= cur_inf ();
2169 struct inferior
*inferior
;
2171 pid
= parse_pid_to_attach (args
);
2173 if (pid
== getpid ()) /* Trying to masturbate? */
2174 error (_("I refuse to debug myself!"));
2178 const char *exec_file
= get_exec_file (0);
2181 printf_unfiltered ("Attaching to program `%s', pid %d\n",
2184 printf_unfiltered ("Attaching to pid %d\n", pid
);
2187 inf_debug (inf
, "attaching to pid: %d", pid
);
2189 inf_attach (inf
, pid
);
2193 inferior
= current_inferior ();
2194 inferior_appeared (inferior
, pid
);
2195 inferior
->attach_flag
= 1;
2197 inf_update_procs (inf
);
2199 inferior_ptid
= ptid_t (pid
, inf_pick_first_thread (), 0);
2201 /* We have to initialize the terminal settings now, since the code
2202 below might try to restore them. */
2203 target_terminal::init ();
2205 /* If the process was stopped before we attached, make it continue the next
2206 time the user does a continue. */
2207 inf_validate_procinfo (inf
);
2209 inf_update_signal_thread (inf
);
2210 inf_set_traced (inf
, inf
->want_signals
);
2212 #if 0 /* Do we need this? */
2213 renumber_threads (0); /* Give our threads reasonable names. */
2218 /* Take a program previously attached to and detaches it.
2219 The program resumes execution and will no longer stop
2220 on signals, etc. We'd better not have left any breakpoints
2221 in the program or it'll die when it hits one. For this
2222 to work, it may be necessary for the process to have been
2223 previously attached. It *might* work if the program was
2224 started via fork. */
2226 gnu_nat_target::detach (inferior
*inf
, int from_tty
)
2232 const char *exec_file
= get_exec_file (0);
2235 printf_unfiltered ("Detaching from program `%s' pid %d\n",
2236 exec_file
, gnu_current_inf
->pid
);
2238 printf_unfiltered ("Detaching from pid %d\n", gnu_current_inf
->pid
);
2241 pid
= gnu_current_inf
->pid
;
2243 inf_detach (gnu_current_inf
);
2245 inferior_ptid
= null_ptid
;
2246 detach_inferior (find_inferior_pid (this, pid
));
2248 maybe_unpush_target ();
2253 gnu_nat_target::stop (ptid_t ptid
)
2255 error (_("stop target function not implemented"));
2259 gnu_nat_target::thread_alive (ptid_t ptid
)
2261 inf_update_procs (gnu_current_inf
);
2262 return !!inf_tid_to_thread (gnu_current_inf
,
2267 /* Read inferior task's LEN bytes from ADDR and copy it to MYADDR in
2268 gdb's address space. Return 0 on failure; number of bytes read
2271 gnu_read_inferior (task_t task
, CORE_ADDR addr
, gdb_byte
*myaddr
, int length
)
2274 vm_address_t low_address
= (vm_address_t
) trunc_page (addr
);
2275 vm_size_t aligned_length
=
2276 (vm_size_t
) round_page (addr
+ length
) - low_address
;
2278 mach_msg_type_number_t copy_count
;
2280 /* Get memory from inferior with page aligned addresses. */
2281 err
= vm_read (task
, low_address
, aligned_length
, &copied
, ©_count
);
2285 err
= hurd_safe_copyin (myaddr
, (void *) (addr
- low_address
+ copied
),
2289 warning (_("Read from inferior faulted: %s"), safe_strerror (err
));
2293 err
= vm_deallocate (mach_task_self (), copied
, copy_count
);
2295 warning (_("gnu_read_inferior vm_deallocate failed: %s"),
2296 safe_strerror (err
));
2301 #define CHK_GOTO_OUT(str,ret) \
2302 do if (ret != KERN_SUCCESS) { errstr = #str; goto out; } while(0)
2304 struct vm_region_list
2306 struct vm_region_list
*next
;
2307 vm_prot_t protection
;
2312 struct obstack region_obstack
;
2314 /* Write gdb's LEN bytes from MYADDR and copy it to ADDR in inferior
2315 task's address space. */
2317 gnu_write_inferior (task_t task
, CORE_ADDR addr
,
2318 const gdb_byte
*myaddr
, int length
)
2321 vm_address_t low_address
= (vm_address_t
) trunc_page (addr
);
2322 vm_size_t aligned_length
=
2323 (vm_size_t
) round_page (addr
+ length
) - low_address
;
2325 mach_msg_type_number_t copy_count
;
2328 const char *errstr
= "Bug in gnu_write_inferior";
2330 struct vm_region_list
*region_element
;
2331 struct vm_region_list
*region_head
= NULL
;
2333 /* Get memory from inferior with page aligned addresses. */
2334 err
= vm_read (task
,
2339 CHK_GOTO_OUT ("gnu_write_inferior vm_read failed", err
);
2343 err
= hurd_safe_copyout ((void *) (addr
- low_address
+ copied
),
2345 CHK_GOTO_OUT ("Write to inferior faulted", err
);
2347 obstack_init (®ion_obstack
);
2349 /* Do writes atomically.
2350 First check for holes and unwritable memory. */
2352 vm_size_t remaining_length
= aligned_length
;
2353 vm_address_t region_address
= low_address
;
2355 struct vm_region_list
*scan
;
2357 while (region_address
< low_address
+ aligned_length
)
2359 vm_prot_t protection
;
2360 vm_prot_t max_protection
;
2361 vm_inherit_t inheritance
;
2363 mach_port_t object_name
;
2365 vm_size_t region_length
= remaining_length
;
2366 vm_address_t old_address
= region_address
;
2368 err
= vm_region (task
,
2377 CHK_GOTO_OUT ("vm_region failed", err
);
2379 /* Check for holes in memory. */
2380 if (old_address
!= region_address
)
2382 warning (_("No memory at 0x%lx. Nothing written"),
2389 if (!(max_protection
& VM_PROT_WRITE
))
2391 warning (_("Memory at address 0x%lx is unwritable. "
2399 /* Chain the regions for later use. */
2400 region_element
= XOBNEW (®ion_obstack
, struct vm_region_list
);
2402 region_element
->protection
= protection
;
2403 region_element
->start
= region_address
;
2404 region_element
->length
= region_length
;
2406 /* Chain the regions along with protections. */
2407 region_element
->next
= region_head
;
2408 region_head
= region_element
;
2410 region_address
+= region_length
;
2411 remaining_length
= remaining_length
- region_length
;
2414 /* If things fail after this, we give up.
2415 Somebody is messing up inferior_task's mappings. */
2417 /* Enable writes to the chained vm regions. */
2418 for (scan
= region_head
; scan
; scan
= scan
->next
)
2420 if (!(scan
->protection
& VM_PROT_WRITE
))
2422 err
= vm_protect (task
,
2426 scan
->protection
| VM_PROT_WRITE
);
2427 CHK_GOTO_OUT ("vm_protect: enable write failed", err
);
2431 err
= vm_write (task
,
2435 CHK_GOTO_OUT ("vm_write failed", err
);
2437 /* Set up the original region protections, if they were changed. */
2438 for (scan
= region_head
; scan
; scan
= scan
->next
)
2440 if (!(scan
->protection
& VM_PROT_WRITE
))
2442 err
= vm_protect (task
,
2447 CHK_GOTO_OUT ("vm_protect: enable write failed", err
);
2455 obstack_free (®ion_obstack
, 0);
2457 (void) vm_deallocate (mach_task_self (),
2462 if (err
!= KERN_SUCCESS
)
2464 warning (_("%s: %s"), errstr
, mach_error_string (err
));
2473 /* Implement the to_xfer_partial target_ops method for
2474 TARGET_OBJECT_MEMORY. */
2476 static enum target_xfer_status
2477 gnu_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2478 CORE_ADDR memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2480 task_t task
= (gnu_current_inf
2481 ? (gnu_current_inf
->task
2482 ? gnu_current_inf
->task
->port
: 0)
2486 if (task
== MACH_PORT_NULL
)
2487 return TARGET_XFER_E_IO
;
2489 if (writebuf
!= NULL
)
2491 inf_debug (gnu_current_inf
, "writing %s[%s] <-- %s",
2492 paddress (target_gdbarch (), memaddr
), pulongest (len
),
2493 host_address_to_string (writebuf
));
2494 res
= gnu_write_inferior (task
, memaddr
, writebuf
, len
);
2498 inf_debug (gnu_current_inf
, "reading %s[%s] --> %s",
2499 paddress (target_gdbarch (), memaddr
), pulongest (len
),
2500 host_address_to_string (readbuf
));
2501 res
= gnu_read_inferior (task
, memaddr
, readbuf
, len
);
2503 gdb_assert (res
>= 0);
2505 return TARGET_XFER_E_IO
;
2508 *xfered_len
= (ULONGEST
) res
;
2509 return TARGET_XFER_OK
;
2513 /* GNU does not have auxv, but we can at least fake the AT_ENTRY entry for PIE
2515 static enum target_xfer_status
2516 gnu_xfer_auxv (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2517 CORE_ADDR memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2519 task_t task
= (gnu_current_inf
2520 ? (gnu_current_inf
->task
2521 ? gnu_current_inf
->task
->port
: 0)
2526 ElfW(auxv_t
) auxv
[2];
2528 if (task
== MACH_PORT_NULL
)
2529 return TARGET_XFER_E_IO
;
2530 if (writebuf
!= NULL
)
2531 return TARGET_XFER_E_IO
;
2533 if (memaddr
== sizeof (auxv
))
2534 return TARGET_XFER_EOF
;
2535 if (memaddr
> sizeof (auxv
))
2536 return TARGET_XFER_E_IO
;
2538 err
= proc_task2proc (proc_server
, task
, &proc
);
2540 return TARGET_XFER_E_IO
;
2542 /* Get entry from proc server. */
2543 err
= proc_get_entry (proc
, &entry
);
2545 return TARGET_XFER_E_IO
;
2547 /* Fake auxv entry. */
2548 auxv
[0].a_type
= AT_ENTRY
;
2549 auxv
[0].a_un
.a_val
= entry
;
2550 auxv
[1].a_type
= AT_NULL
;
2551 auxv
[1].a_un
.a_val
= 0;
2553 inf_debug (gnu_current_inf
, "reading auxv %s[%s] --> %s",
2554 paddress (target_gdbarch (), memaddr
), pulongest (len
),
2555 host_address_to_string (readbuf
));
2557 if (memaddr
+ len
> sizeof (auxv
))
2558 len
= sizeof (auxv
) - memaddr
;
2560 memcpy (readbuf
, (gdb_byte
*) &auxv
+ memaddr
, len
);
2563 return TARGET_XFER_OK
;
2566 /* Target to_xfer_partial implementation. */
2568 enum target_xfer_status
2569 gnu_nat_target::xfer_partial (enum target_object object
,
2570 const char *annex
, gdb_byte
*readbuf
,
2571 const gdb_byte
*writebuf
, ULONGEST offset
,
2572 ULONGEST len
, ULONGEST
*xfered_len
)
2576 case TARGET_OBJECT_MEMORY
:
2577 return gnu_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2578 case TARGET_OBJECT_AUXV
:
2579 return gnu_xfer_auxv (readbuf
, writebuf
, offset
, len
, xfered_len
);
2581 return TARGET_XFER_E_IO
;
2585 /* Call FUNC on each memory region in the task. */
2588 gnu_nat_target::find_memory_regions (find_memory_region_ftype func
,
2593 vm_address_t region_address
, last_region_address
, last_region_end
;
2594 vm_prot_t last_protection
;
2596 if (gnu_current_inf
== 0 || gnu_current_inf
->task
== 0)
2598 task
= gnu_current_inf
->task
->port
;
2599 if (task
== MACH_PORT_NULL
)
2602 region_address
= last_region_address
= last_region_end
= VM_MIN_ADDRESS
;
2603 last_protection
= VM_PROT_NONE
;
2604 while (region_address
< VM_MAX_ADDRESS
)
2606 vm_prot_t protection
;
2607 vm_prot_t max_protection
;
2608 vm_inherit_t inheritance
;
2610 mach_port_t object_name
;
2612 vm_size_t region_length
= VM_MAX_ADDRESS
- region_address
;
2614 err
= vm_region (task
,
2623 if (err
== KERN_NO_SPACE
)
2625 if (err
!= KERN_SUCCESS
)
2627 warning (_("vm_region failed: %s"), mach_error_string (err
));
2631 if (protection
== last_protection
&& region_address
== last_region_end
)
2632 /* This region is contiguous with and indistinguishable from
2633 the previous one, so we just extend that one. */
2634 last_region_end
= region_address
+= region_length
;
2637 /* This region is distinct from the last one we saw, so report
2638 that previous one. */
2639 if (last_protection
!= VM_PROT_NONE
)
2640 (*func
) (last_region_address
,
2641 last_region_end
- last_region_address
,
2642 last_protection
& VM_PROT_READ
,
2643 last_protection
& VM_PROT_WRITE
,
2644 last_protection
& VM_PROT_EXECUTE
,
2645 1, /* MODIFIED is unknown, pass it as true. */
2647 last_region_address
= region_address
;
2648 last_region_end
= region_address
+= region_length
;
2649 last_protection
= protection
;
2653 /* Report the final region. */
2654 if (last_region_end
> last_region_address
&& last_protection
!= VM_PROT_NONE
)
2655 (*func
) (last_region_address
, last_region_end
- last_region_address
,
2656 last_protection
& VM_PROT_READ
,
2657 last_protection
& VM_PROT_WRITE
,
2658 last_protection
& VM_PROT_EXECUTE
,
2659 1, /* MODIFIED is unknown, pass it as true. */
2666 /* Return printable description of proc. */
2668 proc_string (struct proc
*proc
)
2670 static char tid_str
[80];
2672 if (proc_is_task (proc
))
2673 xsnprintf (tid_str
, sizeof (tid_str
), "process %d", proc
->inf
->pid
);
2675 xsnprintf (tid_str
, sizeof (tid_str
), "Thread %d.%d",
2676 proc
->inf
->pid
, proc
->tid
);
2681 gnu_nat_target::pid_to_str (ptid_t ptid
)
2683 struct inf
*inf
= gnu_current_inf
;
2684 int tid
= ptid
.lwp ();
2685 struct proc
*thread
= inf_tid_to_thread (inf
, tid
);
2688 return proc_string (thread
);
2690 return string_printf ("bogus thread id %d", tid
);
2694 /* User task commands. */
2696 static struct cmd_list_element
*set_task_cmd_list
= 0;
2697 static struct cmd_list_element
*show_task_cmd_list
= 0;
2698 /* User thread commands. */
2700 /* Commands with a prefix of `set/show thread'. */
2701 extern struct cmd_list_element
*thread_cmd_list
;
2702 struct cmd_list_element
*set_thread_cmd_list
= NULL
;
2703 struct cmd_list_element
*show_thread_cmd_list
= NULL
;
2705 /* Commands with a prefix of `set/show thread default'. */
2706 struct cmd_list_element
*set_thread_default_cmd_list
= NULL
;
2707 struct cmd_list_element
*show_thread_default_cmd_list
= NULL
;
2710 set_thread_cmd (const char *args
, int from_tty
)
2712 printf_unfiltered ("\"set thread\" must be followed by the "
2713 "name of a thread property, or \"default\".\n");
2717 show_thread_cmd (const char *args
, int from_tty
)
2719 printf_unfiltered ("\"show thread\" must be followed by the "
2720 "name of a thread property, or \"default\".\n");
2724 set_thread_default_cmd (const char *args
, int from_tty
)
2726 printf_unfiltered ("\"set thread default\" must be followed "
2727 "by the name of a thread property.\n");
2731 show_thread_default_cmd (const char *args
, int from_tty
)
2733 printf_unfiltered ("\"show thread default\" must be followed "
2734 "by the name of a thread property.\n");
2738 parse_int_arg (const char *args
, const char *cmd_prefix
)
2743 int val
= strtoul (args
, &arg_end
, 10);
2745 if (*args
&& *arg_end
== '\0')
2748 error (_("Illegal argument for \"%s\" command, should be an integer."),
2753 _parse_bool_arg (const char *args
, const char *t_val
, const char *f_val
,
2754 const char *cmd_prefix
)
2756 if (!args
|| strcmp (args
, t_val
) == 0)
2758 else if (strcmp (args
, f_val
) == 0)
2761 error (_("Illegal argument for \"%s\" command, "
2762 "should be \"%s\" or \"%s\"."),
2763 cmd_prefix
, t_val
, f_val
);
2766 #define parse_bool_arg(args, cmd_prefix) \
2767 _parse_bool_arg (args, "on", "off", cmd_prefix)
2770 check_empty (const char *args
, const char *cmd_prefix
)
2773 error (_("Garbage after \"%s\" command: `%s'"), cmd_prefix
, args
);
2776 /* Returns the alive thread named by INFERIOR_PID, or signals an error. */
2777 static struct proc
*
2780 struct inf
*inf
= cur_inf ();
2781 struct proc
*thread
= inf_tid_to_thread (inf
,
2782 inferior_ptid
.lwp ());
2784 error (_("No current thread."));
2788 /* Returns the current inferior, but signals an error if it has no task. */
2792 struct inf
*inf
= cur_inf ();
2795 error (_("No current process."));
2801 set_task_pause_cmd (int arg
, int from_tty
)
2803 struct inf
*inf
= cur_inf ();
2804 int old_sc
= inf
->pause_sc
;
2806 inf
->pause_sc
= arg
;
2808 if (old_sc
== 0 && inf
->pause_sc
!= 0)
2809 /* If the task is currently unsuspended, immediately suspend it,
2810 otherwise wait until the next time it gets control. */
2811 gnu_target
->inf_suspend (inf
);
2815 set_task_pause_cmd (const char *args
, int from_tty
)
2817 set_task_pause_cmd (parse_bool_arg (args
, "set task pause"), from_tty
);
2821 show_task_pause_cmd (const char *args
, int from_tty
)
2823 struct inf
*inf
= cur_inf ();
2825 check_empty (args
, "show task pause");
2826 printf_unfiltered ("The inferior task %s suspended while gdb has control.\n",
2828 ? (inf
->pause_sc
== 0 ? "isn't" : "is")
2829 : (inf
->pause_sc
== 0 ? "won't be" : "will be"));
2833 set_task_detach_sc_cmd (const char *args
, int from_tty
)
2835 cur_inf ()->detach_sc
= parse_int_arg (args
,
2836 "set task detach-suspend-count");
2840 show_task_detach_sc_cmd (const char *args
, int from_tty
)
2842 check_empty (args
, "show task detach-suspend-count");
2843 printf_unfiltered ("The inferior task will be left with a "
2844 "suspend count of %d when detaching.\n",
2845 cur_inf ()->detach_sc
);
2850 set_thread_default_pause_cmd (const char *args
, int from_tty
)
2852 struct inf
*inf
= cur_inf ();
2854 inf
->default_thread_pause_sc
=
2855 parse_bool_arg (args
, "set thread default pause") ? 0 : 1;
2859 show_thread_default_pause_cmd (const char *args
, int from_tty
)
2861 struct inf
*inf
= cur_inf ();
2862 int sc
= inf
->default_thread_pause_sc
;
2864 check_empty (args
, "show thread default pause");
2865 printf_unfiltered ("New threads %s suspended while gdb has control%s.\n",
2866 sc
? "are" : "aren't",
2867 !sc
&& inf
->pause_sc
? " (but the task is)" : "");
2871 set_thread_default_run_cmd (const char *args
, int from_tty
)
2873 struct inf
*inf
= cur_inf ();
2875 inf
->default_thread_run_sc
=
2876 parse_bool_arg (args
, "set thread default run") ? 0 : 1;
2880 show_thread_default_run_cmd (const char *args
, int from_tty
)
2882 struct inf
*inf
= cur_inf ();
2884 check_empty (args
, "show thread default run");
2885 printf_unfiltered ("New threads %s allowed to run.\n",
2886 inf
->default_thread_run_sc
== 0 ? "are" : "aren't");
2890 set_thread_default_detach_sc_cmd (const char *args
, int from_tty
)
2892 cur_inf ()->default_thread_detach_sc
=
2893 parse_int_arg (args
, "set thread default detach-suspend-count");
2897 show_thread_default_detach_sc_cmd (const char *args
, int from_tty
)
2899 check_empty (args
, "show thread default detach-suspend-count");
2900 printf_unfiltered ("New threads will get a detach-suspend-count of %d.\n",
2901 cur_inf ()->default_thread_detach_sc
);
2905 /* Steal a send right called NAME in the inferior task, and make it PROC's
2906 saved exception port. */
2908 gnu_nat_target::steal_exc_port (struct proc
*proc
, mach_port_t name
)
2912 mach_msg_type_name_t port_type
;
2914 if (!proc
|| !proc
->inf
->task
)
2915 error (_("No inferior task."));
2917 err
= mach_port_extract_right (proc
->inf
->task
->port
,
2918 name
, MACH_MSG_TYPE_COPY_SEND
,
2921 error (_("Couldn't extract send right %lu from inferior: %s"),
2922 name
, safe_strerror (err
));
2924 if (proc
->saved_exc_port
)
2925 /* Get rid of our reference to the old one. */
2926 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
2928 proc
->saved_exc_port
= port
;
2930 if (!proc
->exc_port
)
2931 /* If PROC is a thread, we may not have set its exception port
2932 before. We can't use proc_steal_exc_port because it also sets
2935 proc
->exc_port
= proc
->inf
->event_port
;
2936 err
= proc_set_exception_port (proc
, proc
->exc_port
);
2937 error (_("Can't set exception port for %s: %s"),
2938 proc_string (proc
), safe_strerror (err
));
2943 set_task_exc_port_cmd (const char *args
, int from_tty
)
2945 struct inf
*inf
= cur_inf ();
2948 error (_("No argument to \"set task exception-port\" command."));
2949 gnu_target
->steal_exc_port (inf
->task
, parse_and_eval_address (args
));
2953 set_stopped_cmd (const char *args
, int from_tty
)
2955 cur_inf ()->stopped
= _parse_bool_arg (args
, "yes", "no", "set stopped");
2959 show_stopped_cmd (const char *args
, int from_tty
)
2961 struct inf
*inf
= active_inf ();
2963 check_empty (args
, "show stopped");
2964 printf_unfiltered ("The inferior process %s stopped.\n",
2965 inf
->stopped
? "is" : "isn't");
2969 set_sig_thread_cmd (const char *args
, int from_tty
)
2971 struct inf
*inf
= cur_inf ();
2973 if (!args
|| (!isdigit (*args
) && strcmp (args
, "none") != 0))
2974 error (_("Illegal argument to \"set signal-thread\" command.\n"
2975 "Should be a thread ID, or \"none\"."));
2977 if (strcmp (args
, "none") == 0)
2978 inf
->signal_thread
= 0;
2981 struct thread_info
*tp
= parse_thread_id (args
, NULL
);
2982 inf
->signal_thread
= inf_tid_to_thread (inf
, tp
->ptid
.lwp ());
2987 show_sig_thread_cmd (const char *args
, int from_tty
)
2989 struct inf
*inf
= active_inf ();
2991 check_empty (args
, "show signal-thread");
2992 if (inf
->signal_thread
)
2993 printf_unfiltered ("The signal thread is %s.\n",
2994 proc_string (inf
->signal_thread
));
2996 printf_unfiltered ("There is no signal thread.\n");
3001 set_signals_cmd (int arg
, int from_tty
)
3003 struct inf
*inf
= cur_inf ();
3005 inf
->want_signals
= arg
;
3007 if (inf
->task
&& inf
->want_signals
!= inf
->traced
)
3008 /* Make this take effect immediately in a running process. */
3009 gnu_target
->inf_set_traced (inf
, inf
->want_signals
);
3013 set_signals_cmd (const char *args
, int from_tty
)
3015 set_signals_cmd(parse_bool_arg (args
, "set signals"), from_tty
);
3019 show_signals_cmd (const char *args
, int from_tty
)
3021 struct inf
*inf
= cur_inf ();
3023 check_empty (args
, "show signals");
3024 printf_unfiltered ("The inferior process's signals %s intercepted.\n",
3026 ? (inf
->traced
? "are" : "aren't")
3027 : (inf
->want_signals
? "will be" : "won't be"));
3031 set_exceptions_cmd (int arg
, int from_tty
)
3033 struct inf
*inf
= cur_inf ();
3035 /* Make this take effect immediately in a running process. */
3038 inf
->want_exceptions
= arg
;
3042 set_exceptions_cmd (const char *args
, int from_tty
)
3044 set_exceptions_cmd (parse_bool_arg (args
, "set exceptions"), from_tty
);
3048 show_exceptions_cmd (const char *args
, int from_tty
)
3050 struct inf
*inf
= cur_inf ();
3052 check_empty (args
, "show exceptions");
3053 printf_unfiltered ("Exceptions in the inferior %s trapped.\n",
3055 ? (inf
->want_exceptions
? "are" : "aren't")
3056 : (inf
->want_exceptions
? "will be" : "won't be"));
3061 set_task_cmd (const char *args
, int from_tty
)
3063 printf_unfiltered ("\"set task\" must be followed by the name"
3064 " of a task property.\n");
3068 show_task_cmd (const char *args
, int from_tty
)
3070 struct inf
*inf
= cur_inf ();
3072 check_empty (args
, "show task");
3074 show_signals_cmd (0, from_tty
);
3075 show_exceptions_cmd (0, from_tty
);
3076 show_task_pause_cmd (0, from_tty
);
3078 if (inf
->pause_sc
== 0)
3079 show_thread_default_pause_cmd (0, from_tty
);
3080 show_thread_default_run_cmd (0, from_tty
);
3084 show_stopped_cmd (0, from_tty
);
3085 show_sig_thread_cmd (0, from_tty
);
3088 if (inf
->detach_sc
!= 0)
3089 show_task_detach_sc_cmd (0, from_tty
);
3090 if (inf
->default_thread_detach_sc
!= 0)
3091 show_thread_default_detach_sc_cmd (0, from_tty
);
3096 set_noninvasive_cmd (const char *args
, int from_tty
)
3098 /* Invert the sense of the arg for each component. */
3099 int inv_arg
= parse_bool_arg (args
, "set noninvasive") ? 0 : 1;
3101 set_task_pause_cmd (inv_arg
, from_tty
);
3102 set_signals_cmd (inv_arg
, from_tty
);
3103 set_exceptions_cmd (inv_arg
, from_tty
);
3108 info_port_rights (const char *args
, mach_port_type_t only
)
3110 struct inf
*inf
= active_inf ();
3111 struct value
*vmark
= value_mark ();
3114 /* Explicit list of port rights. */
3118 struct value
*val
= parse_to_comma_and_eval (&args
);
3119 long right
= value_as_long (val
);
3121 print_port_info (right
, 0, inf
->task
->port
, PORTINFO_DETAILS
,
3125 error (_("%ld: %s."), right
, safe_strerror (err
));
3129 /* Print all of them. */
3132 print_task_ports_info (inf
->task
->port
, only
, PORTINFO_DETAILS
,
3135 error (_("%s."), safe_strerror (err
));
3138 value_free_to_mark (vmark
);
3142 info_send_rights_cmd (const char *args
, int from_tty
)
3144 info_port_rights (args
, MACH_PORT_TYPE_SEND
);
3148 info_recv_rights_cmd (const char *args
, int from_tty
)
3150 info_port_rights (args
, MACH_PORT_TYPE_RECEIVE
);
3154 info_port_sets_cmd (const char *args
, int from_tty
)
3156 info_port_rights (args
, MACH_PORT_TYPE_PORT_SET
);
3160 info_dead_names_cmd (const char *args
, int from_tty
)
3162 info_port_rights (args
, MACH_PORT_TYPE_DEAD_NAME
);
3166 info_port_rights_cmd (const char *args
, int from_tty
)
3168 info_port_rights (args
, ~0);
3173 add_task_commands (void)
3175 add_cmd ("pause", class_run
, set_thread_default_pause_cmd
, _("\
3176 Set whether the new threads are suspended while gdb has control.\n\
3177 This property normally has no effect because the whole task is\n\
3178 suspended, however, that may be disabled with \"set task pause off\".\n\
3179 The default value is \"off\"."),
3180 &set_thread_default_cmd_list
);
3181 add_cmd ("pause", no_class
, show_thread_default_pause_cmd
, _("\
3182 Show whether new threads are suspended while gdb has control."),
3183 &show_thread_default_cmd_list
);
3185 add_cmd ("run", class_run
, set_thread_default_run_cmd
, _("\
3186 Set whether new threads are allowed to run (once gdb has noticed them)."),
3187 &set_thread_default_cmd_list
);
3188 add_cmd ("run", no_class
, show_thread_default_run_cmd
, _("\
3189 Show whether new threads are allowed to run (once gdb has noticed them)."),
3190 &show_thread_default_cmd_list
);
3192 add_cmd ("detach-suspend-count", class_run
, set_thread_default_detach_sc_cmd
,
3193 _("Set the default detach-suspend-count value for new threads."),
3194 &set_thread_default_cmd_list
);
3195 add_cmd ("detach-suspend-count", no_class
, show_thread_default_detach_sc_cmd
,
3196 _("Show the default detach-suspend-count value for new threads."),
3197 &show_thread_default_cmd_list
);
3199 add_cmd ("signals", class_run
, set_signals_cmd
, _("\
3200 Set whether the inferior process's signals will be intercepted.\n\
3201 Mach exceptions (such as breakpoint traps) are not affected."),
3203 add_alias_cmd ("sigs", "signals", class_run
, 1, &setlist
);
3204 add_cmd ("signals", no_class
, show_signals_cmd
, _("\
3205 Show whether the inferior process's signals will be intercepted."),
3207 add_alias_cmd ("sigs", "signals", no_class
, 1, &showlist
);
3209 add_cmd ("signal-thread", class_run
, set_sig_thread_cmd
, _("\
3210 Set the thread that gdb thinks is the libc signal thread.\n\
3211 This thread is run when delivering a signal to a non-stopped process."),
3213 add_alias_cmd ("sigthread", "signal-thread", class_run
, 1, &setlist
);
3214 add_cmd ("signal-thread", no_class
, show_sig_thread_cmd
, _("\
3215 Set the thread that gdb thinks is the libc signal thread."),
3217 add_alias_cmd ("sigthread", "signal-thread", no_class
, 1, &showlist
);
3219 add_cmd ("stopped", class_run
, set_stopped_cmd
, _("\
3220 Set whether gdb thinks the inferior process is stopped as with SIGSTOP.\n\
3221 Stopped process will be continued by sending them a signal."),
3223 add_cmd ("stopped", no_class
, show_stopped_cmd
, _("\
3224 Show whether gdb thinks the inferior process is stopped as with SIGSTOP."),
3227 add_cmd ("exceptions", class_run
, set_exceptions_cmd
, _("\
3228 Set whether exceptions in the inferior process will be trapped.\n\
3229 When exceptions are turned off, neither breakpoints nor single-stepping\n\
3232 /* Allow `set exc' despite conflict with `set exception-port'. */
3233 add_alias_cmd ("exc", "exceptions", class_run
, 1, &setlist
);
3234 add_cmd ("exceptions", no_class
, show_exceptions_cmd
, _("\
3235 Show whether exceptions in the inferior process will be trapped."),
3238 add_prefix_cmd ("task", no_class
, set_task_cmd
,
3239 _("Command prefix for setting task attributes."),
3240 &set_task_cmd_list
, "set task ", 0, &setlist
);
3241 add_prefix_cmd ("task", no_class
, show_task_cmd
,
3242 _("Command prefix for showing task attributes."),
3243 &show_task_cmd_list
, "show task ", 0, &showlist
);
3245 add_cmd ("pause", class_run
, set_task_pause_cmd
, _("\
3246 Set whether the task is suspended while gdb has control.\n\
3247 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3248 until the next time the program is continued.\n\
3249 When setting this to \"off\", \"set thread default pause on\" can be\n\
3250 used to pause individual threads by default instead."),
3251 &set_task_cmd_list
);
3252 add_cmd ("pause", no_class
, show_task_pause_cmd
,
3253 _("Show whether the task is suspended while gdb has control."),
3254 &show_task_cmd_list
);
3256 add_cmd ("detach-suspend-count", class_run
, set_task_detach_sc_cmd
,
3257 _("Set the suspend count will leave on the thread when detaching."),
3258 &set_task_cmd_list
);
3259 add_cmd ("detach-suspend-count", no_class
, show_task_detach_sc_cmd
,
3260 _("Show the suspend count will leave "
3261 "on the thread when detaching."),
3262 &show_task_cmd_list
);
3264 add_cmd ("exception-port", no_class
, set_task_exc_port_cmd
, _("\
3265 Set the task exception port to which we forward exceptions.\n\
3266 The argument should be the value of the send right in the task."),
3267 &set_task_cmd_list
);
3268 add_alias_cmd ("excp", "exception-port", no_class
, 1, &set_task_cmd_list
);
3269 add_alias_cmd ("exc-port", "exception-port", no_class
, 1,
3270 &set_task_cmd_list
);
3272 /* A convenient way of turning on all options require to noninvasively
3273 debug running tasks. */
3274 add_cmd ("noninvasive", no_class
, set_noninvasive_cmd
, _("\
3275 Set task options so that we interfere as little as possible.\n\
3276 This is the same as setting `task pause', `exceptions', and\n\
3277 `signals' to the opposite value."),
3280 /* Commands to show information about the task's ports. */
3281 add_info ("send-rights", info_send_rights_cmd
,
3282 _("Show information about the task's send rights."));
3283 add_info ("receive-rights", info_recv_rights_cmd
,
3284 _("Show information about the task's receive rights."));
3285 add_info ("port-rights", info_port_rights_cmd
,
3286 _("Show information about the task's port rights."));
3287 add_info ("port-sets", info_port_sets_cmd
,
3288 _("Show information about the task's port sets."));
3289 add_info ("dead-names", info_dead_names_cmd
,
3290 _("Show information about the task's dead names."));
3291 add_info_alias ("ports", "port-rights", 1);
3292 add_info_alias ("port", "port-rights", 1);
3293 add_info_alias ("psets", "port-sets", 1);
3298 set_thread_pause_cmd (const char *args
, int from_tty
)
3300 struct proc
*thread
= cur_thread ();
3301 int old_sc
= thread
->pause_sc
;
3303 thread
->pause_sc
= parse_bool_arg (args
, "set thread pause");
3304 if (old_sc
== 0 && thread
->pause_sc
!= 0 && thread
->inf
->pause_sc
== 0)
3305 /* If the task is currently unsuspended, immediately suspend it,
3306 otherwise wait until the next time it gets control. */
3307 gnu_target
->inf_suspend (thread
->inf
);
3311 show_thread_pause_cmd (const char *args
, int from_tty
)
3313 struct proc
*thread
= cur_thread ();
3314 int sc
= thread
->pause_sc
;
3316 check_empty (args
, "show task pause");
3317 printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n",
3318 proc_string (thread
),
3319 sc
? "is" : "isn't",
3320 !sc
&& thread
->inf
->pause_sc
? " (but the task is)" : "");
3324 set_thread_run_cmd (const char *args
, int from_tty
)
3326 struct proc
*thread
= cur_thread ();
3328 thread
->run_sc
= parse_bool_arg (args
, "set thread run") ? 0 : 1;
3332 show_thread_run_cmd (const char *args
, int from_tty
)
3334 struct proc
*thread
= cur_thread ();
3336 check_empty (args
, "show thread run");
3337 printf_unfiltered ("Thread %s %s allowed to run.",
3338 proc_string (thread
),
3339 thread
->run_sc
== 0 ? "is" : "isn't");
3343 set_thread_detach_sc_cmd (const char *args
, int from_tty
)
3345 cur_thread ()->detach_sc
= parse_int_arg (args
,
3346 "set thread detach-suspend-count");
3350 show_thread_detach_sc_cmd (const char *args
, int from_tty
)
3352 struct proc
*thread
= cur_thread ();
3354 check_empty (args
, "show thread detach-suspend-count");
3355 printf_unfiltered ("Thread %s will be left with a suspend count"
3356 " of %d when detaching.\n",
3357 proc_string (thread
),
3362 set_thread_exc_port_cmd (const char *args
, int from_tty
)
3364 struct proc
*thread
= cur_thread ();
3367 error (_("No argument to \"set thread exception-port\" command."));
3368 gnu_target
->steal_exc_port (thread
, parse_and_eval_address (args
));
3373 show_thread_cmd (char *args
, int from_tty
)
3375 struct proc
*thread
= cur_thread ();
3377 check_empty (args
, "show thread");
3378 show_thread_run_cmd (0, from_tty
);
3379 show_thread_pause_cmd (0, from_tty
);
3380 if (thread
->detach_sc
!= 0)
3381 show_thread_detach_sc_cmd (0, from_tty
);
3386 thread_takeover_sc_cmd (const char *args
, int from_tty
)
3388 struct proc
*thread
= cur_thread ();
3390 thread_basic_info_data_t _info
;
3391 thread_basic_info_t info
= &_info
;
3392 mach_msg_type_number_t info_len
= THREAD_BASIC_INFO_COUNT
;
3394 = mach_thread_info (thread
->port
, THREAD_BASIC_INFO
,
3395 (int *) &info
, &info_len
);
3397 error (("%s."), safe_strerror (err
));
3398 thread
->sc
= info
->suspend_count
;
3400 printf_unfiltered ("Suspend count was %d.\n", thread
->sc
);
3402 vm_deallocate (mach_task_self (), (vm_address_t
) info
,
3403 info_len
* sizeof (int));
3408 add_thread_commands (void)
3410 add_prefix_cmd ("thread", no_class
, set_thread_cmd
,
3411 _("Command prefix for setting thread properties."),
3412 &set_thread_cmd_list
, "set thread ", 0, &setlist
);
3413 add_prefix_cmd ("default", no_class
, show_thread_cmd
,
3414 _("Command prefix for setting default thread properties."),
3415 &set_thread_default_cmd_list
, "set thread default ", 0,
3416 &set_thread_cmd_list
);
3417 add_prefix_cmd ("thread", no_class
, set_thread_default_cmd
,
3418 _("Command prefix for showing thread properties."),
3419 &show_thread_cmd_list
, "show thread ", 0, &showlist
);
3420 add_prefix_cmd ("default", no_class
, show_thread_default_cmd
,
3421 _("Command prefix for showing default thread properties."),
3422 &show_thread_default_cmd_list
, "show thread default ", 0,
3423 &show_thread_cmd_list
);
3425 add_cmd ("pause", class_run
, set_thread_pause_cmd
, _("\
3426 Set whether the current thread is suspended while gdb has control.\n\
3427 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3428 until the next time the program is continued. This property normally\n\
3429 has no effect because the whole task is suspended, however, that may\n\
3430 be disabled with \"set task pause off\".\n\
3431 The default value is \"off\"."),
3432 &set_thread_cmd_list
);
3433 add_cmd ("pause", no_class
, show_thread_pause_cmd
, _("\
3434 Show whether the current thread is suspended while gdb has control."),
3435 &show_thread_cmd_list
);
3437 add_cmd ("run", class_run
, set_thread_run_cmd
,
3438 _("Set whether the current thread is allowed to run."),
3439 &set_thread_cmd_list
);
3440 add_cmd ("run", no_class
, show_thread_run_cmd
,
3441 _("Show whether the current thread is allowed to run."),
3442 &show_thread_cmd_list
);
3444 add_cmd ("detach-suspend-count", class_run
, set_thread_detach_sc_cmd
, _("\
3445 Set the suspend count will leave on the thread when detaching.\n\
3446 Note that this is relative to suspend count when gdb noticed the thread;\n\
3447 use the `thread takeover-suspend-count' to force it to an absolute value."),
3448 &set_thread_cmd_list
);
3449 add_cmd ("detach-suspend-count", no_class
, show_thread_detach_sc_cmd
, _("\
3450 Show the suspend count will leave on the thread when detaching.\n\
3451 Note that this is relative to suspend count when gdb noticed the thread;\n\
3452 use the `thread takeover-suspend-count' to force it to an absolute value."),
3453 &show_thread_cmd_list
);
3455 add_cmd ("exception-port", no_class
, set_thread_exc_port_cmd
, _("\
3456 Set the thread exception port to which we forward exceptions.\n\
3457 This overrides the task exception port.\n\
3458 The argument should be the value of the send right in the task."),
3459 &set_thread_cmd_list
);
3460 add_alias_cmd ("excp", "exception-port", no_class
, 1, &set_thread_cmd_list
);
3461 add_alias_cmd ("exc-port", "exception-port", no_class
, 1,
3462 &set_thread_cmd_list
);
3464 add_cmd ("takeover-suspend-count", no_class
, thread_takeover_sc_cmd
, _("\
3465 Force the threads absolute suspend-count to be gdb's.\n\
3466 Prior to giving this command, gdb's thread suspend-counts are relative\n\
3467 to the thread's initial suspend-count when gdb notices the threads."),
3471 void _initialize_gnu_nat ();
3473 _initialize_gnu_nat ()
3475 proc_server
= getproc ();
3477 add_task_commands ();
3478 add_thread_commands ();
3479 add_setshow_boolean_cmd ("gnu-nat", class_maintenance
,
3481 _("Set debugging output for the gnu backend."),
3482 _("Show debugging output for the gnu backend."),
3490 #ifdef FLUSH_INFERIOR_CACHE
3492 /* When over-writing code on some machines the I-Cache must be flushed
3493 explicitly, because it is not kept coherent by the lazy hardware.
3494 This definitely includes breakpoints, for instance, or else we
3495 end up looping in mysterious Bpt traps. */
3498 flush_inferior_icache (CORE_ADDR pc
, int amount
)
3500 vm_machine_attribute_val_t flush
= MATTR_VAL_ICACHE_FLUSH
;
3503 ret
= vm_machine_attribute (gnu_current_inf
->task
->port
,
3508 if (ret
!= KERN_SUCCESS
)
3509 warning (_("Error flushing inferior's cache : %s"), safe_strerror (ret
));
3511 #endif /* FLUSH_INFERIOR_CACHE */