1 /* Interface GDB to the GNU Hurd.
2 Copyright (C) 1992-2014 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/>. */
32 #include <sys/ptrace.h>
35 #include <mach_error.h>
36 #include <mach/exception.h>
37 #include <mach/message.h>
38 #include <mach/notify.h>
39 #include <mach/vm_attributes.h>
42 #include <hurd/interrupt.h>
44 #include <hurd/msg_request.h>
45 #include <hurd/process.h>
46 /* Defined in <hurd/process.h>, but we need forward declarations from
47 <hurd/process_request.h> as well. */
49 #include <hurd/process_request.h>
50 #include <hurd/signal.h>
51 #include <hurd/sigpreempt.h>
63 #include "gdbthread.h"
64 #include "gdb_assert.h"
65 #include "gdb_obstack.h"
68 #include "inf-child.h"
70 #include "exc_request_S.h"
72 #include "process_reply_S.h"
73 #include "msg_reply_S.h"
74 #include "exc_request_U.h"
77 static process_t proc_server
= MACH_PORT_NULL
;
79 /* If we've sent a proc_wait_request to the proc server, the pid of the
80 process we asked about. We can only ever have one outstanding. */
81 int proc_wait_pid
= 0;
83 /* The number of wait requests we've sent, and expect replies from. */
84 int proc_waits_pending
= 0;
86 int gnu_debug_flag
= 0;
90 static struct inf
*make_inf ();
91 void inf_clear_wait (struct inf
*inf
);
92 void inf_cleanup (struct inf
*inf
);
93 void inf_startup (struct inf
*inf
, int pid
);
94 int inf_update_suspends (struct inf
*inf
);
95 void inf_set_pid (struct inf
*inf
, pid_t pid
);
96 void inf_validate_procs (struct inf
*inf
);
97 void inf_steal_exc_ports (struct inf
*inf
);
98 void inf_restore_exc_ports (struct inf
*inf
);
99 void inf_set_threads_resume_sc (struct inf
*inf
,
100 struct proc
*run_thread
,
102 int inf_set_threads_resume_sc_for_signal_thread (struct inf
*inf
);
103 void inf_suspend (struct inf
*inf
);
104 void inf_resume (struct inf
*inf
);
105 void inf_set_step_thread (struct inf
*inf
, struct proc
*proc
);
106 void inf_detach (struct inf
*inf
);
107 void inf_attach (struct inf
*inf
, int pid
);
108 void inf_signal (struct inf
*inf
, enum gdb_signal sig
);
109 void inf_continue (struct inf
*inf
);
111 #define inf_debug(_inf, msg, args...) \
112 do { struct inf *__inf = (_inf); \
113 debug ("{inf %d %s}: " msg, __inf->pid, \
114 host_address_to_string (__inf) , ##args); } while (0)
116 void proc_abort (struct proc
*proc
, int force
);
117 struct proc
*make_proc (struct inf
*inf
, mach_port_t port
, int tid
);
118 struct proc
*_proc_free (struct proc
*proc
);
119 int proc_update_sc (struct proc
*proc
);
120 error_t
proc_get_exception_port (struct proc
*proc
, mach_port_t
* port
);
121 error_t
proc_set_exception_port (struct proc
*proc
, mach_port_t port
);
122 static mach_port_t
_proc_get_exc_port (struct proc
*proc
);
123 void proc_steal_exc_port (struct proc
*proc
, mach_port_t exc_port
);
124 void proc_restore_exc_port (struct proc
*proc
);
125 int proc_trace (struct proc
*proc
, int set
);
127 /* Evaluate RPC_EXPR in a scope with the variables MSGPORT and REFPORT bound
128 to INF's msg port and task port respectively. If it has no msg port,
129 EIEIO is returned. INF must refer to a running process! */
130 #define INF_MSGPORT_RPC(inf, rpc_expr) \
131 HURD_MSGPORT_RPC (proc_getmsgport (proc_server, inf->pid, &msgport), \
132 (refport = inf->task->port, 0), 0, \
133 msgport ? (rpc_expr) : EIEIO)
135 /* Like INF_MSGPORT_RPC, but will also resume the signal thread to ensure
136 there's someone around to deal with the RPC (and resuspend things
137 afterwards). This effects INF's threads' resume_sc count. */
138 #define INF_RESUME_MSGPORT_RPC(inf, rpc_expr) \
139 (inf_set_threads_resume_sc_for_signal_thread (inf) \
142 __e = INF_MSGPORT_RPC (inf, rpc_expr); \
148 /* The state passed by an exception message. */
151 int exception
; /* The exception code. */
153 mach_port_t handler
; /* The real exception port to handle this. */
154 mach_port_t reply
; /* The reply port from the exception call. */
157 /* The results of the last wait an inf did. */
160 struct target_waitstatus status
; /* The status returned to gdb. */
161 struct exc_state exc
; /* The exception that caused us to return. */
162 struct proc
*thread
; /* The thread in question. */
163 int suppress
; /* Something trivial happened. */
166 /* The state of an inferior. */
169 /* Fields describing the current inferior. */
171 struct proc
*task
; /* The mach task. */
172 struct proc
*threads
; /* A linked list of all threads in TASK. */
174 /* True if THREADS needn't be validated by querying the task. We
175 assume that we and the task in question are the only ones
176 frobbing the thread list, so as long as we don't let any code
177 run, we don't have to worry about THREADS changing. */
178 int threads_up_to_date
;
180 pid_t pid
; /* The real system PID. */
182 struct inf_wait wait
; /* What to return from target_wait. */
184 /* One thread proc in INF may be in `single-stepping mode'. This
186 struct proc
*step_thread
;
188 /* The thread we think is the signal thread. */
189 struct proc
*signal_thread
;
191 mach_port_t event_port
; /* Where we receive various msgs. */
193 /* True if we think at least one thread in the inferior could currently be
195 unsigned int running
:1;
197 /* True if the process has stopped (in the proc server sense). Note that
198 since a proc server `stop' leaves the signal thread running, the inf can
199 be RUNNING && STOPPED... */
200 unsigned int stopped
:1;
202 /* True if the inferior has no message port. */
203 unsigned int nomsg
:1;
205 /* True if the inferior is traced. */
206 unsigned int traced
:1;
208 /* True if we shouldn't try waiting for the inferior, usually because we
209 can't for some reason. */
210 unsigned int no_wait
:1;
212 /* When starting a new inferior, we don't try to validate threads until all
213 the proper execs have been done. This is a count of how many execs we
215 unsigned pending_execs
;
217 /* Fields describing global state. */
219 /* The task suspend count used when gdb has control. This is normally 1 to
220 make things easier for us, but sometimes (like when attaching to vital
221 system servers) it may be desirable to let the task continue to run
222 (pausing individual threads as necessary). */
225 /* The task suspend count left when detaching from a task. */
228 /* The initial values used for the run_sc and pause_sc of newly discovered
229 threads -- see the definition of those fields in struct proc. */
230 int default_thread_run_sc
;
231 int default_thread_pause_sc
;
232 int default_thread_detach_sc
;
234 /* True if the process should be traced when started/attached. Newly
235 started processes *must* be traced at first to exec them properly, but
236 if this is false, tracing is turned off as soon it has done so. */
239 /* True if exceptions from the inferior process should be trapped. This
240 must be on to use breakpoints. */
246 __proc_pid (struct proc
*proc
)
248 return proc
->inf
->pid
;
252 /* Update PROC's real suspend count to match it's desired one. Returns true
253 if we think PROC is now in a runnable state. */
255 proc_update_sc (struct proc
*proc
)
259 int delta
= proc
->sc
- proc
->cur_sc
;
262 proc_debug (proc
, "sc: %d --> %d", proc
->cur_sc
, proc
->sc
);
264 if (proc
->sc
== 0 && proc
->state_changed
)
265 /* Since PROC may start running, we must write back any state changes. */
267 gdb_assert (proc_is_thread (proc
));
268 proc_debug (proc
, "storing back changed thread state");
269 err
= thread_set_state (proc
->port
, THREAD_STATE_FLAVOR
,
270 (thread_state_t
) &proc
->state
, THREAD_STATE_SIZE
);
272 proc
->state_changed
= 0;
277 while (delta
-- > 0 && !err
)
279 if (proc_is_task (proc
))
280 err
= task_suspend (proc
->port
);
282 err
= thread_suspend (proc
->port
);
287 while (delta
++ < 0 && !err
)
289 if (proc_is_task (proc
))
290 err
= task_resume (proc
->port
);
292 err
= thread_resume (proc
->port
);
296 proc
->cur_sc
= proc
->sc
;
298 /* If we got an error, then the task/thread has disappeared. */
299 running
= !err
&& proc
->sc
== 0;
301 proc_debug (proc
, "is %s", err
? "dead" : running
? "running" : "suspended");
303 proc_debug (proc
, "err = %s", safe_strerror (err
));
308 proc
->state_valid
= proc
->state_changed
= 0;
309 proc
->fetched_regs
= 0;
316 /* Thread_abort is called on PROC if needed. PROC must be a thread proc.
317 If PROC is deemed `precious', then nothing is done unless FORCE is true.
318 In particular, a thread is precious if it's running (in which case forcing
319 it includes suspending it first), or if it has an exception pending. */
321 proc_abort (struct proc
*proc
, int force
)
323 gdb_assert (proc_is_thread (proc
));
327 struct inf
*inf
= proc
->inf
;
328 int running
= (proc
->cur_sc
== 0 && inf
->task
->cur_sc
== 0);
330 if (running
&& force
)
333 inf_update_suspends (proc
->inf
);
335 warning (_("Stopped %s."), proc_string (proc
));
337 else if (proc
== inf
->wait
.thread
&& inf
->wait
.exc
.reply
&& !force
)
338 /* An exception is pending on PROC, which don't mess with. */
342 /* We only abort the thread if it's not actually running. */
344 thread_abort (proc
->port
);
345 proc_debug (proc
, "aborted");
349 proc_debug (proc
, "not aborting");
353 /* Make sure that the state field in PROC is up to date, and return a pointer
354 to it, or 0 if something is wrong. If WILL_MODIFY is true, makes sure
355 that the thread is stopped and aborted first, and sets the state_changed
356 field in PROC to true. */
358 proc_get_state (struct proc
*proc
, int will_modify
)
360 int was_aborted
= proc
->aborted
;
362 proc_debug (proc
, "updating state info%s",
363 will_modify
? " (with intention to modify)" : "");
365 proc_abort (proc
, will_modify
);
367 if (!was_aborted
&& proc
->aborted
)
368 /* PROC's state may have changed since we last fetched it. */
369 proc
->state_valid
= 0;
371 if (!proc
->state_valid
)
373 mach_msg_type_number_t state_size
= THREAD_STATE_SIZE
;
375 thread_get_state (proc
->port
, THREAD_STATE_FLAVOR
,
376 (thread_state_t
) &proc
->state
, &state_size
);
378 proc_debug (proc
, "getting thread state");
379 proc
->state_valid
= !err
;
382 if (proc
->state_valid
)
385 proc
->state_changed
= 1;
386 return (thread_state_t
) &proc
->state
;
393 /* Set PORT to PROC's exception port. */
395 proc_get_exception_port (struct proc
* proc
, mach_port_t
* port
)
397 if (proc_is_task (proc
))
398 return task_get_exception_port (proc
->port
, port
);
400 return thread_get_exception_port (proc
->port
, port
);
403 /* Set PROC's exception port to PORT. */
405 proc_set_exception_port (struct proc
* proc
, mach_port_t port
)
407 proc_debug (proc
, "setting exception port: %d", port
);
408 if (proc_is_task (proc
))
409 return task_set_exception_port (proc
->port
, port
);
411 return thread_set_exception_port (proc
->port
, port
);
414 /* Get PROC's exception port, cleaning up a bit if proc has died. */
416 _proc_get_exc_port (struct proc
*proc
)
418 mach_port_t exc_port
;
419 error_t err
= proc_get_exception_port (proc
, &exc_port
);
422 /* PROC must be dead. */
425 mach_port_deallocate (mach_task_self (), proc
->exc_port
);
426 proc
->exc_port
= MACH_PORT_NULL
;
427 if (proc
->saved_exc_port
)
428 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
429 proc
->saved_exc_port
= MACH_PORT_NULL
;
435 /* Replace PROC's exception port with EXC_PORT, unless it's already
436 been done. Stash away any existing exception port so we can
439 proc_steal_exc_port (struct proc
*proc
, mach_port_t exc_port
)
441 mach_port_t cur_exc_port
= _proc_get_exc_port (proc
);
447 proc_debug (proc
, "inserting exception port: %d", exc_port
);
449 if (cur_exc_port
!= exc_port
)
450 /* Put in our exception port. */
451 err
= proc_set_exception_port (proc
, exc_port
);
453 if (err
|| cur_exc_port
== proc
->exc_port
)
454 /* We previously set the exception port, and it's still set. So we
455 just keep the old saved port which is what the proc set. */
458 mach_port_deallocate (mach_task_self (), cur_exc_port
);
461 /* Keep a copy of PROC's old exception port so it can be restored. */
463 if (proc
->saved_exc_port
)
464 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
465 proc
->saved_exc_port
= cur_exc_port
;
468 proc_debug (proc
, "saved exception port: %d", proc
->saved_exc_port
);
471 proc
->exc_port
= exc_port
;
473 warning (_("Error setting exception port for %s: %s"),
474 proc_string (proc
), safe_strerror (err
));
478 /* If we previously replaced PROC's exception port, put back what we
479 found there at the time, unless *our* exception port has since been
480 overwritten, in which case who knows what's going on. */
482 proc_restore_exc_port (struct proc
*proc
)
484 mach_port_t cur_exc_port
= _proc_get_exc_port (proc
);
490 proc_debug (proc
, "restoring real exception port");
492 if (proc
->exc_port
== cur_exc_port
)
493 /* Our's is still there. */
494 err
= proc_set_exception_port (proc
, proc
->saved_exc_port
);
496 if (proc
->saved_exc_port
)
497 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
498 proc
->saved_exc_port
= MACH_PORT_NULL
;
501 proc
->exc_port
= MACH_PORT_NULL
;
503 warning (_("Error setting exception port for %s: %s"),
504 proc_string (proc
), safe_strerror (err
));
509 /* Turns hardware tracing in PROC on or off when SET is true or false,
510 respectively. Returns true on success. */
512 proc_trace (struct proc
*proc
, int set
)
514 thread_state_t state
= proc_get_state (proc
, 1);
517 return 0; /* The thread must be dead. */
519 proc_debug (proc
, "tracing %s", set
? "on" : "off");
523 /* XXX We don't get the exception unless the thread has its own
524 exception port???? */
525 if (proc
->exc_port
== MACH_PORT_NULL
)
526 proc_steal_exc_port (proc
, proc
->inf
->event_port
);
527 THREAD_STATE_SET_TRACED (state
);
530 THREAD_STATE_CLEAR_TRACED (state
);
536 /* A variable from which to assign new TIDs. */
537 static int next_thread_id
= 1;
539 /* Returns a new proc structure with the given fields. Also adds a
540 notification for PORT becoming dead to be sent to INF's notify port. */
542 make_proc (struct inf
*inf
, mach_port_t port
, int tid
)
545 mach_port_t prev_port
= MACH_PORT_NULL
;
546 struct proc
*proc
= xmalloc (sizeof (struct proc
));
552 proc
->saved_exc_port
= MACH_PORT_NULL
;
553 proc
->exc_port
= MACH_PORT_NULL
;
558 /* Note that these are all the values for threads; the task simply uses the
559 corresponding field in INF directly. */
560 proc
->run_sc
= inf
->default_thread_run_sc
;
561 proc
->pause_sc
= inf
->default_thread_pause_sc
;
562 proc
->detach_sc
= inf
->default_thread_detach_sc
;
563 proc
->resume_sc
= proc
->run_sc
;
567 proc
->state_valid
= 0;
568 proc
->state_changed
= 0;
570 proc_debug (proc
, "is new");
572 /* Get notified when things die. */
574 mach_port_request_notification (mach_task_self (), port
,
575 MACH_NOTIFY_DEAD_NAME
, 1,
577 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
580 warning (_("Couldn't request notification for port %d: %s"),
581 port
, safe_strerror (err
));
584 proc_debug (proc
, "notifications to: %d", inf
->event_port
);
585 if (prev_port
!= MACH_PORT_NULL
)
586 mach_port_deallocate (mach_task_self (), prev_port
);
589 if (inf
->want_exceptions
)
591 if (proc_is_task (proc
))
592 /* Make the task exception port point to us. */
593 proc_steal_exc_port (proc
, inf
->event_port
);
595 /* Just clear thread exception ports -- they default to the
597 proc_steal_exc_port (proc
, MACH_PORT_NULL
);
603 /* Frees PROC and any resources it uses, and returns the value of PROC's
606 _proc_free (struct proc
*proc
)
608 struct inf
*inf
= proc
->inf
;
609 struct proc
*next
= proc
->next
;
611 proc_debug (proc
, "freeing...");
613 if (proc
== inf
->step_thread
)
614 /* Turn off single stepping. */
615 inf_set_step_thread (inf
, 0);
616 if (proc
== inf
->wait
.thread
)
617 inf_clear_wait (inf
);
618 if (proc
== inf
->signal_thread
)
619 inf
->signal_thread
= 0;
621 if (proc
->port
!= MACH_PORT_NULL
)
623 if (proc
->exc_port
!= MACH_PORT_NULL
)
624 /* Restore the original exception port. */
625 proc_restore_exc_port (proc
);
626 if (proc
->cur_sc
!= 0)
627 /* Resume the thread/task. */
630 proc_update_sc (proc
);
632 mach_port_deallocate (mach_task_self (), proc
->port
);
643 struct inf
*inf
= xmalloc (sizeof (struct inf
));
647 inf
->threads_up_to_date
= 0;
649 inf
->wait
.status
.kind
= TARGET_WAITKIND_SPURIOUS
;
650 inf
->wait
.thread
= 0;
651 inf
->wait
.exc
.handler
= MACH_PORT_NULL
;
652 inf
->wait
.exc
.reply
= MACH_PORT_NULL
;
653 inf
->step_thread
= 0;
654 inf
->signal_thread
= 0;
655 inf
->event_port
= MACH_PORT_NULL
;
661 inf
->pending_execs
= 0;
664 inf
->default_thread_run_sc
= 0;
665 inf
->default_thread_pause_sc
= 0;
666 inf
->default_thread_detach_sc
= 0;
667 inf
->want_signals
= 1; /* By default */
668 inf
->want_exceptions
= 1; /* By default */
673 /* Clear INF's target wait status. */
675 inf_clear_wait (struct inf
*inf
)
677 inf_debug (inf
, "clearing wait");
678 inf
->wait
.status
.kind
= TARGET_WAITKIND_SPURIOUS
;
679 inf
->wait
.thread
= 0;
680 inf
->wait
.suppress
= 0;
681 if (inf
->wait
.exc
.handler
!= MACH_PORT_NULL
)
683 mach_port_deallocate (mach_task_self (), inf
->wait
.exc
.handler
);
684 inf
->wait
.exc
.handler
= MACH_PORT_NULL
;
686 if (inf
->wait
.exc
.reply
!= MACH_PORT_NULL
)
688 mach_port_deallocate (mach_task_self (), inf
->wait
.exc
.reply
);
689 inf
->wait
.exc
.reply
= MACH_PORT_NULL
;
695 inf_cleanup (struct inf
*inf
)
697 inf_debug (inf
, "cleanup");
699 inf_clear_wait (inf
);
701 inf_set_pid (inf
, -1);
708 inf
->pending_execs
= 0;
712 mach_port_destroy (mach_task_self (), inf
->event_port
);
713 inf
->event_port
= MACH_PORT_NULL
;
718 inf_startup (struct inf
*inf
, int pid
)
722 inf_debug (inf
, "startup: pid = %d", pid
);
726 /* Make the port on which we receive all events. */
727 err
= mach_port_allocate (mach_task_self (),
728 MACH_PORT_RIGHT_RECEIVE
, &inf
->event_port
);
730 error (_("Error allocating event port: %s"), safe_strerror (err
));
732 /* Make a send right for it, so we can easily copy it for other people. */
733 mach_port_insert_right (mach_task_self (), inf
->event_port
,
734 inf
->event_port
, MACH_MSG_TYPE_MAKE_SEND
);
735 inf_set_pid (inf
, pid
);
739 /* Close current process, if any, and attach INF to process PORT. */
741 inf_set_pid (struct inf
*inf
, pid_t pid
)
744 struct proc
*task
= inf
->task
;
746 inf_debug (inf
, "setting pid: %d", pid
);
749 task_port
= MACH_PORT_NULL
;
752 error_t err
= proc_pid2task (proc_server
, pid
, &task_port
);
755 error (_("Error getting task for pid %d: %s"),
756 pid
, safe_strerror (err
));
759 inf_debug (inf
, "setting task: %d", task_port
);
762 task_suspend (task_port
);
764 if (task
&& task
->port
!= task_port
)
767 inf_validate_procs (inf
); /* Trash all the threads. */
768 _proc_free (task
); /* And the task. */
771 if (task_port
!= MACH_PORT_NULL
)
773 inf
->task
= make_proc (inf
, task_port
, PROC_TID_TASK
);
774 inf
->threads_up_to_date
= 0;
781 /* Reflect task_suspend above. */
782 inf
->task
->sc
= inf
->task
->cur_sc
= 1;
789 /* Validates INF's stopped, nomsg and traced field from the actual
790 proc server state. Note that the traced field is only updated from
791 the proc server state if we do not have a message port. If we do
792 have a message port we'd better look at the tracemask itself. */
794 inf_validate_procinfo (struct inf
*inf
)
797 mach_msg_type_number_t noise_len
= 0;
799 mach_msg_type_number_t pi_len
= 0;
802 proc_getprocinfo (proc_server
, inf
->pid
, &info_flags
,
803 (procinfo_t
*) &pi
, &pi_len
, &noise
, &noise_len
);
807 inf
->stopped
= !!(pi
->state
& PI_STOPPED
);
808 inf
->nomsg
= !!(pi
->state
& PI_NOMSG
);
810 inf
->traced
= !!(pi
->state
& PI_TRACED
);
811 vm_deallocate (mach_task_self (), (vm_address_t
) pi
, pi_len
);
813 vm_deallocate (mach_task_self (), (vm_address_t
) noise
, noise_len
);
817 /* Validates INF's task suspend count. If it's higher than we expect,
818 verify with the user before `stealing' the extra count. */
820 inf_validate_task_sc (struct inf
*inf
)
823 mach_msg_type_number_t noise_len
= 0;
825 mach_msg_type_number_t pi_len
= 0;
826 int info_flags
= PI_FETCH_TASKINFO
;
827 int suspend_count
= -1;
831 err
= proc_getprocinfo (proc_server
, inf
->pid
, &info_flags
,
832 (procinfo_t
*) &pi
, &pi_len
, &noise
, &noise_len
);
835 inf
->task
->dead
= 1; /* oh well */
839 if (inf
->task
->cur_sc
< pi
->taskinfo
.suspend_count
&& suspend_count
== -1)
841 /* The proc server might have suspended the task while stopping
842 it. This happens when the task is handling a traced signal.
843 Refetch the suspend count. The proc server should be
844 finished stopping the task by now. */
845 suspend_count
= pi
->taskinfo
.suspend_count
;
849 suspend_count
= pi
->taskinfo
.suspend_count
;
851 vm_deallocate (mach_task_self (), (vm_address_t
) pi
, pi_len
);
853 vm_deallocate (mach_task_self (), (vm_address_t
) pi
, pi_len
);
855 if (inf
->task
->cur_sc
< suspend_count
)
859 target_terminal_ours (); /* Allow I/O. */
860 abort
= !query (_("Pid %d has an additional task suspend count of %d;"
861 " clear it? "), inf
->pid
,
862 suspend_count
- inf
->task
->cur_sc
);
863 target_terminal_inferior (); /* Give it back to the child. */
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
;
991 /* Make INF's list of threads be consistent with reality of TASK. */
993 inf_validate_procs (struct inf
*inf
)
995 thread_array_t threads
;
996 mach_msg_type_number_t num_threads
, i
;
997 struct proc
*task
= inf
->task
;
999 /* If no threads are currently running, this function will guarantee that
1000 things are up to date. The exception is if there are zero threads --
1001 then it is almost certainly in an odd state, and probably some outside
1002 agent will create threads. */
1003 inf
->threads_up_to_date
= inf
->threads
? !inf
->running
: 0;
1007 error_t err
= task_threads (task
->port
, &threads
, &num_threads
);
1009 inf_debug (inf
, "fetching threads");
1011 /* TASK must be dead. */
1021 inf_debug (inf
, "no task");
1025 /* Make things normally linear. */
1026 mach_msg_type_number_t search_start
= 0;
1027 /* Which thread in PROCS corresponds to each task thread, & the task. */
1028 struct proc
*matched
[num_threads
+ 1];
1029 /* The last thread in INF->threads, so we can add to the end. */
1030 struct proc
*last
= 0;
1031 /* The current thread we're considering. */
1032 struct proc
*thread
= inf
->threads
;
1034 memset (matched
, 0, sizeof (matched
));
1038 mach_msg_type_number_t left
;
1040 for (i
= search_start
, left
= num_threads
; left
; i
++, left
--)
1042 if (i
>= num_threads
)
1043 i
-= num_threads
; /* I wrapped around. */
1044 if (thread
->port
== threads
[i
])
1045 /* We already know about this thread. */
1047 matched
[i
] = thread
;
1049 thread
= thread
->next
;
1057 proc_debug (thread
, "died!");
1058 thread
->port
= MACH_PORT_NULL
;
1059 thread
= _proc_free (thread
); /* THREAD is dead. */
1061 last
->next
= thread
;
1063 inf
->threads
= thread
;
1067 for (i
= 0; i
< num_threads
; i
++)
1070 /* Throw away the duplicate send right. */
1071 mach_port_deallocate (mach_task_self (), threads
[i
]);
1073 /* THREADS[I] is a thread we don't know about yet! */
1077 thread
= make_proc (inf
, threads
[i
], next_thread_id
++);
1079 last
->next
= thread
;
1081 inf
->threads
= thread
;
1083 proc_debug (thread
, "new thread: %d", threads
[i
]);
1085 ptid
= ptid_build (inf
->pid
, thread
->tid
, 0);
1087 /* Tell GDB's generic thread code. */
1089 if (ptid_equal (inferior_ptid
, pid_to_ptid (inf
->pid
)))
1090 /* This is the first time we're hearing about thread
1091 ids, after a fork-child. */
1092 thread_change_ptid (inferior_ptid
, ptid
);
1093 else if (inf
->pending_execs
!= 0)
1094 /* This is a shell thread. */
1095 add_thread_silent (ptid
);
1101 vm_deallocate (mach_task_self (),
1102 (vm_address_t
) threads
, (num_threads
* sizeof (thread_t
)));
1107 /* Makes sure that INF's thread list is synced with the actual process. */
1109 inf_update_procs (struct inf
*inf
)
1113 if (!inf
->threads_up_to_date
)
1114 inf_validate_procs (inf
);
1118 /* Sets the resume_sc of each thread in inf. That of RUN_THREAD is set to 0,
1119 and others are set to their run_sc if RUN_OTHERS is true, and otherwise
1122 inf_set_threads_resume_sc (struct inf
*inf
,
1123 struct proc
*run_thread
, int run_others
)
1125 struct proc
*thread
;
1127 inf_update_procs (inf
);
1128 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1129 if (thread
== run_thread
)
1130 thread
->resume_sc
= 0;
1131 else if (run_others
)
1132 thread
->resume_sc
= thread
->run_sc
;
1134 thread
->resume_sc
= thread
->pause_sc
;
1138 /* Cause INF to continue execution immediately; individual threads may still
1139 be suspended (but their suspend counts will be updated). */
1141 inf_resume (struct inf
*inf
)
1143 struct proc
*thread
;
1145 inf_update_procs (inf
);
1147 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1148 thread
->sc
= thread
->resume_sc
;
1152 if (!inf
->pending_execs
)
1153 /* Try to make sure our task count is correct -- in the case where
1154 we're waiting for an exec though, things are too volatile, so just
1155 assume things will be reasonable (which they usually will be). */
1156 inf_validate_task_sc (inf
);
1160 inf_update_suspends (inf
);
1163 /* Cause INF to stop execution immediately; individual threads may still
1166 inf_suspend (struct inf
*inf
)
1168 struct proc
*thread
;
1170 inf_update_procs (inf
);
1172 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1173 thread
->sc
= thread
->pause_sc
;
1176 inf
->task
->sc
= inf
->pause_sc
;
1178 inf_update_suspends (inf
);
1182 /* INF has one thread PROC that is in single-stepping mode. This
1183 function changes it to be PROC, changing any old step_thread to be
1184 a normal one. A PROC of 0 clears any existing value. */
1186 inf_set_step_thread (struct inf
*inf
, struct proc
*thread
)
1188 gdb_assert (!thread
|| proc_is_thread (thread
));
1191 inf_debug (inf
, "setting step thread: %d/%d", inf
->pid
, thread
->tid
);
1193 inf_debug (inf
, "clearing step thread");
1195 if (inf
->step_thread
!= thread
)
1197 if (inf
->step_thread
&& inf
->step_thread
->port
!= MACH_PORT_NULL
)
1198 if (!proc_trace (inf
->step_thread
, 0))
1200 if (thread
&& proc_trace (thread
, 1))
1201 inf
->step_thread
= thread
;
1203 inf
->step_thread
= 0;
1208 /* Set up the thread resume_sc's so that only the signal thread is running
1209 (plus whatever other thread are set to always run). Returns true if we
1210 did so, or false if we can't find a signal thread. */
1212 inf_set_threads_resume_sc_for_signal_thread (struct inf
*inf
)
1214 if (inf
->signal_thread
)
1216 inf_set_threads_resume_sc (inf
, inf
->signal_thread
, 0);
1224 inf_update_signal_thread (struct inf
*inf
)
1226 /* XXX for now we assume that if there's a msgport, the 2nd thread is
1227 the signal thread. */
1228 inf
->signal_thread
= inf
->threads
? inf
->threads
->next
: 0;
1232 /* Detachs from INF's inferior task, letting it run once again... */
1234 inf_detach (struct inf
*inf
)
1236 struct proc
*task
= inf
->task
;
1238 inf_debug (inf
, "detaching...");
1240 inf_clear_wait (inf
);
1241 inf_set_step_thread (inf
, 0);
1245 struct proc
*thread
;
1247 inf_validate_procinfo (inf
);
1249 inf_set_traced (inf
, 0);
1255 inf_signal (inf
, GDB_SIGNAL_0
);
1258 proc_restore_exc_port (task
);
1259 task
->sc
= inf
->detach_sc
;
1261 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1263 proc_restore_exc_port (thread
);
1264 thread
->sc
= thread
->detach_sc
;
1267 inf_update_suspends (inf
);
1273 /* Attaches INF to the process with process id PID, returning it in a
1274 suspended state suitable for debugging. */
1276 inf_attach (struct inf
*inf
, int pid
)
1278 inf_debug (inf
, "attaching: %d", pid
);
1283 inf_startup (inf
, pid
);
1287 /* Makes sure that we've got our exception ports entrenched in the process. */
1289 inf_steal_exc_ports (struct inf
*inf
)
1291 struct proc
*thread
;
1293 inf_debug (inf
, "stealing exception ports");
1295 inf_set_step_thread (inf
, 0); /* The step thread is special. */
1297 proc_steal_exc_port (inf
->task
, inf
->event_port
);
1298 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1299 proc_steal_exc_port (thread
, MACH_PORT_NULL
);
1302 /* Makes sure the process has its own exception ports. */
1304 inf_restore_exc_ports (struct inf
*inf
)
1306 struct proc
*thread
;
1308 inf_debug (inf
, "restoring exception ports");
1310 inf_set_step_thread (inf
, 0); /* The step thread is special. */
1312 proc_restore_exc_port (inf
->task
);
1313 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1314 proc_restore_exc_port (thread
);
1318 /* Deliver signal SIG to INF. If INF is stopped, delivering a signal, even
1319 signal 0, will continue it. INF is assumed to be in a paused state, and
1320 the resume_sc's of INF's threads may be affected. */
1322 inf_signal (struct inf
*inf
, enum gdb_signal sig
)
1325 int host_sig
= gdb_signal_to_host (sig
);
1327 #define NAME gdb_signal_to_name (sig)
1329 if (host_sig
>= _NSIG
)
1330 /* A mach exception. Exceptions are encoded in the signal space by
1331 putting them after _NSIG; this assumes they're positive (and not
1332 extremely large)! */
1334 struct inf_wait
*w
= &inf
->wait
;
1336 if (w
->status
.kind
== TARGET_WAITKIND_STOPPED
1337 && w
->status
.value
.sig
== sig
1338 && w
->thread
&& !w
->thread
->aborted
)
1339 /* We're passing through the last exception we received. This is
1340 kind of bogus, because exceptions are per-thread whereas gdb
1341 treats signals as per-process. We just forward the exception to
1342 the correct handler, even it's not for the same thread as TID --
1343 i.e., we pretend it's global. */
1345 struct exc_state
*e
= &w
->exc
;
1347 inf_debug (inf
, "passing through exception:"
1348 " task = %d, thread = %d, exc = %d"
1349 ", code = %d, subcode = %d",
1350 w
->thread
->port
, inf
->task
->port
,
1351 e
->exception
, e
->code
, e
->subcode
);
1353 exception_raise_request (e
->handler
,
1354 e
->reply
, MACH_MSG_TYPE_MOVE_SEND_ONCE
,
1355 w
->thread
->port
, inf
->task
->port
,
1356 e
->exception
, e
->code
, e
->subcode
);
1359 error (_("Can't forward spontaneous exception (%s)."), NAME
);
1362 /* A Unix signal. */
1364 /* The process is stopped and expecting a signal. Just send off a
1365 request and let it get handled when we resume everything. */
1367 inf_debug (inf
, "sending %s to stopped process", NAME
);
1369 INF_MSGPORT_RPC (inf
,
1370 msg_sig_post_untraced_request (msgport
,
1372 MACH_MSG_TYPE_MAKE_SEND_ONCE
,
1376 /* Posting an untraced signal automatically continues it.
1377 We clear this here rather than when we get the reply
1378 because we'd rather assume it's not stopped when it
1379 actually is, than the reverse. */
1383 /* It's not expecting it. We have to let just the signal thread
1384 run, and wait for it to get into a reasonable state before we
1385 can continue the rest of the process. When we finally resume the
1386 process the signal we request will be the very first thing that
1389 inf_debug (inf
, "sending %s to unstopped process"
1390 " (so resuming signal thread)", NAME
);
1392 INF_RESUME_MSGPORT_RPC (inf
,
1393 msg_sig_post_untraced (msgport
, host_sig
,
1398 /* Can't do too much... */
1399 warning (_("Can't deliver signal %s: No signal thread."), NAME
);
1401 warning (_("Delivering signal %s: %s"), NAME
, safe_strerror (err
));
1407 /* Continue INF without delivering a signal. This is meant to be used
1408 when INF does not have a message port. */
1410 inf_continue (struct inf
*inf
)
1413 error_t err
= proc_pid2proc (proc_server
, inf
->pid
, &proc
);
1417 inf_debug (inf
, "continuing process");
1419 err
= proc_mark_cont (proc
);
1422 struct proc
*thread
;
1424 for (thread
= inf
->threads
; thread
; thread
= thread
->next
)
1425 thread_resume (thread
->port
);
1432 warning (_("Can't continue process: %s"), safe_strerror (err
));
1436 /* The inferior used for all gdb target ops. */
1437 struct inf
*gnu_current_inf
= 0;
1439 /* The inferior being waited for by gnu_wait. Since GDB is decidely not
1440 multi-threaded, we don't bother to lock this. */
1441 struct inf
*waiting_inf
;
1443 /* Wait for something to happen in the inferior, returning what in STATUS. */
1445 gnu_wait (struct target_ops
*ops
,
1446 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
1450 mach_msg_header_t hdr
;
1451 mach_msg_type_t type
;
1455 struct proc
*thread
;
1456 struct inf
*inf
= gnu_current_inf
;
1458 extern int exc_server (mach_msg_header_t
*, mach_msg_header_t
*);
1459 extern int msg_reply_server (mach_msg_header_t
*, mach_msg_header_t
*);
1460 extern int notify_server (mach_msg_header_t
*, mach_msg_header_t
*);
1461 extern int process_reply_server (mach_msg_header_t
*, mach_msg_header_t
*);
1463 gdb_assert (inf
->task
);
1465 if (!inf
->threads
&& !inf
->pending_execs
)
1466 /* No threads! Assume that maybe some outside agency is frobbing our
1467 task, and really look for new threads. If we can't find any, just tell
1468 the user to try again later. */
1470 inf_validate_procs (inf
);
1471 if (!inf
->threads
&& !inf
->task
->dead
)
1472 error (_("There are no threads; try again later."));
1477 inf_debug (inf
, "waiting for: %s", target_pid_to_str (ptid
));
1480 if (proc_wait_pid
!= inf
->pid
&& !inf
->no_wait
)
1481 /* Always get information on events from the proc server. */
1483 inf_debug (inf
, "requesting wait on pid %d", inf
->pid
);
1486 /* The proc server is single-threaded, and only allows a single
1487 outstanding wait request, so we have to cancel the previous one. */
1489 inf_debug (inf
, "cancelling previous wait on pid %d", proc_wait_pid
);
1490 interrupt_operation (proc_server
, 0);
1494 proc_wait_request (proc_server
, inf
->event_port
, inf
->pid
, WUNTRACED
);
1496 warning (_("wait request failed: %s"), safe_strerror (err
));
1499 inf_debug (inf
, "waits pending: %d", proc_waits_pending
);
1500 proc_wait_pid
= inf
->pid
;
1501 /* Even if proc_waits_pending was > 0 before, we still won't
1502 get any other replies, because it was either from a
1503 different INF, or a different process attached to INF --
1504 and the event port, which is the wait reply port, changes
1505 when you switch processes. */
1506 proc_waits_pending
= 1;
1510 inf_clear_wait (inf
);
1512 /* What can happen? (1) Dead name notification; (2) Exceptions arrive;
1513 (3) wait reply from the proc server. */
1515 inf_debug (inf
, "waiting for an event...");
1516 err
= mach_msg (&msg
.hdr
, MACH_RCV_MSG
| MACH_RCV_INTERRUPT
,
1517 0, sizeof (struct msg
), inf
->event_port
,
1518 MACH_MSG_TIMEOUT_NONE
, MACH_PORT_NULL
);
1520 /* Re-suspend the task. */
1523 if (!inf
->task
&& inf
->pending_execs
)
1524 /* When doing an exec, it's possible that the old task wasn't reused
1525 (e.g., setuid execs). So if the task seems to have disappeared,
1526 attempt to refetch it, as the pid should still be the same. */
1527 inf_set_pid (inf
, inf
->pid
);
1529 if (err
== EMACH_RCV_INTERRUPTED
)
1530 inf_debug (inf
, "interrupted");
1532 error (_("Couldn't wait for an event: %s"), safe_strerror (err
));
1537 mach_msg_header_t hdr
;
1538 mach_msg_type_t err_type
;
1544 inf_debug (inf
, "event: msgid = %d", msg
.hdr
.msgh_id
);
1546 /* Handle what we got. */
1547 if (!notify_server (&msg
.hdr
, &reply
.hdr
)
1548 && !exc_server (&msg
.hdr
, &reply
.hdr
)
1549 && !process_reply_server (&msg
.hdr
, &reply
.hdr
)
1550 && !msg_reply_server (&msg
.hdr
, &reply
.hdr
))
1551 /* Whatever it is, it's something strange. */
1552 error (_("Got a strange event, msg id = %d."), msg
.hdr
.msgh_id
);
1555 error (_("Handling event, msgid = %d: %s"),
1556 msg
.hdr
.msgh_id
, safe_strerror (reply
.err
));
1559 if (inf
->pending_execs
)
1560 /* We're waiting for the inferior to finish execing. */
1562 struct inf_wait
*w
= &inf
->wait
;
1563 enum target_waitkind kind
= w
->status
.kind
;
1565 if (kind
== TARGET_WAITKIND_SPURIOUS
)
1566 /* Since gdb is actually counting the number of times the inferior
1567 stops, expecting one stop per exec, we only return major events
1571 inf_debug (inf
, "pending_execs = %d, ignoring minor event",
1572 inf
->pending_execs
);
1574 else if (kind
== TARGET_WAITKIND_STOPPED
1575 && w
->status
.value
.sig
== GDB_SIGNAL_TRAP
)
1576 /* Ah hah! A SIGTRAP from the inferior while starting up probably
1577 means we've succesfully completed an exec! */
1579 if (--inf
->pending_execs
== 0)
1582 #if 0 /* do we need this? */
1583 prune_threads (1); /* Get rid of the old shell
1585 renumber_threads (0); /* Give our threads reasonable
1589 inf_debug (inf
, "pending exec completed, pending_execs => %d",
1590 inf
->pending_execs
);
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 = %d, task = %d, 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 <%d>",
1704 thread
->saved_exc_port
);
1705 inf
->wait
.exc
.handler
= thread
->saved_exc_port
;
1709 inf_debug (waiting_inf
, "Handler is task exception port <%d>",
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 = %d", 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. */
1800 warning (_("illegal rpc: %s"), fun
);
1805 do_mach_notify_no_senders (mach_port_t notify
, mach_port_mscount_t count
)
1807 return ill_rpc ("do_mach_notify_no_senders");
1811 do_mach_notify_port_deleted (mach_port_t notify
, mach_port_t name
)
1813 return ill_rpc ("do_mach_notify_port_deleted");
1817 do_mach_notify_msg_accepted (mach_port_t notify
, mach_port_t name
)
1819 return ill_rpc ("do_mach_notify_msg_accepted");
1823 do_mach_notify_port_destroyed (mach_port_t notify
, mach_port_t name
)
1825 return ill_rpc ("do_mach_notify_port_destroyed");
1829 do_mach_notify_send_once (mach_port_t notify
)
1831 return ill_rpc ("do_mach_notify_send_once");
1835 /* Process_reply server routines. We only use process_wait_reply. */
1838 S_proc_wait_reply (mach_port_t reply
, error_t err
,
1839 int status
, int sigcode
, rusage_t rusage
, pid_t pid
)
1841 struct inf
*inf
= waiting_inf
;
1843 inf_debug (inf
, "err = %s, pid = %d, status = 0x%x, sigcode = %d",
1844 err
? safe_strerror (err
) : "0", pid
, status
, sigcode
);
1846 if (err
&& proc_wait_pid
&& (!inf
->task
|| !inf
->task
->port
))
1847 /* Ack. The task has died, but the task-died notification code didn't
1848 tell anyone because it thought a more detailed reply from the
1849 procserver was forthcoming. However, we now learn that won't
1850 happen... So we have to act like the task just died, and this time,
1852 inf_task_died_status (inf
);
1854 if (--proc_waits_pending
== 0)
1855 /* PROC_WAIT_PID represents the most recent wait. We will always get
1856 replies in order because the proc server is single threaded. */
1859 inf_debug (inf
, "waits pending now: %d", proc_waits_pending
);
1865 warning (_("Can't wait for pid %d: %s"),
1866 inf
->pid
, safe_strerror (err
));
1869 /* Since we can't see the inferior's signals, don't trap them. */
1870 inf_set_traced (inf
, 0);
1873 else if (pid
== inf
->pid
)
1875 store_waitstatus (&inf
->wait
.status
, status
);
1876 if (inf
->wait
.status
.kind
== TARGET_WAITKIND_STOPPED
)
1877 /* The process has sent us a signal, and stopped itself in a sane
1878 state pending our actions. */
1880 inf_debug (inf
, "process has stopped itself");
1885 inf
->wait
.suppress
= 1; /* Something odd happened. Ignore. */
1891 S_proc_setmsgport_reply (mach_port_t reply
, error_t err
,
1892 mach_port_t old_msg_port
)
1894 return ill_rpc ("S_proc_setmsgport_reply");
1898 S_proc_getmsgport_reply (mach_port_t reply
, error_t err
, mach_port_t msg_port
)
1900 return ill_rpc ("S_proc_getmsgport_reply");
1904 /* Msg_reply server routines. We only use msg_sig_post_untraced_reply. */
1907 S_msg_sig_post_untraced_reply (mach_port_t reply
, error_t err
)
1909 struct inf
*inf
= waiting_inf
;
1912 /* EBUSY is what we get when the crash server has grabbed control of the
1913 process and doesn't like what signal we tried to send it. Just act
1914 like the process stopped (using a signal of 0 should mean that the
1915 *next* time the user continues, it will pass signal 0, which the crash
1916 server should like). */
1918 inf
->wait
.status
.kind
= TARGET_WAITKIND_STOPPED
;
1919 inf
->wait
.status
.value
.sig
= GDB_SIGNAL_0
;
1922 warning (_("Signal delivery failed: %s"), safe_strerror (err
));
1925 /* We only get this reply when we've posted a signal to a process which we
1926 thought was stopped, and which we expected to continue after the signal.
1927 Given that the signal has failed for some reason, it's reasonable to
1928 assume it's still stopped. */
1931 inf
->wait
.suppress
= 1;
1937 S_msg_sig_post_reply (mach_port_t reply
, error_t err
)
1939 return ill_rpc ("S_msg_sig_post_reply");
1943 /* Returns the number of messages queued for the receive right PORT. */
1944 static mach_port_msgcount_t
1945 port_msgs_queued (mach_port_t port
)
1947 struct mach_port_status status
;
1949 mach_port_get_receive_status (mach_task_self (), port
, &status
);
1954 return status
.mps_msgcount
;
1958 /* Resume execution of the inferior process.
1960 If STEP is nonzero, single-step it.
1961 If SIGNAL is nonzero, give it that signal.
1964 -1 true Single step the current thread allowing other threads to run.
1965 -1 false Continue the current thread allowing other threads to run.
1966 X true Single step the given thread, don't allow any others to run.
1967 X false Continue the given thread, do not allow any others to run.
1968 (Where X, of course, is anything except -1)
1970 Note that a resume may not `take' if there are pending exceptions/&c
1971 still unprocessed from the last resume we did (any given resume may result
1972 in multiple events returned by wait). */
1975 gnu_resume (struct target_ops
*ops
,
1976 ptid_t ptid
, int step
, enum gdb_signal sig
)
1978 struct proc
*step_thread
= 0;
1980 struct inf
*inf
= gnu_current_inf
;
1982 inf_debug (inf
, "ptid = %s, step = %d, sig = %d",
1983 target_pid_to_str (ptid
), step
, sig
);
1985 inf_validate_procinfo (inf
);
1987 if (sig
!= GDB_SIGNAL_0
|| inf
->stopped
)
1989 if (sig
== GDB_SIGNAL_0
&& inf
->nomsg
)
1992 inf_signal (inf
, sig
);
1994 else if (inf
->wait
.exc
.reply
!= MACH_PORT_NULL
)
1995 /* We received an exception to which we have chosen not to forward, so
1996 abort the faulting thread, which will perhaps retake it. */
1998 proc_abort (inf
->wait
.thread
, 1);
1999 warning (_("Aborting %s with unforwarded exception %s."),
2000 proc_string (inf
->wait
.thread
),
2001 gdb_signal_to_name (inf
->wait
.status
.value
.sig
));
2004 if (port_msgs_queued (inf
->event_port
))
2005 /* If there are still messages in our event queue, don't bother resuming
2006 the process, as we're just going to stop it right away anyway. */
2009 inf_update_procs (inf
);
2011 /* A specific PTID means `step only this process id'. */
2012 resume_all
= ptid_equal (ptid
, minus_one_ptid
);
2015 /* Allow all threads to run, except perhaps single-stepping one. */
2017 inf_debug (inf
, "running all threads; tid = %d",
2018 ptid_get_pid (inferior_ptid
));
2019 ptid
= inferior_ptid
; /* What to step. */
2020 inf_set_threads_resume_sc (inf
, 0, 1);
2023 /* Just allow a single thread to run. */
2025 struct proc
*thread
= inf_tid_to_thread (inf
, ptid_get_lwp (ptid
));
2028 error (_("Can't run single thread id %s: no such thread!"),
2029 target_pid_to_str (ptid
));
2030 inf_debug (inf
, "running one thread: %s", target_pid_to_str (ptid
));
2031 inf_set_threads_resume_sc (inf
, thread
, 0);
2036 step_thread
= inf_tid_to_thread (inf
, ptid_get_lwp (ptid
));
2038 warning (_("Can't step thread id %s: no such thread."),
2039 target_pid_to_str (ptid
));
2041 inf_debug (inf
, "stepping thread: %s", target_pid_to_str (ptid
));
2043 if (step_thread
!= inf
->step_thread
)
2044 inf_set_step_thread (inf
, step_thread
);
2046 inf_debug (inf
, "here we go...");
2052 gnu_kill_inferior (struct target_ops
*ops
)
2054 struct proc
*task
= gnu_current_inf
->task
;
2058 proc_debug (task
, "terminating...");
2059 task_terminate (task
->port
);
2060 inf_set_pid (gnu_current_inf
, -1);
2062 target_mourn_inferior ();
2065 /* Clean up after the inferior dies. */
2067 gnu_mourn_inferior (struct target_ops
*ops
)
2069 inf_debug (gnu_current_inf
, "rip");
2070 inf_detach (gnu_current_inf
);
2071 unpush_target (ops
);
2072 generic_mourn_inferior ();
2076 /* Fork an inferior process, and start debugging it. */
2078 /* Set INFERIOR_PID to the first thread available in the child, if any. */
2080 inf_pick_first_thread (void)
2082 if (gnu_current_inf
->task
&& gnu_current_inf
->threads
)
2083 /* The first thread. */
2084 return gnu_current_inf
->threads
->tid
;
2086 /* What may be the next thread. */
2087 return next_thread_id
;
2093 if (!gnu_current_inf
)
2094 gnu_current_inf
= make_inf ();
2095 return gnu_current_inf
;
2099 gnu_create_inferior (struct target_ops
*ops
,
2100 char *exec_file
, char *allargs
, char **env
,
2103 struct inf
*inf
= cur_inf ();
2106 void trace_me (void)
2108 /* We're in the child; make this process stop as soon as it execs. */
2109 inf_debug (inf
, "tracing self");
2110 if (ptrace (PTRACE_TRACEME
) != 0)
2111 error (_("ptrace (PTRACE_TRACEME) failed!"));
2114 inf_debug (inf
, "creating inferior");
2116 pid
= fork_inferior (exec_file
, allargs
, env
, trace_me
,
2117 NULL
, NULL
, NULL
, NULL
);
2119 /* Attach to the now stopped child, which is actually a shell... */
2120 inf_debug (inf
, "attaching to child: %d", pid
);
2122 inf_attach (inf
, pid
);
2126 inf
->pending_execs
= 2;
2130 /* Now let the child run again, knowing that it will stop
2131 immediately because of the ptrace. */
2134 /* We now have thread info. */
2135 thread_change_ptid (inferior_ptid
,
2136 ptid_build (inf
->pid
, inf_pick_first_thread (), 0));
2138 startup_inferior (inf
->pending_execs
);
2140 inf_validate_procinfo (inf
);
2141 inf_update_signal_thread (inf
);
2142 inf_set_traced (inf
, inf
->want_signals
);
2144 /* Execing the process will have trashed our exception ports; steal them
2145 back (or make sure they're restored if the user wants that). */
2146 if (inf
->want_exceptions
)
2147 inf_steal_exc_ports (inf
);
2149 inf_restore_exc_ports (inf
);
2153 /* Attach to process PID, then initialize for debugging it
2154 and wait for the trace-trap that results from attaching. */
2156 gnu_attach (struct target_ops
*ops
, char *args
, int from_tty
)
2160 struct inf
*inf
= cur_inf ();
2161 struct inferior
*inferior
;
2163 pid
= parse_pid_to_attach (args
);
2165 if (pid
== getpid ()) /* Trying to masturbate? */
2166 error (_("I refuse to debug myself!"));
2170 exec_file
= (char *) get_exec_file (0);
2173 printf_unfiltered ("Attaching to program `%s', pid %d\n",
2176 printf_unfiltered ("Attaching to pid %d\n", pid
);
2178 gdb_flush (gdb_stdout
);
2181 inf_debug (inf
, "attaching to pid: %d", pid
);
2183 inf_attach (inf
, pid
);
2187 inferior
= current_inferior ();
2188 inferior_appeared (inferior
, pid
);
2189 inferior
->attach_flag
= 1;
2191 inf_update_procs (inf
);
2193 inferior_ptid
= ptid_build (pid
, inf_pick_first_thread (), 0);
2195 /* We have to initialize the terminal settings now, since the code
2196 below might try to restore them. */
2197 target_terminal_init ();
2199 /* If the process was stopped before we attached, make it continue the next
2200 time the user does a continue. */
2201 inf_validate_procinfo (inf
);
2203 inf_update_signal_thread (inf
);
2204 inf_set_traced (inf
, inf
->want_signals
);
2206 #if 0 /* Do we need this? */
2207 renumber_threads (0); /* Give our threads reasonable names. */
2212 /* Take a program previously attached to and detaches it.
2213 The program resumes execution and will no longer stop
2214 on signals, etc. We'd better not have left any breakpoints
2215 in the program or it'll die when it hits one. For this
2216 to work, it may be necessary for the process to have been
2217 previously attached. It *might* work if the program was
2218 started via fork. */
2220 gnu_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
2226 char *exec_file
= get_exec_file (0);
2229 printf_unfiltered ("Detaching from program `%s' pid %d\n",
2230 exec_file
, gnu_current_inf
->pid
);
2232 printf_unfiltered ("Detaching from pid %d\n", gnu_current_inf
->pid
);
2233 gdb_flush (gdb_stdout
);
2236 pid
= gnu_current_inf
->pid
;
2238 inf_detach (gnu_current_inf
);
2240 inferior_ptid
= null_ptid
;
2241 detach_inferior (pid
);
2243 unpush_target (ops
); /* Pop out of handling an inferior. */
2247 gnu_terminal_init_inferior (void)
2249 gdb_assert (gnu_current_inf
);
2250 terminal_init_inferior_with_pgrp (gnu_current_inf
->pid
);
2254 gnu_stop (ptid_t ptid
)
2256 error (_("to_stop target function not implemented"));
2260 gnu_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2262 inf_update_procs (gnu_current_inf
);
2263 return !!inf_tid_to_thread (gnu_current_inf
,
2264 ptid_get_lwp (ptid
));
2268 /* Read inferior task's LEN bytes from ADDR and copy it to MYADDR in
2269 gdb's address space. Return 0 on failure; number of bytes read
2272 gnu_read_inferior (task_t task
, CORE_ADDR addr
, gdb_byte
*myaddr
, int length
)
2275 vm_address_t low_address
= (vm_address_t
) trunc_page (addr
);
2276 vm_size_t aligned_length
=
2277 (vm_size_t
) round_page (addr
+ length
) - low_address
;
2281 /* Get memory from inferior with page aligned addresses. */
2282 err
= vm_read (task
, low_address
, aligned_length
, &copied
, ©_count
);
2286 err
= hurd_safe_copyin (myaddr
, (void *) (addr
- low_address
+ copied
),
2290 warning (_("Read from inferior faulted: %s"), safe_strerror (err
));
2294 err
= vm_deallocate (mach_task_self (), copied
, copy_count
);
2296 warning (_("gnu_read_inferior vm_deallocate failed: %s"),
2297 safe_strerror (err
));
2302 #define CHK_GOTO_OUT(str,ret) \
2303 do if (ret != KERN_SUCCESS) { errstr = #str; goto out; } while(0)
2305 struct vm_region_list
2307 struct vm_region_list
*next
;
2308 vm_prot_t protection
;
2313 struct obstack region_obstack
;
2315 /* Write gdb's LEN bytes from MYADDR and copy it to ADDR in inferior
2316 task's address space. */
2318 gnu_write_inferior (task_t task
, CORE_ADDR addr
,
2319 const gdb_byte
*myaddr
, int length
)
2322 vm_address_t low_address
= (vm_address_t
) trunc_page (addr
);
2323 vm_size_t aligned_length
=
2324 (vm_size_t
) round_page (addr
+ length
) - low_address
;
2329 char *errstr
= "Bug in gnu_write_inferior";
2331 struct vm_region_list
*region_element
;
2332 struct vm_region_list
*region_head
= (struct vm_region_list
*) NULL
;
2334 /* Get memory from inferior with page aligned addresses. */
2335 err
= vm_read (task
,
2340 CHK_GOTO_OUT ("gnu_write_inferior vm_read failed", err
);
2344 err
= hurd_safe_copyout ((void *) (addr
- low_address
+ copied
),
2346 CHK_GOTO_OUT ("Write to inferior faulted", err
);
2348 obstack_init (®ion_obstack
);
2350 /* Do writes atomically.
2351 First check for holes and unwritable memory. */
2353 vm_size_t remaining_length
= aligned_length
;
2354 vm_address_t region_address
= low_address
;
2356 struct vm_region_list
*scan
;
2358 while (region_address
< low_address
+ aligned_length
)
2360 vm_prot_t protection
;
2361 vm_prot_t max_protection
;
2362 vm_inherit_t inheritance
;
2364 mach_port_t object_name
;
2366 vm_size_t region_length
= remaining_length
;
2367 vm_address_t old_address
= region_address
;
2369 err
= vm_region (task
,
2378 CHK_GOTO_OUT ("vm_region failed", err
);
2380 /* Check for holes in memory. */
2381 if (old_address
!= region_address
)
2383 warning (_("No memory at 0x%x. Nothing written"),
2390 if (!(max_protection
& VM_PROT_WRITE
))
2392 warning (_("Memory at address 0x%x is unwritable. "
2400 /* Chain the regions for later use. */
2402 (struct vm_region_list
*)
2403 obstack_alloc (®ion_obstack
, sizeof (struct vm_region_list
));
2405 region_element
->protection
= protection
;
2406 region_element
->start
= region_address
;
2407 region_element
->length
= region_length
;
2409 /* Chain the regions along with protections. */
2410 region_element
->next
= region_head
;
2411 region_head
= region_element
;
2413 region_address
+= region_length
;
2414 remaining_length
= remaining_length
- region_length
;
2417 /* If things fail after this, we give up.
2418 Somebody is messing up inferior_task's mappings. */
2420 /* Enable writes to the chained vm regions. */
2421 for (scan
= region_head
; scan
; scan
= scan
->next
)
2423 if (!(scan
->protection
& VM_PROT_WRITE
))
2425 err
= vm_protect (task
,
2429 scan
->protection
| VM_PROT_WRITE
);
2430 CHK_GOTO_OUT ("vm_protect: enable write failed", err
);
2434 err
= vm_write (task
,
2438 CHK_GOTO_OUT ("vm_write failed", err
);
2440 /* Set up the original region protections, if they were changed. */
2441 for (scan
= region_head
; scan
; scan
= scan
->next
)
2443 if (!(scan
->protection
& VM_PROT_WRITE
))
2445 err
= vm_protect (task
,
2450 CHK_GOTO_OUT ("vm_protect: enable write failed", err
);
2458 obstack_free (®ion_obstack
, 0);
2460 (void) vm_deallocate (mach_task_self (),
2465 if (err
!= KERN_SUCCESS
)
2467 warning (_("%s: %s"), errstr
, mach_error_string (err
));
2476 /* Implement the to_xfer_partial target_ops method for
2477 TARGET_OBJECT_MEMORY. */
2479 static enum target_xfer_status
2480 gnu_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
2481 CORE_ADDR memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
2483 task_t task
= (gnu_current_inf
2484 ? (gnu_current_inf
->task
2485 ? gnu_current_inf
->task
->port
: 0)
2489 if (task
== MACH_PORT_NULL
)
2490 return TARGET_XFER_E_IO
;
2492 if (writebuf
!= NULL
)
2494 inf_debug (gnu_current_inf
, "writing %s[%s] <-- %s",
2495 paddress (target_gdbarch (), memaddr
), pulongest (len
),
2496 host_address_to_string (writebuf
));
2497 res
= gnu_write_inferior (task
, memaddr
, writebuf
, len
);
2501 inf_debug (gnu_current_inf
, "reading %s[%s] --> %s",
2502 paddress (target_gdbarch (), memaddr
), pulongest (len
),
2503 host_address_to_string (readbuf
));
2504 res
= gnu_read_inferior (task
, memaddr
, readbuf
, len
);
2506 gdb_assert (res
>= 0);
2508 return TARGET_XFER_E_IO
;
2511 *xfered_len
= (ULONGEST
) res
;
2512 return TARGET_XFER_OK
;
2516 /* Target to_xfer_partial implementation. */
2518 static enum target_xfer_status
2519 gnu_xfer_partial (struct target_ops
*ops
, enum target_object object
,
2520 const char *annex
, gdb_byte
*readbuf
,
2521 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
2522 ULONGEST
*xfered_len
)
2526 case TARGET_OBJECT_MEMORY
:
2527 return gnu_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
2529 return TARGET_XFER_E_IO
;
2533 /* Call FUNC on each memory region in the task. */
2535 gnu_find_memory_regions (find_memory_region_ftype func
, void *data
)
2539 vm_address_t region_address
, last_region_address
, last_region_end
;
2540 vm_prot_t last_protection
;
2542 if (gnu_current_inf
== 0 || gnu_current_inf
->task
== 0)
2544 task
= gnu_current_inf
->task
->port
;
2545 if (task
== MACH_PORT_NULL
)
2548 region_address
= last_region_address
= last_region_end
= VM_MIN_ADDRESS
;
2549 last_protection
= VM_PROT_NONE
;
2550 while (region_address
< VM_MAX_ADDRESS
)
2552 vm_prot_t protection
;
2553 vm_prot_t max_protection
;
2554 vm_inherit_t inheritance
;
2556 mach_port_t object_name
;
2558 vm_size_t region_length
= VM_MAX_ADDRESS
- region_address
;
2559 vm_address_t old_address
= region_address
;
2561 err
= vm_region (task
,
2570 if (err
== KERN_NO_SPACE
)
2572 if (err
!= KERN_SUCCESS
)
2574 warning (_("vm_region failed: %s"), mach_error_string (err
));
2578 if (protection
== last_protection
&& region_address
== last_region_end
)
2579 /* This region is contiguous with and indistinguishable from
2580 the previous one, so we just extend that one. */
2581 last_region_end
= region_address
+= region_length
;
2584 /* This region is distinct from the last one we saw, so report
2585 that previous one. */
2586 if (last_protection
!= VM_PROT_NONE
)
2587 (*func
) (last_region_address
,
2588 last_region_end
- last_region_address
,
2589 last_protection
& VM_PROT_READ
,
2590 last_protection
& VM_PROT_WRITE
,
2591 last_protection
& VM_PROT_EXECUTE
,
2592 1, /* MODIFIED is unknown, pass it as true. */
2594 last_region_address
= region_address
;
2595 last_region_end
= region_address
+= region_length
;
2596 last_protection
= protection
;
2600 /* Report the final region. */
2601 if (last_region_end
> last_region_address
&& last_protection
!= VM_PROT_NONE
)
2602 (*func
) (last_region_address
, last_region_end
- last_region_address
,
2603 last_protection
& VM_PROT_READ
,
2604 last_protection
& VM_PROT_WRITE
,
2605 last_protection
& VM_PROT_EXECUTE
,
2606 1, /* MODIFIED is unknown, pass it as true. */
2613 /* Return printable description of proc. */
2615 proc_string (struct proc
*proc
)
2617 static char tid_str
[80];
2619 if (proc_is_task (proc
))
2620 xsnprintf (tid_str
, sizeof (tid_str
), "process %d", proc
->inf
->pid
);
2622 xsnprintf (tid_str
, sizeof (tid_str
), "Thread %d.%d",
2623 proc
->inf
->pid
, proc
->tid
);
2628 gnu_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
2630 struct inf
*inf
= gnu_current_inf
;
2631 int tid
= ptid_get_lwp (ptid
);
2632 struct proc
*thread
= inf_tid_to_thread (inf
, tid
);
2635 return proc_string (thread
);
2638 static char tid_str
[80];
2640 xsnprintf (tid_str
, sizeof (tid_str
), "bogus thread id %d", tid
);
2646 /* Create a prototype generic GNU/Hurd target. The client can
2647 override it with local methods. */
2652 struct target_ops
*t
= inf_child_target ();
2654 t
->to_shortname
= "GNU";
2655 t
->to_longname
= "GNU Hurd process";
2656 t
->to_doc
= "GNU Hurd process";
2658 t
->to_attach
= gnu_attach
;
2659 t
->to_attach_no_wait
= 1;
2660 t
->to_detach
= gnu_detach
;
2661 t
->to_resume
= gnu_resume
;
2662 t
->to_wait
= gnu_wait
;
2663 t
->to_xfer_partial
= gnu_xfer_partial
;
2664 t
->to_find_memory_regions
= gnu_find_memory_regions
;
2665 t
->to_terminal_init
= gnu_terminal_init_inferior
;
2666 t
->to_kill
= gnu_kill_inferior
;
2667 t
->to_create_inferior
= gnu_create_inferior
;
2668 t
->to_mourn_inferior
= gnu_mourn_inferior
;
2669 t
->to_thread_alive
= gnu_thread_alive
;
2670 t
->to_pid_to_str
= gnu_pid_to_str
;
2671 t
->to_stop
= gnu_stop
;
2677 /* User task commands. */
2679 static struct cmd_list_element
*set_task_cmd_list
= 0;
2680 static struct cmd_list_element
*show_task_cmd_list
= 0;
2681 /* User thread commands. */
2683 /* Commands with a prefix of `set/show thread'. */
2684 extern struct cmd_list_element
*thread_cmd_list
;
2685 struct cmd_list_element
*set_thread_cmd_list
= NULL
;
2686 struct cmd_list_element
*show_thread_cmd_list
= NULL
;
2688 /* Commands with a prefix of `set/show thread default'. */
2689 struct cmd_list_element
*set_thread_default_cmd_list
= NULL
;
2690 struct cmd_list_element
*show_thread_default_cmd_list
= NULL
;
2693 set_thread_cmd (char *args
, int from_tty
)
2695 printf_unfiltered ("\"set thread\" must be followed by the "
2696 "name of a thread property, or \"default\".\n");
2700 show_thread_cmd (char *args
, int from_tty
)
2702 printf_unfiltered ("\"show thread\" must be followed by the "
2703 "name of a thread property, or \"default\".\n");
2707 set_thread_default_cmd (char *args
, int from_tty
)
2709 printf_unfiltered ("\"set thread default\" must be followed "
2710 "by the name of a thread property.\n");
2714 show_thread_default_cmd (char *args
, int from_tty
)
2716 printf_unfiltered ("\"show thread default\" must be followed "
2717 "by the name of a thread property.\n");
2721 parse_int_arg (char *args
, char *cmd_prefix
)
2726 int val
= strtoul (args
, &arg_end
, 10);
2728 if (*args
&& *arg_end
== '\0')
2731 error (_("Illegal argument for \"%s\" command, should be an integer."),
2736 _parse_bool_arg (char *args
, char *t_val
, char *f_val
, char *cmd_prefix
)
2738 if (!args
|| strcmp (args
, t_val
) == 0)
2740 else if (strcmp (args
, f_val
) == 0)
2743 error (_("Illegal argument for \"%s\" command, "
2744 "should be \"%s\" or \"%s\"."),
2745 cmd_prefix
, t_val
, f_val
);
2748 #define parse_bool_arg(args, cmd_prefix) \
2749 _parse_bool_arg (args, "on", "off", cmd_prefix)
2752 check_empty (char *args
, char *cmd_prefix
)
2755 error (_("Garbage after \"%s\" command: `%s'"), cmd_prefix
, args
);
2758 /* Returns the alive thread named by INFERIOR_PID, or signals an error. */
2759 static struct proc
*
2762 struct inf
*inf
= cur_inf ();
2763 struct proc
*thread
= inf_tid_to_thread (inf
,
2764 ptid_get_lwp (inferior_ptid
));
2766 error (_("No current thread."));
2770 /* Returns the current inferior, but signals an error if it has no task. */
2774 struct inf
*inf
= cur_inf ();
2777 error (_("No current process."));
2783 set_task_pause_cmd (char *args
, int from_tty
)
2785 struct inf
*inf
= cur_inf ();
2786 int old_sc
= inf
->pause_sc
;
2788 inf
->pause_sc
= parse_bool_arg (args
, "set task pause");
2790 if (old_sc
== 0 && inf
->pause_sc
!= 0)
2791 /* If the task is currently unsuspended, immediately suspend it,
2792 otherwise wait until the next time it gets control. */
2797 show_task_pause_cmd (char *args
, int from_tty
)
2799 struct inf
*inf
= cur_inf ();
2801 check_empty (args
, "show task pause");
2802 printf_unfiltered ("The inferior task %s suspended while gdb has control.\n",
2804 ? (inf
->pause_sc
== 0 ? "isn't" : "is")
2805 : (inf
->pause_sc
== 0 ? "won't be" : "will be"));
2809 set_task_detach_sc_cmd (char *args
, int from_tty
)
2811 cur_inf ()->detach_sc
= parse_int_arg (args
,
2812 "set task detach-suspend-count");
2816 show_task_detach_sc_cmd (char *args
, int from_tty
)
2818 check_empty (args
, "show task detach-suspend-count");
2819 printf_unfiltered ("The inferior task will be left with a "
2820 "suspend count of %d when detaching.\n",
2821 cur_inf ()->detach_sc
);
2826 set_thread_default_pause_cmd (char *args
, int from_tty
)
2828 struct inf
*inf
= cur_inf ();
2830 inf
->default_thread_pause_sc
=
2831 parse_bool_arg (args
, "set thread default pause") ? 0 : 1;
2835 show_thread_default_pause_cmd (char *args
, int from_tty
)
2837 struct inf
*inf
= cur_inf ();
2838 int sc
= inf
->default_thread_pause_sc
;
2840 check_empty (args
, "show thread default pause");
2841 printf_unfiltered ("New threads %s suspended while gdb has control%s.\n",
2842 sc
? "are" : "aren't",
2843 !sc
&& inf
->pause_sc
? " (but the task is)" : "");
2847 set_thread_default_run_cmd (char *args
, int from_tty
)
2849 struct inf
*inf
= cur_inf ();
2851 inf
->default_thread_run_sc
=
2852 parse_bool_arg (args
, "set thread default run") ? 0 : 1;
2856 show_thread_default_run_cmd (char *args
, int from_tty
)
2858 struct inf
*inf
= cur_inf ();
2860 check_empty (args
, "show thread default run");
2861 printf_unfiltered ("New threads %s allowed to run.\n",
2862 inf
->default_thread_run_sc
== 0 ? "are" : "aren't");
2866 set_thread_default_detach_sc_cmd (char *args
, int from_tty
)
2868 cur_inf ()->default_thread_detach_sc
=
2869 parse_int_arg (args
, "set thread default detach-suspend-count");
2873 show_thread_default_detach_sc_cmd (char *args
, int from_tty
)
2875 check_empty (args
, "show thread default detach-suspend-count");
2876 printf_unfiltered ("New threads will get a detach-suspend-count of %d.\n",
2877 cur_inf ()->default_thread_detach_sc
);
2881 /* Steal a send right called NAME in the inferior task, and make it PROC's
2882 saved exception port. */
2884 steal_exc_port (struct proc
*proc
, mach_port_t name
)
2888 mach_msg_type_name_t port_type
;
2890 if (!proc
|| !proc
->inf
->task
)
2891 error (_("No inferior task."));
2893 err
= mach_port_extract_right (proc
->inf
->task
->port
,
2894 name
, MACH_MSG_TYPE_COPY_SEND
,
2897 error (_("Couldn't extract send right %d from inferior: %s"),
2898 name
, safe_strerror (err
));
2900 if (proc
->saved_exc_port
)
2901 /* Get rid of our reference to the old one. */
2902 mach_port_deallocate (mach_task_self (), proc
->saved_exc_port
);
2904 proc
->saved_exc_port
= port
;
2906 if (!proc
->exc_port
)
2907 /* If PROC is a thread, we may not have set its exception port
2908 before. We can't use proc_steal_exc_port because it also sets
2911 proc
->exc_port
= proc
->inf
->event_port
;
2912 err
= proc_set_exception_port (proc
, proc
->exc_port
);
2913 error (_("Can't set exception port for %s: %s"),
2914 proc_string (proc
), safe_strerror (err
));
2919 set_task_exc_port_cmd (char *args
, int from_tty
)
2921 struct inf
*inf
= cur_inf ();
2924 error (_("No argument to \"set task exception-port\" command."));
2925 steal_exc_port (inf
->task
, parse_and_eval_address (args
));
2929 set_stopped_cmd (char *args
, int from_tty
)
2931 cur_inf ()->stopped
= _parse_bool_arg (args
, "yes", "no", "set stopped");
2935 show_stopped_cmd (char *args
, int from_tty
)
2937 struct inf
*inf
= active_inf ();
2939 check_empty (args
, "show stopped");
2940 printf_unfiltered ("The inferior process %s stopped.\n",
2941 inf
->stopped
? "is" : "isn't");
2945 set_sig_thread_cmd (char *args
, int from_tty
)
2947 struct inf
*inf
= cur_inf ();
2949 if (!args
|| (!isdigit (*args
) && strcmp (args
, "none") != 0))
2950 error (_("Illegal argument to \"set signal-thread\" command.\n"
2951 "Should be an integer thread ID, or `none'."));
2953 if (strcmp (args
, "none") == 0)
2954 inf
->signal_thread
= 0;
2957 ptid_t ptid
= thread_id_to_pid (atoi (args
));
2959 if (ptid_equal (ptid
, minus_one_ptid
))
2960 error (_("Thread ID %s not known. "
2961 "Use the \"info threads\" command to\n"
2962 "see the IDs of currently known threads."), args
);
2963 inf
->signal_thread
= inf_tid_to_thread (inf
, ptid_get_lwp (ptid
));
2968 show_sig_thread_cmd (char *args
, int from_tty
)
2970 struct inf
*inf
= active_inf ();
2972 check_empty (args
, "show signal-thread");
2973 if (inf
->signal_thread
)
2974 printf_unfiltered ("The signal thread is %s.\n",
2975 proc_string (inf
->signal_thread
));
2977 printf_unfiltered ("There is no signal thread.\n");
2982 set_signals_cmd (char *args
, int from_tty
)
2984 struct inf
*inf
= cur_inf ();
2986 inf
->want_signals
= parse_bool_arg (args
, "set signals");
2988 if (inf
->task
&& inf
->want_signals
!= inf
->traced
)
2989 /* Make this take effect immediately in a running process. */
2990 inf_set_traced (inf
, inf
->want_signals
);
2994 show_signals_cmd (char *args
, int from_tty
)
2996 struct inf
*inf
= cur_inf ();
2998 check_empty (args
, "show signals");
2999 printf_unfiltered ("The inferior process's signals %s intercepted.\n",
3001 ? (inf
->traced
? "are" : "aren't")
3002 : (inf
->want_signals
? "will be" : "won't be"));
3006 set_exceptions_cmd (char *args
, int from_tty
)
3008 struct inf
*inf
= cur_inf ();
3009 int val
= parse_bool_arg (args
, "set exceptions");
3011 /* Make this take effect immediately in a running process. */
3014 inf
->want_exceptions
= val
;
3018 show_exceptions_cmd (char *args
, int from_tty
)
3020 struct inf
*inf
= cur_inf ();
3022 check_empty (args
, "show exceptions");
3023 printf_unfiltered ("Exceptions in the inferior %s trapped.\n",
3025 ? (inf
->want_exceptions
? "are" : "aren't")
3026 : (inf
->want_exceptions
? "will be" : "won't be"));
3031 set_task_cmd (char *args
, int from_tty
)
3033 printf_unfiltered ("\"set task\" must be followed by the name"
3034 " of a task property.\n");
3038 show_task_cmd (char *args
, int from_tty
)
3040 struct inf
*inf
= cur_inf ();
3042 check_empty (args
, "show task");
3044 show_signals_cmd (0, from_tty
);
3045 show_exceptions_cmd (0, from_tty
);
3046 show_task_pause_cmd (0, from_tty
);
3048 if (inf
->pause_sc
== 0)
3049 show_thread_default_pause_cmd (0, from_tty
);
3050 show_thread_default_run_cmd (0, from_tty
);
3054 show_stopped_cmd (0, from_tty
);
3055 show_sig_thread_cmd (0, from_tty
);
3058 if (inf
->detach_sc
!= 0)
3059 show_task_detach_sc_cmd (0, from_tty
);
3060 if (inf
->default_thread_detach_sc
!= 0)
3061 show_thread_default_detach_sc_cmd (0, from_tty
);
3066 set_noninvasive_cmd (char *args
, int from_tty
)
3068 /* Invert the sense of the arg for each component. */
3069 char *inv_args
= parse_bool_arg (args
, "set noninvasive") ? "off" : "on";
3071 set_task_pause_cmd (inv_args
, from_tty
);
3072 set_signals_cmd (inv_args
, from_tty
);
3073 set_exceptions_cmd (inv_args
, from_tty
);
3078 info_port_rights (const char *args
, mach_port_type_t only
)
3080 struct inf
*inf
= active_inf ();
3081 struct value
*vmark
= value_mark ();
3084 /* Explicit list of port rights. */
3088 struct value
*val
= parse_to_comma_and_eval (&args
);
3089 long right
= value_as_long (val
);
3091 print_port_info (right
, 0, inf
->task
->port
, PORTINFO_DETAILS
,
3095 error (_("%ld: %s."), right
, safe_strerror (err
));
3099 /* Print all of them. */
3102 print_task_ports_info (inf
->task
->port
, only
, PORTINFO_DETAILS
,
3105 error (_("%s."), safe_strerror (err
));
3108 value_free_to_mark (vmark
);
3112 info_send_rights_cmd (char *args
, int from_tty
)
3114 info_port_rights (args
, MACH_PORT_TYPE_SEND
);
3118 info_recv_rights_cmd (char *args
, int from_tty
)
3120 info_port_rights (args
, MACH_PORT_TYPE_RECEIVE
);
3124 info_port_sets_cmd (char *args
, int from_tty
)
3126 info_port_rights (args
, MACH_PORT_TYPE_PORT_SET
);
3130 info_dead_names_cmd (char *args
, int from_tty
)
3132 info_port_rights (args
, MACH_PORT_TYPE_DEAD_NAME
);
3136 info_port_rights_cmd (char *args
, int from_tty
)
3138 info_port_rights (args
, ~0);
3143 add_task_commands (void)
3145 add_cmd ("pause", class_run
, set_thread_default_pause_cmd
, _("\
3146 Set whether the new threads are suspended while gdb has control.\n\
3147 This property normally has no effect because the whole task is\n\
3148 suspended, however, that may be disabled with \"set task pause off\".\n\
3149 The default value is \"off\"."),
3150 &set_thread_default_cmd_list
);
3151 add_cmd ("pause", no_class
, show_thread_default_pause_cmd
, _("\
3152 Show whether new threads are suspended while gdb has control."),
3153 &show_thread_default_cmd_list
);
3155 add_cmd ("run", class_run
, set_thread_default_run_cmd
, _("\
3156 Set whether new threads are allowed to run (once gdb has noticed them)."),
3157 &set_thread_default_cmd_list
);
3158 add_cmd ("run", no_class
, show_thread_default_run_cmd
, _("\
3159 Show whether new threads are allowed to run (once gdb has noticed them)."),
3160 &show_thread_default_cmd_list
);
3162 add_cmd ("detach-suspend-count", class_run
, set_thread_default_detach_sc_cmd
,
3163 _("Set the default detach-suspend-count value for new threads."),
3164 &set_thread_default_cmd_list
);
3165 add_cmd ("detach-suspend-count", no_class
, show_thread_default_detach_sc_cmd
,
3166 _("Show the default detach-suspend-count value for new threads."),
3167 &show_thread_default_cmd_list
);
3169 add_cmd ("signals", class_run
, set_signals_cmd
, _("\
3170 Set whether the inferior process's signals will be intercepted.\n\
3171 Mach exceptions (such as breakpoint traps) are not affected."),
3173 add_alias_cmd ("sigs", "signals", class_run
, 1, &setlist
);
3174 add_cmd ("signals", no_class
, show_signals_cmd
, _("\
3175 Show whether the inferior process's signals will be intercepted."),
3177 add_alias_cmd ("sigs", "signals", no_class
, 1, &showlist
);
3179 add_cmd ("signal-thread", class_run
, set_sig_thread_cmd
, _("\
3180 Set the thread that gdb thinks is the libc signal thread.\n\
3181 This thread is run when delivering a signal to a non-stopped process."),
3183 add_alias_cmd ("sigthread", "signal-thread", class_run
, 1, &setlist
);
3184 add_cmd ("signal-thread", no_class
, show_sig_thread_cmd
, _("\
3185 Set the thread that gdb thinks is the libc signal thread."),
3187 add_alias_cmd ("sigthread", "signal-thread", no_class
, 1, &showlist
);
3189 add_cmd ("stopped", class_run
, set_stopped_cmd
, _("\
3190 Set whether gdb thinks the inferior process is stopped as with SIGSTOP.\n\
3191 Stopped process will be continued by sending them a signal."),
3193 add_cmd ("stopped", no_class
, show_stopped_cmd
, _("\
3194 Show whether gdb thinks the inferior process is stopped as with SIGSTOP."),
3197 add_cmd ("exceptions", class_run
, set_exceptions_cmd
, _("\
3198 Set whether exceptions in the inferior process will be trapped.\n\
3199 When exceptions are turned off, neither breakpoints nor single-stepping\n\
3202 /* Allow `set exc' despite conflict with `set exception-port'. */
3203 add_alias_cmd ("exc", "exceptions", class_run
, 1, &setlist
);
3204 add_cmd ("exceptions", no_class
, show_exceptions_cmd
, _("\
3205 Show whether exceptions in the inferior process will be trapped."),
3208 add_prefix_cmd ("task", no_class
, set_task_cmd
,
3209 _("Command prefix for setting task attributes."),
3210 &set_task_cmd_list
, "set task ", 0, &setlist
);
3211 add_prefix_cmd ("task", no_class
, show_task_cmd
,
3212 _("Command prefix for showing task attributes."),
3213 &show_task_cmd_list
, "show task ", 0, &showlist
);
3215 add_cmd ("pause", class_run
, set_task_pause_cmd
, _("\
3216 Set whether the task is suspended while gdb has control.\n\
3217 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3218 until the next time the program is continued.\n\
3219 When setting this to \"off\", \"set thread default pause on\" can be\n\
3220 used to pause individual threads by default instead."),
3221 &set_task_cmd_list
);
3222 add_cmd ("pause", no_class
, show_task_pause_cmd
,
3223 _("Show whether the task is suspended while gdb has control."),
3224 &show_task_cmd_list
);
3226 add_cmd ("detach-suspend-count", class_run
, set_task_detach_sc_cmd
,
3227 _("Set the suspend count will leave on the thread when detaching."),
3228 &set_task_cmd_list
);
3229 add_cmd ("detach-suspend-count", no_class
, show_task_detach_sc_cmd
,
3230 _("Show the suspend count will leave "
3231 "on the thread when detaching."),
3232 &show_task_cmd_list
);
3234 add_cmd ("exception-port", no_class
, set_task_exc_port_cmd
, _("\
3235 Set the task exception port to which we forward exceptions.\n\
3236 The argument should be the value of the send right in the task."),
3237 &set_task_cmd_list
);
3238 add_alias_cmd ("excp", "exception-port", no_class
, 1, &set_task_cmd_list
);
3239 add_alias_cmd ("exc-port", "exception-port", no_class
, 1,
3240 &set_task_cmd_list
);
3242 /* A convenient way of turning on all options require to noninvasively
3243 debug running tasks. */
3244 add_cmd ("noninvasive", no_class
, set_noninvasive_cmd
, _("\
3245 Set task options so that we interfere as little as possible.\n\
3246 This is the same as setting `task pause', `exceptions', and\n\
3247 `signals' to the opposite value."),
3250 /* Commands to show information about the task's ports. */
3251 add_cmd ("send-rights", class_info
, info_send_rights_cmd
,
3252 _("Show information about the task's send rights"),
3254 add_cmd ("receive-rights", class_info
, info_recv_rights_cmd
,
3255 _("Show information about the task's receive rights"),
3257 add_cmd ("port-rights", class_info
, info_port_rights_cmd
,
3258 _("Show information about the task's port rights"),
3260 add_cmd ("port-sets", class_info
, info_port_sets_cmd
,
3261 _("Show information about the task's port sets"),
3263 add_cmd ("dead-names", class_info
, info_dead_names_cmd
,
3264 _("Show information about the task's dead names"),
3266 add_info_alias ("ports", "port-rights", 1);
3267 add_info_alias ("port", "port-rights", 1);
3268 add_info_alias ("psets", "port-sets", 1);
3273 set_thread_pause_cmd (char *args
, int from_tty
)
3275 struct proc
*thread
= cur_thread ();
3276 int old_sc
= thread
->pause_sc
;
3278 thread
->pause_sc
= parse_bool_arg (args
, "set thread pause");
3279 if (old_sc
== 0 && thread
->pause_sc
!= 0 && thread
->inf
->pause_sc
== 0)
3280 /* If the task is currently unsuspended, immediately suspend it,
3281 otherwise wait until the next time it gets control. */
3282 inf_suspend (thread
->inf
);
3286 show_thread_pause_cmd (char *args
, int from_tty
)
3288 struct proc
*thread
= cur_thread ();
3289 int sc
= thread
->pause_sc
;
3291 check_empty (args
, "show task pause");
3292 printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n",
3293 proc_string (thread
),
3294 sc
? "is" : "isn't",
3295 !sc
&& thread
->inf
->pause_sc
? " (but the task is)" : "");
3299 set_thread_run_cmd (char *args
, int from_tty
)
3301 struct proc
*thread
= cur_thread ();
3303 thread
->run_sc
= parse_bool_arg (args
, "set thread run") ? 0 : 1;
3307 show_thread_run_cmd (char *args
, int from_tty
)
3309 struct proc
*thread
= cur_thread ();
3311 check_empty (args
, "show thread run");
3312 printf_unfiltered ("Thread %s %s allowed to run.",
3313 proc_string (thread
),
3314 thread
->run_sc
== 0 ? "is" : "isn't");
3318 set_thread_detach_sc_cmd (char *args
, int from_tty
)
3320 cur_thread ()->detach_sc
= parse_int_arg (args
,
3321 "set thread detach-suspend-count");
3325 show_thread_detach_sc_cmd (char *args
, int from_tty
)
3327 struct proc
*thread
= cur_thread ();
3329 check_empty (args
, "show thread detach-suspend-count");
3330 printf_unfiltered ("Thread %s will be left with a suspend count"
3331 " of %d when detaching.\n",
3332 proc_string (thread
),
3337 set_thread_exc_port_cmd (char *args
, int from_tty
)
3339 struct proc
*thread
= cur_thread ();
3342 error (_("No argument to \"set thread exception-port\" command."));
3343 steal_exc_port (thread
, parse_and_eval_address (args
));
3348 show_thread_cmd (char *args
, int from_tty
)
3350 struct proc
*thread
= cur_thread ();
3352 check_empty (args
, "show thread");
3353 show_thread_run_cmd (0, from_tty
);
3354 show_thread_pause_cmd (0, from_tty
);
3355 if (thread
->detach_sc
!= 0)
3356 show_thread_detach_sc_cmd (0, from_tty
);
3361 thread_takeover_sc_cmd (char *args
, int from_tty
)
3363 struct proc
*thread
= cur_thread ();
3365 thread_basic_info_data_t _info
;
3366 thread_basic_info_t info
= &_info
;
3367 mach_msg_type_number_t info_len
= THREAD_BASIC_INFO_COUNT
;
3369 thread_info (thread
->port
, THREAD_BASIC_INFO
, (int *) &info
, &info_len
);
3371 error (("%s."), safe_strerror (err
));
3372 thread
->sc
= info
->suspend_count
;
3374 printf_unfiltered ("Suspend count was %d.\n", thread
->sc
);
3376 vm_deallocate (mach_task_self (), (vm_address_t
) info
,
3377 info_len
* sizeof (int));
3382 add_thread_commands (void)
3384 add_prefix_cmd ("thread", no_class
, set_thread_cmd
,
3385 _("Command prefix for setting thread properties."),
3386 &set_thread_cmd_list
, "set thread ", 0, &setlist
);
3387 add_prefix_cmd ("default", no_class
, show_thread_cmd
,
3388 _("Command prefix for setting default thread properties."),
3389 &set_thread_default_cmd_list
, "set thread default ", 0,
3390 &set_thread_cmd_list
);
3391 add_prefix_cmd ("thread", no_class
, set_thread_default_cmd
,
3392 _("Command prefix for showing thread properties."),
3393 &show_thread_cmd_list
, "show thread ", 0, &showlist
);
3394 add_prefix_cmd ("default", no_class
, show_thread_default_cmd
,
3395 _("Command prefix for showing default thread properties."),
3396 &show_thread_default_cmd_list
, "show thread default ", 0,
3397 &show_thread_cmd_list
);
3399 add_cmd ("pause", class_run
, set_thread_pause_cmd
, _("\
3400 Set whether the current thread is suspended while gdb has control.\n\
3401 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3402 until the next time the program is continued. This property normally\n\
3403 has no effect because the whole task is suspended, however, that may\n\
3404 be disabled with \"set task pause off\".\n\
3405 The default value is \"off\"."),
3406 &set_thread_cmd_list
);
3407 add_cmd ("pause", no_class
, show_thread_pause_cmd
, _("\
3408 Show whether the current thread is suspended while gdb has control."),
3409 &show_thread_cmd_list
);
3411 add_cmd ("run", class_run
, set_thread_run_cmd
,
3412 _("Set whether the current thread is allowed to run."),
3413 &set_thread_cmd_list
);
3414 add_cmd ("run", no_class
, show_thread_run_cmd
,
3415 _("Show whether the current thread is allowed to run."),
3416 &show_thread_cmd_list
);
3418 add_cmd ("detach-suspend-count", class_run
, set_thread_detach_sc_cmd
, _("\
3419 Set the suspend count will leave on the thread when detaching.\n\
3420 Note that this is relative to suspend count when gdb noticed the thread;\n\
3421 use the `thread takeover-suspend-count' to force it to an absolute value."),
3422 &set_thread_cmd_list
);
3423 add_cmd ("detach-suspend-count", no_class
, show_thread_detach_sc_cmd
, _("\
3424 Show the suspend count will leave on the thread when detaching.\n\
3425 Note that this is relative to suspend count when gdb noticed the thread;\n\
3426 use the `thread takeover-suspend-count' to force it to an absolute value."),
3427 &show_thread_cmd_list
);
3429 add_cmd ("exception-port", no_class
, set_thread_exc_port_cmd
, _("\
3430 Set the thread exception port to which we forward exceptions.\n\
3431 This overrides the task exception port.\n\
3432 The argument should be the value of the send right in the task."),
3433 &set_thread_cmd_list
);
3434 add_alias_cmd ("excp", "exception-port", no_class
, 1, &set_thread_cmd_list
);
3435 add_alias_cmd ("exc-port", "exception-port", no_class
, 1,
3436 &set_thread_cmd_list
);
3438 add_cmd ("takeover-suspend-count", no_class
, thread_takeover_sc_cmd
, _("\
3439 Force the threads absolute suspend-count to be gdb's.\n\
3440 Prior to giving this command, gdb's thread suspend-counts are relative\n\
3441 to the thread's initial suspend-count when gdb notices the threads."),
3447 /* -Wmissing-prototypes */
3448 extern initialize_file_ftype _initialize_gnu_nat
;
3451 _initialize_gnu_nat (void)
3453 proc_server
= getproc ();
3455 add_task_commands ();
3456 add_thread_commands ();
3457 add_setshow_boolean_cmd ("gnu-nat", class_maintenance
,
3459 _("Set debugging output for the gnu backend."),
3460 _("Show debugging output for the gnu backend."),
3468 #ifdef FLUSH_INFERIOR_CACHE
3470 /* When over-writing code on some machines the I-Cache must be flushed
3471 explicitly, because it is not kept coherent by the lazy hardware.
3472 This definitely includes breakpoints, for instance, or else we
3473 end up looping in mysterious Bpt traps. */
3476 flush_inferior_icache (CORE_ADDR pc
, int amount
)
3478 vm_machine_attribute_val_t flush
= MATTR_VAL_ICACHE_FLUSH
;
3481 ret
= vm_machine_attribute (gnu_current_inf
->task
->port
,
3486 if (ret
!= KERN_SUCCESS
)
3487 warning (_("Error flushing inferior's cache : %s"), safe_strerror (ret
));
3489 #endif /* FLUSH_INFERIOR_CACHE */