1 /* Interface GDB to the GNU Hurd.
2 Copyright (C) 1992-2018 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 /* Mach/Hurd headers are not yet ready for C++ compilation. */
27 #include <mach_error.h>
28 #include <mach/exception.h>
29 #include <mach/message.h>
30 #include <mach/notify.h>
31 #include <mach/vm_attributes.h>
34 #include <hurd/interrupt.h>
36 #include <hurd/msg_request.h>
37 #include <hurd/process.h>
38 /* Defined in <hurd/process.h>, but we need forward declarations from
39 <hurd/process_request.h> as well. */
41 #include <hurd/process_request.h>
42 #include <hurd/signal.h>
43 #include <hurd/sigpreempt.h>
54 #include <sys/ptrace.h>
66 #include "gdbthread.h"
67 #include "gdb_obstack.h"
68 #include "tid-parse.h"
71 #include "inf-child.h"
73 /* MIG stubs are not yet ready for C++ compilation. */
76 #include "exc_request_S.h"
78 #include "process_reply_S.h"
79 #include "msg_reply_S.h"
80 #include "exc_request_U.h"
84 static process_t proc_server
= MACH_PORT_NULL
;
86 /* If we've sent a proc_wait_request to the proc server, the pid of the
87 process we asked about. We can only ever have one outstanding. */
88 int proc_wait_pid
= 0;
90 /* The number of wait requests we've sent, and expect replies from. */
91 int proc_waits_pending
= 0;
93 int gnu_debug_flag
= 0;
97 static struct inf
*make_inf ();
98 void inf_clear_wait (struct inf
*inf
);
99 void inf_cleanup (struct inf
*inf
);
100 void inf_startup (struct inf
*inf
, int pid
);
101 int inf_update_suspends (struct inf
*inf
);
102 void inf_set_pid (struct inf
*inf
, pid_t pid
);
103 void inf_validate_procs (struct inf
*inf
);
104 void inf_steal_exc_ports (struct inf
*inf
);
105 void inf_restore_exc_ports (struct inf
*inf
);
106 void inf_set_threads_resume_sc (struct inf
*inf
,
107 struct proc
*run_thread
,
109 int inf_set_threads_resume_sc_for_signal_thread (struct inf
*inf
);
110 void inf_suspend (struct inf
*inf
);
111 void inf_resume (struct inf
*inf
);
112 void inf_set_step_thread (struct inf
*inf
, struct proc
*proc
);
113 void inf_detach (struct inf
*inf
);
114 void inf_attach (struct inf
*inf
, int pid
);
115 void inf_signal (struct inf
*inf
, enum gdb_signal sig
);
116 void inf_continue (struct inf
*inf
);
118 #define inf_debug(_inf, msg, args...) \
119 do { struct inf *__inf = (_inf); \
120 debug ("{inf %d %s}: " msg, __inf->pid, \
121 host_address_to_string (__inf) , ##args); } while (0)
123 void proc_abort (struct proc
*proc
, int force
);
124 struct proc
*make_proc (struct inf
*inf
, mach_port_t port
, int tid
);
125 struct proc
*_proc_free (struct proc
*proc
);
126 int proc_update_sc (struct proc
*proc
);
127 kern_return_t
proc_get_exception_port (struct proc
*proc
, mach_port_t
* port
);
128 kern_return_t
proc_set_exception_port (struct proc
*proc
, mach_port_t port
);
129 static mach_port_t
_proc_get_exc_port (struct proc
*proc
);
130 void proc_steal_exc_port (struct proc
*proc
, mach_port_t exc_port
);
131 void proc_restore_exc_port (struct proc
*proc
);
132 int proc_trace (struct proc
*proc
, int set
);
134 /* Evaluate RPC_EXPR in a scope with the variables MSGPORT and REFPORT bound
135 to INF's msg port and task port respectively. If it has no msg port,
136 EIEIO is returned. INF must refer to a running process! */
137 #define INF_MSGPORT_RPC(inf, rpc_expr) \
138 HURD_MSGPORT_RPC (proc_getmsgport (proc_server, inf->pid, &msgport), \
139 (refport = inf->task->port, 0), 0, \
140 msgport ? (rpc_expr) : EIEIO)
142 /* Like INF_MSGPORT_RPC, but will also resume the signal thread to ensure
143 there's someone around to deal with the RPC (and resuspend things
144 afterwards). This effects INF's threads' resume_sc count. */
145 #define INF_RESUME_MSGPORT_RPC(inf, rpc_expr) \
146 (inf_set_threads_resume_sc_for_signal_thread (inf) \
147 ? ({ kern_return_t __e; \
149 __e = INF_MSGPORT_RPC (inf, rpc_expr); \
155 /* The state passed by an exception message. */
158 int exception
; /* The exception code. */
160 mach_port_t handler
; /* The real exception port to handle this. */
161 mach_port_t reply
; /* The reply port from the exception call. */
164 /* The results of the last wait an inf did. */
167 struct target_waitstatus status
; /* The status returned to gdb. */
168 struct exc_state exc
; /* The exception that caused us to return. */
169 struct proc
*thread
; /* The thread in question. */
170 int suppress
; /* Something trivial happened. */
173 /* The state of an inferior. */
176 /* Fields describing the current inferior. */
178 struct proc
*task
; /* The mach task. */
179 struct proc
*threads
; /* A linked list of all threads in TASK. */
181 /* True if THREADS needn't be validated by querying the task. We
182 assume that we and the task in question are the only ones
183 frobbing the thread list, so as long as we don't let any code
184 run, we don't have to worry about THREADS changing. */
185 int threads_up_to_date
;
187 pid_t pid
; /* The real system PID. */
189 struct inf_wait wait
; /* What to return from target_wait. */
191 /* One thread proc in INF may be in `single-stepping mode'. This
193 struct proc
*step_thread
;
195 /* The thread we think is the signal thread. */
196 struct proc
*signal_thread
;
198 mach_port_t event_port
; /* Where we receive various msgs. */
200 /* True if we think at least one thread in the inferior could currently be
202 unsigned int running
:1;
204 /* True if the process has stopped (in the proc server sense). Note that
205 since a proc server `stop' leaves the signal thread running, the inf can
206 be RUNNING && STOPPED... */
207 unsigned int stopped
:1;
209 /* True if the inferior has no message port. */
210 unsigned int nomsg
:1;
212 /* True if the inferior is traced. */
213 unsigned int traced
:1;
215 /* True if we shouldn't try waiting for the inferior, usually because we
216 can't for some reason. */
217 unsigned int no_wait
:1;
219 /* When starting a new inferior, we don't try to validate threads until all
220 the proper execs have been done, which this flag states we still
222 unsigned int pending_execs
:1;
224 /* Fields describing global state. */
226 /* The task suspend count used when gdb has control. This is normally 1 to
227 make things easier for us, but sometimes (like when attaching to vital
228 system servers) it may be desirable to let the task continue to run
229 (pausing individual threads as necessary). */
232 /* The task suspend count left when detaching from a task. */
235 /* The initial values used for the run_sc and pause_sc of newly discovered
236 threads -- see the definition of those fields in struct proc. */
237 int default_thread_run_sc
;
238 int default_thread_pause_sc
;
239 int default_thread_detach_sc
;
241 /* True if the process should be traced when started/attached. Newly
242 started processes *must* be traced at first to exec them properly, but
243 if this is false, tracing is turned off as soon it has done so. */
246 /* True if exceptions from the inferior process should be trapped. This
247 must be on to use breakpoints. */
253 __proc_pid (struct proc
*proc
)
255 return proc
->inf
->pid
;
259 /* Update PROC's real suspend count to match it's desired one. Returns true
260 if we think PROC is now in a runnable state. */
262 proc_update_sc (struct proc
*proc
)
266 int delta
= proc
->sc
- proc
->cur_sc
;
269 proc_debug (proc
, "sc: %d --> %d", proc
->cur_sc
, proc
->sc
);
271 if (proc
->sc
== 0 && proc
->state_changed
)
272 /* Since PROC may start running, we must write back any state changes. */
274 gdb_assert (proc_is_thread (proc
));
275 proc_debug (proc
, "storing back changed thread state");
276 err
= thread_set_state (proc
->port
, THREAD_STATE_FLAVOR
,
277 (thread_state_t
) &proc
->state
, THREAD_STATE_SIZE
);
279 proc
->state_changed
= 0;
284 while (delta
-- > 0 && !err
)
286 if (proc_is_task (proc
))
287 err
= task_suspend (proc
->port
);
289 err
= thread_suspend (proc
->port
);
294 while (delta
++ < 0 && !err
)
296 if (proc_is_task (proc
))
297 err
= task_resume (proc
->port
);
299 err
= thread_resume (proc
->port
);
303 proc
->cur_sc
= proc
->sc
;
305 /* If we got an error, then the task/thread has disappeared. */
306 running
= !err
&& proc
->sc
== 0;
308 proc_debug (proc
, "is %s", err
? "dead" : running
? "running" : "suspended");
310 proc_debug (proc
, "err = %s", safe_strerror (err
));
315 proc
->state_valid
= proc
->state_changed
= 0;
316 proc
->fetched_regs
= 0;
323 /* Thread_abort is called on PROC if needed. PROC must be a thread proc.
324 If PROC is deemed `precious', then nothing is done unless FORCE is true.
325 In particular, a thread is precious if it's running (in which case forcing
326 it includes suspending it first), or if it has an exception pending. */
328 proc_abort (struct proc
*proc
, int force
)
330 gdb_assert (proc_is_thread (proc
));
334 struct inf
*inf
= proc
->inf
;
335 int running
= (proc
->cur_sc
== 0 && inf
->task
->cur_sc
== 0);
337 if (running
&& force
)
340 inf_update_suspends (proc
->inf
);
342 warning (_("Stopped %s."), proc_string (proc
));
344 else if (proc
== inf
->wait
.thread
&& inf
->wait
.exc
.reply
&& !force
)
345 /* An exception is pending on PROC, which don't mess with. */
349 /* We only abort the thread if it's not actually running. */
351 thread_abort (proc
->port
);
352 proc_debug (proc
, "aborted");
356 proc_debug (proc
, "not aborting");
360 /* Make sure that the state field in PROC is up to date, and return a pointer
361 to it, or 0 if something is wrong. If WILL_MODIFY is true, makes sure
362 that the thread is stopped and aborted first, and sets the state_changed
363 field in PROC to true. */
365 proc_get_state (struct proc
*proc
, int will_modify
)
367 int was_aborted
= proc
->aborted
;
369 proc_debug (proc
, "updating state info%s",
370 will_modify
? " (with intention to modify)" : "");
372 proc_abort (proc
, will_modify
);
374 if (!was_aborted
&& proc
->aborted
)
375 /* PROC's state may have changed since we last fetched it. */
376 proc
->state_valid
= 0;
378 if (!proc
->state_valid
)
380 mach_msg_type_number_t state_size
= THREAD_STATE_SIZE
;
382 thread_get_state (proc
->port
, THREAD_STATE_FLAVOR
,
383 (thread_state_t
) &proc
->state
, &state_size
);
385 proc_debug (proc
, "getting thread state");
386 proc
->state_valid
= !err
;
389 if (proc
->state_valid
)
392 proc
->state_changed
= 1;
393 return (thread_state_t
) &proc
->state
;
400 /* Set PORT to PROC's exception port. */
402 proc_get_exception_port (struct proc
* proc
, mach_port_t
* port
)
404 if (proc_is_task (proc
))
405 return task_get_exception_port (proc
->port
, port
);
407 return thread_get_exception_port (proc
->port
, port
);
410 /* Set PROC's exception port to PORT. */
412 proc_set_exception_port (struct proc
* proc
, mach_port_t port
)
414 proc_debug (proc
, "setting exception port: %lu", port
);
415 if (proc_is_task (proc
))
416 return task_set_exception_port (proc
->port
, port
);
418 return thread_set_exception_port (proc
->port
, port
);
421 /* Get PROC's exception port, cleaning up a bit if proc has died. */
423 _proc_get_exc_port (struct proc
*proc
)
425 mach_port_t exc_port
;
426 kern_return_t err
= proc_get_exception_port (proc
, &exc_port
);
429 /* PROC must be dead. */
432 mach_port_deallocate (mach_task_self (), proc
->exc_port
);
433 proc
->exc_port
= MACH_PORT_NULL
;
434 if (proc
->saved_exc_port
)
435 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
436 proc
->saved_exc_port
= MACH_PORT_NULL
;
442 /* Replace PROC's exception port with EXC_PORT, unless it's already
443 been done. Stash away any existing exception port so we can
446 proc_steal_exc_port (struct proc
*proc
, mach_port_t exc_port
)
448 mach_port_t cur_exc_port
= _proc_get_exc_port (proc
);
452 kern_return_t err
= 0;
454 proc_debug (proc
, "inserting exception port: %lu", exc_port
);
456 if (cur_exc_port
!= exc_port
)
457 /* Put in our exception port. */
458 err
= proc_set_exception_port (proc
, exc_port
);
460 if (err
|| cur_exc_port
== proc
->exc_port
)
461 /* We previously set the exception port, and it's still set. So we
462 just keep the old saved port which is what the proc set. */
465 mach_port_deallocate (mach_task_self (), cur_exc_port
);
468 /* Keep a copy of PROC's old exception port so it can be restored. */
470 if (proc
->saved_exc_port
)
471 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
472 proc
->saved_exc_port
= cur_exc_port
;
475 proc_debug (proc
, "saved exception port: %lu", proc
->saved_exc_port
);
478 proc
->exc_port
= exc_port
;
480 warning (_("Error setting exception port for %s: %s"),
481 proc_string (proc
), safe_strerror (err
));
485 /* If we previously replaced PROC's exception port, put back what we
486 found there at the time, unless *our* exception port has since been
487 overwritten, in which case who knows what's going on. */
489 proc_restore_exc_port (struct proc
*proc
)
491 mach_port_t cur_exc_port
= _proc_get_exc_port (proc
);
495 kern_return_t err
= 0;
497 proc_debug (proc
, "restoring real exception port");
499 if (proc
->exc_port
== cur_exc_port
)
500 /* Our's is still there. */
501 err
= proc_set_exception_port (proc
, proc
->saved_exc_port
);
503 if (proc
->saved_exc_port
)
504 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
505 proc
->saved_exc_port
= MACH_PORT_NULL
;
508 proc
->exc_port
= MACH_PORT_NULL
;
510 warning (_("Error setting exception port for %s: %s"),
511 proc_string (proc
), safe_strerror (err
));
516 /* Turns hardware tracing in PROC on or off when SET is true or false,
517 respectively. Returns true on success. */
519 proc_trace (struct proc
*proc
, int set
)
521 thread_state_t state
= proc_get_state (proc
, 1);
524 return 0; /* The thread must be dead. */
526 proc_debug (proc
, "tracing %s", set
? "on" : "off");
530 /* XXX We don't get the exception unless the thread has its own
531 exception port???? */
532 if (proc
->exc_port
== MACH_PORT_NULL
)
533 proc_steal_exc_port (proc
, proc
->inf
->event_port
);
534 THREAD_STATE_SET_TRACED (state
);
537 THREAD_STATE_CLEAR_TRACED (state
);
543 /* A variable from which to assign new TIDs. */
544 static int next_thread_id
= 1;
546 /* Returns a new proc structure with the given fields. Also adds a
547 notification for PORT becoming dead to be sent to INF's notify port. */
549 make_proc (struct inf
*inf
, mach_port_t port
, int tid
)
552 mach_port_t prev_port
= MACH_PORT_NULL
;
553 struct proc
*proc
= XNEW (struct proc
);
559 proc
->saved_exc_port
= MACH_PORT_NULL
;
560 proc
->exc_port
= MACH_PORT_NULL
;
565 /* Note that these are all the values for threads; the task simply uses the
566 corresponding field in INF directly. */
567 proc
->run_sc
= inf
->default_thread_run_sc
;
568 proc
->pause_sc
= inf
->default_thread_pause_sc
;
569 proc
->detach_sc
= inf
->default_thread_detach_sc
;
570 proc
->resume_sc
= proc
->run_sc
;
574 proc
->state_valid
= 0;
575 proc
->state_changed
= 0;
577 proc_debug (proc
, "is new");
579 /* Get notified when things die. */
581 mach_port_request_notification (mach_task_self (), port
,
582 MACH_NOTIFY_DEAD_NAME
, 1,
584 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
587 warning (_("Couldn't request notification for port %lu: %s"),
588 port
, safe_strerror (err
));
591 proc_debug (proc
, "notifications to: %lu", inf
->event_port
);
592 if (prev_port
!= MACH_PORT_NULL
)
593 mach_port_deallocate (mach_task_self (), prev_port
);
596 if (inf
->want_exceptions
)
598 if (proc_is_task (proc
))
599 /* Make the task exception port point to us. */
600 proc_steal_exc_port (proc
, inf
->event_port
);
602 /* Just clear thread exception ports -- they default to the
604 proc_steal_exc_port (proc
, MACH_PORT_NULL
);
610 /* Frees PROC and any resources it uses, and returns the value of PROC's
613 _proc_free (struct proc
*proc
)
615 struct inf
*inf
= proc
->inf
;
616 struct proc
*next
= proc
->next
;
618 proc_debug (proc
, "freeing...");
620 if (proc
== inf
->step_thread
)
621 /* Turn off single stepping. */
622 inf_set_step_thread (inf
, 0);
623 if (proc
== inf
->wait
.thread
)
624 inf_clear_wait (inf
);
625 if (proc
== inf
->signal_thread
)
626 inf
->signal_thread
= 0;
628 if (proc
->port
!= MACH_PORT_NULL
)
630 if (proc
->exc_port
!= MACH_PORT_NULL
)
631 /* Restore the original exception port. */
632 proc_restore_exc_port (proc
);
633 if (proc
->cur_sc
!= 0)
634 /* Resume the thread/task. */
637 proc_update_sc (proc
);
639 mach_port_deallocate (mach_task_self (), proc
->port
);
650 struct inf
*inf
= XNEW (struct inf
);
654 inf
->threads_up_to_date
= 0;
656 inf
->wait
.status
.kind
= TARGET_WAITKIND_SPURIOUS
;
657 inf
->wait
.thread
= 0;
658 inf
->wait
.exc
.handler
= MACH_PORT_NULL
;
659 inf
->wait
.exc
.reply
= MACH_PORT_NULL
;
660 inf
->step_thread
= 0;
661 inf
->signal_thread
= 0;
662 inf
->event_port
= MACH_PORT_NULL
;
668 inf
->pending_execs
= 0;
671 inf
->default_thread_run_sc
= 0;
672 inf
->default_thread_pause_sc
= 0;
673 inf
->default_thread_detach_sc
= 0;
674 inf
->want_signals
= 1; /* By default */
675 inf
->want_exceptions
= 1; /* By default */
680 /* Clear INF's target wait status. */
682 inf_clear_wait (struct inf
*inf
)
684 inf_debug (inf
, "clearing wait");
685 inf
->wait
.status
.kind
= TARGET_WAITKIND_SPURIOUS
;
686 inf
->wait
.thread
= 0;
687 inf
->wait
.suppress
= 0;
688 if (inf
->wait
.exc
.handler
!= MACH_PORT_NULL
)
690 mach_port_deallocate (mach_task_self (), inf
->wait
.exc
.handler
);
691 inf
->wait
.exc
.handler
= MACH_PORT_NULL
;
693 if (inf
->wait
.exc
.reply
!= MACH_PORT_NULL
)
695 mach_port_deallocate (mach_task_self (), inf
->wait
.exc
.reply
);
696 inf
->wait
.exc
.reply
= MACH_PORT_NULL
;
702 inf_cleanup (struct inf
*inf
)
704 inf_debug (inf
, "cleanup");
706 inf_clear_wait (inf
);
708 inf_set_pid (inf
, -1);
715 inf
->pending_execs
= 0;
719 mach_port_destroy (mach_task_self (), inf
->event_port
);
720 inf
->event_port
= MACH_PORT_NULL
;
725 inf_startup (struct inf
*inf
, int pid
)
729 inf_debug (inf
, "startup: pid = %d", pid
);
733 /* Make the port on which we receive all events. */
734 err
= mach_port_allocate (mach_task_self (),
735 MACH_PORT_RIGHT_RECEIVE
, &inf
->event_port
);
737 error (_("Error allocating event port: %s"), safe_strerror (err
));
739 /* Make a send right for it, so we can easily copy it for other people. */
740 mach_port_insert_right (mach_task_self (), inf
->event_port
,
741 inf
->event_port
, MACH_MSG_TYPE_MAKE_SEND
);
742 inf_set_pid (inf
, pid
);
746 /* Close current process, if any, and attach INF to process PORT. */
748 inf_set_pid (struct inf
*inf
, pid_t pid
)
751 struct proc
*task
= inf
->task
;
753 inf_debug (inf
, "setting pid: %d", pid
);
756 task_port
= MACH_PORT_NULL
;
759 kern_return_t err
= proc_pid2task (proc_server
, pid
, &task_port
);
762 error (_("Error getting task for pid %d: %s"),
763 pid
, safe_strerror (err
));
766 inf_debug (inf
, "setting task: %lu", task_port
);
769 task_suspend (task_port
);
771 if (task
&& task
->port
!= task_port
)
774 inf_validate_procs (inf
); /* Trash all the threads. */
775 _proc_free (task
); /* And the task. */
778 if (task_port
!= MACH_PORT_NULL
)
780 inf
->task
= make_proc (inf
, task_port
, PROC_TID_TASK
);
781 inf
->threads_up_to_date
= 0;
788 /* Reflect task_suspend above. */
789 inf
->task
->sc
= inf
->task
->cur_sc
= 1;
796 /* Validates INF's stopped, nomsg and traced field from the actual
797 proc server state. Note that the traced field is only updated from
798 the proc server state if we do not have a message port. If we do
799 have a message port we'd better look at the tracemask itself. */
801 inf_validate_procinfo (struct inf
*inf
)
804 mach_msg_type_number_t noise_len
= 0;
806 mach_msg_type_number_t pi_len
= 0;
809 proc_getprocinfo (proc_server
, inf
->pid
, &info_flags
,
810 (procinfo_t
*) &pi
, &pi_len
, &noise
, &noise_len
);
814 inf
->stopped
= !!(pi
->state
& PI_STOPPED
);
815 inf
->nomsg
= !!(pi
->state
& PI_NOMSG
);
817 inf
->traced
= !!(pi
->state
& PI_TRACED
);
818 vm_deallocate (mach_task_self (), (vm_address_t
) pi
,
819 pi_len
* sizeof (*(procinfo_t
) 0));
821 vm_deallocate (mach_task_self (), (vm_address_t
) noise
, noise_len
);
825 /* Validates INF's task suspend count. If it's higher than we expect,
826 verify with the user before `stealing' the extra count. */
828 inf_validate_task_sc (struct inf
*inf
)
831 mach_msg_type_number_t noise_len
= 0;
833 mach_msg_type_number_t pi_len
= 0;
834 int info_flags
= PI_FETCH_TASKINFO
;
835 int suspend_count
= -1;
839 err
= proc_getprocinfo (proc_server
, inf
->pid
, &info_flags
,
840 (procinfo_t
*) &pi
, &pi_len
, &noise
, &noise_len
);
843 inf
->task
->dead
= 1; /* oh well */
847 if (inf
->task
->cur_sc
< pi
->taskinfo
.suspend_count
&& suspend_count
== -1)
849 /* The proc server might have suspended the task while stopping
850 it. This happens when the task is handling a traced signal.
851 Refetch the suspend count. The proc server should be
852 finished stopping the task by now. */
853 suspend_count
= pi
->taskinfo
.suspend_count
;
857 suspend_count
= pi
->taskinfo
.suspend_count
;
859 vm_deallocate (mach_task_self (), (vm_address_t
) pi
,
860 pi_len
* sizeof (*(procinfo_t
) 0));
862 vm_deallocate (mach_task_self (), (vm_address_t
) noise
, noise_len
);
864 if (inf
->task
->cur_sc
< suspend_count
)
866 if (!query (_("Pid %d has an additional task suspend count of %d;"
867 " clear it? "), inf
->pid
,
868 suspend_count
- inf
->task
->cur_sc
))
869 error (_("Additional task suspend count left untouched."));
871 inf
->task
->cur_sc
= suspend_count
;
875 /* Turns tracing for INF on or off, depending on ON, unless it already
876 is. If INF is running, the resume_sc count of INF's threads will
877 be modified, and the signal thread will briefly be run to change
880 inf_set_traced (struct inf
*inf
, int on
)
882 if (on
== inf
->traced
)
885 if (inf
->task
&& !inf
->task
->dead
)
886 /* Make it take effect immediately. */
888 sigset_t mask
= on
? ~(sigset_t
) 0 : 0;
890 INF_RESUME_MSGPORT_RPC (inf
, msg_set_init_int (msgport
, refport
,
891 INIT_TRACEMASK
, mask
));
896 warning (_("Can't modify tracing state for pid %d: %s"),
897 inf
->pid
, "No signal thread");
901 warning (_("Can't modify tracing state for pid %d: %s"),
902 inf
->pid
, safe_strerror (err
));
911 /* Makes all the real suspend count deltas of all the procs in INF
912 match the desired values. Careful to always do thread/task suspend
913 counts in the safe order. Returns true if at least one thread is
914 thought to be running. */
916 inf_update_suspends (struct inf
*inf
)
918 struct proc
*task
= inf
->task
;
920 /* We don't have to update INF->threads even though we're iterating over it
921 because we'll change a thread only if it already has an existing proc
923 inf_debug (inf
, "updating suspend counts");
928 int task_running
= (task
->sc
== 0), thread_running
= 0;
930 if (task
->sc
> task
->cur_sc
)
931 /* The task is becoming _more_ suspended; do before any threads. */
932 task_running
= proc_update_sc (task
);
934 if (inf
->pending_execs
)
935 /* When we're waiting for an exec, things may be happening behind our
936 back, so be conservative. */
939 /* Do all the thread suspend counts. */
940 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
941 thread_running
|= proc_update_sc (thread
);
943 if (task
->sc
!= task
->cur_sc
)
944 /* We didn't do the task first, because we wanted to wait for the
945 threads; do it now. */
946 task_running
= proc_update_sc (task
);
948 inf_debug (inf
, "%srunning...",
949 (thread_running
&& task_running
) ? "" : "not ");
951 inf
->running
= thread_running
&& task_running
;
953 /* Once any thread has executed some code, we can't depend on the
954 threads list any more. */
956 inf
->threads_up_to_date
= 0;
965 /* Converts a GDB pid to a struct proc. */
967 inf_tid_to_thread (struct inf
*inf
, int tid
)
969 struct proc
*thread
= inf
->threads
;
972 if (thread
->tid
== tid
)
975 thread
= thread
->next
;
979 /* Converts a thread port to a struct proc. */
981 inf_port_to_thread (struct inf
*inf
, mach_port_t port
)
983 struct proc
*thread
= inf
->threads
;
986 if (thread
->port
== port
)
989 thread
= thread
->next
;
996 inf_threads (struct inf
*inf
, inf_threads_ftype
*f
, void *arg
)
1000 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1005 /* Make INF's list of threads be consistent with reality of TASK. */
1007 inf_validate_procs (struct inf
*inf
)
1009 thread_array_t threads
;
1010 mach_msg_type_number_t num_threads
, i
;
1011 struct proc
*task
= inf
->task
;
1013 /* If no threads are currently running, this function will guarantee that
1014 things are up to date. The exception is if there are zero threads --
1015 then it is almost certainly in an odd state, and probably some outside
1016 agent will create threads. */
1017 inf
->threads_up_to_date
= inf
->threads
? !inf
->running
: 0;
1021 kern_return_t err
= task_threads (task
->port
, &threads
, &num_threads
);
1023 inf_debug (inf
, "fetching threads");
1025 /* TASK must be dead. */
1035 inf_debug (inf
, "no task");
1039 /* Make things normally linear. */
1040 mach_msg_type_number_t search_start
= 0;
1041 /* Which thread in PROCS corresponds to each task thread, & the task. */
1042 struct proc
*matched
[num_threads
+ 1];
1043 /* The last thread in INF->threads, so we can add to the end. */
1044 struct proc
*last
= 0;
1045 /* The current thread we're considering. */
1046 struct proc
*thread
= inf
->threads
;
1048 memset (matched
, 0, sizeof (matched
));
1052 mach_msg_type_number_t left
;
1054 for (i
= search_start
, left
= num_threads
; left
; i
++, left
--)
1056 if (i
>= num_threads
)
1057 i
-= num_threads
; /* I wrapped around. */
1058 if (thread
->port
== threads
[i
])
1059 /* We already know about this thread. */
1061 matched
[i
] = thread
;
1063 thread
= thread
->next
;
1071 proc_debug (thread
, "died!");
1072 thread
->port
= MACH_PORT_NULL
;
1073 thread
= _proc_free (thread
); /* THREAD is dead. */
1075 last
->next
= thread
;
1077 inf
->threads
= thread
;
1081 for (i
= 0; i
< num_threads
; i
++)
1084 /* Throw away the duplicate send right. */
1085 mach_port_deallocate (mach_task_self (), threads
[i
]);
1087 /* THREADS[I] is a thread we don't know about yet! */
1091 thread
= make_proc (inf
, threads
[i
], next_thread_id
++);
1093 last
->next
= thread
;
1095 inf
->threads
= thread
;
1097 proc_debug (thread
, "new thread: %lu", threads
[i
]);
1099 ptid
= ptid_build (inf
->pid
, thread
->tid
, 0);
1101 /* Tell GDB's generic thread code. */
1103 if (ptid_equal (inferior_ptid
, pid_to_ptid (inf
->pid
)))
1104 /* This is the first time we're hearing about thread
1105 ids, after a fork-child. */
1106 thread_change_ptid (inferior_ptid
, ptid
);
1107 else if (inf
->pending_execs
!= 0)
1108 /* This is a shell thread. */
1109 add_thread_silent (ptid
);
1115 vm_deallocate (mach_task_self (),
1116 (vm_address_t
) threads
, (num_threads
* sizeof (thread_t
)));
1121 /* Makes sure that INF's thread list is synced with the actual process. */
1123 inf_update_procs (struct inf
*inf
)
1127 if (!inf
->threads_up_to_date
)
1128 inf_validate_procs (inf
);
1132 /* Sets the resume_sc of each thread in inf. That of RUN_THREAD is set to 0,
1133 and others are set to their run_sc if RUN_OTHERS is true, and otherwise
1136 inf_set_threads_resume_sc (struct inf
*inf
,
1137 struct proc
*run_thread
, int run_others
)
1139 struct proc
*thread
;
1141 inf_update_procs (inf
);
1142 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1143 if (thread
== run_thread
)
1144 thread
->resume_sc
= 0;
1145 else if (run_others
)
1146 thread
->resume_sc
= thread
->run_sc
;
1148 thread
->resume_sc
= thread
->pause_sc
;
1152 /* Cause INF to continue execution immediately; individual threads may still
1153 be suspended (but their suspend counts will be updated). */
1155 inf_resume (struct inf
*inf
)
1157 struct proc
*thread
;
1159 inf_update_procs (inf
);
1161 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1162 thread
->sc
= thread
->resume_sc
;
1166 if (!inf
->pending_execs
)
1167 /* Try to make sure our task count is correct -- in the case where
1168 we're waiting for an exec though, things are too volatile, so just
1169 assume things will be reasonable (which they usually will be). */
1170 inf_validate_task_sc (inf
);
1174 inf_update_suspends (inf
);
1177 /* Cause INF to stop execution immediately; individual threads may still
1180 inf_suspend (struct inf
*inf
)
1182 struct proc
*thread
;
1184 inf_update_procs (inf
);
1186 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1187 thread
->sc
= thread
->pause_sc
;
1190 inf
->task
->sc
= inf
->pause_sc
;
1192 inf_update_suspends (inf
);
1196 /* INF has one thread PROC that is in single-stepping mode. This
1197 function changes it to be PROC, changing any old step_thread to be
1198 a normal one. A PROC of 0 clears any existing value. */
1200 inf_set_step_thread (struct inf
*inf
, struct proc
*thread
)
1202 gdb_assert (!thread
|| proc_is_thread (thread
));
1205 inf_debug (inf
, "setting step thread: %d/%d", inf
->pid
, thread
->tid
);
1207 inf_debug (inf
, "clearing step thread");
1209 if (inf
->step_thread
!= thread
)
1211 if (inf
->step_thread
&& inf
->step_thread
->port
!= MACH_PORT_NULL
)
1212 if (!proc_trace (inf
->step_thread
, 0))
1214 if (thread
&& proc_trace (thread
, 1))
1215 inf
->step_thread
= thread
;
1217 inf
->step_thread
= 0;
1222 /* Set up the thread resume_sc's so that only the signal thread is running
1223 (plus whatever other thread are set to always run). Returns true if we
1224 did so, or false if we can't find a signal thread. */
1226 inf_set_threads_resume_sc_for_signal_thread (struct inf
*inf
)
1228 if (inf
->signal_thread
)
1230 inf_set_threads_resume_sc (inf
, inf
->signal_thread
, 0);
1238 inf_update_signal_thread (struct inf
*inf
)
1240 /* XXX for now we assume that if there's a msgport, the 2nd thread is
1241 the signal thread. */
1242 inf
->signal_thread
= inf
->threads
? inf
->threads
->next
: 0;
1246 /* Detachs from INF's inferior task, letting it run once again... */
1248 inf_detach (struct inf
*inf
)
1250 struct proc
*task
= inf
->task
;
1252 inf_debug (inf
, "detaching...");
1254 inf_clear_wait (inf
);
1255 inf_set_step_thread (inf
, 0);
1259 struct proc
*thread
;
1261 inf_validate_procinfo (inf
);
1263 inf_set_traced (inf
, 0);
1269 inf_signal (inf
, GDB_SIGNAL_0
);
1272 proc_restore_exc_port (task
);
1273 task
->sc
= inf
->detach_sc
;
1275 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1277 proc_restore_exc_port (thread
);
1278 thread
->sc
= thread
->detach_sc
;
1281 inf_update_suspends (inf
);
1287 /* Attaches INF to the process with process id PID, returning it in a
1288 suspended state suitable for debugging. */
1290 inf_attach (struct inf
*inf
, int pid
)
1292 inf_debug (inf
, "attaching: %d", pid
);
1297 inf_startup (inf
, pid
);
1301 /* Makes sure that we've got our exception ports entrenched in the process. */
1303 inf_steal_exc_ports (struct inf
*inf
)
1305 struct proc
*thread
;
1307 inf_debug (inf
, "stealing exception ports");
1309 inf_set_step_thread (inf
, 0); /* The step thread is special. */
1311 proc_steal_exc_port (inf
->task
, inf
->event_port
);
1312 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1313 proc_steal_exc_port (thread
, MACH_PORT_NULL
);
1316 /* Makes sure the process has its own exception ports. */
1318 inf_restore_exc_ports (struct inf
*inf
)
1320 struct proc
*thread
;
1322 inf_debug (inf
, "restoring exception ports");
1324 inf_set_step_thread (inf
, 0); /* The step thread is special. */
1326 proc_restore_exc_port (inf
->task
);
1327 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1328 proc_restore_exc_port (thread
);
1332 /* Deliver signal SIG to INF. If INF is stopped, delivering a signal, even
1333 signal 0, will continue it. INF is assumed to be in a paused state, and
1334 the resume_sc's of INF's threads may be affected. */
1336 inf_signal (struct inf
*inf
, enum gdb_signal sig
)
1338 kern_return_t err
= 0;
1339 int host_sig
= gdb_signal_to_host (sig
);
1341 #define NAME gdb_signal_to_name (sig)
1343 if (host_sig
>= _NSIG
)
1344 /* A mach exception. Exceptions are encoded in the signal space by
1345 putting them after _NSIG; this assumes they're positive (and not
1346 extremely large)! */
1348 struct inf_wait
*w
= &inf
->wait
;
1350 if (w
->status
.kind
== TARGET_WAITKIND_STOPPED
1351 && w
->status
.value
.sig
== sig
1352 && w
->thread
&& !w
->thread
->aborted
)
1353 /* We're passing through the last exception we received. This is
1354 kind of bogus, because exceptions are per-thread whereas gdb
1355 treats signals as per-process. We just forward the exception to
1356 the correct handler, even it's not for the same thread as TID --
1357 i.e., we pretend it's global. */
1359 struct exc_state
*e
= &w
->exc
;
1361 inf_debug (inf
, "passing through exception:"
1362 " task = %lu, thread = %lu, exc = %d"
1363 ", code = %d, subcode = %d",
1364 w
->thread
->port
, inf
->task
->port
,
1365 e
->exception
, e
->code
, e
->subcode
);
1367 exception_raise_request (e
->handler
,
1368 e
->reply
, MACH_MSG_TYPE_MOVE_SEND_ONCE
,
1369 w
->thread
->port
, inf
->task
->port
,
1370 e
->exception
, e
->code
, e
->subcode
);
1373 error (_("Can't forward spontaneous exception (%s)."), NAME
);
1376 /* A Unix signal. */
1378 /* The process is stopped and expecting a signal. Just send off a
1379 request and let it get handled when we resume everything. */
1381 inf_debug (inf
, "sending %s to stopped process", NAME
);
1383 INF_MSGPORT_RPC (inf
,
1384 msg_sig_post_untraced_request (msgport
,
1386 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1390 /* Posting an untraced signal automatically continues it.
1391 We clear this here rather than when we get the reply
1392 because we'd rather assume it's not stopped when it
1393 actually is, than the reverse. */
1397 /* It's not expecting it. We have to let just the signal thread
1398 run, and wait for it to get into a reasonable state before we
1399 can continue the rest of the process. When we finally resume the
1400 process the signal we request will be the very first thing that
1403 inf_debug (inf
, "sending %s to unstopped process"
1404 " (so resuming signal thread)", NAME
);
1406 INF_RESUME_MSGPORT_RPC (inf
,
1407 msg_sig_post_untraced (msgport
, host_sig
,
1412 /* Can't do too much... */
1413 warning (_("Can't deliver signal %s: No signal thread."), NAME
);
1415 warning (_("Delivering signal %s: %s"), NAME
, safe_strerror (err
));
1421 /* Continue INF without delivering a signal. This is meant to be used
1422 when INF does not have a message port. */
1424 inf_continue (struct inf
*inf
)
1427 kern_return_t err
= proc_pid2proc (proc_server
, inf
->pid
, &proc
);
1431 inf_debug (inf
, "continuing process");
1433 err
= proc_mark_cont (proc
);
1436 struct proc
*thread
;
1438 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1439 thread_resume (thread
->port
);
1446 warning (_("Can't continue process: %s"), safe_strerror (err
));
1450 /* The inferior used for all gdb target ops. */
1451 struct inf
*gnu_current_inf
= 0;
1453 /* The inferior being waited for by gnu_wait. Since GDB is decidely not
1454 multi-threaded, we don't bother to lock this. */
1455 struct inf
*waiting_inf
;
1457 /* MIG stubs are not yet ready for C++ compilation. */
1458 extern "C" int exc_server (mach_msg_header_t
*, mach_msg_header_t
*);
1459 extern "C" int msg_reply_server (mach_msg_header_t
*, mach_msg_header_t
*);
1460 extern "C" int notify_server (mach_msg_header_t
*, mach_msg_header_t
*);
1461 extern "C" int process_reply_server (mach_msg_header_t
*, mach_msg_header_t
*);
1463 /* Wait for something to happen in the inferior, returning what in STATUS. */
1465 gnu_wait (struct target_ops
*ops
,
1466 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
1470 mach_msg_header_t hdr
;
1471 mach_msg_type_t type
;
1475 struct proc
*thread
;
1476 struct inf
*inf
= gnu_current_inf
;
1478 gdb_assert (inf
->task
);
1480 if (!inf
->threads
&& !inf
->pending_execs
)
1481 /* No threads! Assume that maybe some outside agency is frobbing our
1482 task, and really look for new threads. If we can't find any, just tell
1483 the user to try again later. */
1485 inf_validate_procs (inf
);
1486 if (!inf
->threads
&& !inf
->task
->dead
)
1487 error (_("There are no threads; try again later."));
1492 inf_debug (inf
, "waiting for: %s", target_pid_to_str (ptid
));
1495 if (proc_wait_pid
!= inf
->pid
&& !inf
->no_wait
)
1496 /* Always get information on events from the proc server. */
1498 inf_debug (inf
, "requesting wait on pid %d", inf
->pid
);
1501 /* The proc server is single-threaded, and only allows a single
1502 outstanding wait request, so we have to cancel the previous one. */
1504 inf_debug (inf
, "cancelling previous wait on pid %d", proc_wait_pid
);
1505 interrupt_operation (proc_server
, 0);
1509 proc_wait_request (proc_server
, inf
->event_port
, inf
->pid
, WUNTRACED
);
1511 warning (_("wait request failed: %s"), safe_strerror (err
));
1514 inf_debug (inf
, "waits pending: %d", proc_waits_pending
);
1515 proc_wait_pid
= inf
->pid
;
1516 /* Even if proc_waits_pending was > 0 before, we still won't
1517 get any other replies, because it was either from a
1518 different INF, or a different process attached to INF --
1519 and the event port, which is the wait reply port, changes
1520 when you switch processes. */
1521 proc_waits_pending
= 1;
1525 inf_clear_wait (inf
);
1527 /* What can happen? (1) Dead name notification; (2) Exceptions arrive;
1528 (3) wait reply from the proc server. */
1530 inf_debug (inf
, "waiting for an event...");
1531 err
= mach_msg (&msg
.hdr
, MACH_RCV_MSG
| MACH_RCV_INTERRUPT
,
1532 0, sizeof (struct msg
), inf
->event_port
,
1533 MACH_MSG_TIMEOUT_NONE
, MACH_PORT_NULL
);
1535 /* Re-suspend the task. */
1538 if (!inf
->task
&& inf
->pending_execs
)
1539 /* When doing an exec, it's possible that the old task wasn't reused
1540 (e.g., setuid execs). So if the task seems to have disappeared,
1541 attempt to refetch it, as the pid should still be the same. */
1542 inf_set_pid (inf
, inf
->pid
);
1544 if (err
== EMACH_RCV_INTERRUPTED
)
1545 inf_debug (inf
, "interrupted");
1547 error (_("Couldn't wait for an event: %s"), safe_strerror (err
));
1552 mach_msg_header_t hdr
;
1553 mach_msg_type_t err_type
;
1559 inf_debug (inf
, "event: msgid = %d", msg
.hdr
.msgh_id
);
1561 /* Handle what we got. */
1562 if (!notify_server (&msg
.hdr
, &reply
.hdr
)
1563 && !exc_server (&msg
.hdr
, &reply
.hdr
)
1564 && !process_reply_server (&msg
.hdr
, &reply
.hdr
)
1565 && !msg_reply_server (&msg
.hdr
, &reply
.hdr
))
1566 /* Whatever it is, it's something strange. */
1567 error (_("Got a strange event, msg id = %d."), msg
.hdr
.msgh_id
);
1570 error (_("Handling event, msgid = %d: %s"),
1571 msg
.hdr
.msgh_id
, safe_strerror (reply
.err
));
1574 if (inf
->pending_execs
)
1575 /* We're waiting for the inferior to finish execing. */
1577 struct inf_wait
*w
= &inf
->wait
;
1578 enum target_waitkind kind
= w
->status
.kind
;
1580 if (kind
== TARGET_WAITKIND_SPURIOUS
)
1581 /* Since gdb is actually counting the number of times the inferior
1582 stops, expecting one stop per exec, we only return major events
1586 inf_debug (inf
, "pending_execs, ignoring minor event");
1588 else if (kind
== TARGET_WAITKIND_STOPPED
1589 && w
->status
.value
.sig
== GDB_SIGNAL_TRAP
)
1590 /* Ah hah! A SIGTRAP from the inferior while starting up probably
1591 means we've succesfully completed an exec! */
1593 inf_debug (inf
, "one pending exec completed");
1595 else if (kind
== TARGET_WAITKIND_STOPPED
)
1596 /* It's possible that this signal is because of a crashed process
1597 being handled by the hurd crash server; in this case, the process
1598 will have an extra task suspend, which we need to know about.
1599 Since the code in inf_resume that normally checks for this is
1600 disabled while INF->pending_execs, we do the check here instead. */
1601 inf_validate_task_sc (inf
);
1604 if (inf
->wait
.suppress
)
1605 /* Some totally spurious event happened that we don't consider
1606 worth returning to gdb. Just keep waiting. */
1608 inf_debug (inf
, "suppressing return, rewaiting...");
1613 /* Pass back out our results. */
1614 memcpy (status
, &inf
->wait
.status
, sizeof (*status
));
1616 thread
= inf
->wait
.thread
;
1618 ptid
= ptid_build (inf
->pid
, thread
->tid
, 0);
1619 else if (ptid_equal (ptid
, minus_one_ptid
))
1620 thread
= inf_tid_to_thread (inf
, -1);
1622 thread
= inf_tid_to_thread (inf
, ptid_get_lwp (ptid
));
1624 if (!thread
|| thread
->port
== MACH_PORT_NULL
)
1626 /* TID is dead; try and find a new thread. */
1627 if (inf_update_procs (inf
) && inf
->threads
)
1628 ptid
= ptid_build (inf
->pid
, inf
->threads
->tid
, 0); /* The first
1632 ptid
= inferior_ptid
; /* let wait_for_inferior handle exit case */
1636 && !ptid_equal (ptid
, minus_one_ptid
)
1637 && status
->kind
!= TARGET_WAITKIND_SPURIOUS
1638 && inf
->pause_sc
== 0 && thread
->pause_sc
== 0)
1639 /* If something actually happened to THREAD, make sure we
1643 inf_update_suspends (inf
);
1646 inf_debug (inf
, "returning ptid = %s, status = %s (%d)",
1647 target_pid_to_str (ptid
),
1648 status
->kind
== TARGET_WAITKIND_EXITED
? "EXITED"
1649 : status
->kind
== TARGET_WAITKIND_STOPPED
? "STOPPED"
1650 : status
->kind
== TARGET_WAITKIND_SIGNALLED
? "SIGNALLED"
1651 : status
->kind
== TARGET_WAITKIND_LOADED
? "LOADED"
1652 : status
->kind
== TARGET_WAITKIND_SPURIOUS
? "SPURIOUS"
1654 status
->value
.integer
);
1660 /* The rpc handler called by exc_server. */
1662 S_exception_raise_request (mach_port_t port
, mach_port_t reply_port
,
1663 thread_t thread_port
, task_t task_port
,
1664 int exception
, int code
, int subcode
)
1666 struct inf
*inf
= waiting_inf
;
1667 struct proc
*thread
= inf_port_to_thread (inf
, thread_port
);
1669 inf_debug (waiting_inf
,
1670 "thread = %lu, task = %lu, exc = %d, code = %d, subcode = %d",
1671 thread_port
, task_port
, exception
, code
, subcode
);
1674 /* We don't know about thread? */
1676 inf_update_procs (inf
);
1677 thread
= inf_port_to_thread (inf
, thread_port
);
1679 /* Give up, the generating thread is gone. */
1683 mach_port_deallocate (mach_task_self (), thread_port
);
1684 mach_port_deallocate (mach_task_self (), task_port
);
1686 if (!thread
->aborted
)
1687 /* THREAD hasn't been aborted since this exception happened (abortion
1688 clears any exception state), so it must be real. */
1690 /* Store away the details; this will destroy any previous info. */
1691 inf
->wait
.thread
= thread
;
1693 inf
->wait
.status
.kind
= TARGET_WAITKIND_STOPPED
;
1695 if (exception
== EXC_BREAKPOINT
)
1696 /* GDB likes to get SIGTRAP for breakpoints. */
1698 inf
->wait
.status
.value
.sig
= GDB_SIGNAL_TRAP
;
1699 mach_port_deallocate (mach_task_self (), reply_port
);
1702 /* Record the exception so that we can forward it later. */
1704 if (thread
->exc_port
== port
)
1706 inf_debug (waiting_inf
, "Handler is thread exception port <%lu>",
1707 thread
->saved_exc_port
);
1708 inf
->wait
.exc
.handler
= thread
->saved_exc_port
;
1712 inf_debug (waiting_inf
, "Handler is task exception port <%lu>",
1713 inf
->task
->saved_exc_port
);
1714 inf
->wait
.exc
.handler
= inf
->task
->saved_exc_port
;
1715 gdb_assert (inf
->task
->exc_port
== port
);
1717 if (inf
->wait
.exc
.handler
!= MACH_PORT_NULL
)
1718 /* Add a reference to the exception handler. */
1719 mach_port_mod_refs (mach_task_self (),
1720 inf
->wait
.exc
.handler
, MACH_PORT_RIGHT_SEND
,
1723 inf
->wait
.exc
.exception
= exception
;
1724 inf
->wait
.exc
.code
= code
;
1725 inf
->wait
.exc
.subcode
= subcode
;
1726 inf
->wait
.exc
.reply
= reply_port
;
1728 /* Exceptions are encoded in the signal space by putting
1729 them after _NSIG; this assumes they're positive (and not
1730 extremely large)! */
1731 inf
->wait
.status
.value
.sig
=
1732 gdb_signal_from_host (_NSIG
+ exception
);
1736 /* A supppressed exception, which ignore. */
1738 inf
->wait
.suppress
= 1;
1739 mach_port_deallocate (mach_task_self (), reply_port
);
1746 /* Fill in INF's wait field after a task has died without giving us more
1747 detailed information. */
1749 inf_task_died_status (struct inf
*inf
)
1751 warning (_("Pid %d died with unknown exit status, using SIGKILL."),
1753 inf
->wait
.status
.kind
= TARGET_WAITKIND_SIGNALLED
;
1754 inf
->wait
.status
.value
.sig
= GDB_SIGNAL_KILL
;
1757 /* Notify server routines. The only real one is dead name notification. */
1759 do_mach_notify_dead_name (mach_port_t notify
, mach_port_t dead_port
)
1761 struct inf
*inf
= waiting_inf
;
1763 inf_debug (waiting_inf
, "port = %lu", dead_port
);
1765 if (inf
->task
&& inf
->task
->port
== dead_port
)
1767 proc_debug (inf
->task
, "is dead");
1768 inf
->task
->port
= MACH_PORT_NULL
;
1769 if (proc_wait_pid
== inf
->pid
)
1770 /* We have a wait outstanding on the process, which will return more
1771 detailed information, so delay until we get that. */
1772 inf
->wait
.suppress
= 1;
1774 /* We never waited for the process (maybe it wasn't a child), so just
1775 pretend it got a SIGKILL. */
1776 inf_task_died_status (inf
);
1780 struct proc
*thread
= inf_port_to_thread (inf
, dead_port
);
1784 proc_debug (thread
, "is dead");
1785 thread
->port
= MACH_PORT_NULL
;
1788 if (inf
->task
->dead
)
1789 /* Since the task is dead, its threads are dying with it. */
1790 inf
->wait
.suppress
= 1;
1793 mach_port_deallocate (mach_task_self (), dead_port
);
1794 inf
->threads_up_to_date
= 0; /* Just in case. */
1800 #define ILL_RPC(fun, ...) \
1801 extern kern_return_t fun (__VA_ARGS__); \
1802 kern_return_t fun (__VA_ARGS__) \
1804 warning (_("illegal rpc: %s"), #fun); \
1808 ILL_RPC (do_mach_notify_no_senders
,
1809 mach_port_t notify
, mach_port_mscount_t count
)
1810 ILL_RPC (do_mach_notify_port_deleted
,
1811 mach_port_t notify
, mach_port_t name
)
1812 ILL_RPC (do_mach_notify_msg_accepted
,
1813 mach_port_t notify
, mach_port_t name
)
1814 ILL_RPC (do_mach_notify_port_destroyed
,
1815 mach_port_t notify
, mach_port_t name
)
1816 ILL_RPC (do_mach_notify_send_once
,
1819 /* Process_reply server routines. We only use process_wait_reply. */
1822 S_proc_wait_reply (mach_port_t reply
, kern_return_t err
,
1823 int status
, int sigcode
, rusage_t rusage
, pid_t pid
)
1825 struct inf
*inf
= waiting_inf
;
1827 inf_debug (inf
, "err = %s, pid = %d, status = 0x%x, sigcode = %d",
1828 err
? safe_strerror (err
) : "0", pid
, status
, sigcode
);
1830 if (err
&& proc_wait_pid
&& (!inf
->task
|| !inf
->task
->port
))
1831 /* Ack. The task has died, but the task-died notification code didn't
1832 tell anyone because it thought a more detailed reply from the
1833 procserver was forthcoming. However, we now learn that won't
1834 happen... So we have to act like the task just died, and this time,
1836 inf_task_died_status (inf
);
1838 if (--proc_waits_pending
== 0)
1839 /* PROC_WAIT_PID represents the most recent wait. We will always get
1840 replies in order because the proc server is single threaded. */
1843 inf_debug (inf
, "waits pending now: %d", proc_waits_pending
);
1849 warning (_("Can't wait for pid %d: %s"),
1850 inf
->pid
, safe_strerror (err
));
1853 /* Since we can't see the inferior's signals, don't trap them. */
1854 inf_set_traced (inf
, 0);
1857 else if (pid
== inf
->pid
)
1859 store_waitstatus (&inf
->wait
.status
, status
);
1860 if (inf
->wait
.status
.kind
== TARGET_WAITKIND_STOPPED
)
1861 /* The process has sent us a signal, and stopped itself in a sane
1862 state pending our actions. */
1864 inf_debug (inf
, "process has stopped itself");
1869 inf
->wait
.suppress
= 1; /* Something odd happened. Ignore. */
1874 ILL_RPC (S_proc_setmsgport_reply
,
1875 mach_port_t reply_port
, kern_return_t return_code
,
1876 mach_port_t oldmsgport
)
1877 ILL_RPC (S_proc_getmsgport_reply
,
1878 mach_port_t reply_port
, kern_return_t return_code
,
1879 mach_port_t msgports
)
1880 ILL_RPC (S_proc_pid2task_reply
,
1881 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t task
)
1882 ILL_RPC (S_proc_task2pid_reply
,
1883 mach_port_t reply_port
, kern_return_t return_code
, pid_t pid
)
1884 ILL_RPC (S_proc_task2proc_reply
,
1885 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t proc
)
1886 ILL_RPC (S_proc_proc2task_reply
,
1887 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t task
)
1888 ILL_RPC (S_proc_pid2proc_reply
,
1889 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t proc
)
1890 ILL_RPC (S_proc_getprocinfo_reply
,
1891 mach_port_t reply_port
, kern_return_t return_code
,
1892 int flags
, procinfo_t procinfo
, mach_msg_type_number_t procinfoCnt
,
1893 data_t threadwaits
, mach_msg_type_number_t threadwaitsCnt
)
1894 ILL_RPC (S_proc_getprocargs_reply
,
1895 mach_port_t reply_port
, kern_return_t return_code
,
1896 data_t procargs
, mach_msg_type_number_t procargsCnt
)
1897 ILL_RPC (S_proc_getprocenv_reply
,
1898 mach_port_t reply_port
, kern_return_t return_code
,
1899 data_t procenv
, mach_msg_type_number_t procenvCnt
)
1900 ILL_RPC (S_proc_getloginid_reply
,
1901 mach_port_t reply_port
, kern_return_t return_code
, pid_t login_id
)
1902 ILL_RPC (S_proc_getloginpids_reply
,
1903 mach_port_t reply_port
, kern_return_t return_code
,
1904 pidarray_t pids
, mach_msg_type_number_t pidsCnt
)
1905 ILL_RPC (S_proc_getlogin_reply
,
1906 mach_port_t reply_port
, kern_return_t return_code
, string_t logname
)
1907 ILL_RPC (S_proc_getsid_reply
,
1908 mach_port_t reply_port
, kern_return_t return_code
, pid_t sid
)
1909 ILL_RPC (S_proc_getsessionpgids_reply
,
1910 mach_port_t reply_port
, kern_return_t return_code
,
1911 pidarray_t pgidset
, mach_msg_type_number_t pgidsetCnt
)
1912 ILL_RPC (S_proc_getsessionpids_reply
,
1913 mach_port_t reply_port
, kern_return_t return_code
,
1914 pidarray_t pidset
, mach_msg_type_number_t pidsetCnt
)
1915 ILL_RPC (S_proc_getsidport_reply
,
1916 mach_port_t reply_port
, kern_return_t return_code
,
1917 mach_port_t sessport
)
1918 ILL_RPC (S_proc_getpgrp_reply
,
1919 mach_port_t reply_port
, kern_return_t return_code
, pid_t pgrp
)
1920 ILL_RPC (S_proc_getpgrppids_reply
,
1921 mach_port_t reply_port
, kern_return_t return_code
,
1922 pidarray_t pidset
, mach_msg_type_number_t pidsetCnt
)
1923 ILL_RPC (S_proc_get_tty_reply
,
1924 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t tty
)
1925 ILL_RPC (S_proc_getnports_reply
,
1926 mach_port_t reply_port
, kern_return_t return_code
,
1927 mach_msg_type_number_t nports
)
1928 ILL_RPC (S_proc_is_important_reply
,
1929 mach_port_t reply_port
, kern_return_t return_code
,
1930 boolean_t essential
)
1931 ILL_RPC (S_proc_get_code_reply
,
1932 mach_port_t reply_port
, kern_return_t return_code
,
1933 vm_address_t start_code
, vm_address_t end_code
)
1935 /* Msg_reply server routines. We only use msg_sig_post_untraced_reply. */
1938 S_msg_sig_post_untraced_reply (mach_port_t reply
, kern_return_t err
)
1940 struct inf
*inf
= waiting_inf
;
1943 /* EBUSY is what we get when the crash server has grabbed control of the
1944 process and doesn't like what signal we tried to send it. Just act
1945 like the process stopped (using a signal of 0 should mean that the
1946 *next* time the user continues, it will pass signal 0, which the crash
1947 server should like). */
1949 inf
->wait
.status
.kind
= TARGET_WAITKIND_STOPPED
;
1950 inf
->wait
.status
.value
.sig
= GDB_SIGNAL_0
;
1953 warning (_("Signal delivery failed: %s"), safe_strerror (err
));
1956 /* We only get this reply when we've posted a signal to a process which we
1957 thought was stopped, and which we expected to continue after the signal.
1958 Given that the signal has failed for some reason, it's reasonable to
1959 assume it's still stopped. */
1962 inf
->wait
.suppress
= 1;
1967 ILL_RPC (S_msg_sig_post_reply
,
1968 mach_port_t reply
, kern_return_t err
)
1970 /* Returns the number of messages queued for the receive right PORT. */
1971 static mach_port_msgcount_t
1972 port_msgs_queued (mach_port_t port
)
1974 struct mach_port_status status
;
1976 mach_port_get_receive_status (mach_task_self (), port
, &status
);
1981 return status
.mps_msgcount
;
1985 /* Resume execution of the inferior process.
1987 If STEP is nonzero, single-step it.
1988 If SIGNAL is nonzero, give it that signal.
1991 -1 true Single step the current thread allowing other threads to run.
1992 -1 false Continue the current thread allowing other threads to run.
1993 X true Single step the given thread, don't allow any others to run.
1994 X false Continue the given thread, do not allow any others to run.
1995 (Where X, of course, is anything except -1)
1997 Note that a resume may not `take' if there are pending exceptions/&c
1998 still unprocessed from the last resume we did (any given resume may result
1999 in multiple events returned by wait). */
2002 gnu_resume (struct target_ops
*ops
,
2003 ptid_t ptid
, int step
, enum gdb_signal sig
)
2005 struct proc
*step_thread
= 0;
2007 struct inf
*inf
= gnu_current_inf
;
2009 inf_debug (inf
, "ptid = %s, step = %d, sig = %d",
2010 target_pid_to_str (ptid
), step
, sig
);
2012 inf_validate_procinfo (inf
);
2014 if (sig
!= GDB_SIGNAL_0
|| inf
->stopped
)
2016 if (sig
== GDB_SIGNAL_0
&& inf
->nomsg
)
2019 inf_signal (inf
, sig
);
2021 else if (inf
->wait
.exc
.reply
!= MACH_PORT_NULL
)
2022 /* We received an exception to which we have chosen not to forward, so
2023 abort the faulting thread, which will perhaps retake it. */
2025 proc_abort (inf
->wait
.thread
, 1);
2026 warning (_("Aborting %s with unforwarded exception %s."),
2027 proc_string (inf
->wait
.thread
),
2028 gdb_signal_to_name (inf
->wait
.status
.value
.sig
));
2031 if (port_msgs_queued (inf
->event_port
))
2032 /* If there are still messages in our event queue, don't bother resuming
2033 the process, as we're just going to stop it right away anyway. */
2036 inf_update_procs (inf
);
2038 /* A specific PTID means `step only this process id'. */
2039 resume_all
= ptid_equal (ptid
, minus_one_ptid
);
2042 /* Allow all threads to run, except perhaps single-stepping one. */
2044 inf_debug (inf
, "running all threads; tid = %d",
2045 ptid_get_pid (inferior_ptid
));
2046 ptid
= inferior_ptid
; /* What to step. */
2047 inf_set_threads_resume_sc (inf
, 0, 1);
2050 /* Just allow a single thread to run. */
2052 struct proc
*thread
= inf_tid_to_thread (inf
, ptid_get_lwp (ptid
));
2055 error (_("Can't run single thread id %s: no such thread!"),
2056 target_pid_to_str (ptid
));
2057 inf_debug (inf
, "running one thread: %s", target_pid_to_str (ptid
));
2058 inf_set_threads_resume_sc (inf
, thread
, 0);
2063 step_thread
= inf_tid_to_thread (inf
, ptid_get_lwp (ptid
));
2065 warning (_("Can't step thread id %s: no such thread."),
2066 target_pid_to_str (ptid
));
2068 inf_debug (inf
, "stepping thread: %s", target_pid_to_str (ptid
));
2070 if (step_thread
!= inf
->step_thread
)
2071 inf_set_step_thread (inf
, step_thread
);
2073 inf_debug (inf
, "here we go...");
2079 gnu_kill_inferior (struct target_ops
*ops
)
2081 struct proc
*task
= gnu_current_inf
->task
;
2085 proc_debug (task
, "terminating...");
2086 task_terminate (task
->port
);
2087 inf_set_pid (gnu_current_inf
, -1);
2089 target_mourn_inferior (inferior_ptid
);
2092 /* Clean up after the inferior dies. */
2094 gnu_mourn_inferior (struct target_ops
*ops
)
2096 inf_debug (gnu_current_inf
, "rip");
2097 inf_detach (gnu_current_inf
);
2098 inf_child_mourn_inferior (ops
);
2102 /* Fork an inferior process, and start debugging it. */
2104 /* Set INFERIOR_PID to the first thread available in the child, if any. */
2106 inf_pick_first_thread (void)
2108 if (gnu_current_inf
->task
&& gnu_current_inf
->threads
)
2109 /* The first thread. */
2110 return gnu_current_inf
->threads
->tid
;
2112 /* What may be the next thread. */
2113 return next_thread_id
;
2119 if (!gnu_current_inf
)
2120 gnu_current_inf
= make_inf ();
2121 return gnu_current_inf
;
2125 gnu_ptrace_me (void)
2127 /* We're in the child; make this process stop as soon as it execs. */
2128 struct inf
*inf
= cur_inf ();
2129 inf_debug (inf
, "tracing self");
2130 if (ptrace (PTRACE_TRACEME
) != 0)
2131 trace_start_error_with_name ("ptrace");
2135 gnu_create_inferior (struct target_ops
*ops
,
2136 const char *exec_file
, const std::string
&allargs
,
2140 struct inf
*inf
= cur_inf ();
2143 inf_debug (inf
, "creating inferior");
2145 pid
= fork_inferior (exec_file
, allargs
, env
, gnu_ptrace_me
,
2146 NULL
, NULL
, NULL
, NULL
);
2148 /* We have something that executes now. We'll be running through
2149 the shell at this point (if startup-with-shell is true), but the
2150 pid shouldn't change. */
2151 add_thread_silent (pid_to_ptid (pid
));
2153 /* Attach to the now stopped child, which is actually a shell... */
2154 inf_debug (inf
, "attaching to child: %d", pid
);
2156 inf_attach (inf
, pid
);
2160 inf
->pending_execs
= 1;
2164 /* Now let the child run again, knowing that it will stop
2165 immediately because of the ptrace. */
2168 /* We now have thread info. */
2169 thread_change_ptid (inferior_ptid
,
2170 ptid_build (inf
->pid
, inf_pick_first_thread (), 0));
2172 gdb_startup_inferior (pid
, START_INFERIOR_TRAPS_EXPECTED
);
2174 inf
->pending_execs
= 0;
2175 /* Get rid of the old shell threads. */
2178 inf_validate_procinfo (inf
);
2179 inf_update_signal_thread (inf
);
2180 inf_set_traced (inf
, inf
->want_signals
);
2182 /* Execing the process will have trashed our exception ports; steal them
2183 back (or make sure they're restored if the user wants that). */
2184 if (inf
->want_exceptions
)
2185 inf_steal_exc_ports (inf
);
2187 inf_restore_exc_ports (inf
);
2191 /* Attach to process PID, then initialize for debugging it
2192 and wait for the trace-trap that results from attaching. */
2194 gnu_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
2198 struct inf
*inf
= cur_inf ();
2199 struct inferior
*inferior
;
2201 pid
= parse_pid_to_attach (args
);
2203 if (pid
== getpid ()) /* Trying to masturbate? */
2204 error (_("I refuse to debug myself!"));
2208 exec_file
= (char *) get_exec_file (0);
2211 printf_unfiltered ("Attaching to program `%s', pid %d\n",
2214 printf_unfiltered ("Attaching to pid %d\n", pid
);
2216 gdb_flush (gdb_stdout
);
2219 inf_debug (inf
, "attaching to pid: %d", pid
);
2221 inf_attach (inf
, pid
);
2225 inferior
= current_inferior ();
2226 inferior_appeared (inferior
, pid
);
2227 inferior
->attach_flag
= 1;
2229 inf_update_procs (inf
);
2231 inferior_ptid
= ptid_build (pid
, inf_pick_first_thread (), 0);
2233 /* We have to initialize the terminal settings now, since the code
2234 below might try to restore them. */
2235 target_terminal::init ();
2237 /* If the process was stopped before we attached, make it continue the next
2238 time the user does a continue. */
2239 inf_validate_procinfo (inf
);
2241 inf_update_signal_thread (inf
);
2242 inf_set_traced (inf
, inf
->want_signals
);
2244 #if 0 /* Do we need this? */
2245 renumber_threads (0); /* Give our threads reasonable names. */
2250 /* Take a program previously attached to and detaches it.
2251 The program resumes execution and will no longer stop
2252 on signals, etc. We'd better not have left any breakpoints
2253 in the program or it'll die when it hits one. For this
2254 to work, it may be necessary for the process to have been
2255 previously attached. It *might* work if the program was
2256 started via fork. */
2258 gnu_detach (struct target_ops
*ops
, inferior
*inf
, int from_tty
)
2264 char *exec_file
= get_exec_file (0);
2267 printf_unfiltered ("Detaching from program `%s' pid %d\n",
2268 exec_file
, gnu_current_inf
->pid
);
2270 printf_unfiltered ("Detaching from pid %d\n", gnu_current_inf
->pid
);
2271 gdb_flush (gdb_stdout
);
2274 pid
= gnu_current_inf
->pid
;
2276 inf_detach (gnu_current_inf
);
2278 inferior_ptid
= null_ptid
;
2279 detach_inferior (pid
);
2281 inf_child_maybe_unpush_target (ops
);
2286 gnu_stop (struct target_ops
*self
, ptid_t ptid
)
2288 error (_("to_stop target function not implemented"));
2292 gnu_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2294 inf_update_procs (gnu_current_inf
);
2295 return !!inf_tid_to_thread (gnu_current_inf
,
2296 ptid_get_lwp (ptid
));
2300 /* Read inferior task's LEN bytes from ADDR and copy it to MYADDR in
2301 gdb's address space. Return 0 on failure; number of bytes read
2304 gnu_read_inferior (task_t task
, CORE_ADDR addr
, gdb_byte
*myaddr
, int length
)
2307 vm_address_t low_address
= (vm_address_t
) trunc_page (addr
);
2308 vm_size_t aligned_length
=
2309 (vm_size_t
) round_page (addr
+ length
) - low_address
;
2311 mach_msg_type_number_t copy_count
;
2313 /* Get memory from inferior with page aligned addresses. */
2314 err
= vm_read (task
, low_address
, aligned_length
, &copied
, ©_count
);
2318 err
= hurd_safe_copyin (myaddr
, (void *) (addr
- low_address
+ copied
),
2322 warning (_("Read from inferior faulted: %s"), safe_strerror (err
));
2326 err
= vm_deallocate (mach_task_self (), copied
, copy_count
);
2328 warning (_("gnu_read_inferior vm_deallocate failed: %s"),
2329 safe_strerror (err
));
2334 #define CHK_GOTO_OUT(str,ret) \
2335 do if (ret != KERN_SUCCESS) { errstr = #str; goto out; } while(0)
2337 struct vm_region_list
2339 struct vm_region_list
*next
;
2340 vm_prot_t protection
;
2345 struct obstack region_obstack
;
2347 /* Write gdb's LEN bytes from MYADDR and copy it to ADDR in inferior
2348 task's address space. */
2350 gnu_write_inferior (task_t task
, CORE_ADDR addr
,
2351 const gdb_byte
*myaddr
, int length
)
2354 vm_address_t low_address
= (vm_address_t
) trunc_page (addr
);
2355 vm_size_t aligned_length
=
2356 (vm_size_t
) round_page (addr
+ length
) - low_address
;
2358 mach_msg_type_number_t copy_count
;
2361 char *errstr
= "Bug in gnu_write_inferior";
2363 struct vm_region_list
*region_element
;
2364 struct vm_region_list
*region_head
= NULL
;
2366 /* Get memory from inferior with page aligned addresses. */
2367 err
= vm_read (task
,
2372 CHK_GOTO_OUT ("gnu_write_inferior vm_read failed", err
);
2376 err
= hurd_safe_copyout ((void *) (addr
- low_address
+ copied
),
2378 CHK_GOTO_OUT ("Write to inferior faulted", err
);
2380 obstack_init (®ion_obstack
);
2382 /* Do writes atomically.
2383 First check for holes and unwritable memory. */
2385 vm_size_t remaining_length
= aligned_length
;
2386 vm_address_t region_address
= low_address
;
2388 struct vm_region_list
*scan
;
2390 while (region_address
< low_address
+ aligned_length
)
2392 vm_prot_t protection
;
2393 vm_prot_t max_protection
;
2394 vm_inherit_t inheritance
;
2396 mach_port_t object_name
;
2398 vm_size_t region_length
= remaining_length
;
2399 vm_address_t old_address
= region_address
;
2401 err
= vm_region (task
,
2410 CHK_GOTO_OUT ("vm_region failed", err
);
2412 /* Check for holes in memory. */
2413 if (old_address
!= region_address
)
2415 warning (_("No memory at 0x%lx. Nothing written"),
2422 if (!(max_protection
& VM_PROT_WRITE
))
2424 warning (_("Memory at address 0x%lx is unwritable. "
2432 /* Chain the regions for later use. */
2433 region_element
= XOBNEW (®ion_obstack
, struct vm_region_list
);
2435 region_element
->protection
= protection
;
2436 region_element
->start
= region_address
;
2437 region_element
->length
= region_length
;
2439 /* Chain the regions along with protections. */
2440 region_element
->next
= region_head
;
2441 region_head
= region_element
;
2443 region_address
+= region_length
;
2444 remaining_length
= remaining_length
- region_length
;
2447 /* If things fail after this, we give up.
2448 Somebody is messing up inferior_task's mappings. */
2450 /* Enable writes to the chained vm regions. */
2451 for (scan
= region_head
; scan
; scan
= scan
->next
)
2453 if (!(scan
->protection
& VM_PROT_WRITE
))
2455 err
= vm_protect (task
,
2459 scan
->protection
| VM_PROT_WRITE
);
2460 CHK_GOTO_OUT ("vm_protect: enable write failed", err
);
2464 err
= vm_write (task
,
2468 CHK_GOTO_OUT ("vm_write failed", err
);
2470 /* Set up the original region protections, if they were changed. */
2471 for (scan
= region_head
; scan
; scan
= scan
->next
)
2473 if (!(scan
->protection
& VM_PROT_WRITE
))
2475 err
= vm_protect (task
,
2480 CHK_GOTO_OUT ("vm_protect: enable write failed", err
);
2488 obstack_free (®ion_obstack
, 0);
2490 (void) vm_deallocate (mach_task_self (),
2495 if (err
!= KERN_SUCCESS
)
2497 warning (_("%s: %s"), errstr
, mach_error_string (err
));
2506 /* Implement the to_xfer_partial target_ops method for
2507 TARGET_OBJECT_MEMORY. */
2509 static enum target_xfer_status
2510 gnu_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2511 CORE_ADDR memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2513 task_t task
= (gnu_current_inf
2514 ? (gnu_current_inf
->task
2515 ? gnu_current_inf
->task
->port
: 0)
2519 if (task
== MACH_PORT_NULL
)
2520 return TARGET_XFER_E_IO
;
2522 if (writebuf
!= NULL
)
2524 inf_debug (gnu_current_inf
, "writing %s[%s] <-- %s",
2525 paddress (target_gdbarch (), memaddr
), pulongest (len
),
2526 host_address_to_string (writebuf
));
2527 res
= gnu_write_inferior (task
, memaddr
, writebuf
, len
);
2531 inf_debug (gnu_current_inf
, "reading %s[%s] --> %s",
2532 paddress (target_gdbarch (), memaddr
), pulongest (len
),
2533 host_address_to_string (readbuf
));
2534 res
= gnu_read_inferior (task
, memaddr
, readbuf
, len
);
2536 gdb_assert (res
>= 0);
2538 return TARGET_XFER_E_IO
;
2541 *xfered_len
= (ULONGEST
) res
;
2542 return TARGET_XFER_OK
;
2546 /* GNU does not have auxv, but we can at least fake the AT_ENTRY entry for PIE
2548 static enum target_xfer_status
2549 gnu_xfer_auxv (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2550 CORE_ADDR memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2552 task_t task
= (gnu_current_inf
2553 ? (gnu_current_inf
->task
2554 ? gnu_current_inf
->task
->port
: 0)
2560 ElfW(auxv_t
) auxv
[2];
2562 if (task
== MACH_PORT_NULL
)
2563 return TARGET_XFER_E_IO
;
2564 if (writebuf
!= NULL
)
2565 return TARGET_XFER_E_IO
;
2567 if (memaddr
== sizeof (auxv
))
2568 return TARGET_XFER_EOF
;
2569 if (memaddr
> sizeof (auxv
))
2570 return TARGET_XFER_E_IO
;
2572 err
= proc_task2proc (proc_server
, task
, &proc
);
2574 return TARGET_XFER_E_IO
;
2576 /* Get entry from proc server. */
2577 err
= proc_get_entry (proc
, &entry
);
2579 return TARGET_XFER_E_IO
;
2581 /* Fake auxv entry. */
2582 auxv
[0].a_type
= AT_ENTRY
;
2583 auxv
[0].a_un
.a_val
= entry
;
2584 auxv
[1].a_type
= AT_NULL
;
2585 auxv
[1].a_un
.a_val
= 0;
2587 inf_debug (gnu_current_inf
, "reading auxv %s[%s] --> %s",
2588 paddress (target_gdbarch (), memaddr
), pulongest (len
),
2589 host_address_to_string (readbuf
));
2591 if (memaddr
+ len
> sizeof (auxv
))
2592 len
= sizeof (auxv
) - memaddr
;
2594 memcpy (readbuf
, (gdb_byte
*) &auxv
+ memaddr
, len
);
2597 return TARGET_XFER_OK
;
2600 /* Target to_xfer_partial implementation. */
2602 static enum target_xfer_status
2603 gnu_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2604 const char *annex
, gdb_byte
*readbuf
,
2605 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
2606 ULONGEST
*xfered_len
)
2610 case TARGET_OBJECT_MEMORY
:
2611 return gnu_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2612 case TARGET_OBJECT_AUXV
:
2613 return gnu_xfer_auxv (readbuf
, writebuf
, offset
, len
, xfered_len
);
2615 return TARGET_XFER_E_IO
;
2619 /* Call FUNC on each memory region in the task. */
2621 gnu_find_memory_regions (struct target_ops
*self
,
2622 find_memory_region_ftype func
, void *data
)
2626 vm_address_t region_address
, last_region_address
, last_region_end
;
2627 vm_prot_t last_protection
;
2629 if (gnu_current_inf
== 0 || gnu_current_inf
->task
== 0)
2631 task
= gnu_current_inf
->task
->port
;
2632 if (task
== MACH_PORT_NULL
)
2635 region_address
= last_region_address
= last_region_end
= VM_MIN_ADDRESS
;
2636 last_protection
= VM_PROT_NONE
;
2637 while (region_address
< VM_MAX_ADDRESS
)
2639 vm_prot_t protection
;
2640 vm_prot_t max_protection
;
2641 vm_inherit_t inheritance
;
2643 mach_port_t object_name
;
2645 vm_size_t region_length
= VM_MAX_ADDRESS
- region_address
;
2646 vm_address_t old_address
= region_address
;
2648 err
= vm_region (task
,
2657 if (err
== KERN_NO_SPACE
)
2659 if (err
!= KERN_SUCCESS
)
2661 warning (_("vm_region failed: %s"), mach_error_string (err
));
2665 if (protection
== last_protection
&& region_address
== last_region_end
)
2666 /* This region is contiguous with and indistinguishable from
2667 the previous one, so we just extend that one. */
2668 last_region_end
= region_address
+= region_length
;
2671 /* This region is distinct from the last one we saw, so report
2672 that previous one. */
2673 if (last_protection
!= VM_PROT_NONE
)
2674 (*func
) (last_region_address
,
2675 last_region_end
- last_region_address
,
2676 last_protection
& VM_PROT_READ
,
2677 last_protection
& VM_PROT_WRITE
,
2678 last_protection
& VM_PROT_EXECUTE
,
2679 1, /* MODIFIED is unknown, pass it as true. */
2681 last_region_address
= region_address
;
2682 last_region_end
= region_address
+= region_length
;
2683 last_protection
= protection
;
2687 /* Report the final region. */
2688 if (last_region_end
> last_region_address
&& last_protection
!= VM_PROT_NONE
)
2689 (*func
) (last_region_address
, last_region_end
- last_region_address
,
2690 last_protection
& VM_PROT_READ
,
2691 last_protection
& VM_PROT_WRITE
,
2692 last_protection
& VM_PROT_EXECUTE
,
2693 1, /* MODIFIED is unknown, pass it as true. */
2700 /* Return printable description of proc. */
2702 proc_string (struct proc
*proc
)
2704 static char tid_str
[80];
2706 if (proc_is_task (proc
))
2707 xsnprintf (tid_str
, sizeof (tid_str
), "process %d", proc
->inf
->pid
);
2709 xsnprintf (tid_str
, sizeof (tid_str
), "Thread %d.%d",
2710 proc
->inf
->pid
, proc
->tid
);
2715 gnu_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2717 struct inf
*inf
= gnu_current_inf
;
2718 int tid
= ptid_get_lwp (ptid
);
2719 struct proc
*thread
= inf_tid_to_thread (inf
, tid
);
2722 return proc_string (thread
);
2725 static char tid_str
[80];
2727 xsnprintf (tid_str
, sizeof (tid_str
), "bogus thread id %d", tid
);
2733 /* Create a prototype generic GNU/Hurd target. The client can
2734 override it with local methods. */
2739 struct target_ops
*t
= inf_child_target ();
2741 t
->to_attach
= gnu_attach
;
2742 t
->to_attach_no_wait
= 1;
2743 t
->to_detach
= gnu_detach
;
2744 t
->to_resume
= gnu_resume
;
2745 t
->to_wait
= gnu_wait
;
2746 t
->to_xfer_partial
= gnu_xfer_partial
;
2747 t
->to_find_memory_regions
= gnu_find_memory_regions
;
2748 t
->to_kill
= gnu_kill_inferior
;
2749 t
->to_create_inferior
= gnu_create_inferior
;
2750 t
->to_mourn_inferior
= gnu_mourn_inferior
;
2751 t
->to_thread_alive
= gnu_thread_alive
;
2752 t
->to_pid_to_str
= gnu_pid_to_str
;
2753 t
->to_stop
= gnu_stop
;
2759 /* User task commands. */
2761 static struct cmd_list_element
*set_task_cmd_list
= 0;
2762 static struct cmd_list_element
*show_task_cmd_list
= 0;
2763 /* User thread commands. */
2765 /* Commands with a prefix of `set/show thread'. */
2766 extern struct cmd_list_element
*thread_cmd_list
;
2767 struct cmd_list_element
*set_thread_cmd_list
= NULL
;
2768 struct cmd_list_element
*show_thread_cmd_list
= NULL
;
2770 /* Commands with a prefix of `set/show thread default'. */
2771 struct cmd_list_element
*set_thread_default_cmd_list
= NULL
;
2772 struct cmd_list_element
*show_thread_default_cmd_list
= NULL
;
2775 set_thread_cmd (const char *args
, int from_tty
)
2777 printf_unfiltered ("\"set thread\" must be followed by the "
2778 "name of a thread property, or \"default\".\n");
2782 show_thread_cmd (const char *args
, int from_tty
)
2784 printf_unfiltered ("\"show thread\" must be followed by the "
2785 "name of a thread property, or \"default\".\n");
2789 set_thread_default_cmd (const char *args
, int from_tty
)
2791 printf_unfiltered ("\"set thread default\" must be followed "
2792 "by the name of a thread property.\n");
2796 show_thread_default_cmd (const char *args
, int from_tty
)
2798 printf_unfiltered ("\"show thread default\" must be followed "
2799 "by the name of a thread property.\n");
2803 parse_int_arg (const char *args
, char *cmd_prefix
)
2808 int val
= strtoul (args
, &arg_end
, 10);
2810 if (*args
&& *arg_end
== '\0')
2813 error (_("Illegal argument for \"%s\" command, should be an integer."),
2818 _parse_bool_arg (const char *args
, char *t_val
, char *f_val
, char *cmd_prefix
)
2820 if (!args
|| strcmp (args
, t_val
) == 0)
2822 else if (strcmp (args
, f_val
) == 0)
2825 error (_("Illegal argument for \"%s\" command, "
2826 "should be \"%s\" or \"%s\"."),
2827 cmd_prefix
, t_val
, f_val
);
2830 #define parse_bool_arg(args, cmd_prefix) \
2831 _parse_bool_arg (args, "on", "off", cmd_prefix)
2834 check_empty (const char *args
, char *cmd_prefix
)
2837 error (_("Garbage after \"%s\" command: `%s'"), cmd_prefix
, args
);
2840 /* Returns the alive thread named by INFERIOR_PID, or signals an error. */
2841 static struct proc
*
2844 struct inf
*inf
= cur_inf ();
2845 struct proc
*thread
= inf_tid_to_thread (inf
,
2846 ptid_get_lwp (inferior_ptid
));
2848 error (_("No current thread."));
2852 /* Returns the current inferior, but signals an error if it has no task. */
2856 struct inf
*inf
= cur_inf ();
2859 error (_("No current process."));
2865 set_task_pause_cmd (int arg
, int from_tty
)
2867 struct inf
*inf
= cur_inf ();
2868 int old_sc
= inf
->pause_sc
;
2870 inf
->pause_sc
= arg
;
2872 if (old_sc
== 0 && inf
->pause_sc
!= 0)
2873 /* If the task is currently unsuspended, immediately suspend it,
2874 otherwise wait until the next time it gets control. */
2879 set_task_pause_cmd (const char *args
, int from_tty
)
2881 set_task_pause_cmd (parse_bool_arg (args
, "set task pause"), from_tty
);
2885 show_task_pause_cmd (const char *args
, int from_tty
)
2887 struct inf
*inf
= cur_inf ();
2889 check_empty (args
, "show task pause");
2890 printf_unfiltered ("The inferior task %s suspended while gdb has control.\n",
2892 ? (inf
->pause_sc
== 0 ? "isn't" : "is")
2893 : (inf
->pause_sc
== 0 ? "won't be" : "will be"));
2897 set_task_detach_sc_cmd (const char *args
, int from_tty
)
2899 cur_inf ()->detach_sc
= parse_int_arg (args
,
2900 "set task detach-suspend-count");
2904 show_task_detach_sc_cmd (const char *args
, int from_tty
)
2906 check_empty (args
, "show task detach-suspend-count");
2907 printf_unfiltered ("The inferior task will be left with a "
2908 "suspend count of %d when detaching.\n",
2909 cur_inf ()->detach_sc
);
2914 set_thread_default_pause_cmd (const char *args
, int from_tty
)
2916 struct inf
*inf
= cur_inf ();
2918 inf
->default_thread_pause_sc
=
2919 parse_bool_arg (args
, "set thread default pause") ? 0 : 1;
2923 show_thread_default_pause_cmd (const char *args
, int from_tty
)
2925 struct inf
*inf
= cur_inf ();
2926 int sc
= inf
->default_thread_pause_sc
;
2928 check_empty (args
, "show thread default pause");
2929 printf_unfiltered ("New threads %s suspended while gdb has control%s.\n",
2930 sc
? "are" : "aren't",
2931 !sc
&& inf
->pause_sc
? " (but the task is)" : "");
2935 set_thread_default_run_cmd (const char *args
, int from_tty
)
2937 struct inf
*inf
= cur_inf ();
2939 inf
->default_thread_run_sc
=
2940 parse_bool_arg (args
, "set thread default run") ? 0 : 1;
2944 show_thread_default_run_cmd (const char *args
, int from_tty
)
2946 struct inf
*inf
= cur_inf ();
2948 check_empty (args
, "show thread default run");
2949 printf_unfiltered ("New threads %s allowed to run.\n",
2950 inf
->default_thread_run_sc
== 0 ? "are" : "aren't");
2954 set_thread_default_detach_sc_cmd (const char *args
, int from_tty
)
2956 cur_inf ()->default_thread_detach_sc
=
2957 parse_int_arg (args
, "set thread default detach-suspend-count");
2961 show_thread_default_detach_sc_cmd (const char *args
, int from_tty
)
2963 check_empty (args
, "show thread default detach-suspend-count");
2964 printf_unfiltered ("New threads will get a detach-suspend-count of %d.\n",
2965 cur_inf ()->default_thread_detach_sc
);
2969 /* Steal a send right called NAME in the inferior task, and make it PROC's
2970 saved exception port. */
2972 steal_exc_port (struct proc
*proc
, mach_port_t name
)
2976 mach_msg_type_name_t port_type
;
2978 if (!proc
|| !proc
->inf
->task
)
2979 error (_("No inferior task."));
2981 err
= mach_port_extract_right (proc
->inf
->task
->port
,
2982 name
, MACH_MSG_TYPE_COPY_SEND
,
2985 error (_("Couldn't extract send right %lu from inferior: %s"),
2986 name
, safe_strerror (err
));
2988 if (proc
->saved_exc_port
)
2989 /* Get rid of our reference to the old one. */
2990 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
2992 proc
->saved_exc_port
= port
;
2994 if (!proc
->exc_port
)
2995 /* If PROC is a thread, we may not have set its exception port
2996 before. We can't use proc_steal_exc_port because it also sets
2999 proc
->exc_port
= proc
->inf
->event_port
;
3000 err
= proc_set_exception_port (proc
, proc
->exc_port
);
3001 error (_("Can't set exception port for %s: %s"),
3002 proc_string (proc
), safe_strerror (err
));
3007 set_task_exc_port_cmd (const char *args
, int from_tty
)
3009 struct inf
*inf
= cur_inf ();
3012 error (_("No argument to \"set task exception-port\" command."));
3013 steal_exc_port (inf
->task
, parse_and_eval_address (args
));
3017 set_stopped_cmd (const char *args
, int from_tty
)
3019 cur_inf ()->stopped
= _parse_bool_arg (args
, "yes", "no", "set stopped");
3023 show_stopped_cmd (const char *args
, int from_tty
)
3025 struct inf
*inf
= active_inf ();
3027 check_empty (args
, "show stopped");
3028 printf_unfiltered ("The inferior process %s stopped.\n",
3029 inf
->stopped
? "is" : "isn't");
3033 set_sig_thread_cmd (const char *args
, int from_tty
)
3035 struct inf
*inf
= cur_inf ();
3037 if (!args
|| (!isdigit (*args
) && strcmp (args
, "none") != 0))
3038 error (_("Illegal argument to \"set signal-thread\" command.\n"
3039 "Should be a thread ID, or \"none\"."));
3041 if (strcmp (args
, "none") == 0)
3042 inf
->signal_thread
= 0;
3045 struct thread_info
*tp
= parse_thread_id (args
, NULL
);
3046 inf
->signal_thread
= inf_tid_to_thread (inf
, ptid_get_lwp (tp
->ptid
));
3051 show_sig_thread_cmd (const char *args
, int from_tty
)
3053 struct inf
*inf
= active_inf ();
3055 check_empty (args
, "show signal-thread");
3056 if (inf
->signal_thread
)
3057 printf_unfiltered ("The signal thread is %s.\n",
3058 proc_string (inf
->signal_thread
));
3060 printf_unfiltered ("There is no signal thread.\n");
3065 set_signals_cmd (int arg
, int from_tty
)
3067 struct inf
*inf
= cur_inf ();
3069 inf
->want_signals
= arg
;
3071 if (inf
->task
&& inf
->want_signals
!= inf
->traced
)
3072 /* Make this take effect immediately in a running process. */
3073 inf_set_traced (inf
, inf
->want_signals
);
3077 set_signals_cmd (const char *args
, int from_tty
)
3079 set_signals_cmd(parse_bool_arg (args
, "set signals"), from_tty
);
3083 show_signals_cmd (const char *args
, int from_tty
)
3085 struct inf
*inf
= cur_inf ();
3087 check_empty (args
, "show signals");
3088 printf_unfiltered ("The inferior process's signals %s intercepted.\n",
3090 ? (inf
->traced
? "are" : "aren't")
3091 : (inf
->want_signals
? "will be" : "won't be"));
3095 set_exceptions_cmd (int arg
, int from_tty
)
3097 struct inf
*inf
= cur_inf ();
3099 /* Make this take effect immediately in a running process. */
3102 inf
->want_exceptions
= arg
;
3106 set_exceptions_cmd (const char *args
, int from_tty
)
3108 set_exceptions_cmd (parse_bool_arg (args
, "set exceptions"), from_tty
);
3112 show_exceptions_cmd (const char *args
, int from_tty
)
3114 struct inf
*inf
= cur_inf ();
3116 check_empty (args
, "show exceptions");
3117 printf_unfiltered ("Exceptions in the inferior %s trapped.\n",
3119 ? (inf
->want_exceptions
? "are" : "aren't")
3120 : (inf
->want_exceptions
? "will be" : "won't be"));
3125 set_task_cmd (const char *args
, int from_tty
)
3127 printf_unfiltered ("\"set task\" must be followed by the name"
3128 " of a task property.\n");
3132 show_task_cmd (const char *args
, int from_tty
)
3134 struct inf
*inf
= cur_inf ();
3136 check_empty (args
, "show task");
3138 show_signals_cmd (0, from_tty
);
3139 show_exceptions_cmd (0, from_tty
);
3140 show_task_pause_cmd (0, from_tty
);
3142 if (inf
->pause_sc
== 0)
3143 show_thread_default_pause_cmd (0, from_tty
);
3144 show_thread_default_run_cmd (0, from_tty
);
3148 show_stopped_cmd (0, from_tty
);
3149 show_sig_thread_cmd (0, from_tty
);
3152 if (inf
->detach_sc
!= 0)
3153 show_task_detach_sc_cmd (0, from_tty
);
3154 if (inf
->default_thread_detach_sc
!= 0)
3155 show_thread_default_detach_sc_cmd (0, from_tty
);
3160 set_noninvasive_cmd (const char *args
, int from_tty
)
3162 /* Invert the sense of the arg for each component. */
3163 int inv_arg
= parse_bool_arg (args
, "set noninvasive") ? 0 : 1;
3165 set_task_pause_cmd (inv_arg
, from_tty
);
3166 set_signals_cmd (inv_arg
, from_tty
);
3167 set_exceptions_cmd (inv_arg
, from_tty
);
3172 info_port_rights (const char *args
, mach_port_type_t only
)
3174 struct inf
*inf
= active_inf ();
3175 struct value
*vmark
= value_mark ();
3178 /* Explicit list of port rights. */
3182 struct value
*val
= parse_to_comma_and_eval (&args
);
3183 long right
= value_as_long (val
);
3185 print_port_info (right
, 0, inf
->task
->port
, PORTINFO_DETAILS
,
3189 error (_("%ld: %s."), right
, safe_strerror (err
));
3193 /* Print all of them. */
3196 print_task_ports_info (inf
->task
->port
, only
, PORTINFO_DETAILS
,
3199 error (_("%s."), safe_strerror (err
));
3202 value_free_to_mark (vmark
);
3206 info_send_rights_cmd (const char *args
, int from_tty
)
3208 info_port_rights (args
, MACH_PORT_TYPE_SEND
);
3212 info_recv_rights_cmd (const char *args
, int from_tty
)
3214 info_port_rights (args
, MACH_PORT_TYPE_RECEIVE
);
3218 info_port_sets_cmd (const char *args
, int from_tty
)
3220 info_port_rights (args
, MACH_PORT_TYPE_PORT_SET
);
3224 info_dead_names_cmd (const char *args
, int from_tty
)
3226 info_port_rights (args
, MACH_PORT_TYPE_DEAD_NAME
);
3230 info_port_rights_cmd (const char *args
, int from_tty
)
3232 info_port_rights (args
, ~0);
3237 add_task_commands (void)
3239 add_cmd ("pause", class_run
, set_thread_default_pause_cmd
, _("\
3240 Set whether the new threads are suspended while gdb has control.\n\
3241 This property normally has no effect because the whole task is\n\
3242 suspended, however, that may be disabled with \"set task pause off\".\n\
3243 The default value is \"off\"."),
3244 &set_thread_default_cmd_list
);
3245 add_cmd ("pause", no_class
, show_thread_default_pause_cmd
, _("\
3246 Show whether new threads are suspended while gdb has control."),
3247 &show_thread_default_cmd_list
);
3249 add_cmd ("run", class_run
, set_thread_default_run_cmd
, _("\
3250 Set whether new threads are allowed to run (once gdb has noticed them)."),
3251 &set_thread_default_cmd_list
);
3252 add_cmd ("run", no_class
, show_thread_default_run_cmd
, _("\
3253 Show whether new threads are allowed to run (once gdb has noticed them)."),
3254 &show_thread_default_cmd_list
);
3256 add_cmd ("detach-suspend-count", class_run
, set_thread_default_detach_sc_cmd
,
3257 _("Set the default detach-suspend-count value for new threads."),
3258 &set_thread_default_cmd_list
);
3259 add_cmd ("detach-suspend-count", no_class
, show_thread_default_detach_sc_cmd
,
3260 _("Show the default detach-suspend-count value for new threads."),
3261 &show_thread_default_cmd_list
);
3263 add_cmd ("signals", class_run
, set_signals_cmd
, _("\
3264 Set whether the inferior process's signals will be intercepted.\n\
3265 Mach exceptions (such as breakpoint traps) are not affected."),
3267 add_alias_cmd ("sigs", "signals", class_run
, 1, &setlist
);
3268 add_cmd ("signals", no_class
, show_signals_cmd
, _("\
3269 Show whether the inferior process's signals will be intercepted."),
3271 add_alias_cmd ("sigs", "signals", no_class
, 1, &showlist
);
3273 add_cmd ("signal-thread", class_run
, set_sig_thread_cmd
, _("\
3274 Set the thread that gdb thinks is the libc signal thread.\n\
3275 This thread is run when delivering a signal to a non-stopped process."),
3277 add_alias_cmd ("sigthread", "signal-thread", class_run
, 1, &setlist
);
3278 add_cmd ("signal-thread", no_class
, show_sig_thread_cmd
, _("\
3279 Set the thread that gdb thinks is the libc signal thread."),
3281 add_alias_cmd ("sigthread", "signal-thread", no_class
, 1, &showlist
);
3283 add_cmd ("stopped", class_run
, set_stopped_cmd
, _("\
3284 Set whether gdb thinks the inferior process is stopped as with SIGSTOP.\n\
3285 Stopped process will be continued by sending them a signal."),
3287 add_cmd ("stopped", no_class
, show_stopped_cmd
, _("\
3288 Show whether gdb thinks the inferior process is stopped as with SIGSTOP."),
3291 add_cmd ("exceptions", class_run
, set_exceptions_cmd
, _("\
3292 Set whether exceptions in the inferior process will be trapped.\n\
3293 When exceptions are turned off, neither breakpoints nor single-stepping\n\
3296 /* Allow `set exc' despite conflict with `set exception-port'. */
3297 add_alias_cmd ("exc", "exceptions", class_run
, 1, &setlist
);
3298 add_cmd ("exceptions", no_class
, show_exceptions_cmd
, _("\
3299 Show whether exceptions in the inferior process will be trapped."),
3302 add_prefix_cmd ("task", no_class
, set_task_cmd
,
3303 _("Command prefix for setting task attributes."),
3304 &set_task_cmd_list
, "set task ", 0, &setlist
);
3305 add_prefix_cmd ("task", no_class
, show_task_cmd
,
3306 _("Command prefix for showing task attributes."),
3307 &show_task_cmd_list
, "show task ", 0, &showlist
);
3309 add_cmd ("pause", class_run
, set_task_pause_cmd
, _("\
3310 Set whether the task is suspended while gdb has control.\n\
3311 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3312 until the next time the program is continued.\n\
3313 When setting this to \"off\", \"set thread default pause on\" can be\n\
3314 used to pause individual threads by default instead."),
3315 &set_task_cmd_list
);
3316 add_cmd ("pause", no_class
, show_task_pause_cmd
,
3317 _("Show whether the task is suspended while gdb has control."),
3318 &show_task_cmd_list
);
3320 add_cmd ("detach-suspend-count", class_run
, set_task_detach_sc_cmd
,
3321 _("Set the suspend count will leave on the thread when detaching."),
3322 &set_task_cmd_list
);
3323 add_cmd ("detach-suspend-count", no_class
, show_task_detach_sc_cmd
,
3324 _("Show the suspend count will leave "
3325 "on the thread when detaching."),
3326 &show_task_cmd_list
);
3328 add_cmd ("exception-port", no_class
, set_task_exc_port_cmd
, _("\
3329 Set the task exception port to which we forward exceptions.\n\
3330 The argument should be the value of the send right in the task."),
3331 &set_task_cmd_list
);
3332 add_alias_cmd ("excp", "exception-port", no_class
, 1, &set_task_cmd_list
);
3333 add_alias_cmd ("exc-port", "exception-port", no_class
, 1,
3334 &set_task_cmd_list
);
3336 /* A convenient way of turning on all options require to noninvasively
3337 debug running tasks. */
3338 add_cmd ("noninvasive", no_class
, set_noninvasive_cmd
, _("\
3339 Set task options so that we interfere as little as possible.\n\
3340 This is the same as setting `task pause', `exceptions', and\n\
3341 `signals' to the opposite value."),
3344 /* Commands to show information about the task's ports. */
3345 add_info ("send-rights", info_send_rights_cmd
,
3346 _("Show information about the task's send rights"));
3347 add_info ("receive-rights", info_recv_rights_cmd
,
3348 _("Show information about the task's receive rights"));
3349 add_info ("port-rights", info_port_rights_cmd
,
3350 _("Show information about the task's port rights"));
3351 add_info ("port-sets", info_port_sets_cmd
,
3352 _("Show information about the task's port sets"));
3353 add_info ("dead-names", info_dead_names_cmd
,
3354 _("Show information about the task's dead names"));
3355 add_info_alias ("ports", "port-rights", 1);
3356 add_info_alias ("port", "port-rights", 1);
3357 add_info_alias ("psets", "port-sets", 1);
3362 set_thread_pause_cmd (const char *args
, int from_tty
)
3364 struct proc
*thread
= cur_thread ();
3365 int old_sc
= thread
->pause_sc
;
3367 thread
->pause_sc
= parse_bool_arg (args
, "set thread pause");
3368 if (old_sc
== 0 && thread
->pause_sc
!= 0 && thread
->inf
->pause_sc
== 0)
3369 /* If the task is currently unsuspended, immediately suspend it,
3370 otherwise wait until the next time it gets control. */
3371 inf_suspend (thread
->inf
);
3375 show_thread_pause_cmd (const char *args
, int from_tty
)
3377 struct proc
*thread
= cur_thread ();
3378 int sc
= thread
->pause_sc
;
3380 check_empty (args
, "show task pause");
3381 printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n",
3382 proc_string (thread
),
3383 sc
? "is" : "isn't",
3384 !sc
&& thread
->inf
->pause_sc
? " (but the task is)" : "");
3388 set_thread_run_cmd (const char *args
, int from_tty
)
3390 struct proc
*thread
= cur_thread ();
3392 thread
->run_sc
= parse_bool_arg (args
, "set thread run") ? 0 : 1;
3396 show_thread_run_cmd (const char *args
, int from_tty
)
3398 struct proc
*thread
= cur_thread ();
3400 check_empty (args
, "show thread run");
3401 printf_unfiltered ("Thread %s %s allowed to run.",
3402 proc_string (thread
),
3403 thread
->run_sc
== 0 ? "is" : "isn't");
3407 set_thread_detach_sc_cmd (const char *args
, int from_tty
)
3409 cur_thread ()->detach_sc
= parse_int_arg (args
,
3410 "set thread detach-suspend-count");
3414 show_thread_detach_sc_cmd (const char *args
, int from_tty
)
3416 struct proc
*thread
= cur_thread ();
3418 check_empty (args
, "show thread detach-suspend-count");
3419 printf_unfiltered ("Thread %s will be left with a suspend count"
3420 " of %d when detaching.\n",
3421 proc_string (thread
),
3426 set_thread_exc_port_cmd (const char *args
, int from_tty
)
3428 struct proc
*thread
= cur_thread ();
3431 error (_("No argument to \"set thread exception-port\" command."));
3432 steal_exc_port (thread
, parse_and_eval_address (args
));
3437 show_thread_cmd (char *args
, int from_tty
)
3439 struct proc
*thread
= cur_thread ();
3441 check_empty (args
, "show thread");
3442 show_thread_run_cmd (0, from_tty
);
3443 show_thread_pause_cmd (0, from_tty
);
3444 if (thread
->detach_sc
!= 0)
3445 show_thread_detach_sc_cmd (0, from_tty
);
3450 thread_takeover_sc_cmd (const char *args
, int from_tty
)
3452 struct proc
*thread
= cur_thread ();
3454 thread_basic_info_data_t _info
;
3455 thread_basic_info_t info
= &_info
;
3456 mach_msg_type_number_t info_len
= THREAD_BASIC_INFO_COUNT
;
3458 thread_info (thread
->port
, THREAD_BASIC_INFO
, (int *) &info
, &info_len
);
3460 error (("%s."), safe_strerror (err
));
3461 thread
->sc
= info
->suspend_count
;
3463 printf_unfiltered ("Suspend count was %d.\n", thread
->sc
);
3465 vm_deallocate (mach_task_self (), (vm_address_t
) info
,
3466 info_len
* sizeof (int));
3471 add_thread_commands (void)
3473 add_prefix_cmd ("thread", no_class
, set_thread_cmd
,
3474 _("Command prefix for setting thread properties."),
3475 &set_thread_cmd_list
, "set thread ", 0, &setlist
);
3476 add_prefix_cmd ("default", no_class
, show_thread_cmd
,
3477 _("Command prefix for setting default thread properties."),
3478 &set_thread_default_cmd_list
, "set thread default ", 0,
3479 &set_thread_cmd_list
);
3480 add_prefix_cmd ("thread", no_class
, set_thread_default_cmd
,
3481 _("Command prefix for showing thread properties."),
3482 &show_thread_cmd_list
, "show thread ", 0, &showlist
);
3483 add_prefix_cmd ("default", no_class
, show_thread_default_cmd
,
3484 _("Command prefix for showing default thread properties."),
3485 &show_thread_default_cmd_list
, "show thread default ", 0,
3486 &show_thread_cmd_list
);
3488 add_cmd ("pause", class_run
, set_thread_pause_cmd
, _("\
3489 Set whether the current thread is suspended while gdb has control.\n\
3490 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3491 until the next time the program is continued. This property normally\n\
3492 has no effect because the whole task is suspended, however, that may\n\
3493 be disabled with \"set task pause off\".\n\
3494 The default value is \"off\"."),
3495 &set_thread_cmd_list
);
3496 add_cmd ("pause", no_class
, show_thread_pause_cmd
, _("\
3497 Show whether the current thread is suspended while gdb has control."),
3498 &show_thread_cmd_list
);
3500 add_cmd ("run", class_run
, set_thread_run_cmd
,
3501 _("Set whether the current thread is allowed to run."),
3502 &set_thread_cmd_list
);
3503 add_cmd ("run", no_class
, show_thread_run_cmd
,
3504 _("Show whether the current thread is allowed to run."),
3505 &show_thread_cmd_list
);
3507 add_cmd ("detach-suspend-count", class_run
, set_thread_detach_sc_cmd
, _("\
3508 Set the suspend count will leave on the thread when detaching.\n\
3509 Note that this is relative to suspend count when gdb noticed the thread;\n\
3510 use the `thread takeover-suspend-count' to force it to an absolute value."),
3511 &set_thread_cmd_list
);
3512 add_cmd ("detach-suspend-count", no_class
, show_thread_detach_sc_cmd
, _("\
3513 Show the suspend count will leave on the thread when detaching.\n\
3514 Note that this is relative to suspend count when gdb noticed the thread;\n\
3515 use the `thread takeover-suspend-count' to force it to an absolute value."),
3516 &show_thread_cmd_list
);
3518 add_cmd ("exception-port", no_class
, set_thread_exc_port_cmd
, _("\
3519 Set the thread exception port to which we forward exceptions.\n\
3520 This overrides the task exception port.\n\
3521 The argument should be the value of the send right in the task."),
3522 &set_thread_cmd_list
);
3523 add_alias_cmd ("excp", "exception-port", no_class
, 1, &set_thread_cmd_list
);
3524 add_alias_cmd ("exc-port", "exception-port", no_class
, 1,
3525 &set_thread_cmd_list
);
3527 add_cmd ("takeover-suspend-count", no_class
, thread_takeover_sc_cmd
, _("\
3528 Force the threads absolute suspend-count to be gdb's.\n\
3529 Prior to giving this command, gdb's thread suspend-counts are relative\n\
3530 to the thread's initial suspend-count when gdb notices the threads."),
3535 _initialize_gnu_nat (void)
3537 proc_server
= getproc ();
3539 add_task_commands ();
3540 add_thread_commands ();
3541 add_setshow_boolean_cmd ("gnu-nat", class_maintenance
,
3543 _("Set debugging output for the gnu backend."),
3544 _("Show debugging output for the gnu backend."),
3552 #ifdef FLUSH_INFERIOR_CACHE
3554 /* When over-writing code on some machines the I-Cache must be flushed
3555 explicitly, because it is not kept coherent by the lazy hardware.
3556 This definitely includes breakpoints, for instance, or else we
3557 end up looping in mysterious Bpt traps. */
3560 flush_inferior_icache (CORE_ADDR pc
, int amount
)
3562 vm_machine_attribute_val_t flush
= MATTR_VAL_ICACHE_FLUSH
;
3565 ret
= vm_machine_attribute (gnu_current_inf
->task
->port
,
3570 if (ret
!= KERN_SUCCESS
)
3571 warning (_("Error flushing inferior's cache : %s"), safe_strerror (ret
));
3573 #endif /* FLUSH_INFERIOR_CACHE */