1 /* Interface GDB to the GNU Hurd.
2 Copyright (C) 1992-2016 Free Software Foundation, Inc.
4 This file is part of GDB.
6 Written by Miles Bader <miles@gnu.ai.mit.edu>
8 Some code and ideas from m3-nat.c by Jukka Virtanen <jtv@hut.fi>
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
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>
64 #include "gdbthread.h"
65 #include "gdb_obstack.h"
68 #include "inf-child.h"
70 /* MIG stubs are not yet ready for C++ compilation. */
73 #include "exc_request_S.h"
75 #include "process_reply_S.h"
76 #include "msg_reply_S.h"
77 #include "exc_request_U.h"
81 static process_t proc_server
= MACH_PORT_NULL
;
83 /* If we've sent a proc_wait_request to the proc server, the pid of the
84 process we asked about. We can only ever have one outstanding. */
85 int proc_wait_pid
= 0;
87 /* The number of wait requests we've sent, and expect replies from. */
88 int proc_waits_pending
= 0;
90 int gnu_debug_flag
= 0;
94 static struct inf
*make_inf ();
95 void inf_clear_wait (struct inf
*inf
);
96 void inf_cleanup (struct inf
*inf
);
97 void inf_startup (struct inf
*inf
, int pid
);
98 int inf_update_suspends (struct inf
*inf
);
99 void inf_set_pid (struct inf
*inf
, pid_t pid
);
100 void inf_validate_procs (struct inf
*inf
);
101 void inf_steal_exc_ports (struct inf
*inf
);
102 void inf_restore_exc_ports (struct inf
*inf
);
103 void inf_set_threads_resume_sc (struct inf
*inf
,
104 struct proc
*run_thread
,
106 int inf_set_threads_resume_sc_for_signal_thread (struct inf
*inf
);
107 void inf_suspend (struct inf
*inf
);
108 void inf_resume (struct inf
*inf
);
109 void inf_set_step_thread (struct inf
*inf
, struct proc
*proc
);
110 void inf_detach (struct inf
*inf
);
111 void inf_attach (struct inf
*inf
, int pid
);
112 void inf_signal (struct inf
*inf
, enum gdb_signal sig
);
113 void inf_continue (struct inf
*inf
);
115 #define inf_debug(_inf, msg, args...) \
116 do { struct inf *__inf = (_inf); \
117 debug ("{inf %d %s}: " msg, __inf->pid, \
118 host_address_to_string (__inf) , ##args); } while (0)
120 void proc_abort (struct proc
*proc
, int force
);
121 struct proc
*make_proc (struct inf
*inf
, mach_port_t port
, int tid
);
122 struct proc
*_proc_free (struct proc
*proc
);
123 int proc_update_sc (struct proc
*proc
);
124 kern_return_t
proc_get_exception_port (struct proc
*proc
, mach_port_t
* port
);
125 kern_return_t
proc_set_exception_port (struct proc
*proc
, mach_port_t port
);
126 static mach_port_t
_proc_get_exc_port (struct proc
*proc
);
127 void proc_steal_exc_port (struct proc
*proc
, mach_port_t exc_port
);
128 void proc_restore_exc_port (struct proc
*proc
);
129 int proc_trace (struct proc
*proc
, int set
);
131 /* Evaluate RPC_EXPR in a scope with the variables MSGPORT and REFPORT bound
132 to INF's msg port and task port respectively. If it has no msg port,
133 EIEIO is returned. INF must refer to a running process! */
134 #define INF_MSGPORT_RPC(inf, rpc_expr) \
135 HURD_MSGPORT_RPC (proc_getmsgport (proc_server, inf->pid, &msgport), \
136 (refport = inf->task->port, 0), 0, \
137 msgport ? (rpc_expr) : EIEIO)
139 /* Like INF_MSGPORT_RPC, but will also resume the signal thread to ensure
140 there's someone around to deal with the RPC (and resuspend things
141 afterwards). This effects INF's threads' resume_sc count. */
142 #define INF_RESUME_MSGPORT_RPC(inf, rpc_expr) \
143 (inf_set_threads_resume_sc_for_signal_thread (inf) \
144 ? ({ kern_return_t __e; \
146 __e = INF_MSGPORT_RPC (inf, rpc_expr); \
152 /* The state passed by an exception message. */
155 int exception
; /* The exception code. */
157 mach_port_t handler
; /* The real exception port to handle this. */
158 mach_port_t reply
; /* The reply port from the exception call. */
161 /* The results of the last wait an inf did. */
164 struct target_waitstatus status
; /* The status returned to gdb. */
165 struct exc_state exc
; /* The exception that caused us to return. */
166 struct proc
*thread
; /* The thread in question. */
167 int suppress
; /* Something trivial happened. */
170 /* The state of an inferior. */
173 /* Fields describing the current inferior. */
175 struct proc
*task
; /* The mach task. */
176 struct proc
*threads
; /* A linked list of all threads in TASK. */
178 /* True if THREADS needn't be validated by querying the task. We
179 assume that we and the task in question are the only ones
180 frobbing the thread list, so as long as we don't let any code
181 run, we don't have to worry about THREADS changing. */
182 int threads_up_to_date
;
184 pid_t pid
; /* The real system PID. */
186 struct inf_wait wait
; /* What to return from target_wait. */
188 /* One thread proc in INF may be in `single-stepping mode'. This
190 struct proc
*step_thread
;
192 /* The thread we think is the signal thread. */
193 struct proc
*signal_thread
;
195 mach_port_t event_port
; /* Where we receive various msgs. */
197 /* True if we think at least one thread in the inferior could currently be
199 unsigned int running
:1;
201 /* True if the process has stopped (in the proc server sense). Note that
202 since a proc server `stop' leaves the signal thread running, the inf can
203 be RUNNING && STOPPED... */
204 unsigned int stopped
:1;
206 /* True if the inferior has no message port. */
207 unsigned int nomsg
:1;
209 /* True if the inferior is traced. */
210 unsigned int traced
:1;
212 /* True if we shouldn't try waiting for the inferior, usually because we
213 can't for some reason. */
214 unsigned int no_wait
:1;
216 /* When starting a new inferior, we don't try to validate threads until all
217 the proper execs have been done, which this flag states we still
219 unsigned int pending_execs
:1;
221 /* Fields describing global state. */
223 /* The task suspend count used when gdb has control. This is normally 1 to
224 make things easier for us, but sometimes (like when attaching to vital
225 system servers) it may be desirable to let the task continue to run
226 (pausing individual threads as necessary). */
229 /* The task suspend count left when detaching from a task. */
232 /* The initial values used for the run_sc and pause_sc of newly discovered
233 threads -- see the definition of those fields in struct proc. */
234 int default_thread_run_sc
;
235 int default_thread_pause_sc
;
236 int default_thread_detach_sc
;
238 /* True if the process should be traced when started/attached. Newly
239 started processes *must* be traced at first to exec them properly, but
240 if this is false, tracing is turned off as soon it has done so. */
243 /* True if exceptions from the inferior process should be trapped. This
244 must be on to use breakpoints. */
250 __proc_pid (struct proc
*proc
)
252 return proc
->inf
->pid
;
256 /* Update PROC's real suspend count to match it's desired one. Returns true
257 if we think PROC is now in a runnable state. */
259 proc_update_sc (struct proc
*proc
)
263 int delta
= proc
->sc
- proc
->cur_sc
;
266 proc_debug (proc
, "sc: %d --> %d", proc
->cur_sc
, proc
->sc
);
268 if (proc
->sc
== 0 && proc
->state_changed
)
269 /* Since PROC may start running, we must write back any state changes. */
271 gdb_assert (proc_is_thread (proc
));
272 proc_debug (proc
, "storing back changed thread state");
273 err
= thread_set_state (proc
->port
, THREAD_STATE_FLAVOR
,
274 (thread_state_t
) &proc
->state
, THREAD_STATE_SIZE
);
276 proc
->state_changed
= 0;
281 while (delta
-- > 0 && !err
)
283 if (proc_is_task (proc
))
284 err
= task_suspend (proc
->port
);
286 err
= thread_suspend (proc
->port
);
291 while (delta
++ < 0 && !err
)
293 if (proc_is_task (proc
))
294 err
= task_resume (proc
->port
);
296 err
= thread_resume (proc
->port
);
300 proc
->cur_sc
= proc
->sc
;
302 /* If we got an error, then the task/thread has disappeared. */
303 running
= !err
&& proc
->sc
== 0;
305 proc_debug (proc
, "is %s", err
? "dead" : running
? "running" : "suspended");
307 proc_debug (proc
, "err = %s", safe_strerror (err
));
312 proc
->state_valid
= proc
->state_changed
= 0;
313 proc
->fetched_regs
= 0;
320 /* Thread_abort is called on PROC if needed. PROC must be a thread proc.
321 If PROC is deemed `precious', then nothing is done unless FORCE is true.
322 In particular, a thread is precious if it's running (in which case forcing
323 it includes suspending it first), or if it has an exception pending. */
325 proc_abort (struct proc
*proc
, int force
)
327 gdb_assert (proc_is_thread (proc
));
331 struct inf
*inf
= proc
->inf
;
332 int running
= (proc
->cur_sc
== 0 && inf
->task
->cur_sc
== 0);
334 if (running
&& force
)
337 inf_update_suspends (proc
->inf
);
339 warning (_("Stopped %s."), proc_string (proc
));
341 else if (proc
== inf
->wait
.thread
&& inf
->wait
.exc
.reply
&& !force
)
342 /* An exception is pending on PROC, which don't mess with. */
346 /* We only abort the thread if it's not actually running. */
348 thread_abort (proc
->port
);
349 proc_debug (proc
, "aborted");
353 proc_debug (proc
, "not aborting");
357 /* Make sure that the state field in PROC is up to date, and return a pointer
358 to it, or 0 if something is wrong. If WILL_MODIFY is true, makes sure
359 that the thread is stopped and aborted first, and sets the state_changed
360 field in PROC to true. */
362 proc_get_state (struct proc
*proc
, int will_modify
)
364 int was_aborted
= proc
->aborted
;
366 proc_debug (proc
, "updating state info%s",
367 will_modify
? " (with intention to modify)" : "");
369 proc_abort (proc
, will_modify
);
371 if (!was_aborted
&& proc
->aborted
)
372 /* PROC's state may have changed since we last fetched it. */
373 proc
->state_valid
= 0;
375 if (!proc
->state_valid
)
377 mach_msg_type_number_t state_size
= THREAD_STATE_SIZE
;
379 thread_get_state (proc
->port
, THREAD_STATE_FLAVOR
,
380 (thread_state_t
) &proc
->state
, &state_size
);
382 proc_debug (proc
, "getting thread state");
383 proc
->state_valid
= !err
;
386 if (proc
->state_valid
)
389 proc
->state_changed
= 1;
390 return (thread_state_t
) &proc
->state
;
397 /* Set PORT to PROC's exception port. */
399 proc_get_exception_port (struct proc
* proc
, mach_port_t
* port
)
401 if (proc_is_task (proc
))
402 return task_get_exception_port (proc
->port
, port
);
404 return thread_get_exception_port (proc
->port
, port
);
407 /* Set PROC's exception port to PORT. */
409 proc_set_exception_port (struct proc
* proc
, mach_port_t port
)
411 proc_debug (proc
, "setting exception port: %lu", port
);
412 if (proc_is_task (proc
))
413 return task_set_exception_port (proc
->port
, port
);
415 return thread_set_exception_port (proc
->port
, port
);
418 /* Get PROC's exception port, cleaning up a bit if proc has died. */
420 _proc_get_exc_port (struct proc
*proc
)
422 mach_port_t exc_port
;
423 kern_return_t err
= proc_get_exception_port (proc
, &exc_port
);
426 /* PROC must be dead. */
429 mach_port_deallocate (mach_task_self (), proc
->exc_port
);
430 proc
->exc_port
= MACH_PORT_NULL
;
431 if (proc
->saved_exc_port
)
432 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
433 proc
->saved_exc_port
= MACH_PORT_NULL
;
439 /* Replace PROC's exception port with EXC_PORT, unless it's already
440 been done. Stash away any existing exception port so we can
443 proc_steal_exc_port (struct proc
*proc
, mach_port_t exc_port
)
445 mach_port_t cur_exc_port
= _proc_get_exc_port (proc
);
449 kern_return_t err
= 0;
451 proc_debug (proc
, "inserting exception port: %lu", exc_port
);
453 if (cur_exc_port
!= exc_port
)
454 /* Put in our exception port. */
455 err
= proc_set_exception_port (proc
, exc_port
);
457 if (err
|| cur_exc_port
== proc
->exc_port
)
458 /* We previously set the exception port, and it's still set. So we
459 just keep the old saved port which is what the proc set. */
462 mach_port_deallocate (mach_task_self (), cur_exc_port
);
465 /* Keep a copy of PROC's old exception port so it can be restored. */
467 if (proc
->saved_exc_port
)
468 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
469 proc
->saved_exc_port
= cur_exc_port
;
472 proc_debug (proc
, "saved exception port: %lu", proc
->saved_exc_port
);
475 proc
->exc_port
= exc_port
;
477 warning (_("Error setting exception port for %s: %s"),
478 proc_string (proc
), safe_strerror (err
));
482 /* If we previously replaced PROC's exception port, put back what we
483 found there at the time, unless *our* exception port has since been
484 overwritten, in which case who knows what's going on. */
486 proc_restore_exc_port (struct proc
*proc
)
488 mach_port_t cur_exc_port
= _proc_get_exc_port (proc
);
492 kern_return_t err
= 0;
494 proc_debug (proc
, "restoring real exception port");
496 if (proc
->exc_port
== cur_exc_port
)
497 /* Our's is still there. */
498 err
= proc_set_exception_port (proc
, proc
->saved_exc_port
);
500 if (proc
->saved_exc_port
)
501 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
502 proc
->saved_exc_port
= MACH_PORT_NULL
;
505 proc
->exc_port
= MACH_PORT_NULL
;
507 warning (_("Error setting exception port for %s: %s"),
508 proc_string (proc
), safe_strerror (err
));
513 /* Turns hardware tracing in PROC on or off when SET is true or false,
514 respectively. Returns true on success. */
516 proc_trace (struct proc
*proc
, int set
)
518 thread_state_t state
= proc_get_state (proc
, 1);
521 return 0; /* The thread must be dead. */
523 proc_debug (proc
, "tracing %s", set
? "on" : "off");
527 /* XXX We don't get the exception unless the thread has its own
528 exception port???? */
529 if (proc
->exc_port
== MACH_PORT_NULL
)
530 proc_steal_exc_port (proc
, proc
->inf
->event_port
);
531 THREAD_STATE_SET_TRACED (state
);
534 THREAD_STATE_CLEAR_TRACED (state
);
540 /* A variable from which to assign new TIDs. */
541 static int next_thread_id
= 1;
543 /* Returns a new proc structure with the given fields. Also adds a
544 notification for PORT becoming dead to be sent to INF's notify port. */
546 make_proc (struct inf
*inf
, mach_port_t port
, int tid
)
549 mach_port_t prev_port
= MACH_PORT_NULL
;
550 struct proc
*proc
= XNEW (struct proc
);
556 proc
->saved_exc_port
= MACH_PORT_NULL
;
557 proc
->exc_port
= MACH_PORT_NULL
;
562 /* Note that these are all the values for threads; the task simply uses the
563 corresponding field in INF directly. */
564 proc
->run_sc
= inf
->default_thread_run_sc
;
565 proc
->pause_sc
= inf
->default_thread_pause_sc
;
566 proc
->detach_sc
= inf
->default_thread_detach_sc
;
567 proc
->resume_sc
= proc
->run_sc
;
571 proc
->state_valid
= 0;
572 proc
->state_changed
= 0;
574 proc_debug (proc
, "is new");
576 /* Get notified when things die. */
578 mach_port_request_notification (mach_task_self (), port
,
579 MACH_NOTIFY_DEAD_NAME
, 1,
581 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
584 warning (_("Couldn't request notification for port %lu: %s"),
585 port
, safe_strerror (err
));
588 proc_debug (proc
, "notifications to: %lu", inf
->event_port
);
589 if (prev_port
!= MACH_PORT_NULL
)
590 mach_port_deallocate (mach_task_self (), prev_port
);
593 if (inf
->want_exceptions
)
595 if (proc_is_task (proc
))
596 /* Make the task exception port point to us. */
597 proc_steal_exc_port (proc
, inf
->event_port
);
599 /* Just clear thread exception ports -- they default to the
601 proc_steal_exc_port (proc
, MACH_PORT_NULL
);
607 /* Frees PROC and any resources it uses, and returns the value of PROC's
610 _proc_free (struct proc
*proc
)
612 struct inf
*inf
= proc
->inf
;
613 struct proc
*next
= proc
->next
;
615 proc_debug (proc
, "freeing...");
617 if (proc
== inf
->step_thread
)
618 /* Turn off single stepping. */
619 inf_set_step_thread (inf
, 0);
620 if (proc
== inf
->wait
.thread
)
621 inf_clear_wait (inf
);
622 if (proc
== inf
->signal_thread
)
623 inf
->signal_thread
= 0;
625 if (proc
->port
!= MACH_PORT_NULL
)
627 if (proc
->exc_port
!= MACH_PORT_NULL
)
628 /* Restore the original exception port. */
629 proc_restore_exc_port (proc
);
630 if (proc
->cur_sc
!= 0)
631 /* Resume the thread/task. */
634 proc_update_sc (proc
);
636 mach_port_deallocate (mach_task_self (), proc
->port
);
647 struct inf
*inf
= XNEW (struct inf
);
651 inf
->threads_up_to_date
= 0;
653 inf
->wait
.status
.kind
= TARGET_WAITKIND_SPURIOUS
;
654 inf
->wait
.thread
= 0;
655 inf
->wait
.exc
.handler
= MACH_PORT_NULL
;
656 inf
->wait
.exc
.reply
= MACH_PORT_NULL
;
657 inf
->step_thread
= 0;
658 inf
->signal_thread
= 0;
659 inf
->event_port
= MACH_PORT_NULL
;
665 inf
->pending_execs
= 0;
668 inf
->default_thread_run_sc
= 0;
669 inf
->default_thread_pause_sc
= 0;
670 inf
->default_thread_detach_sc
= 0;
671 inf
->want_signals
= 1; /* By default */
672 inf
->want_exceptions
= 1; /* By default */
677 /* Clear INF's target wait status. */
679 inf_clear_wait (struct inf
*inf
)
681 inf_debug (inf
, "clearing wait");
682 inf
->wait
.status
.kind
= TARGET_WAITKIND_SPURIOUS
;
683 inf
->wait
.thread
= 0;
684 inf
->wait
.suppress
= 0;
685 if (inf
->wait
.exc
.handler
!= MACH_PORT_NULL
)
687 mach_port_deallocate (mach_task_self (), inf
->wait
.exc
.handler
);
688 inf
->wait
.exc
.handler
= MACH_PORT_NULL
;
690 if (inf
->wait
.exc
.reply
!= MACH_PORT_NULL
)
692 mach_port_deallocate (mach_task_self (), inf
->wait
.exc
.reply
);
693 inf
->wait
.exc
.reply
= MACH_PORT_NULL
;
699 inf_cleanup (struct inf
*inf
)
701 inf_debug (inf
, "cleanup");
703 inf_clear_wait (inf
);
705 inf_set_pid (inf
, -1);
712 inf
->pending_execs
= 0;
716 mach_port_destroy (mach_task_self (), inf
->event_port
);
717 inf
->event_port
= MACH_PORT_NULL
;
722 inf_startup (struct inf
*inf
, int pid
)
726 inf_debug (inf
, "startup: pid = %d", pid
);
730 /* Make the port on which we receive all events. */
731 err
= mach_port_allocate (mach_task_self (),
732 MACH_PORT_RIGHT_RECEIVE
, &inf
->event_port
);
734 error (_("Error allocating event port: %s"), safe_strerror (err
));
736 /* Make a send right for it, so we can easily copy it for other people. */
737 mach_port_insert_right (mach_task_self (), inf
->event_port
,
738 inf
->event_port
, MACH_MSG_TYPE_MAKE_SEND
);
739 inf_set_pid (inf
, pid
);
743 /* Close current process, if any, and attach INF to process PORT. */
745 inf_set_pid (struct inf
*inf
, pid_t pid
)
748 struct proc
*task
= inf
->task
;
750 inf_debug (inf
, "setting pid: %d", pid
);
753 task_port
= MACH_PORT_NULL
;
756 kern_return_t err
= proc_pid2task (proc_server
, pid
, &task_port
);
759 error (_("Error getting task for pid %d: %s"),
760 pid
, safe_strerror (err
));
763 inf_debug (inf
, "setting task: %lu", task_port
);
766 task_suspend (task_port
);
768 if (task
&& task
->port
!= task_port
)
771 inf_validate_procs (inf
); /* Trash all the threads. */
772 _proc_free (task
); /* And the task. */
775 if (task_port
!= MACH_PORT_NULL
)
777 inf
->task
= make_proc (inf
, task_port
, PROC_TID_TASK
);
778 inf
->threads_up_to_date
= 0;
785 /* Reflect task_suspend above. */
786 inf
->task
->sc
= inf
->task
->cur_sc
= 1;
793 /* Validates INF's stopped, nomsg and traced field from the actual
794 proc server state. Note that the traced field is only updated from
795 the proc server state if we do not have a message port. If we do
796 have a message port we'd better look at the tracemask itself. */
798 inf_validate_procinfo (struct inf
*inf
)
801 mach_msg_type_number_t noise_len
= 0;
803 mach_msg_type_number_t pi_len
= 0;
806 proc_getprocinfo (proc_server
, inf
->pid
, &info_flags
,
807 (procinfo_t
*) &pi
, &pi_len
, &noise
, &noise_len
);
811 inf
->stopped
= !!(pi
->state
& PI_STOPPED
);
812 inf
->nomsg
= !!(pi
->state
& PI_NOMSG
);
814 inf
->traced
= !!(pi
->state
& PI_TRACED
);
815 vm_deallocate (mach_task_self (), (vm_address_t
) pi
,
816 pi_len
* sizeof (*(procinfo_t
) 0));
818 vm_deallocate (mach_task_self (), (vm_address_t
) noise
, noise_len
);
822 /* Validates INF's task suspend count. If it's higher than we expect,
823 verify with the user before `stealing' the extra count. */
825 inf_validate_task_sc (struct inf
*inf
)
828 mach_msg_type_number_t noise_len
= 0;
830 mach_msg_type_number_t pi_len
= 0;
831 int info_flags
= PI_FETCH_TASKINFO
;
832 int suspend_count
= -1;
836 err
= proc_getprocinfo (proc_server
, inf
->pid
, &info_flags
,
837 (procinfo_t
*) &pi
, &pi_len
, &noise
, &noise_len
);
840 inf
->task
->dead
= 1; /* oh well */
844 if (inf
->task
->cur_sc
< pi
->taskinfo
.suspend_count
&& suspend_count
== -1)
846 /* The proc server might have suspended the task while stopping
847 it. This happens when the task is handling a traced signal.
848 Refetch the suspend count. The proc server should be
849 finished stopping the task by now. */
850 suspend_count
= pi
->taskinfo
.suspend_count
;
854 suspend_count
= pi
->taskinfo
.suspend_count
;
856 vm_deallocate (mach_task_self (), (vm_address_t
) pi
,
857 pi_len
* sizeof (*(procinfo_t
) 0));
859 vm_deallocate (mach_task_self (), (vm_address_t
) noise
, noise_len
);
861 if (inf
->task
->cur_sc
< suspend_count
)
863 if (!query (_("Pid %d has an additional task suspend count of %d;"
864 " clear it? "), inf
->pid
,
865 suspend_count
- inf
->task
->cur_sc
))
866 error (_("Additional task suspend count left untouched."));
868 inf
->task
->cur_sc
= suspend_count
;
872 /* Turns tracing for INF on or off, depending on ON, unless it already
873 is. If INF is running, the resume_sc count of INF's threads will
874 be modified, and the signal thread will briefly be run to change
877 inf_set_traced (struct inf
*inf
, int on
)
879 if (on
== inf
->traced
)
882 if (inf
->task
&& !inf
->task
->dead
)
883 /* Make it take effect immediately. */
885 sigset_t mask
= on
? ~(sigset_t
) 0 : 0;
887 INF_RESUME_MSGPORT_RPC (inf
, msg_set_init_int (msgport
, refport
,
888 INIT_TRACEMASK
, mask
));
893 warning (_("Can't modify tracing state for pid %d: %s"),
894 inf
->pid
, "No signal thread");
898 warning (_("Can't modify tracing state for pid %d: %s"),
899 inf
->pid
, safe_strerror (err
));
908 /* Makes all the real suspend count deltas of all the procs in INF
909 match the desired values. Careful to always do thread/task suspend
910 counts in the safe order. Returns true if at least one thread is
911 thought to be running. */
913 inf_update_suspends (struct inf
*inf
)
915 struct proc
*task
= inf
->task
;
917 /* We don't have to update INF->threads even though we're iterating over it
918 because we'll change a thread only if it already has an existing proc
920 inf_debug (inf
, "updating suspend counts");
925 int task_running
= (task
->sc
== 0), thread_running
= 0;
927 if (task
->sc
> task
->cur_sc
)
928 /* The task is becoming _more_ suspended; do before any threads. */
929 task_running
= proc_update_sc (task
);
931 if (inf
->pending_execs
)
932 /* When we're waiting for an exec, things may be happening behind our
933 back, so be conservative. */
936 /* Do all the thread suspend counts. */
937 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
938 thread_running
|= proc_update_sc (thread
);
940 if (task
->sc
!= task
->cur_sc
)
941 /* We didn't do the task first, because we wanted to wait for the
942 threads; do it now. */
943 task_running
= proc_update_sc (task
);
945 inf_debug (inf
, "%srunning...",
946 (thread_running
&& task_running
) ? "" : "not ");
948 inf
->running
= thread_running
&& task_running
;
950 /* Once any thread has executed some code, we can't depend on the
951 threads list any more. */
953 inf
->threads_up_to_date
= 0;
962 /* Converts a GDB pid to a struct proc. */
964 inf_tid_to_thread (struct inf
*inf
, int tid
)
966 struct proc
*thread
= inf
->threads
;
969 if (thread
->tid
== tid
)
972 thread
= thread
->next
;
976 /* Converts a thread port to a struct proc. */
978 inf_port_to_thread (struct inf
*inf
, mach_port_t port
)
980 struct proc
*thread
= inf
->threads
;
983 if (thread
->port
== port
)
986 thread
= thread
->next
;
993 inf_threads (struct inf
*inf
, inf_threads_ftype
*f
, void *arg
)
997 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1002 /* Make INF's list of threads be consistent with reality of TASK. */
1004 inf_validate_procs (struct inf
*inf
)
1006 thread_array_t threads
;
1007 mach_msg_type_number_t num_threads
, i
;
1008 struct proc
*task
= inf
->task
;
1010 /* If no threads are currently running, this function will guarantee that
1011 things are up to date. The exception is if there are zero threads --
1012 then it is almost certainly in an odd state, and probably some outside
1013 agent will create threads. */
1014 inf
->threads_up_to_date
= inf
->threads
? !inf
->running
: 0;
1018 kern_return_t err
= task_threads (task
->port
, &threads
, &num_threads
);
1020 inf_debug (inf
, "fetching threads");
1022 /* TASK must be dead. */
1032 inf_debug (inf
, "no task");
1036 /* Make things normally linear. */
1037 mach_msg_type_number_t search_start
= 0;
1038 /* Which thread in PROCS corresponds to each task thread, & the task. */
1039 struct proc
*matched
[num_threads
+ 1];
1040 /* The last thread in INF->threads, so we can add to the end. */
1041 struct proc
*last
= 0;
1042 /* The current thread we're considering. */
1043 struct proc
*thread
= inf
->threads
;
1045 memset (matched
, 0, sizeof (matched
));
1049 mach_msg_type_number_t left
;
1051 for (i
= search_start
, left
= num_threads
; left
; i
++, left
--)
1053 if (i
>= num_threads
)
1054 i
-= num_threads
; /* I wrapped around. */
1055 if (thread
->port
== threads
[i
])
1056 /* We already know about this thread. */
1058 matched
[i
] = thread
;
1060 thread
= thread
->next
;
1068 proc_debug (thread
, "died!");
1069 thread
->port
= MACH_PORT_NULL
;
1070 thread
= _proc_free (thread
); /* THREAD is dead. */
1072 last
->next
= thread
;
1074 inf
->threads
= thread
;
1078 for (i
= 0; i
< num_threads
; i
++)
1081 /* Throw away the duplicate send right. */
1082 mach_port_deallocate (mach_task_self (), threads
[i
]);
1084 /* THREADS[I] is a thread we don't know about yet! */
1088 thread
= make_proc (inf
, threads
[i
], next_thread_id
++);
1090 last
->next
= thread
;
1092 inf
->threads
= thread
;
1094 proc_debug (thread
, "new thread: %lu", threads
[i
]);
1096 ptid
= ptid_build (inf
->pid
, thread
->tid
, 0);
1098 /* Tell GDB's generic thread code. */
1100 if (ptid_equal (inferior_ptid
, pid_to_ptid (inf
->pid
)))
1101 /* This is the first time we're hearing about thread
1102 ids, after a fork-child. */
1103 thread_change_ptid (inferior_ptid
, ptid
);
1104 else if (inf
->pending_execs
!= 0)
1105 /* This is a shell thread. */
1106 add_thread_silent (ptid
);
1112 vm_deallocate (mach_task_self (),
1113 (vm_address_t
) threads
, (num_threads
* sizeof (thread_t
)));
1118 /* Makes sure that INF's thread list is synced with the actual process. */
1120 inf_update_procs (struct inf
*inf
)
1124 if (!inf
->threads_up_to_date
)
1125 inf_validate_procs (inf
);
1129 /* Sets the resume_sc of each thread in inf. That of RUN_THREAD is set to 0,
1130 and others are set to their run_sc if RUN_OTHERS is true, and otherwise
1133 inf_set_threads_resume_sc (struct inf
*inf
,
1134 struct proc
*run_thread
, int run_others
)
1136 struct proc
*thread
;
1138 inf_update_procs (inf
);
1139 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1140 if (thread
== run_thread
)
1141 thread
->resume_sc
= 0;
1142 else if (run_others
)
1143 thread
->resume_sc
= thread
->run_sc
;
1145 thread
->resume_sc
= thread
->pause_sc
;
1149 /* Cause INF to continue execution immediately; individual threads may still
1150 be suspended (but their suspend counts will be updated). */
1152 inf_resume (struct inf
*inf
)
1154 struct proc
*thread
;
1156 inf_update_procs (inf
);
1158 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1159 thread
->sc
= thread
->resume_sc
;
1163 if (!inf
->pending_execs
)
1164 /* Try to make sure our task count is correct -- in the case where
1165 we're waiting for an exec though, things are too volatile, so just
1166 assume things will be reasonable (which they usually will be). */
1167 inf_validate_task_sc (inf
);
1171 inf_update_suspends (inf
);
1174 /* Cause INF to stop execution immediately; individual threads may still
1177 inf_suspend (struct inf
*inf
)
1179 struct proc
*thread
;
1181 inf_update_procs (inf
);
1183 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1184 thread
->sc
= thread
->pause_sc
;
1187 inf
->task
->sc
= inf
->pause_sc
;
1189 inf_update_suspends (inf
);
1193 /* INF has one thread PROC that is in single-stepping mode. This
1194 function changes it to be PROC, changing any old step_thread to be
1195 a normal one. A PROC of 0 clears any existing value. */
1197 inf_set_step_thread (struct inf
*inf
, struct proc
*thread
)
1199 gdb_assert (!thread
|| proc_is_thread (thread
));
1202 inf_debug (inf
, "setting step thread: %d/%d", inf
->pid
, thread
->tid
);
1204 inf_debug (inf
, "clearing step thread");
1206 if (inf
->step_thread
!= thread
)
1208 if (inf
->step_thread
&& inf
->step_thread
->port
!= MACH_PORT_NULL
)
1209 if (!proc_trace (inf
->step_thread
, 0))
1211 if (thread
&& proc_trace (thread
, 1))
1212 inf
->step_thread
= thread
;
1214 inf
->step_thread
= 0;
1219 /* Set up the thread resume_sc's so that only the signal thread is running
1220 (plus whatever other thread are set to always run). Returns true if we
1221 did so, or false if we can't find a signal thread. */
1223 inf_set_threads_resume_sc_for_signal_thread (struct inf
*inf
)
1225 if (inf
->signal_thread
)
1227 inf_set_threads_resume_sc (inf
, inf
->signal_thread
, 0);
1235 inf_update_signal_thread (struct inf
*inf
)
1237 /* XXX for now we assume that if there's a msgport, the 2nd thread is
1238 the signal thread. */
1239 inf
->signal_thread
= inf
->threads
? inf
->threads
->next
: 0;
1243 /* Detachs from INF's inferior task, letting it run once again... */
1245 inf_detach (struct inf
*inf
)
1247 struct proc
*task
= inf
->task
;
1249 inf_debug (inf
, "detaching...");
1251 inf_clear_wait (inf
);
1252 inf_set_step_thread (inf
, 0);
1256 struct proc
*thread
;
1258 inf_validate_procinfo (inf
);
1260 inf_set_traced (inf
, 0);
1266 inf_signal (inf
, GDB_SIGNAL_0
);
1269 proc_restore_exc_port (task
);
1270 task
->sc
= inf
->detach_sc
;
1272 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1274 proc_restore_exc_port (thread
);
1275 thread
->sc
= thread
->detach_sc
;
1278 inf_update_suspends (inf
);
1284 /* Attaches INF to the process with process id PID, returning it in a
1285 suspended state suitable for debugging. */
1287 inf_attach (struct inf
*inf
, int pid
)
1289 inf_debug (inf
, "attaching: %d", pid
);
1294 inf_startup (inf
, pid
);
1298 /* Makes sure that we've got our exception ports entrenched in the process. */
1300 inf_steal_exc_ports (struct inf
*inf
)
1302 struct proc
*thread
;
1304 inf_debug (inf
, "stealing exception ports");
1306 inf_set_step_thread (inf
, 0); /* The step thread is special. */
1308 proc_steal_exc_port (inf
->task
, inf
->event_port
);
1309 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1310 proc_steal_exc_port (thread
, MACH_PORT_NULL
);
1313 /* Makes sure the process has its own exception ports. */
1315 inf_restore_exc_ports (struct inf
*inf
)
1317 struct proc
*thread
;
1319 inf_debug (inf
, "restoring exception ports");
1321 inf_set_step_thread (inf
, 0); /* The step thread is special. */
1323 proc_restore_exc_port (inf
->task
);
1324 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1325 proc_restore_exc_port (thread
);
1329 /* Deliver signal SIG to INF. If INF is stopped, delivering a signal, even
1330 signal 0, will continue it. INF is assumed to be in a paused state, and
1331 the resume_sc's of INF's threads may be affected. */
1333 inf_signal (struct inf
*inf
, enum gdb_signal sig
)
1335 kern_return_t err
= 0;
1336 int host_sig
= gdb_signal_to_host (sig
);
1338 #define NAME gdb_signal_to_name (sig)
1340 if (host_sig
>= _NSIG
)
1341 /* A mach exception. Exceptions are encoded in the signal space by
1342 putting them after _NSIG; this assumes they're positive (and not
1343 extremely large)! */
1345 struct inf_wait
*w
= &inf
->wait
;
1347 if (w
->status
.kind
== TARGET_WAITKIND_STOPPED
1348 && w
->status
.value
.sig
== sig
1349 && w
->thread
&& !w
->thread
->aborted
)
1350 /* We're passing through the last exception we received. This is
1351 kind of bogus, because exceptions are per-thread whereas gdb
1352 treats signals as per-process. We just forward the exception to
1353 the correct handler, even it's not for the same thread as TID --
1354 i.e., we pretend it's global. */
1356 struct exc_state
*e
= &w
->exc
;
1358 inf_debug (inf
, "passing through exception:"
1359 " task = %lu, thread = %lu, exc = %d"
1360 ", code = %d, subcode = %d",
1361 w
->thread
->port
, inf
->task
->port
,
1362 e
->exception
, e
->code
, e
->subcode
);
1364 exception_raise_request (e
->handler
,
1365 e
->reply
, MACH_MSG_TYPE_MOVE_SEND_ONCE
,
1366 w
->thread
->port
, inf
->task
->port
,
1367 e
->exception
, e
->code
, e
->subcode
);
1370 error (_("Can't forward spontaneous exception (%s)."), NAME
);
1373 /* A Unix signal. */
1375 /* The process is stopped and expecting a signal. Just send off a
1376 request and let it get handled when we resume everything. */
1378 inf_debug (inf
, "sending %s to stopped process", NAME
);
1380 INF_MSGPORT_RPC (inf
,
1381 msg_sig_post_untraced_request (msgport
,
1383 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1387 /* Posting an untraced signal automatically continues it.
1388 We clear this here rather than when we get the reply
1389 because we'd rather assume it's not stopped when it
1390 actually is, than the reverse. */
1394 /* It's not expecting it. We have to let just the signal thread
1395 run, and wait for it to get into a reasonable state before we
1396 can continue the rest of the process. When we finally resume the
1397 process the signal we request will be the very first thing that
1400 inf_debug (inf
, "sending %s to unstopped process"
1401 " (so resuming signal thread)", NAME
);
1403 INF_RESUME_MSGPORT_RPC (inf
,
1404 msg_sig_post_untraced (msgport
, host_sig
,
1409 /* Can't do too much... */
1410 warning (_("Can't deliver signal %s: No signal thread."), NAME
);
1412 warning (_("Delivering signal %s: %s"), NAME
, safe_strerror (err
));
1418 /* Continue INF without delivering a signal. This is meant to be used
1419 when INF does not have a message port. */
1421 inf_continue (struct inf
*inf
)
1424 kern_return_t err
= proc_pid2proc (proc_server
, inf
->pid
, &proc
);
1428 inf_debug (inf
, "continuing process");
1430 err
= proc_mark_cont (proc
);
1433 struct proc
*thread
;
1435 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1436 thread_resume (thread
->port
);
1443 warning (_("Can't continue process: %s"), safe_strerror (err
));
1447 /* The inferior used for all gdb target ops. */
1448 struct inf
*gnu_current_inf
= 0;
1450 /* The inferior being waited for by gnu_wait. Since GDB is decidely not
1451 multi-threaded, we don't bother to lock this. */
1452 struct inf
*waiting_inf
;
1454 /* MIG stubs are not yet ready for C++ compilation. */
1455 extern "C" int exc_server (mach_msg_header_t
*, mach_msg_header_t
*);
1456 extern "C" int msg_reply_server (mach_msg_header_t
*, mach_msg_header_t
*);
1457 extern "C" int notify_server (mach_msg_header_t
*, mach_msg_header_t
*);
1458 extern "C" int process_reply_server (mach_msg_header_t
*, mach_msg_header_t
*);
1460 /* Wait for something to happen in the inferior, returning what in STATUS. */
1462 gnu_wait (struct target_ops
*ops
,
1463 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
1467 mach_msg_header_t hdr
;
1468 mach_msg_type_t type
;
1472 struct proc
*thread
;
1473 struct inf
*inf
= gnu_current_inf
;
1475 gdb_assert (inf
->task
);
1477 if (!inf
->threads
&& !inf
->pending_execs
)
1478 /* No threads! Assume that maybe some outside agency is frobbing our
1479 task, and really look for new threads. If we can't find any, just tell
1480 the user to try again later. */
1482 inf_validate_procs (inf
);
1483 if (!inf
->threads
&& !inf
->task
->dead
)
1484 error (_("There are no threads; try again later."));
1489 inf_debug (inf
, "waiting for: %s", target_pid_to_str (ptid
));
1492 if (proc_wait_pid
!= inf
->pid
&& !inf
->no_wait
)
1493 /* Always get information on events from the proc server. */
1495 inf_debug (inf
, "requesting wait on pid %d", inf
->pid
);
1498 /* The proc server is single-threaded, and only allows a single
1499 outstanding wait request, so we have to cancel the previous one. */
1501 inf_debug (inf
, "cancelling previous wait on pid %d", proc_wait_pid
);
1502 interrupt_operation (proc_server
, 0);
1506 proc_wait_request (proc_server
, inf
->event_port
, inf
->pid
, WUNTRACED
);
1508 warning (_("wait request failed: %s"), safe_strerror (err
));
1511 inf_debug (inf
, "waits pending: %d", proc_waits_pending
);
1512 proc_wait_pid
= inf
->pid
;
1513 /* Even if proc_waits_pending was > 0 before, we still won't
1514 get any other replies, because it was either from a
1515 different INF, or a different process attached to INF --
1516 and the event port, which is the wait reply port, changes
1517 when you switch processes. */
1518 proc_waits_pending
= 1;
1522 inf_clear_wait (inf
);
1524 /* What can happen? (1) Dead name notification; (2) Exceptions arrive;
1525 (3) wait reply from the proc server. */
1527 inf_debug (inf
, "waiting for an event...");
1528 err
= mach_msg (&msg
.hdr
, MACH_RCV_MSG
| MACH_RCV_INTERRUPT
,
1529 0, sizeof (struct msg
), inf
->event_port
,
1530 MACH_MSG_TIMEOUT_NONE
, MACH_PORT_NULL
);
1532 /* Re-suspend the task. */
1535 if (!inf
->task
&& inf
->pending_execs
)
1536 /* When doing an exec, it's possible that the old task wasn't reused
1537 (e.g., setuid execs). So if the task seems to have disappeared,
1538 attempt to refetch it, as the pid should still be the same. */
1539 inf_set_pid (inf
, inf
->pid
);
1541 if (err
== EMACH_RCV_INTERRUPTED
)
1542 inf_debug (inf
, "interrupted");
1544 error (_("Couldn't wait for an event: %s"), safe_strerror (err
));
1549 mach_msg_header_t hdr
;
1550 mach_msg_type_t err_type
;
1556 inf_debug (inf
, "event: msgid = %d", msg
.hdr
.msgh_id
);
1558 /* Handle what we got. */
1559 if (!notify_server (&msg
.hdr
, &reply
.hdr
)
1560 && !exc_server (&msg
.hdr
, &reply
.hdr
)
1561 && !process_reply_server (&msg
.hdr
, &reply
.hdr
)
1562 && !msg_reply_server (&msg
.hdr
, &reply
.hdr
))
1563 /* Whatever it is, it's something strange. */
1564 error (_("Got a strange event, msg id = %d."), msg
.hdr
.msgh_id
);
1567 error (_("Handling event, msgid = %d: %s"),
1568 msg
.hdr
.msgh_id
, safe_strerror (reply
.err
));
1571 if (inf
->pending_execs
)
1572 /* We're waiting for the inferior to finish execing. */
1574 struct inf_wait
*w
= &inf
->wait
;
1575 enum target_waitkind kind
= w
->status
.kind
;
1577 if (kind
== TARGET_WAITKIND_SPURIOUS
)
1578 /* Since gdb is actually counting the number of times the inferior
1579 stops, expecting one stop per exec, we only return major events
1583 inf_debug (inf
, "pending_execs, ignoring minor event");
1585 else if (kind
== TARGET_WAITKIND_STOPPED
1586 && w
->status
.value
.sig
== GDB_SIGNAL_TRAP
)
1587 /* Ah hah! A SIGTRAP from the inferior while starting up probably
1588 means we've succesfully completed an exec! */
1590 inf_debug (inf
, "one pending exec completed");
1592 else if (kind
== TARGET_WAITKIND_STOPPED
)
1593 /* It's possible that this signal is because of a crashed process
1594 being handled by the hurd crash server; in this case, the process
1595 will have an extra task suspend, which we need to know about.
1596 Since the code in inf_resume that normally checks for this is
1597 disabled while INF->pending_execs, we do the check here instead. */
1598 inf_validate_task_sc (inf
);
1601 if (inf
->wait
.suppress
)
1602 /* Some totally spurious event happened that we don't consider
1603 worth returning to gdb. Just keep waiting. */
1605 inf_debug (inf
, "suppressing return, rewaiting...");
1610 /* Pass back out our results. */
1611 memcpy (status
, &inf
->wait
.status
, sizeof (*status
));
1613 thread
= inf
->wait
.thread
;
1615 ptid
= ptid_build (inf
->pid
, thread
->tid
, 0);
1616 else if (ptid_equal (ptid
, minus_one_ptid
))
1617 thread
= inf_tid_to_thread (inf
, -1);
1619 thread
= inf_tid_to_thread (inf
, ptid_get_lwp (ptid
));
1621 if (!thread
|| thread
->port
== MACH_PORT_NULL
)
1623 /* TID is dead; try and find a new thread. */
1624 if (inf_update_procs (inf
) && inf
->threads
)
1625 ptid
= ptid_build (inf
->pid
, inf
->threads
->tid
, 0); /* The first
1629 ptid
= inferior_ptid
; /* let wait_for_inferior handle exit case */
1633 && !ptid_equal (ptid
, minus_one_ptid
)
1634 && status
->kind
!= TARGET_WAITKIND_SPURIOUS
1635 && inf
->pause_sc
== 0 && thread
->pause_sc
== 0)
1636 /* If something actually happened to THREAD, make sure we
1640 inf_update_suspends (inf
);
1643 inf_debug (inf
, "returning ptid = %s, status = %s (%d)",
1644 target_pid_to_str (ptid
),
1645 status
->kind
== TARGET_WAITKIND_EXITED
? "EXITED"
1646 : status
->kind
== TARGET_WAITKIND_STOPPED
? "STOPPED"
1647 : status
->kind
== TARGET_WAITKIND_SIGNALLED
? "SIGNALLED"
1648 : status
->kind
== TARGET_WAITKIND_LOADED
? "LOADED"
1649 : status
->kind
== TARGET_WAITKIND_SPURIOUS
? "SPURIOUS"
1651 status
->value
.integer
);
1657 /* The rpc handler called by exc_server. */
1659 S_exception_raise_request (mach_port_t port
, mach_port_t reply_port
,
1660 thread_t thread_port
, task_t task_port
,
1661 int exception
, int code
, int subcode
)
1663 struct inf
*inf
= waiting_inf
;
1664 struct proc
*thread
= inf_port_to_thread (inf
, thread_port
);
1666 inf_debug (waiting_inf
,
1667 "thread = %lu, task = %lu, exc = %d, code = %d, subcode = %d",
1668 thread_port
, task_port
, exception
, code
, subcode
);
1671 /* We don't know about thread? */
1673 inf_update_procs (inf
);
1674 thread
= inf_port_to_thread (inf
, thread_port
);
1676 /* Give up, the generating thread is gone. */
1680 mach_port_deallocate (mach_task_self (), thread_port
);
1681 mach_port_deallocate (mach_task_self (), task_port
);
1683 if (!thread
->aborted
)
1684 /* THREAD hasn't been aborted since this exception happened (abortion
1685 clears any exception state), so it must be real. */
1687 /* Store away the details; this will destroy any previous info. */
1688 inf
->wait
.thread
= thread
;
1690 inf
->wait
.status
.kind
= TARGET_WAITKIND_STOPPED
;
1692 if (exception
== EXC_BREAKPOINT
)
1693 /* GDB likes to get SIGTRAP for breakpoints. */
1695 inf
->wait
.status
.value
.sig
= GDB_SIGNAL_TRAP
;
1696 mach_port_deallocate (mach_task_self (), reply_port
);
1699 /* Record the exception so that we can forward it later. */
1701 if (thread
->exc_port
== port
)
1703 inf_debug (waiting_inf
, "Handler is thread exception port <%lu>",
1704 thread
->saved_exc_port
);
1705 inf
->wait
.exc
.handler
= thread
->saved_exc_port
;
1709 inf_debug (waiting_inf
, "Handler is task exception port <%lu>",
1710 inf
->task
->saved_exc_port
);
1711 inf
->wait
.exc
.handler
= inf
->task
->saved_exc_port
;
1712 gdb_assert (inf
->task
->exc_port
== port
);
1714 if (inf
->wait
.exc
.handler
!= MACH_PORT_NULL
)
1715 /* Add a reference to the exception handler. */
1716 mach_port_mod_refs (mach_task_self (),
1717 inf
->wait
.exc
.handler
, MACH_PORT_RIGHT_SEND
,
1720 inf
->wait
.exc
.exception
= exception
;
1721 inf
->wait
.exc
.code
= code
;
1722 inf
->wait
.exc
.subcode
= subcode
;
1723 inf
->wait
.exc
.reply
= reply_port
;
1725 /* Exceptions are encoded in the signal space by putting
1726 them after _NSIG; this assumes they're positive (and not
1727 extremely large)! */
1728 inf
->wait
.status
.value
.sig
=
1729 gdb_signal_from_host (_NSIG
+ exception
);
1733 /* A supppressed exception, which ignore. */
1735 inf
->wait
.suppress
= 1;
1736 mach_port_deallocate (mach_task_self (), reply_port
);
1743 /* Fill in INF's wait field after a task has died without giving us more
1744 detailed information. */
1746 inf_task_died_status (struct inf
*inf
)
1748 warning (_("Pid %d died with unknown exit status, using SIGKILL."),
1750 inf
->wait
.status
.kind
= TARGET_WAITKIND_SIGNALLED
;
1751 inf
->wait
.status
.value
.sig
= GDB_SIGNAL_KILL
;
1754 /* Notify server routines. The only real one is dead name notification. */
1756 do_mach_notify_dead_name (mach_port_t notify
, mach_port_t dead_port
)
1758 struct inf
*inf
= waiting_inf
;
1760 inf_debug (waiting_inf
, "port = %lu", dead_port
);
1762 if (inf
->task
&& inf
->task
->port
== dead_port
)
1764 proc_debug (inf
->task
, "is dead");
1765 inf
->task
->port
= MACH_PORT_NULL
;
1766 if (proc_wait_pid
== inf
->pid
)
1767 /* We have a wait outstanding on the process, which will return more
1768 detailed information, so delay until we get that. */
1769 inf
->wait
.suppress
= 1;
1771 /* We never waited for the process (maybe it wasn't a child), so just
1772 pretend it got a SIGKILL. */
1773 inf_task_died_status (inf
);
1777 struct proc
*thread
= inf_port_to_thread (inf
, dead_port
);
1781 proc_debug (thread
, "is dead");
1782 thread
->port
= MACH_PORT_NULL
;
1785 if (inf
->task
->dead
)
1786 /* Since the task is dead, its threads are dying with it. */
1787 inf
->wait
.suppress
= 1;
1790 mach_port_deallocate (mach_task_self (), dead_port
);
1791 inf
->threads_up_to_date
= 0; /* Just in case. */
1797 #define ILL_RPC(fun, ...) \
1798 extern kern_return_t fun (__VA_ARGS__); \
1799 kern_return_t fun (__VA_ARGS__) \
1801 warning (_("illegal rpc: %s"), #fun); \
1805 ILL_RPC (do_mach_notify_no_senders
,
1806 mach_port_t notify
, mach_port_mscount_t count
)
1807 ILL_RPC (do_mach_notify_port_deleted
,
1808 mach_port_t notify
, mach_port_t name
)
1809 ILL_RPC (do_mach_notify_msg_accepted
,
1810 mach_port_t notify
, mach_port_t name
)
1811 ILL_RPC (do_mach_notify_port_destroyed
,
1812 mach_port_t notify
, mach_port_t name
)
1813 ILL_RPC (do_mach_notify_send_once
,
1816 /* Process_reply server routines. We only use process_wait_reply. */
1819 S_proc_wait_reply (mach_port_t reply
, kern_return_t err
,
1820 int status
, int sigcode
, rusage_t rusage
, pid_t pid
)
1822 struct inf
*inf
= waiting_inf
;
1824 inf_debug (inf
, "err = %s, pid = %d, status = 0x%x, sigcode = %d",
1825 err
? safe_strerror (err
) : "0", pid
, status
, sigcode
);
1827 if (err
&& proc_wait_pid
&& (!inf
->task
|| !inf
->task
->port
))
1828 /* Ack. The task has died, but the task-died notification code didn't
1829 tell anyone because it thought a more detailed reply from the
1830 procserver was forthcoming. However, we now learn that won't
1831 happen... So we have to act like the task just died, and this time,
1833 inf_task_died_status (inf
);
1835 if (--proc_waits_pending
== 0)
1836 /* PROC_WAIT_PID represents the most recent wait. We will always get
1837 replies in order because the proc server is single threaded. */
1840 inf_debug (inf
, "waits pending now: %d", proc_waits_pending
);
1846 warning (_("Can't wait for pid %d: %s"),
1847 inf
->pid
, safe_strerror (err
));
1850 /* Since we can't see the inferior's signals, don't trap them. */
1851 inf_set_traced (inf
, 0);
1854 else if (pid
== inf
->pid
)
1856 store_waitstatus (&inf
->wait
.status
, status
);
1857 if (inf
->wait
.status
.kind
== TARGET_WAITKIND_STOPPED
)
1858 /* The process has sent us a signal, and stopped itself in a sane
1859 state pending our actions. */
1861 inf_debug (inf
, "process has stopped itself");
1866 inf
->wait
.suppress
= 1; /* Something odd happened. Ignore. */
1871 ILL_RPC (S_proc_setmsgport_reply
,
1872 mach_port_t reply_port
, kern_return_t return_code
,
1873 mach_port_t oldmsgport
)
1874 ILL_RPC (S_proc_getmsgport_reply
,
1875 mach_port_t reply_port
, kern_return_t return_code
,
1876 mach_port_t msgports
)
1877 ILL_RPC (S_proc_pid2task_reply
,
1878 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t task
)
1879 ILL_RPC (S_proc_task2pid_reply
,
1880 mach_port_t reply_port
, kern_return_t return_code
, pid_t pid
)
1881 ILL_RPC (S_proc_task2proc_reply
,
1882 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t proc
)
1883 ILL_RPC (S_proc_proc2task_reply
,
1884 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t task
)
1885 ILL_RPC (S_proc_pid2proc_reply
,
1886 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t proc
)
1887 ILL_RPC (S_proc_getprocinfo_reply
,
1888 mach_port_t reply_port
, kern_return_t return_code
,
1889 int flags
, procinfo_t procinfo
, mach_msg_type_number_t procinfoCnt
,
1890 data_t threadwaits
, mach_msg_type_number_t threadwaitsCnt
)
1891 ILL_RPC (S_proc_getprocargs_reply
,
1892 mach_port_t reply_port
, kern_return_t return_code
,
1893 data_t procargs
, mach_msg_type_number_t procargsCnt
)
1894 ILL_RPC (S_proc_getprocenv_reply
,
1895 mach_port_t reply_port
, kern_return_t return_code
,
1896 data_t procenv
, mach_msg_type_number_t procenvCnt
)
1897 ILL_RPC (S_proc_getloginid_reply
,
1898 mach_port_t reply_port
, kern_return_t return_code
, pid_t login_id
)
1899 ILL_RPC (S_proc_getloginpids_reply
,
1900 mach_port_t reply_port
, kern_return_t return_code
,
1901 pidarray_t pids
, mach_msg_type_number_t pidsCnt
)
1902 ILL_RPC (S_proc_getlogin_reply
,
1903 mach_port_t reply_port
, kern_return_t return_code
, string_t logname
)
1904 ILL_RPC (S_proc_getsid_reply
,
1905 mach_port_t reply_port
, kern_return_t return_code
, pid_t sid
)
1906 ILL_RPC (S_proc_getsessionpgids_reply
,
1907 mach_port_t reply_port
, kern_return_t return_code
,
1908 pidarray_t pgidset
, mach_msg_type_number_t pgidsetCnt
)
1909 ILL_RPC (S_proc_getsessionpids_reply
,
1910 mach_port_t reply_port
, kern_return_t return_code
,
1911 pidarray_t pidset
, mach_msg_type_number_t pidsetCnt
)
1912 ILL_RPC (S_proc_getsidport_reply
,
1913 mach_port_t reply_port
, kern_return_t return_code
,
1914 mach_port_t sessport
)
1915 ILL_RPC (S_proc_getpgrp_reply
,
1916 mach_port_t reply_port
, kern_return_t return_code
, pid_t pgrp
)
1917 ILL_RPC (S_proc_getpgrppids_reply
,
1918 mach_port_t reply_port
, kern_return_t return_code
,
1919 pidarray_t pidset
, mach_msg_type_number_t pidsetCnt
)
1920 ILL_RPC (S_proc_get_tty_reply
,
1921 mach_port_t reply_port
, kern_return_t return_code
, mach_port_t tty
)
1922 ILL_RPC (S_proc_getnports_reply
,
1923 mach_port_t reply_port
, kern_return_t return_code
,
1924 mach_msg_type_number_t nports
)
1925 ILL_RPC (S_proc_is_important_reply
,
1926 mach_port_t reply_port
, kern_return_t return_code
,
1927 boolean_t essential
)
1928 ILL_RPC (S_proc_get_code_reply
,
1929 mach_port_t reply_port
, kern_return_t return_code
,
1930 vm_address_t start_code
, vm_address_t end_code
)
1932 /* Msg_reply server routines. We only use msg_sig_post_untraced_reply. */
1935 S_msg_sig_post_untraced_reply (mach_port_t reply
, kern_return_t err
)
1937 struct inf
*inf
= waiting_inf
;
1940 /* EBUSY is what we get when the crash server has grabbed control of the
1941 process and doesn't like what signal we tried to send it. Just act
1942 like the process stopped (using a signal of 0 should mean that the
1943 *next* time the user continues, it will pass signal 0, which the crash
1944 server should like). */
1946 inf
->wait
.status
.kind
= TARGET_WAITKIND_STOPPED
;
1947 inf
->wait
.status
.value
.sig
= GDB_SIGNAL_0
;
1950 warning (_("Signal delivery failed: %s"), safe_strerror (err
));
1953 /* We only get this reply when we've posted a signal to a process which we
1954 thought was stopped, and which we expected to continue after the signal.
1955 Given that the signal has failed for some reason, it's reasonable to
1956 assume it's still stopped. */
1959 inf
->wait
.suppress
= 1;
1964 ILL_RPC (S_msg_sig_post_reply
,
1965 mach_port_t reply
, kern_return_t err
)
1967 /* Returns the number of messages queued for the receive right PORT. */
1968 static mach_port_msgcount_t
1969 port_msgs_queued (mach_port_t port
)
1971 struct mach_port_status status
;
1973 mach_port_get_receive_status (mach_task_self (), port
, &status
);
1978 return status
.mps_msgcount
;
1982 /* Resume execution of the inferior process.
1984 If STEP is nonzero, single-step it.
1985 If SIGNAL is nonzero, give it that signal.
1988 -1 true Single step the current thread allowing other threads to run.
1989 -1 false Continue the current thread allowing other threads to run.
1990 X true Single step the given thread, don't allow any others to run.
1991 X false Continue the given thread, do not allow any others to run.
1992 (Where X, of course, is anything except -1)
1994 Note that a resume may not `take' if there are pending exceptions/&c
1995 still unprocessed from the last resume we did (any given resume may result
1996 in multiple events returned by wait). */
1999 gnu_resume (struct target_ops
*ops
,
2000 ptid_t ptid
, int step
, enum gdb_signal sig
)
2002 struct proc
*step_thread
= 0;
2004 struct inf
*inf
= gnu_current_inf
;
2006 inf_debug (inf
, "ptid = %s, step = %d, sig = %d",
2007 target_pid_to_str (ptid
), step
, sig
);
2009 inf_validate_procinfo (inf
);
2011 if (sig
!= GDB_SIGNAL_0
|| inf
->stopped
)
2013 if (sig
== GDB_SIGNAL_0
&& inf
->nomsg
)
2016 inf_signal (inf
, sig
);
2018 else if (inf
->wait
.exc
.reply
!= MACH_PORT_NULL
)
2019 /* We received an exception to which we have chosen not to forward, so
2020 abort the faulting thread, which will perhaps retake it. */
2022 proc_abort (inf
->wait
.thread
, 1);
2023 warning (_("Aborting %s with unforwarded exception %s."),
2024 proc_string (inf
->wait
.thread
),
2025 gdb_signal_to_name (inf
->wait
.status
.value
.sig
));
2028 if (port_msgs_queued (inf
->event_port
))
2029 /* If there are still messages in our event queue, don't bother resuming
2030 the process, as we're just going to stop it right away anyway. */
2033 inf_update_procs (inf
);
2035 /* A specific PTID means `step only this process id'. */
2036 resume_all
= ptid_equal (ptid
, minus_one_ptid
);
2039 /* Allow all threads to run, except perhaps single-stepping one. */
2041 inf_debug (inf
, "running all threads; tid = %d",
2042 ptid_get_pid (inferior_ptid
));
2043 ptid
= inferior_ptid
; /* What to step. */
2044 inf_set_threads_resume_sc (inf
, 0, 1);
2047 /* Just allow a single thread to run. */
2049 struct proc
*thread
= inf_tid_to_thread (inf
, ptid_get_lwp (ptid
));
2052 error (_("Can't run single thread id %s: no such thread!"),
2053 target_pid_to_str (ptid
));
2054 inf_debug (inf
, "running one thread: %s", target_pid_to_str (ptid
));
2055 inf_set_threads_resume_sc (inf
, thread
, 0);
2060 step_thread
= inf_tid_to_thread (inf
, ptid_get_lwp (ptid
));
2062 warning (_("Can't step thread id %s: no such thread."),
2063 target_pid_to_str (ptid
));
2065 inf_debug (inf
, "stepping thread: %s", target_pid_to_str (ptid
));
2067 if (step_thread
!= inf
->step_thread
)
2068 inf_set_step_thread (inf
, step_thread
);
2070 inf_debug (inf
, "here we go...");
2076 gnu_kill_inferior (struct target_ops
*ops
)
2078 struct proc
*task
= gnu_current_inf
->task
;
2082 proc_debug (task
, "terminating...");
2083 task_terminate (task
->port
);
2084 inf_set_pid (gnu_current_inf
, -1);
2086 target_mourn_inferior (inferior_ptid
);
2089 /* Clean up after the inferior dies. */
2091 gnu_mourn_inferior (struct target_ops
*ops
)
2093 inf_debug (gnu_current_inf
, "rip");
2094 inf_detach (gnu_current_inf
);
2095 inf_child_mourn_inferior (ops
);
2099 /* Fork an inferior process, and start debugging it. */
2101 /* Set INFERIOR_PID to the first thread available in the child, if any. */
2103 inf_pick_first_thread (void)
2105 if (gnu_current_inf
->task
&& gnu_current_inf
->threads
)
2106 /* The first thread. */
2107 return gnu_current_inf
->threads
->tid
;
2109 /* What may be the next thread. */
2110 return next_thread_id
;
2116 if (!gnu_current_inf
)
2117 gnu_current_inf
= make_inf ();
2118 return gnu_current_inf
;
2122 gnu_ptrace_me (void)
2124 /* We're in the child; make this process stop as soon as it execs. */
2125 struct inf
*inf
= cur_inf ();
2126 inf_debug (inf
, "tracing self");
2127 if (ptrace (PTRACE_TRACEME
) != 0)
2128 error (_("ptrace (PTRACE_TRACEME) failed!"));
2132 gnu_create_inferior (struct target_ops
*ops
,
2133 char *exec_file
, char *allargs
, char **env
,
2136 struct inf
*inf
= cur_inf ();
2139 inf_debug (inf
, "creating inferior");
2141 pid
= fork_inferior (exec_file
, allargs
, env
, gnu_ptrace_me
,
2142 NULL
, NULL
, NULL
, NULL
);
2144 /* Attach to the now stopped child, which is actually a shell... */
2145 inf_debug (inf
, "attaching to child: %d", pid
);
2147 inf_attach (inf
, pid
);
2151 inf
->pending_execs
= 1;
2155 /* Now let the child run again, knowing that it will stop
2156 immediately because of the ptrace. */
2159 /* We now have thread info. */
2160 thread_change_ptid (inferior_ptid
,
2161 ptid_build (inf
->pid
, inf_pick_first_thread (), 0));
2163 startup_inferior (START_INFERIOR_TRAPS_EXPECTED
);
2164 inf
->pending_execs
= 0;
2166 inf_validate_procinfo (inf
);
2167 inf_update_signal_thread (inf
);
2168 inf_set_traced (inf
, inf
->want_signals
);
2170 /* Execing the process will have trashed our exception ports; steal them
2171 back (or make sure they're restored if the user wants that). */
2172 if (inf
->want_exceptions
)
2173 inf_steal_exc_ports (inf
);
2175 inf_restore_exc_ports (inf
);
2179 /* Attach to process PID, then initialize for debugging it
2180 and wait for the trace-trap that results from attaching. */
2182 gnu_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
2186 struct inf
*inf
= cur_inf ();
2187 struct inferior
*inferior
;
2189 pid
= parse_pid_to_attach (args
);
2191 if (pid
== getpid ()) /* Trying to masturbate? */
2192 error (_("I refuse to debug myself!"));
2196 exec_file
= (char *) get_exec_file (0);
2199 printf_unfiltered ("Attaching to program `%s', pid %d\n",
2202 printf_unfiltered ("Attaching to pid %d\n", pid
);
2204 gdb_flush (gdb_stdout
);
2207 inf_debug (inf
, "attaching to pid: %d", pid
);
2209 inf_attach (inf
, pid
);
2213 inferior
= current_inferior ();
2214 inferior_appeared (inferior
, pid
);
2215 inferior
->attach_flag
= 1;
2217 inf_update_procs (inf
);
2219 inferior_ptid
= ptid_build (pid
, inf_pick_first_thread (), 0);
2221 /* We have to initialize the terminal settings now, since the code
2222 below might try to restore them. */
2223 target_terminal_init ();
2225 /* If the process was stopped before we attached, make it continue the next
2226 time the user does a continue. */
2227 inf_validate_procinfo (inf
);
2229 inf_update_signal_thread (inf
);
2230 inf_set_traced (inf
, inf
->want_signals
);
2232 #if 0 /* Do we need this? */
2233 renumber_threads (0); /* Give our threads reasonable names. */
2238 /* Take a program previously attached to and detaches it.
2239 The program resumes execution and will no longer stop
2240 on signals, etc. We'd better not have left any breakpoints
2241 in the program or it'll die when it hits one. For this
2242 to work, it may be necessary for the process to have been
2243 previously attached. It *might* work if the program was
2244 started via fork. */
2246 gnu_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
2252 char *exec_file
= get_exec_file (0);
2255 printf_unfiltered ("Detaching from program `%s' pid %d\n",
2256 exec_file
, gnu_current_inf
->pid
);
2258 printf_unfiltered ("Detaching from pid %d\n", gnu_current_inf
->pid
);
2259 gdb_flush (gdb_stdout
);
2262 pid
= gnu_current_inf
->pid
;
2264 inf_detach (gnu_current_inf
);
2266 inferior_ptid
= null_ptid
;
2267 detach_inferior (pid
);
2269 inf_child_maybe_unpush_target (ops
);
2273 gnu_terminal_init (struct target_ops
*self
)
2275 gdb_assert (gnu_current_inf
);
2276 child_terminal_init_with_pgrp (gnu_current_inf
->pid
);
2280 gnu_stop (struct target_ops
*self
, ptid_t ptid
)
2282 error (_("to_stop target function not implemented"));
2286 gnu_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2288 inf_update_procs (gnu_current_inf
);
2289 return !!inf_tid_to_thread (gnu_current_inf
,
2290 ptid_get_lwp (ptid
));
2294 /* Read inferior task's LEN bytes from ADDR and copy it to MYADDR in
2295 gdb's address space. Return 0 on failure; number of bytes read
2298 gnu_read_inferior (task_t task
, CORE_ADDR addr
, gdb_byte
*myaddr
, int length
)
2301 vm_address_t low_address
= (vm_address_t
) trunc_page (addr
);
2302 vm_size_t aligned_length
=
2303 (vm_size_t
) round_page (addr
+ length
) - low_address
;
2305 mach_msg_type_number_t copy_count
;
2307 /* Get memory from inferior with page aligned addresses. */
2308 err
= vm_read (task
, low_address
, aligned_length
, &copied
, ©_count
);
2312 err
= hurd_safe_copyin (myaddr
, (void *) (addr
- low_address
+ copied
),
2316 warning (_("Read from inferior faulted: %s"), safe_strerror (err
));
2320 err
= vm_deallocate (mach_task_self (), copied
, copy_count
);
2322 warning (_("gnu_read_inferior vm_deallocate failed: %s"),
2323 safe_strerror (err
));
2328 #define CHK_GOTO_OUT(str,ret) \
2329 do if (ret != KERN_SUCCESS) { errstr = #str; goto out; } while(0)
2331 struct vm_region_list
2333 struct vm_region_list
*next
;
2334 vm_prot_t protection
;
2339 struct obstack region_obstack
;
2341 /* Write gdb's LEN bytes from MYADDR and copy it to ADDR in inferior
2342 task's address space. */
2344 gnu_write_inferior (task_t task
, CORE_ADDR addr
,
2345 const gdb_byte
*myaddr
, int length
)
2348 vm_address_t low_address
= (vm_address_t
) trunc_page (addr
);
2349 vm_size_t aligned_length
=
2350 (vm_size_t
) round_page (addr
+ length
) - low_address
;
2352 mach_msg_type_number_t copy_count
;
2355 char *errstr
= "Bug in gnu_write_inferior";
2357 struct vm_region_list
*region_element
;
2358 struct vm_region_list
*region_head
= NULL
;
2360 /* Get memory from inferior with page aligned addresses. */
2361 err
= vm_read (task
,
2366 CHK_GOTO_OUT ("gnu_write_inferior vm_read failed", err
);
2370 err
= hurd_safe_copyout ((void *) (addr
- low_address
+ copied
),
2372 CHK_GOTO_OUT ("Write to inferior faulted", err
);
2374 obstack_init (®ion_obstack
);
2376 /* Do writes atomically.
2377 First check for holes and unwritable memory. */
2379 vm_size_t remaining_length
= aligned_length
;
2380 vm_address_t region_address
= low_address
;
2382 struct vm_region_list
*scan
;
2384 while (region_address
< low_address
+ aligned_length
)
2386 vm_prot_t protection
;
2387 vm_prot_t max_protection
;
2388 vm_inherit_t inheritance
;
2390 mach_port_t object_name
;
2392 vm_size_t region_length
= remaining_length
;
2393 vm_address_t old_address
= region_address
;
2395 err
= vm_region (task
,
2404 CHK_GOTO_OUT ("vm_region failed", err
);
2406 /* Check for holes in memory. */
2407 if (old_address
!= region_address
)
2409 warning (_("No memory at 0x%lx. Nothing written"),
2416 if (!(max_protection
& VM_PROT_WRITE
))
2418 warning (_("Memory at address 0x%lx is unwritable. "
2426 /* Chain the regions for later use. */
2427 region_element
= XOBNEW (®ion_obstack
, struct vm_region_list
);
2429 region_element
->protection
= protection
;
2430 region_element
->start
= region_address
;
2431 region_element
->length
= region_length
;
2433 /* Chain the regions along with protections. */
2434 region_element
->next
= region_head
;
2435 region_head
= region_element
;
2437 region_address
+= region_length
;
2438 remaining_length
= remaining_length
- region_length
;
2441 /* If things fail after this, we give up.
2442 Somebody is messing up inferior_task's mappings. */
2444 /* Enable writes to the chained vm regions. */
2445 for (scan
= region_head
; scan
; scan
= scan
->next
)
2447 if (!(scan
->protection
& VM_PROT_WRITE
))
2449 err
= vm_protect (task
,
2453 scan
->protection
| VM_PROT_WRITE
);
2454 CHK_GOTO_OUT ("vm_protect: enable write failed", err
);
2458 err
= vm_write (task
,
2462 CHK_GOTO_OUT ("vm_write failed", err
);
2464 /* Set up the original region protections, if they were changed. */
2465 for (scan
= region_head
; scan
; scan
= scan
->next
)
2467 if (!(scan
->protection
& VM_PROT_WRITE
))
2469 err
= vm_protect (task
,
2474 CHK_GOTO_OUT ("vm_protect: enable write failed", err
);
2482 obstack_free (®ion_obstack
, 0);
2484 (void) vm_deallocate (mach_task_self (),
2489 if (err
!= KERN_SUCCESS
)
2491 warning (_("%s: %s"), errstr
, mach_error_string (err
));
2500 /* Implement the to_xfer_partial target_ops method for
2501 TARGET_OBJECT_MEMORY. */
2503 static enum target_xfer_status
2504 gnu_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2505 CORE_ADDR memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2507 task_t task
= (gnu_current_inf
2508 ? (gnu_current_inf
->task
2509 ? gnu_current_inf
->task
->port
: 0)
2513 if (task
== MACH_PORT_NULL
)
2514 return TARGET_XFER_E_IO
;
2516 if (writebuf
!= NULL
)
2518 inf_debug (gnu_current_inf
, "writing %s[%s] <-- %s",
2519 paddress (target_gdbarch (), memaddr
), pulongest (len
),
2520 host_address_to_string (writebuf
));
2521 res
= gnu_write_inferior (task
, memaddr
, writebuf
, len
);
2525 inf_debug (gnu_current_inf
, "reading %s[%s] --> %s",
2526 paddress (target_gdbarch (), memaddr
), pulongest (len
),
2527 host_address_to_string (readbuf
));
2528 res
= gnu_read_inferior (task
, memaddr
, readbuf
, len
);
2530 gdb_assert (res
>= 0);
2532 return TARGET_XFER_E_IO
;
2535 *xfered_len
= (ULONGEST
) res
;
2536 return TARGET_XFER_OK
;
2540 /* Target to_xfer_partial implementation. */
2542 static enum target_xfer_status
2543 gnu_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2544 const char *annex
, gdb_byte
*readbuf
,
2545 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
2546 ULONGEST
*xfered_len
)
2550 case TARGET_OBJECT_MEMORY
:
2551 return gnu_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2553 return TARGET_XFER_E_IO
;
2557 /* Call FUNC on each memory region in the task. */
2559 gnu_find_memory_regions (struct target_ops
*self
,
2560 find_memory_region_ftype func
, void *data
)
2564 vm_address_t region_address
, last_region_address
, last_region_end
;
2565 vm_prot_t last_protection
;
2567 if (gnu_current_inf
== 0 || gnu_current_inf
->task
== 0)
2569 task
= gnu_current_inf
->task
->port
;
2570 if (task
== MACH_PORT_NULL
)
2573 region_address
= last_region_address
= last_region_end
= VM_MIN_ADDRESS
;
2574 last_protection
= VM_PROT_NONE
;
2575 while (region_address
< VM_MAX_ADDRESS
)
2577 vm_prot_t protection
;
2578 vm_prot_t max_protection
;
2579 vm_inherit_t inheritance
;
2581 mach_port_t object_name
;
2583 vm_size_t region_length
= VM_MAX_ADDRESS
- region_address
;
2584 vm_address_t old_address
= region_address
;
2586 err
= vm_region (task
,
2595 if (err
== KERN_NO_SPACE
)
2597 if (err
!= KERN_SUCCESS
)
2599 warning (_("vm_region failed: %s"), mach_error_string (err
));
2603 if (protection
== last_protection
&& region_address
== last_region_end
)
2604 /* This region is contiguous with and indistinguishable from
2605 the previous one, so we just extend that one. */
2606 last_region_end
= region_address
+= region_length
;
2609 /* This region is distinct from the last one we saw, so report
2610 that previous one. */
2611 if (last_protection
!= VM_PROT_NONE
)
2612 (*func
) (last_region_address
,
2613 last_region_end
- last_region_address
,
2614 last_protection
& VM_PROT_READ
,
2615 last_protection
& VM_PROT_WRITE
,
2616 last_protection
& VM_PROT_EXECUTE
,
2617 1, /* MODIFIED is unknown, pass it as true. */
2619 last_region_address
= region_address
;
2620 last_region_end
= region_address
+= region_length
;
2621 last_protection
= protection
;
2625 /* Report the final region. */
2626 if (last_region_end
> last_region_address
&& last_protection
!= VM_PROT_NONE
)
2627 (*func
) (last_region_address
, last_region_end
- last_region_address
,
2628 last_protection
& VM_PROT_READ
,
2629 last_protection
& VM_PROT_WRITE
,
2630 last_protection
& VM_PROT_EXECUTE
,
2631 1, /* MODIFIED is unknown, pass it as true. */
2638 /* Return printable description of proc. */
2640 proc_string (struct proc
*proc
)
2642 static char tid_str
[80];
2644 if (proc_is_task (proc
))
2645 xsnprintf (tid_str
, sizeof (tid_str
), "process %d", proc
->inf
->pid
);
2647 xsnprintf (tid_str
, sizeof (tid_str
), "Thread %d.%d",
2648 proc
->inf
->pid
, proc
->tid
);
2653 gnu_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2655 struct inf
*inf
= gnu_current_inf
;
2656 int tid
= ptid_get_lwp (ptid
);
2657 struct proc
*thread
= inf_tid_to_thread (inf
, tid
);
2660 return proc_string (thread
);
2663 static char tid_str
[80];
2665 xsnprintf (tid_str
, sizeof (tid_str
), "bogus thread id %d", tid
);
2671 /* Create a prototype generic GNU/Hurd target. The client can
2672 override it with local methods. */
2677 struct target_ops
*t
= inf_child_target ();
2679 t
->to_attach
= gnu_attach
;
2680 t
->to_attach_no_wait
= 1;
2681 t
->to_detach
= gnu_detach
;
2682 t
->to_resume
= gnu_resume
;
2683 t
->to_wait
= gnu_wait
;
2684 t
->to_xfer_partial
= gnu_xfer_partial
;
2685 t
->to_find_memory_regions
= gnu_find_memory_regions
;
2686 t
->to_terminal_init
= gnu_terminal_init
;
2687 t
->to_kill
= gnu_kill_inferior
;
2688 t
->to_create_inferior
= gnu_create_inferior
;
2689 t
->to_mourn_inferior
= gnu_mourn_inferior
;
2690 t
->to_thread_alive
= gnu_thread_alive
;
2691 t
->to_pid_to_str
= gnu_pid_to_str
;
2692 t
->to_stop
= gnu_stop
;
2698 /* User task commands. */
2700 static struct cmd_list_element
*set_task_cmd_list
= 0;
2701 static struct cmd_list_element
*show_task_cmd_list
= 0;
2702 /* User thread commands. */
2704 /* Commands with a prefix of `set/show thread'. */
2705 extern struct cmd_list_element
*thread_cmd_list
;
2706 struct cmd_list_element
*set_thread_cmd_list
= NULL
;
2707 struct cmd_list_element
*show_thread_cmd_list
= NULL
;
2709 /* Commands with a prefix of `set/show thread default'. */
2710 struct cmd_list_element
*set_thread_default_cmd_list
= NULL
;
2711 struct cmd_list_element
*show_thread_default_cmd_list
= NULL
;
2714 set_thread_cmd (char *args
, int from_tty
)
2716 printf_unfiltered ("\"set thread\" must be followed by the "
2717 "name of a thread property, or \"default\".\n");
2721 show_thread_cmd (char *args
, int from_tty
)
2723 printf_unfiltered ("\"show thread\" must be followed by the "
2724 "name of a thread property, or \"default\".\n");
2728 set_thread_default_cmd (char *args
, int from_tty
)
2730 printf_unfiltered ("\"set thread default\" must be followed "
2731 "by the name of a thread property.\n");
2735 show_thread_default_cmd (char *args
, int from_tty
)
2737 printf_unfiltered ("\"show thread default\" must be followed "
2738 "by the name of a thread property.\n");
2742 parse_int_arg (char *args
, char *cmd_prefix
)
2747 int val
= strtoul (args
, &arg_end
, 10);
2749 if (*args
&& *arg_end
== '\0')
2752 error (_("Illegal argument for \"%s\" command, should be an integer."),
2757 _parse_bool_arg (char *args
, char *t_val
, char *f_val
, char *cmd_prefix
)
2759 if (!args
|| strcmp (args
, t_val
) == 0)
2761 else if (strcmp (args
, f_val
) == 0)
2764 error (_("Illegal argument for \"%s\" command, "
2765 "should be \"%s\" or \"%s\"."),
2766 cmd_prefix
, t_val
, f_val
);
2769 #define parse_bool_arg(args, cmd_prefix) \
2770 _parse_bool_arg (args, "on", "off", cmd_prefix)
2773 check_empty (char *args
, char *cmd_prefix
)
2776 error (_("Garbage after \"%s\" command: `%s'"), cmd_prefix
, args
);
2779 /* Returns the alive thread named by INFERIOR_PID, or signals an error. */
2780 static struct proc
*
2783 struct inf
*inf
= cur_inf ();
2784 struct proc
*thread
= inf_tid_to_thread (inf
,
2785 ptid_get_lwp (inferior_ptid
));
2787 error (_("No current thread."));
2791 /* Returns the current inferior, but signals an error if it has no task. */
2795 struct inf
*inf
= cur_inf ();
2798 error (_("No current process."));
2804 set_task_pause_cmd (int arg
, int from_tty
)
2806 struct inf
*inf
= cur_inf ();
2807 int old_sc
= inf
->pause_sc
;
2809 inf
->pause_sc
= arg
;
2811 if (old_sc
== 0 && inf
->pause_sc
!= 0)
2812 /* If the task is currently unsuspended, immediately suspend it,
2813 otherwise wait until the next time it gets control. */
2818 set_task_pause_cmd (char *args
, int from_tty
)
2820 set_task_pause_cmd (parse_bool_arg (args
, "set task pause"), from_tty
);
2824 show_task_pause_cmd (char *args
, int from_tty
)
2826 struct inf
*inf
= cur_inf ();
2828 check_empty (args
, "show task pause");
2829 printf_unfiltered ("The inferior task %s suspended while gdb has control.\n",
2831 ? (inf
->pause_sc
== 0 ? "isn't" : "is")
2832 : (inf
->pause_sc
== 0 ? "won't be" : "will be"));
2836 set_task_detach_sc_cmd (char *args
, int from_tty
)
2838 cur_inf ()->detach_sc
= parse_int_arg (args
,
2839 "set task detach-suspend-count");
2843 show_task_detach_sc_cmd (char *args
, int from_tty
)
2845 check_empty (args
, "show task detach-suspend-count");
2846 printf_unfiltered ("The inferior task will be left with a "
2847 "suspend count of %d when detaching.\n",
2848 cur_inf ()->detach_sc
);
2853 set_thread_default_pause_cmd (char *args
, int from_tty
)
2855 struct inf
*inf
= cur_inf ();
2857 inf
->default_thread_pause_sc
=
2858 parse_bool_arg (args
, "set thread default pause") ? 0 : 1;
2862 show_thread_default_pause_cmd (char *args
, int from_tty
)
2864 struct inf
*inf
= cur_inf ();
2865 int sc
= inf
->default_thread_pause_sc
;
2867 check_empty (args
, "show thread default pause");
2868 printf_unfiltered ("New threads %s suspended while gdb has control%s.\n",
2869 sc
? "are" : "aren't",
2870 !sc
&& inf
->pause_sc
? " (but the task is)" : "");
2874 set_thread_default_run_cmd (char *args
, int from_tty
)
2876 struct inf
*inf
= cur_inf ();
2878 inf
->default_thread_run_sc
=
2879 parse_bool_arg (args
, "set thread default run") ? 0 : 1;
2883 show_thread_default_run_cmd (char *args
, int from_tty
)
2885 struct inf
*inf
= cur_inf ();
2887 check_empty (args
, "show thread default run");
2888 printf_unfiltered ("New threads %s allowed to run.\n",
2889 inf
->default_thread_run_sc
== 0 ? "are" : "aren't");
2893 set_thread_default_detach_sc_cmd (char *args
, int from_tty
)
2895 cur_inf ()->default_thread_detach_sc
=
2896 parse_int_arg (args
, "set thread default detach-suspend-count");
2900 show_thread_default_detach_sc_cmd (char *args
, int from_tty
)
2902 check_empty (args
, "show thread default detach-suspend-count");
2903 printf_unfiltered ("New threads will get a detach-suspend-count of %d.\n",
2904 cur_inf ()->default_thread_detach_sc
);
2908 /* Steal a send right called NAME in the inferior task, and make it PROC's
2909 saved exception port. */
2911 steal_exc_port (struct proc
*proc
, mach_port_t name
)
2915 mach_msg_type_name_t port_type
;
2917 if (!proc
|| !proc
->inf
->task
)
2918 error (_("No inferior task."));
2920 err
= mach_port_extract_right (proc
->inf
->task
->port
,
2921 name
, MACH_MSG_TYPE_COPY_SEND
,
2924 error (_("Couldn't extract send right %lu from inferior: %s"),
2925 name
, safe_strerror (err
));
2927 if (proc
->saved_exc_port
)
2928 /* Get rid of our reference to the old one. */
2929 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
2931 proc
->saved_exc_port
= port
;
2933 if (!proc
->exc_port
)
2934 /* If PROC is a thread, we may not have set its exception port
2935 before. We can't use proc_steal_exc_port because it also sets
2938 proc
->exc_port
= proc
->inf
->event_port
;
2939 err
= proc_set_exception_port (proc
, proc
->exc_port
);
2940 error (_("Can't set exception port for %s: %s"),
2941 proc_string (proc
), safe_strerror (err
));
2946 set_task_exc_port_cmd (char *args
, int from_tty
)
2948 struct inf
*inf
= cur_inf ();
2951 error (_("No argument to \"set task exception-port\" command."));
2952 steal_exc_port (inf
->task
, parse_and_eval_address (args
));
2956 set_stopped_cmd (char *args
, int from_tty
)
2958 cur_inf ()->stopped
= _parse_bool_arg (args
, "yes", "no", "set stopped");
2962 show_stopped_cmd (char *args
, int from_tty
)
2964 struct inf
*inf
= active_inf ();
2966 check_empty (args
, "show stopped");
2967 printf_unfiltered ("The inferior process %s stopped.\n",
2968 inf
->stopped
? "is" : "isn't");
2972 set_sig_thread_cmd (char *args
, int from_tty
)
2974 struct inf
*inf
= cur_inf ();
2976 if (!args
|| (!isdigit (*args
) && strcmp (args
, "none") != 0))
2977 error (_("Illegal argument to \"set signal-thread\" command.\n"
2978 "Should be an integer thread ID, or `none'."));
2980 if (strcmp (args
, "none") == 0)
2981 inf
->signal_thread
= 0;
2984 ptid_t ptid
= global_thread_id_to_ptid (atoi (args
));
2986 if (ptid_equal (ptid
, minus_one_ptid
))
2987 error (_("Thread ID %s not known. "
2988 "Use the \"info threads\" command to\n"
2989 "see the IDs of currently known threads."), args
);
2990 inf
->signal_thread
= inf_tid_to_thread (inf
, ptid_get_lwp (ptid
));
2995 show_sig_thread_cmd (char *args
, int from_tty
)
2997 struct inf
*inf
= active_inf ();
2999 check_empty (args
, "show signal-thread");
3000 if (inf
->signal_thread
)
3001 printf_unfiltered ("The signal thread is %s.\n",
3002 proc_string (inf
->signal_thread
));
3004 printf_unfiltered ("There is no signal thread.\n");
3009 set_signals_cmd (int arg
, int from_tty
)
3011 struct inf
*inf
= cur_inf ();
3013 inf
->want_signals
= arg
;
3015 if (inf
->task
&& inf
->want_signals
!= inf
->traced
)
3016 /* Make this take effect immediately in a running process. */
3017 inf_set_traced (inf
, inf
->want_signals
);
3021 set_signals_cmd (char *args
, int from_tty
)
3023 set_signals_cmd(parse_bool_arg (args
, "set signals"), from_tty
);
3027 show_signals_cmd (char *args
, int from_tty
)
3029 struct inf
*inf
= cur_inf ();
3031 check_empty (args
, "show signals");
3032 printf_unfiltered ("The inferior process's signals %s intercepted.\n",
3034 ? (inf
->traced
? "are" : "aren't")
3035 : (inf
->want_signals
? "will be" : "won't be"));
3039 set_exceptions_cmd (int arg
, int from_tty
)
3041 struct inf
*inf
= cur_inf ();
3043 /* Make this take effect immediately in a running process. */
3046 inf
->want_exceptions
= arg
;
3050 set_exceptions_cmd (char *args
, int from_tty
)
3052 set_exceptions_cmd (parse_bool_arg (args
, "set exceptions"), from_tty
);
3056 show_exceptions_cmd (char *args
, int from_tty
)
3058 struct inf
*inf
= cur_inf ();
3060 check_empty (args
, "show exceptions");
3061 printf_unfiltered ("Exceptions in the inferior %s trapped.\n",
3063 ? (inf
->want_exceptions
? "are" : "aren't")
3064 : (inf
->want_exceptions
? "will be" : "won't be"));
3069 set_task_cmd (char *args
, int from_tty
)
3071 printf_unfiltered ("\"set task\" must be followed by the name"
3072 " of a task property.\n");
3076 show_task_cmd (char *args
, int from_tty
)
3078 struct inf
*inf
= cur_inf ();
3080 check_empty (args
, "show task");
3082 show_signals_cmd (0, from_tty
);
3083 show_exceptions_cmd (0, from_tty
);
3084 show_task_pause_cmd (0, from_tty
);
3086 if (inf
->pause_sc
== 0)
3087 show_thread_default_pause_cmd (0, from_tty
);
3088 show_thread_default_run_cmd (0, from_tty
);
3092 show_stopped_cmd (0, from_tty
);
3093 show_sig_thread_cmd (0, from_tty
);
3096 if (inf
->detach_sc
!= 0)
3097 show_task_detach_sc_cmd (0, from_tty
);
3098 if (inf
->default_thread_detach_sc
!= 0)
3099 show_thread_default_detach_sc_cmd (0, from_tty
);
3104 set_noninvasive_cmd (char *args
, int from_tty
)
3106 /* Invert the sense of the arg for each component. */
3107 int inv_arg
= parse_bool_arg (args
, "set noninvasive") ? 0 : 1;
3109 set_task_pause_cmd (inv_arg
, from_tty
);
3110 set_signals_cmd (inv_arg
, from_tty
);
3111 set_exceptions_cmd (inv_arg
, from_tty
);
3116 info_port_rights (const char *args
, mach_port_type_t only
)
3118 struct inf
*inf
= active_inf ();
3119 struct value
*vmark
= value_mark ();
3122 /* Explicit list of port rights. */
3126 struct value
*val
= parse_to_comma_and_eval (&args
);
3127 long right
= value_as_long (val
);
3129 print_port_info (right
, 0, inf
->task
->port
, PORTINFO_DETAILS
,
3133 error (_("%ld: %s."), right
, safe_strerror (err
));
3137 /* Print all of them. */
3140 print_task_ports_info (inf
->task
->port
, only
, PORTINFO_DETAILS
,
3143 error (_("%s."), safe_strerror (err
));
3146 value_free_to_mark (vmark
);
3150 info_send_rights_cmd (char *args
, int from_tty
)
3152 info_port_rights (args
, MACH_PORT_TYPE_SEND
);
3156 info_recv_rights_cmd (char *args
, int from_tty
)
3158 info_port_rights (args
, MACH_PORT_TYPE_RECEIVE
);
3162 info_port_sets_cmd (char *args
, int from_tty
)
3164 info_port_rights (args
, MACH_PORT_TYPE_PORT_SET
);
3168 info_dead_names_cmd (char *args
, int from_tty
)
3170 info_port_rights (args
, MACH_PORT_TYPE_DEAD_NAME
);
3174 info_port_rights_cmd (char *args
, int from_tty
)
3176 info_port_rights (args
, ~0);
3181 add_task_commands (void)
3183 add_cmd ("pause", class_run
, set_thread_default_pause_cmd
, _("\
3184 Set whether the new threads are suspended while gdb has control.\n\
3185 This property normally has no effect because the whole task is\n\
3186 suspended, however, that may be disabled with \"set task pause off\".\n\
3187 The default value is \"off\"."),
3188 &set_thread_default_cmd_list
);
3189 add_cmd ("pause", no_class
, show_thread_default_pause_cmd
, _("\
3190 Show whether new threads are suspended while gdb has control."),
3191 &show_thread_default_cmd_list
);
3193 add_cmd ("run", class_run
, set_thread_default_run_cmd
, _("\
3194 Set whether new threads are allowed to run (once gdb has noticed them)."),
3195 &set_thread_default_cmd_list
);
3196 add_cmd ("run", no_class
, show_thread_default_run_cmd
, _("\
3197 Show whether new threads are allowed to run (once gdb has noticed them)."),
3198 &show_thread_default_cmd_list
);
3200 add_cmd ("detach-suspend-count", class_run
, set_thread_default_detach_sc_cmd
,
3201 _("Set the default detach-suspend-count value for new threads."),
3202 &set_thread_default_cmd_list
);
3203 add_cmd ("detach-suspend-count", no_class
, show_thread_default_detach_sc_cmd
,
3204 _("Show the default detach-suspend-count value for new threads."),
3205 &show_thread_default_cmd_list
);
3207 add_cmd ("signals", class_run
, set_signals_cmd
, _("\
3208 Set whether the inferior process's signals will be intercepted.\n\
3209 Mach exceptions (such as breakpoint traps) are not affected."),
3211 add_alias_cmd ("sigs", "signals", class_run
, 1, &setlist
);
3212 add_cmd ("signals", no_class
, show_signals_cmd
, _("\
3213 Show whether the inferior process's signals will be intercepted."),
3215 add_alias_cmd ("sigs", "signals", no_class
, 1, &showlist
);
3217 add_cmd ("signal-thread", class_run
, set_sig_thread_cmd
, _("\
3218 Set the thread that gdb thinks is the libc signal thread.\n\
3219 This thread is run when delivering a signal to a non-stopped process."),
3221 add_alias_cmd ("sigthread", "signal-thread", class_run
, 1, &setlist
);
3222 add_cmd ("signal-thread", no_class
, show_sig_thread_cmd
, _("\
3223 Set the thread that gdb thinks is the libc signal thread."),
3225 add_alias_cmd ("sigthread", "signal-thread", no_class
, 1, &showlist
);
3227 add_cmd ("stopped", class_run
, set_stopped_cmd
, _("\
3228 Set whether gdb thinks the inferior process is stopped as with SIGSTOP.\n\
3229 Stopped process will be continued by sending them a signal."),
3231 add_cmd ("stopped", no_class
, show_stopped_cmd
, _("\
3232 Show whether gdb thinks the inferior process is stopped as with SIGSTOP."),
3235 add_cmd ("exceptions", class_run
, set_exceptions_cmd
, _("\
3236 Set whether exceptions in the inferior process will be trapped.\n\
3237 When exceptions are turned off, neither breakpoints nor single-stepping\n\
3240 /* Allow `set exc' despite conflict with `set exception-port'. */
3241 add_alias_cmd ("exc", "exceptions", class_run
, 1, &setlist
);
3242 add_cmd ("exceptions", no_class
, show_exceptions_cmd
, _("\
3243 Show whether exceptions in the inferior process will be trapped."),
3246 add_prefix_cmd ("task", no_class
, set_task_cmd
,
3247 _("Command prefix for setting task attributes."),
3248 &set_task_cmd_list
, "set task ", 0, &setlist
);
3249 add_prefix_cmd ("task", no_class
, show_task_cmd
,
3250 _("Command prefix for showing task attributes."),
3251 &show_task_cmd_list
, "show task ", 0, &showlist
);
3253 add_cmd ("pause", class_run
, set_task_pause_cmd
, _("\
3254 Set whether the task is suspended while gdb has control.\n\
3255 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3256 until the next time the program is continued.\n\
3257 When setting this to \"off\", \"set thread default pause on\" can be\n\
3258 used to pause individual threads by default instead."),
3259 &set_task_cmd_list
);
3260 add_cmd ("pause", no_class
, show_task_pause_cmd
,
3261 _("Show whether the task is suspended while gdb has control."),
3262 &show_task_cmd_list
);
3264 add_cmd ("detach-suspend-count", class_run
, set_task_detach_sc_cmd
,
3265 _("Set the suspend count will leave on the thread when detaching."),
3266 &set_task_cmd_list
);
3267 add_cmd ("detach-suspend-count", no_class
, show_task_detach_sc_cmd
,
3268 _("Show the suspend count will leave "
3269 "on the thread when detaching."),
3270 &show_task_cmd_list
);
3272 add_cmd ("exception-port", no_class
, set_task_exc_port_cmd
, _("\
3273 Set the task exception port to which we forward exceptions.\n\
3274 The argument should be the value of the send right in the task."),
3275 &set_task_cmd_list
);
3276 add_alias_cmd ("excp", "exception-port", no_class
, 1, &set_task_cmd_list
);
3277 add_alias_cmd ("exc-port", "exception-port", no_class
, 1,
3278 &set_task_cmd_list
);
3280 /* A convenient way of turning on all options require to noninvasively
3281 debug running tasks. */
3282 add_cmd ("noninvasive", no_class
, set_noninvasive_cmd
, _("\
3283 Set task options so that we interfere as little as possible.\n\
3284 This is the same as setting `task pause', `exceptions', and\n\
3285 `signals' to the opposite value."),
3288 /* Commands to show information about the task's ports. */
3289 add_info ("send-rights", info_send_rights_cmd
,
3290 _("Show information about the task's send rights"));
3291 add_info ("receive-rights", info_recv_rights_cmd
,
3292 _("Show information about the task's receive rights"));
3293 add_info ("port-rights", info_port_rights_cmd
,
3294 _("Show information about the task's port rights"));
3295 add_info ("port-sets", info_port_sets_cmd
,
3296 _("Show information about the task's port sets"));
3297 add_info ("dead-names", info_dead_names_cmd
,
3298 _("Show information about the task's dead names"));
3299 add_info_alias ("ports", "port-rights", 1);
3300 add_info_alias ("port", "port-rights", 1);
3301 add_info_alias ("psets", "port-sets", 1);
3306 set_thread_pause_cmd (char *args
, int from_tty
)
3308 struct proc
*thread
= cur_thread ();
3309 int old_sc
= thread
->pause_sc
;
3311 thread
->pause_sc
= parse_bool_arg (args
, "set thread pause");
3312 if (old_sc
== 0 && thread
->pause_sc
!= 0 && thread
->inf
->pause_sc
== 0)
3313 /* If the task is currently unsuspended, immediately suspend it,
3314 otherwise wait until the next time it gets control. */
3315 inf_suspend (thread
->inf
);
3319 show_thread_pause_cmd (char *args
, int from_tty
)
3321 struct proc
*thread
= cur_thread ();
3322 int sc
= thread
->pause_sc
;
3324 check_empty (args
, "show task pause");
3325 printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n",
3326 proc_string (thread
),
3327 sc
? "is" : "isn't",
3328 !sc
&& thread
->inf
->pause_sc
? " (but the task is)" : "");
3332 set_thread_run_cmd (char *args
, int from_tty
)
3334 struct proc
*thread
= cur_thread ();
3336 thread
->run_sc
= parse_bool_arg (args
, "set thread run") ? 0 : 1;
3340 show_thread_run_cmd (char *args
, int from_tty
)
3342 struct proc
*thread
= cur_thread ();
3344 check_empty (args
, "show thread run");
3345 printf_unfiltered ("Thread %s %s allowed to run.",
3346 proc_string (thread
),
3347 thread
->run_sc
== 0 ? "is" : "isn't");
3351 set_thread_detach_sc_cmd (char *args
, int from_tty
)
3353 cur_thread ()->detach_sc
= parse_int_arg (args
,
3354 "set thread detach-suspend-count");
3358 show_thread_detach_sc_cmd (char *args
, int from_tty
)
3360 struct proc
*thread
= cur_thread ();
3362 check_empty (args
, "show thread detach-suspend-count");
3363 printf_unfiltered ("Thread %s will be left with a suspend count"
3364 " of %d when detaching.\n",
3365 proc_string (thread
),
3370 set_thread_exc_port_cmd (char *args
, int from_tty
)
3372 struct proc
*thread
= cur_thread ();
3375 error (_("No argument to \"set thread exception-port\" command."));
3376 steal_exc_port (thread
, parse_and_eval_address (args
));
3381 show_thread_cmd (char *args
, int from_tty
)
3383 struct proc
*thread
= cur_thread ();
3385 check_empty (args
, "show thread");
3386 show_thread_run_cmd (0, from_tty
);
3387 show_thread_pause_cmd (0, from_tty
);
3388 if (thread
->detach_sc
!= 0)
3389 show_thread_detach_sc_cmd (0, from_tty
);
3394 thread_takeover_sc_cmd (char *args
, int from_tty
)
3396 struct proc
*thread
= cur_thread ();
3398 thread_basic_info_data_t _info
;
3399 thread_basic_info_t info
= &_info
;
3400 mach_msg_type_number_t info_len
= THREAD_BASIC_INFO_COUNT
;
3402 thread_info (thread
->port
, THREAD_BASIC_INFO
, (int *) &info
, &info_len
);
3404 error (("%s."), safe_strerror (err
));
3405 thread
->sc
= info
->suspend_count
;
3407 printf_unfiltered ("Suspend count was %d.\n", thread
->sc
);
3409 vm_deallocate (mach_task_self (), (vm_address_t
) info
,
3410 info_len
* sizeof (int));
3415 add_thread_commands (void)
3417 add_prefix_cmd ("thread", no_class
, set_thread_cmd
,
3418 _("Command prefix for setting thread properties."),
3419 &set_thread_cmd_list
, "set thread ", 0, &setlist
);
3420 add_prefix_cmd ("default", no_class
, show_thread_cmd
,
3421 _("Command prefix for setting default thread properties."),
3422 &set_thread_default_cmd_list
, "set thread default ", 0,
3423 &set_thread_cmd_list
);
3424 add_prefix_cmd ("thread", no_class
, set_thread_default_cmd
,
3425 _("Command prefix for showing thread properties."),
3426 &show_thread_cmd_list
, "show thread ", 0, &showlist
);
3427 add_prefix_cmd ("default", no_class
, show_thread_default_cmd
,
3428 _("Command prefix for showing default thread properties."),
3429 &show_thread_default_cmd_list
, "show thread default ", 0,
3430 &show_thread_cmd_list
);
3432 add_cmd ("pause", class_run
, set_thread_pause_cmd
, _("\
3433 Set whether the current thread is suspended while gdb has control.\n\
3434 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3435 until the next time the program is continued. This property normally\n\
3436 has no effect because the whole task is suspended, however, that may\n\
3437 be disabled with \"set task pause off\".\n\
3438 The default value is \"off\"."),
3439 &set_thread_cmd_list
);
3440 add_cmd ("pause", no_class
, show_thread_pause_cmd
, _("\
3441 Show whether the current thread is suspended while gdb has control."),
3442 &show_thread_cmd_list
);
3444 add_cmd ("run", class_run
, set_thread_run_cmd
,
3445 _("Set whether the current thread is allowed to run."),
3446 &set_thread_cmd_list
);
3447 add_cmd ("run", no_class
, show_thread_run_cmd
,
3448 _("Show whether the current thread is allowed to run."),
3449 &show_thread_cmd_list
);
3451 add_cmd ("detach-suspend-count", class_run
, set_thread_detach_sc_cmd
, _("\
3452 Set the suspend count will leave on the thread when detaching.\n\
3453 Note that this is relative to suspend count when gdb noticed the thread;\n\
3454 use the `thread takeover-suspend-count' to force it to an absolute value."),
3455 &set_thread_cmd_list
);
3456 add_cmd ("detach-suspend-count", no_class
, show_thread_detach_sc_cmd
, _("\
3457 Show the suspend count will leave on the thread when detaching.\n\
3458 Note that this is relative to suspend count when gdb noticed the thread;\n\
3459 use the `thread takeover-suspend-count' to force it to an absolute value."),
3460 &show_thread_cmd_list
);
3462 add_cmd ("exception-port", no_class
, set_thread_exc_port_cmd
, _("\
3463 Set the thread exception port to which we forward exceptions.\n\
3464 This overrides the task exception port.\n\
3465 The argument should be the value of the send right in the task."),
3466 &set_thread_cmd_list
);
3467 add_alias_cmd ("excp", "exception-port", no_class
, 1, &set_thread_cmd_list
);
3468 add_alias_cmd ("exc-port", "exception-port", no_class
, 1,
3469 &set_thread_cmd_list
);
3471 add_cmd ("takeover-suspend-count", no_class
, thread_takeover_sc_cmd
, _("\
3472 Force the threads absolute suspend-count to be gdb's.\n\
3473 Prior to giving this command, gdb's thread suspend-counts are relative\n\
3474 to the thread's initial suspend-count when gdb notices the threads."),
3480 /* -Wmissing-prototypes */
3481 extern initialize_file_ftype _initialize_gnu_nat
;
3484 _initialize_gnu_nat (void)
3486 proc_server
= getproc ();
3488 add_task_commands ();
3489 add_thread_commands ();
3490 add_setshow_boolean_cmd ("gnu-nat", class_maintenance
,
3492 _("Set debugging output for the gnu backend."),
3493 _("Show debugging output for the gnu backend."),
3501 #ifdef FLUSH_INFERIOR_CACHE
3503 /* When over-writing code on some machines the I-Cache must be flushed
3504 explicitly, because it is not kept coherent by the lazy hardware.
3505 This definitely includes breakpoints, for instance, or else we
3506 end up looping in mysterious Bpt traps. */
3509 flush_inferior_icache (CORE_ADDR pc
, int amount
)
3511 vm_machine_attribute_val_t flush
= MATTR_VAL_ICACHE_FLUSH
;
3514 ret
= vm_machine_attribute (gnu_current_inf
->task
->port
,
3519 if (ret
!= KERN_SUCCESS
)
3520 warning (_("Error flushing inferior's cache : %s"), safe_strerror (ret
));
3522 #endif /* FLUSH_INFERIOR_CACHE */