1 /* Interface GDB to the GNU Hurd
2 Copyright (C) 1992, 1995, 1996 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 2 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, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
31 #include <sys/ptrace.h>
33 /* We include this because we don't need the access macros and they conflict
34 with gdb's definitions (ick). This is very non standard! */
35 #include <waitflags.h>
38 #include <mach/message.h>
39 #include <mach/notify.h>
40 #include <mach_error.h>
41 #include <mach/exception.h>
42 #include <mach/vm_attributes.h>
44 #include <hurd/process.h>
45 #include <hurd/process_request.h>
47 #include <hurd/msg_request.h>
48 #include <hurd/signal.h>
49 #include <hurd/interrupt.h>
50 #include <hurd/sigpreempt.h>
66 #include "exc_request_S.h"
68 #include "process_reply_S.h"
69 #include "msg_reply_S.h"
71 #include "exc_request_U.h"
74 static process_t proc_server = MACH_PORT_NULL;
76 /* If we've sent a proc_wait_request to the proc server, the pid of the
77 process we asked about. We can only ever have one outstanding. */
78 int proc_wait_pid = 0;
80 /* The number of wait requests we've sent, and expect replies from. */
81 int proc_waits_pending = 0;
83 int gnu_debug_flag = 0;
87 extern struct target_ops gnu_ops;
88 extern char *strerror();
90 int inf_update_procs (struct inf *inf);
91 static struct inf *make_inf ();
92 static void inf_clear_wait (struct inf *inf);
93 static void inf_cleanup (struct inf *inf);
94 static void inf_startup (struct inf *inf, int pid, task_t task);
95 static int inf_update_suspends (struct inf *inf);
96 static void inf_set_task (struct inf *inf, task_t port);
97 static void inf_validate_procs (struct inf *inf);
98 static void inf_steal_exc_ports (struct inf *inf);
99 static void inf_restore_exc_ports (struct inf *inf);
100 static struct proc *inf_tid_to_proc (struct inf *inf, int tid);
101 static inline void inf_set_threads_resume_sc (struct inf *inf,
102 struct proc *run_thread,
104 static inline int inf_set_threads_resume_sc_for_signal_thread (struct inf *inf);
105 static inline void inf_suspend (struct inf *inf);
106 static inline void inf_resume (struct inf *inf);
107 static void inf_set_step_thread (struct inf *inf, struct proc *proc);
108 static void inf_detach (struct inf *inf);
109 static void inf_attach (struct inf *inf, int pid);
110 static void inf_signal (struct inf *inf, enum target_signal sig);
112 #define inf_debug(_inf, msg, args...) \
113 do { struct inf *__inf = (_inf); \
114 debug ("{inf %d %p}: " msg, __inf->pid, __inf , ##args); } while (0)
116 void proc_abort (struct proc *proc, int force);
117 thread_state_t proc_get_state (struct proc *proc, int force);
118 static struct proc *make_proc (struct inf *inf, mach_port_t port, int tid);
119 static struct proc *_proc_free (struct proc *proc);
120 static int proc_update_sc (struct proc *proc);
121 static error_t proc_get_exception_port (struct proc *proc, mach_port_t *port);
122 static error_t proc_set_exception_port (struct proc *proc, mach_port_t port);
123 static mach_port_t _proc_get_exc_port (struct proc *proc);
124 static void proc_steal_exc_port (struct proc *proc, mach_port_t exc_port);
125 static void proc_restore_exc_port (struct proc *proc);
126 static int proc_trace (struct proc *proc, int set);
127 char *proc_string (struct proc *proc);
129 /* Evaluate RPC_EXPR in a scope with the variables MSGPORT and REFPORT bound
130 to INF's msg port and task port respectively. If it has no msg port,
131 EIEIO is returned. INF must refer to a running process! */
132 #define INF_MSGPORT_RPC(inf, rpc_expr) \
133 HURD_MSGPORT_RPC (proc_getmsgport (proc_server, inf->pid, &msgport), \
134 (refport = inf->task->port, 0), 0, \
135 msgport ? (rpc_expr) : EIEIO)
137 /* Like INF_MSGPORT_RPC, but will also resume the signal thread to ensure
138 there's someone around to deal with the RPC (and resuspend things
139 afterwards). This effects INF's threads' resume_sc count. */
140 #define INF_RESUME_MSGPORT_RPC(inf, rpc_expr) \
141 (inf_set_threads_resume_sc_for_signal_thread (inf) \
144 __e = INF_MSGPORT_RPC (inf, rpc_expr); \
149 #define MIG_SERVER_DIED EMIG_SERVER_DIED /* XXX */
151 /* The state passed by an exception message. */
154 int exception; /* The exception code */
156 mach_port_t handler; /* The real exception port to handle this. */
157 mach_port_t reply; /* The reply port from the exception call. */
160 /* The results of the last wait an inf did. */
163 struct target_waitstatus status; /* The status returned to gdb. */
164 struct exc_state exc; /* The exception that caused us to return. */
165 struct proc *thread; /* The thread in question. */
166 int suppress; /* Something trivial happened. */
169 /* The state of an inferior. */
172 /* Fields describing the current inferior. */
174 struct proc *task; /* The mach task. */
175 struct proc *threads; /* A linked list of all threads in TASK. */
177 /* True if THREADS needn't be validated by querying the task. We assume that
178 we and the task in question are the only ones frobbing the thread list,
179 so as long as we don't let any code run, we don't have to worry about
181 int threads_up_to_date;
183 pid_t pid; /* The real system PID. */
185 struct inf_wait wait; /* What to return from target_wait. */
187 /* One thread proc in INF may be in `single-stepping mode'. This is it. */
188 struct proc *step_thread;
190 /* The thread we think is the signal thread. */
191 struct proc *signal_thread;
193 mach_port_t event_port; /* Where we receive various msgs. */
195 /* True if we think at least one thread in the inferior could currently be
199 /* True if the process has stopped (in the proc server sense). Note that
200 since a proc server `stop' leaves the signal thread running, the inf can
201 be RUNNING && STOPPED... */
204 /* True if the inferior is traced. */
207 /* True if we shouldn't try waiting for the inferior, usually because we
208 can't for some reason. */
211 /* When starting a new inferior, we don't try to validate threads until all
212 the proper execs have been done. This is a count of how many execs we
214 unsigned pending_execs;
216 /* Fields describing global state */
218 /* The task suspend count used when gdb has control. This is normally 1 to
219 make things easier for us, but sometimes (like when attaching to vital
220 system servers) it may be desirable to let the task continue to run
221 (pausing individual threads as necessary). */
224 /* The task suspend count left when detaching from a task. */
227 /* The initial values used for the run_sc and pause_sc of newly discovered
228 threads -- see the definition of those fields in struct proc. */
229 int default_thread_run_sc;
230 int default_thread_pause_sc;
231 int default_thread_detach_sc;
233 /* True if the process should be traced when started/attached. Newly
234 started processes *must* be traced at first to exec them properly, but
235 if this is false, tracing is turned off as soon it has done so. */
238 /* True if exceptions from the inferior process should be trapped. This
239 must be on to use breakpoints. */
244 int __proc_pid (struct proc *proc)
246 return proc->inf->pid;
249 /* Update PROC's real suspend count to match it's desired one. Returns true
250 if we think PROC is now in a runnable state. */
252 proc_update_sc (struct proc *proc)
256 int delta = proc->sc - proc->cur_sc;
259 proc_debug (proc, "sc: %d --> %d", proc->cur_sc, proc->sc);
261 if (proc->sc == 0 && proc->state_changed)
262 /* Since PROC may start running, we must write back any state changes. */
264 assert (proc_is_thread (proc));
265 proc_debug (proc, "storing back changed thread state");
266 err = thread_set_state (proc->port, THREAD_STATE_FLAVOR,
267 (thread_state_t)&proc->state, THREAD_STATE_SIZE);
269 proc->state_changed = 0;
273 while (delta-- > 0 && !err)
274 if (proc_is_task (proc))
275 err = task_suspend (proc->port);
277 err = thread_suspend (proc->port);
279 while (delta++ < 0 && !err)
280 if (proc_is_task (proc))
281 err = task_resume (proc->port);
283 err = thread_resume (proc->port);
286 proc->cur_sc = proc->sc;
288 /* If we got an error, then the task/thread has disappeared. */
289 running = !err && proc->sc == 0;
291 proc_debug (proc, "is %s", err ? "dead" : running ? "running" : "suspended");
293 proc_debug (proc, "err = %s", strerror (err));
298 proc->state_valid = proc->state_changed = 0;
299 proc->fetched_regs = 0;
305 /* Thread_abort is called on PROC if needed. PROC must be a thread proc.
306 If PROC is deemed `precious', then nothing is done unless FORCE is true.
307 In particular, a thread is precious if it's running (in which case forcing
308 it includes suspending it first), or if it has an exception pending. */
310 proc_abort (struct proc *proc, int force)
312 assert (proc_is_thread (proc));
316 struct inf *inf = proc->inf;
317 int running = (proc->cur_sc == 0 && inf->task->cur_sc == 0);
319 if (running && force)
322 inf_update_suspends (proc->inf);
324 warning ("Stopped %s.", proc_string (proc));
326 else if (proc == inf->wait.thread && inf->wait.exc.reply && !force)
327 /* An exception is pending on PROC, which don't mess with. */
331 /* We only abort the thread if it's not actually running. */
333 thread_abort (proc->port);
334 proc_debug (proc, "aborted");
338 proc_debug (proc, "not aborting");
342 /* Make sure that the state field in PROC is up to date, and return a pointer
343 to it, or 0 if something is wrong. If WILL_MODIFY is true, makes sure
344 that the thread is stopped and aborted first, and sets the state_changed
345 field in PROC to true. */
347 proc_get_state (struct proc *proc, int will_modify)
349 int was_aborted = proc->aborted;
351 proc_debug (proc, "updating state info%s",
352 will_modify ? " (with intention to modify)" : "");
354 proc_abort (proc, will_modify);
356 if (! was_aborted && proc->aborted)
357 /* PROC's state may have changed since we last fetched it. */
358 proc->state_valid = 0;
360 if (! proc->state_valid)
362 mach_msg_type_number_t state_size = THREAD_STATE_SIZE;
364 thread_get_state (proc->port, THREAD_STATE_FLAVOR,
365 (thread_state_t)&proc->state, &state_size);
366 proc_debug (proc, "getting thread state");
367 proc->state_valid = !err;
370 if (proc->state_valid)
373 proc->state_changed = 1;
374 return (thread_state_t)&proc->state;
380 /* Set PORT to PROC's exception port. */
382 proc_get_exception_port (struct proc *proc, mach_port_t *port)
384 if (proc_is_task (proc))
385 return task_get_exception_port (proc->port, port);
387 return thread_get_exception_port (proc->port, port);
390 /* Set PROC's exception port to PORT. */
392 proc_set_exception_port (struct proc *proc, mach_port_t port)
394 proc_debug (proc, "setting exception port: %d", port);
395 if (proc_is_task (proc))
396 return task_set_exception_port (proc->port, port);
398 return thread_set_exception_port (proc->port, port);
401 /* Get PROC's exception port, cleaning up a bit if proc has died. */
403 _proc_get_exc_port (struct proc *proc)
405 mach_port_t exc_port;
406 error_t err = proc_get_exception_port (proc, &exc_port);
409 /* PROC must be dead. */
412 mach_port_deallocate (mach_task_self (), proc->exc_port);
413 proc->exc_port = MACH_PORT_NULL;
414 if (proc->saved_exc_port)
415 mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
416 proc->saved_exc_port = MACH_PORT_NULL;
422 /* Replace PROC's exception port with EXC_PORT, unless it's already been
423 done. Stash away any existing exception port so we can restore it later. */
425 proc_steal_exc_port (struct proc *proc, mach_port_t exc_port)
427 mach_port_t cur_exc_port = _proc_get_exc_port (proc);
433 proc_debug (proc, "inserting exception port: %d", exc_port);
435 if (cur_exc_port != exc_port)
436 /* Put in our exception port. */
437 err = proc_set_exception_port (proc, exc_port);
439 if (err || cur_exc_port == proc->exc_port)
440 /* We previously set the exception port, and it's still set. So we
441 just keep the old saved port which is what the proc set. */
444 mach_port_deallocate (mach_task_self (), cur_exc_port);
447 /* Keep a copy of PROC's old exception port so it can be restored. */
449 if (proc->saved_exc_port)
450 mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
451 proc->saved_exc_port = cur_exc_port;
454 proc_debug (proc, "saved exception port: %d", proc->saved_exc_port);
457 proc->exc_port = exc_port;
459 warning ("Error setting exception port for %s: %s",
460 proc_string (proc), strerror (err));
464 /* If we previously replaced PROC's exception port, put back what we
465 found there at the time, unless *our* exception port has since been
466 overwritten, in which case who knows what's going on. */
468 proc_restore_exc_port (struct proc *proc)
470 mach_port_t cur_exc_port = _proc_get_exc_port (proc);
476 proc_debug (proc, "restoring real exception port");
478 if (proc->exc_port == cur_exc_port)
479 /* Our's is still there. */
480 err = proc_set_exception_port (proc, proc->saved_exc_port);
482 if (proc->saved_exc_port)
483 mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
484 proc->saved_exc_port = MACH_PORT_NULL;
487 proc->exc_port = MACH_PORT_NULL;
489 warning ("Error setting exception port for %s: %s",
490 proc_string (proc), strerror (err));
494 /* Turns hardware tracing in PROC on or off when SET is true or false,
495 respectively. Returns true on success. */
497 proc_trace (struct proc *proc, int set)
499 thread_state_t state = proc_get_state (proc, 1);
502 return 0; /* the thread must be dead. */
504 proc_debug (proc, "tracing %s", set ? "on" : "off");
508 /* XXX We don't get the exception unless the thread has its own
509 exception port???? */
510 if (proc->exc_port == MACH_PORT_NULL)
511 proc_steal_exc_port (proc, proc->inf->event_port);
512 THREAD_STATE_SET_TRACED (state);
515 THREAD_STATE_CLEAR_TRACED (state);
520 /* A variable from which to assign new TIDs. */
521 static int next_thread_id = 1;
523 /* Returns a new proc structure with the given fields. Also adds a
524 notification for PORT becoming dead to be sent to INF's notify port. */
526 make_proc (struct inf *inf, mach_port_t port, int tid)
529 mach_port_t prev_port = MACH_PORT_NULL;
530 struct proc *proc = malloc (sizeof (struct proc));
536 proc->saved_exc_port = MACH_PORT_NULL;
537 proc->exc_port = MACH_PORT_NULL;
542 /* Note that these are all the values for threads; the task simply uses the
543 corresponding field in INF directly. */
544 proc->run_sc = inf->default_thread_run_sc;
545 proc->pause_sc = inf->default_thread_pause_sc;
546 proc->detach_sc = inf->default_thread_detach_sc;
547 proc->resume_sc = proc->run_sc;
551 proc->state_valid = 0;
552 proc->state_changed = 0;
554 proc_debug (proc, "is new");
556 /* Get notified when things die. */
558 mach_port_request_notification (mach_task_self(), port,
559 MACH_NOTIFY_DEAD_NAME, 1,
561 MACH_MSG_TYPE_MAKE_SEND_ONCE,
564 warning ("Couldn't request notification for port %d: %s",
565 port, strerror (err));
568 proc_debug (proc, "notifications to: %d", inf->event_port);
569 if (prev_port != MACH_PORT_NULL)
570 mach_port_deallocate (mach_task_self (), prev_port);
573 if (inf->want_exceptions)
574 if (proc_is_task (proc))
575 /* Make the task exception port point to us. */
576 proc_steal_exc_port (proc, inf->event_port);
578 /* Just clear thread exception ports -- they default to the task one. */
579 proc_steal_exc_port (proc, MACH_PORT_NULL);
584 /* Frees PROC and any resources it uses, and returns the value of PROC's
587 _proc_free (struct proc *proc)
589 struct inf *inf = proc->inf;
590 struct proc *next = proc->next;
592 proc_debug (proc, "freeing...");
594 if (proc == inf->step_thread)
595 /* Turn off single stepping. */
596 inf_set_step_thread (inf, 0);
597 if (proc == inf->wait.thread)
598 inf_clear_wait (inf);
599 if (proc == inf->signal_thread)
600 inf->signal_thread = 0;
602 if (proc->port != MACH_PORT_NULL)
604 if (proc->exc_port != MACH_PORT_NULL)
605 /* Restore the original exception port. */
606 proc_restore_exc_port (proc);
607 if (proc->cur_sc != 0)
608 /* Resume the thread/task. */
611 proc_update_sc (proc);
613 mach_port_deallocate (mach_task_self (), proc->port);
620 struct inf *make_inf ()
622 struct inf *inf = malloc (sizeof (struct inf));
629 inf->threads_up_to_date = 0;
631 inf->wait.status.kind = TARGET_WAITKIND_SPURIOUS;
632 inf->wait.thread = 0;
633 inf->wait.exc.handler = MACH_PORT_NULL;
634 inf->wait.exc.reply = MACH_PORT_NULL;
635 inf->step_thread = 0;
636 inf->signal_thread = 0;
637 inf->event_port = MACH_PORT_NULL;
642 inf->pending_execs = 0;
645 inf->default_thread_run_sc = 0;
646 inf->default_thread_pause_sc = 0;
647 inf->default_thread_detach_sc = 0;
648 inf->want_signals = 1; /* By default */
649 inf->want_exceptions = 1; /* By default */
654 /* clear INF's target wait status. */
656 inf_clear_wait (struct inf *inf)
658 inf_debug (inf, "clearing wait");
659 inf->wait.status.kind = TARGET_WAITKIND_SPURIOUS;
660 inf->wait.thread = 0;
661 inf->wait.suppress = 0;
662 if (inf->wait.exc.handler != MACH_PORT_NULL)
664 mach_port_deallocate (mach_task_self (), inf->wait.exc.handler);
665 inf->wait.exc.handler = MACH_PORT_NULL;
667 if (inf->wait.exc.reply != MACH_PORT_NULL)
669 mach_port_deallocate (mach_task_self (), inf->wait.exc.reply);
670 inf->wait.exc.reply = MACH_PORT_NULL;
675 inf_cleanup (struct inf *inf)
677 inf_debug (inf, "cleanup");
679 inf_clear_wait (inf);
681 inf_set_task (inf, MACH_PORT_NULL);
687 inf->pending_execs = 0;
691 mach_port_destroy (mach_task_self (), inf->event_port);
692 inf->event_port = MACH_PORT_NULL;
697 inf_startup (struct inf *inf, int pid, task_t task)
701 inf_debug (inf, "startup: pid = %d, task = %d", pid, task);
705 /* Make the port on which we receive all events. */
706 err = mach_port_allocate (mach_task_self (),
707 MACH_PORT_RIGHT_RECEIVE, &inf->event_port);
709 error ("Error allocating event port: %s", strerror (err));
711 /* Make a send right for it, so we can easily copy it for other people. */
712 mach_port_insert_right (mach_task_self (), inf->event_port,
713 inf->event_port, MACH_MSG_TYPE_MAKE_SEND);
718 inf_set_task (inf, task);
724 inf->task->sc = inf->task->cur_sc = 1; /* Reflect task_suspend above */
728 /* close current process, if any, and attach INF to process PORT */
730 inf_set_task (struct inf *inf, mach_port_t port)
732 struct proc *task = inf->task;
734 inf_debug (inf, "setting task: %d", port);
736 if (task && task->port != port)
739 inf_validate_procs (inf); /* Trash all the threads. */
740 _proc_free (task); /* And the task. */
743 if (port != MACH_PORT_NULL)
745 inf->task = make_proc (inf, port, PROC_TID_TASK);
746 inf->threads_up_to_date = 0;
750 /* Validates INF's stopped field from the actual proc server state. */
752 inf_validate_stopped (struct inf *inf)
755 mach_msg_type_number_t noise_len = 0;
757 mach_msg_type_number_t pi_len = 0;
760 proc_getprocinfo (proc_server, inf->pid, &info_flags,
761 (procinfo_t *)&pi, &pi_len, &noise, &noise_len);
765 inf->stopped = !!(pi->state & PI_STOPPED);
766 vm_deallocate (mach_task_self (), (vm_address_t)pi, pi_len);
768 vm_deallocate (mach_task_self (), (vm_address_t)noise, noise_len);
772 /* Validates INF's task suspend count. If it's higher than we expect, verify
773 with the user before `stealing' the extra count. */
775 inf_validate_task_sc (struct inf *inf)
777 struct task_basic_info info;
778 mach_msg_type_number_t info_len = TASK_BASIC_INFO_COUNT;
780 task_info (inf->task->port, TASK_BASIC_INFO, (task_info_t)&info, &info_len);
783 inf->task->dead = 1; /* oh well */
784 else if (inf->task->cur_sc < info.suspend_count)
788 target_terminal_ours (); /* Allow I/O. */
790 !query ("Pid %d has an additional task suspend count of %d; clear it? ",
791 inf->pid, info.suspend_count - inf->task->cur_sc);
792 target_terminal_inferior (); /* Give it back to the child. */
795 error ("Additional task suspend count left untouched.");
797 inf->task->cur_sc = info.suspend_count;
801 /* Turns tracing for INF on or off, depending on ON, unless it already is.
802 If INF is running, the resume_sc count of INF's threads will be modified,
803 and the signal thread will briefly be run to change the trace state. */
805 inf_set_traced (struct inf *inf, int on)
807 if (on != inf->traced)
808 if (inf->task && !inf->task->dead)
809 /* Make it take effect immediately. */
811 sigset_t mask = on ? ~(sigset_t)0 : 0;
813 INF_RESUME_MSGPORT_RPC (inf, msg_set_init_int (msgport, refport,
814 INIT_TRACEMASK, mask));
818 warning ("Can't modify tracing state for pid %d: No signal thread",
823 warning ("Can't modify tracing state for pid %d: %s",
824 inf->pid, strerror (err));
832 /* Makes all the real suspend count deltas of all the procs in INF match the
833 desired values. Careful to always do thread/task suspend counts in the
834 safe order. Returns true if at least one thread is thought to be running.*/
836 inf_update_suspends (struct inf *inf)
838 struct proc *task = inf->task;
839 /* We don't have to update INF->threads even though we're iterating over it
840 because we'll change a thread only if it already has an existing proc
843 inf_debug (inf, "updating suspend counts");
848 int task_running = (task->sc == 0), thread_running = 0;
850 if (task->sc > task->cur_sc)
851 /* The task is becoming _more_ suspended; do before any threads. */
852 task_running = proc_update_sc (task);
854 if (inf->pending_execs)
855 /* When we're waiting for an exec, things may be happening behind our
856 back, so be conservative. */
859 /* Do all the thread suspend counts. */
860 for (thread = inf->threads; thread; thread = thread->next)
861 thread_running |= proc_update_sc (thread);
863 if (task->sc != task->cur_sc)
864 /* We didn't do the task first, because we wanted to wait for the
865 threads; do it now. */
866 task_running = proc_update_sc (task);
868 inf_debug (inf, "%srunning...",
869 (thread_running && task_running) ? "" : "not ");
871 inf->running = thread_running && task_running;
873 /* Once any thread has executed some code, we can't depend on the
874 threads list any more. */
876 inf->threads_up_to_date = 0;
884 /* Converts a GDB pid to a struct proc. */
886 inf_tid_to_thread (struct inf *inf, int tid)
888 struct proc *thread = inf->threads;
889 if (tid == inf->pid) /* main thread */
892 if (thread->tid == tid)
895 thread = thread->next;
899 /* Converts a thread port to a struct proc. */
901 inf_port_to_thread (struct inf *inf, mach_port_t port)
903 struct proc *thread = inf->threads;
905 if (thread->port == port)
908 thread = thread->next;
912 /* Make INF's list of threads be consistent with reality of TASK. */
914 inf_validate_procs (struct inf *inf)
917 thread_array_t threads;
918 unsigned num_threads;
919 struct proc *task = inf->task;
921 /* If no threads are currently running, this function will guarantee that
922 things are up to date. The exception is if there are zero threads --
923 then it is almost certainly in an odd state, and probably some outside
924 agent will create threads. */
925 inf->threads_up_to_date = inf->threads ? !inf->running : 0;
929 error_t err = task_threads (task->port, &threads, &num_threads);
930 inf_debug (inf, "fetching threads");
932 /* TASK must be dead. */
942 inf_debug (inf, "no task");
946 unsigned search_start = 0; /* Make things normally linear. */
947 /* Which thread in PROCS corresponds to each task thread, & the task. */
948 struct proc *matched[num_threads + 1];
949 /* The last thread in INF->threads, so we can add to the end. */
950 struct proc *last = 0;
951 /* The current thread we're considering. */
952 struct proc *thread = inf->threads;
954 bzero (matched, sizeof (matched));
960 for (i = search_start, left = num_threads; left; i++, left--)
962 if (i >= num_threads)
963 i -= num_threads; /* I wrapped around. */
964 if (thread->port == threads[i])
965 /* We already know about this thread. */
969 thread = thread->next;
977 proc_debug (thread, "died!");
978 thread->port = MACH_PORT_NULL;
979 thread = _proc_free (thread); /* THREAD is dead. */
980 (last ? last->next : inf->threads) = thread;
984 for (i = 0; i < num_threads; i++)
986 /* Throw away the duplicate send right. */
987 mach_port_deallocate (mach_task_self (), threads[i]);
989 /* THREADS[I] is a thread we don't know about yet! */
992 thread = make_proc (inf, threads[i], next_thread_id++);
994 thread = make_proc (inf, threads[i], threads[i]);
996 (last ? last->next : inf->threads) = thread;
998 proc_debug (thread, "new thread: %d", threads[i]);
999 #if 1 /* try leaving this out, see what happens */
1000 add_thread (thread->tid); /* Tell GDB's generic thread code. */
1001 #if 0 /* seems to cause kernel exceptions??? */
1002 target_terminal_ours_for_output (); /* allow debugger I/O */
1003 printf_filtered ("[gnu-nat: New %s]\n",
1004 target_pid_to_str (thread->tid));
1005 target_terminal_inferior (); /* give it back */
1010 vm_deallocate(mach_task_self(),
1011 (vm_address_t)threads, (num_threads * sizeof(thread_t)));
1015 /* Makes sure that INF's thread list is synced with the actual process. */
1017 inf_update_procs (struct inf *inf)
1021 if (! inf->threads_up_to_date)
1022 inf_validate_procs (inf);
1026 /* Sets the resume_sc of each thread in inf. That of RUN_THREAD is set to 0,
1027 and others are set to their run_sc if RUN_OTHERS is true, and otherwise
1030 inf_set_threads_resume_sc (struct inf *inf,
1031 struct proc *run_thread, int run_others)
1033 struct proc *thread;
1034 inf_update_procs (inf);
1035 for (thread = inf->threads; thread; thread = thread->next)
1036 if (thread == run_thread)
1037 thread->resume_sc = 0;
1038 else if (run_others)
1039 thread->resume_sc = thread->run_sc;
1041 thread->resume_sc = thread->pause_sc;
1044 /* Cause INF to continue execution immediately; individual threads may still
1045 be suspended (but their suspend counts will be updated). */
1047 inf_resume (struct inf *inf)
1049 struct proc *thread;
1051 inf_update_procs (inf);
1053 for (thread = inf->threads; thread; thread = thread->next)
1054 thread->sc = thread->resume_sc;
1058 if (! inf->pending_execs)
1059 /* Try to make sure our task count is correct -- in the case where
1060 we're waiting for an exec though, things are too volatile, so just
1061 assume things will be reasonable (which they usually will be). */
1062 inf_validate_task_sc (inf);
1066 inf_update_suspends (inf);
1069 /* Cause INF to stop execution immediately; individual threads may still
1072 inf_suspend (struct inf *inf)
1074 struct proc *thread;
1076 inf_update_procs (inf);
1078 for (thread = inf->threads; thread; thread = thread->next)
1079 thread->sc = thread->pause_sc;
1082 inf->task->sc = inf->pause_sc;
1084 inf_update_suspends (inf);
1087 /* INF has one thread PROC that is in single-stepping mode. This function
1088 changes it to be PROC, changing any old step_thread to be a normal one. A
1089 PROC of 0 clears any existing value. */
1091 inf_set_step_thread (struct inf *inf, struct proc *thread)
1093 assert (!thread || proc_is_thread (thread));
1096 inf_debug (inf, "setting step thread: %d/%d", inf->pid, thread->tid);
1098 inf_debug (inf, "clearing step thread");
1100 if (inf->step_thread != thread)
1102 if (inf->step_thread && inf->step_thread->port != MACH_PORT_NULL)
1103 if (! proc_trace (inf->step_thread, 0))
1105 if (thread && proc_trace (thread, 1))
1106 inf->step_thread = thread;
1108 inf->step_thread = 0;
1112 /* Set up the thread resume_sc's so that only the signal thread is running
1113 (plus whatever other thread are set to always run). Returns true if we
1114 did so, or false if we can't find a signal thread. */
1116 inf_set_threads_resume_sc_for_signal_thread (struct inf *inf)
1118 if (inf->signal_thread)
1120 inf_set_threads_resume_sc (inf, inf->signal_thread, 0);
1128 inf_update_signal_thread (struct inf *inf)
1130 /* XXX for now we assume that if there's a msgport, the 2nd thread is
1131 the signal thread. */
1132 inf->signal_thread = inf->threads ? inf->threads->next : 0;
1135 /* Detachs from INF's inferior task, letting it run once again... */
1137 inf_detach (struct inf *inf)
1139 struct proc *task = inf->task;
1141 inf_debug (inf, "detaching...");
1143 inf_clear_wait (inf);
1144 inf_set_step_thread (inf, 0);
1148 struct proc *thread;
1150 inf_set_traced (inf, 0);
1152 inf_signal (inf, TARGET_SIGNAL_0);
1154 proc_restore_exc_port (task);
1155 task->sc = inf->detach_sc;
1157 for (thread = inf->threads; thread; thread = thread->next)
1159 proc_restore_exc_port (thread);
1160 thread->sc = thread->detach_sc;
1163 inf_update_suspends (inf);
1169 /* Attaches INF to the process with process id PID, returning it in a suspended
1170 state suitable for debugging. */
1172 inf_attach (struct inf *inf, int pid)
1177 inf_debug (inf, "attaching: %d", pid);
1179 err = proc_pid2task (proc_server, pid, &task);
1181 error ("Error getting task for pid %d: %s", pid, strerror (err));
1186 inf_startup (inf, pid, task);
1189 /* Makes sure that we've got our exception ports entrenched in the process. */
1190 void inf_steal_exc_ports (struct inf *inf)
1192 struct proc *thread;
1194 inf_debug (inf, "stealing exception ports");
1196 inf_set_step_thread (inf, 0); /* The step thread is special. */
1198 proc_steal_exc_port (inf->task, inf->event_port);
1199 for (thread = inf->threads; thread; thread = thread->next)
1200 proc_steal_exc_port (thread, MACH_PORT_NULL);
1203 /* Makes sure the process has its own exception ports. */
1204 void inf_restore_exc_ports (struct inf *inf)
1206 struct proc *thread;
1208 inf_debug (inf, "restoring exception ports");
1210 inf_set_step_thread (inf, 0); /* The step thread is special. */
1212 proc_restore_exc_port (inf->task);
1213 for (thread = inf->threads; thread; thread = thread->next)
1214 proc_restore_exc_port (thread);
1217 /* Deliver signal SIG to INF. If INF is stopped, delivering a signal, even
1218 signal 0, will continue it. INF is assumed to be in a paused state, and
1219 the resume_sc's of INF's threads may be affected. */
1221 inf_signal (struct inf *inf, enum target_signal sig)
1224 int host_sig = target_signal_to_host (sig);
1226 #define NAME target_signal_to_name (sig)
1228 if (host_sig >= _NSIG)
1229 /* A mach exception. Exceptions are encoded in the signal space by
1230 putting them after _NSIG; this assumes they're positive (and not
1231 extremely large)! */
1233 struct inf_wait *w = &inf->wait;
1234 if (w->status.kind == TARGET_WAITKIND_STOPPED
1235 && w->status.value.sig == sig
1236 && w->thread && !w->thread->aborted)
1237 /* We're passing through the last exception we received. This is
1238 kind of bogus, because exceptions are per-thread whereas gdb
1239 treats signals as per-process. We just forward the exception to
1240 the correct handler, even it's not for the same thread as TID --
1241 i.e., we pretend it's global. */
1243 struct exc_state *e = &w->exc;
1244 inf_debug (inf, "passing through exception:"
1245 " task = %d, thread = %d, exc = %d"
1246 ", code = %d, subcode = %d",
1247 w->thread->port, inf->task->port,
1248 e->exception, e->code, e->subcode);
1250 exception_raise_request (e->handler,
1251 e->reply, MACH_MSG_TYPE_MOVE_SEND_ONCE,
1252 w->thread->port, inf->task->port,
1253 e->exception, e->code, e->subcode);
1256 error ("Can't forward spontaneous exception (%s).", NAME);
1259 /* A Unix signal. */
1261 /* The process is stopped and expecting a signal. Just send off a
1262 request and let it get handled when we resume everything. */
1264 inf_debug (inf, "sending %s to stopped process", NAME);
1266 INF_MSGPORT_RPC (inf,
1267 msg_sig_post_untraced_request (msgport,
1269 MACH_MSG_TYPE_MAKE_SEND_ONCE,
1273 /* Posting an untraced signal automatically continues it.
1274 We clear this here rather than when we get the reply
1275 because we'd rather assume it's not stopped when it
1276 actually is, than the reverse. */
1280 /* It's not expecting it. We have to let just the signal thread
1281 run, and wait for it to get into a reasonable state before we
1282 can continue the rest of the process. When we finally resume the
1283 process the signal we request will be the very first thing that
1286 inf_debug (inf, "sending %s to unstopped process (so resuming signal thread)", NAME);
1288 INF_RESUME_MSGPORT_RPC (inf, msg_sig_post_untraced (msgport,
1289 host_sig, 0, refport));
1293 /* Can't do too much... */
1294 warning ("Can't deliver signal %s: No signal thread.", NAME);
1296 warning ("Delivering signal %s: %s", NAME, strerror (err));
1301 /* The inferior used for all gdb target ops. */
1302 struct inf *current_inferior = 0;
1304 /* The inferior being waited for by gnu_wait. Since GDB is decidely not
1305 multi-threaded, we don't bother to lock this. */
1306 struct inf *waiting_inf;
1308 /* Wait for something to happen in the inferior, returning what in STATUS. */
1310 gnu_wait (int tid, struct target_waitstatus *status)
1313 mach_msg_header_t hdr;
1314 mach_msg_type_t type;
1318 struct proc *thread;
1319 struct inf *inf = current_inferior;
1323 if (!inf->threads && !inf->pending_execs)
1324 /* No threads! Assume that maybe some outside agency is frobbing our
1325 task, and really look for new threads. If we can't find any, just tell
1326 the user to try again later. */
1328 inf_validate_procs (inf);
1329 if (!inf->threads && !inf->task->dead)
1330 error ("There are no threads; try again later.");
1335 inf_debug (inf, "waiting for: %d", tid);
1338 if (proc_wait_pid != inf->pid && !inf->no_wait)
1339 /* Always get information on events from the proc server. */
1341 inf_debug (inf, "requesting wait on pid %d", inf->pid);
1344 /* The proc server is single-threaded, and only allows a single
1345 outstanding wait request, so we have to cancel the previous one. */
1347 inf_debug (inf, "cancelling previous wait on pid %d", proc_wait_pid);
1348 interrupt_operation (proc_server, 0);
1352 proc_wait_request (proc_server, inf->event_port, inf->pid, WUNTRACED);
1354 warning ("wait request failed: %s", strerror (err));
1357 inf_debug (inf, "waits pending: %d", proc_waits_pending);
1358 proc_wait_pid = inf->pid;
1359 /* Even if proc_waits_pending was > 0 before, we still won't get
1360 any other replies, because it was either from a different INF,
1361 or a different process attached to INF -- and the event port,
1362 which is the wait reply port, changes when you switch processes.*/
1363 proc_waits_pending = 1;
1367 inf_clear_wait (inf);
1369 /* What can happen? (1) Dead name notification; (2) Exceptions arrive;
1370 (3) wait reply from the proc server. */
1372 inf_debug (inf, "waiting for an event...");
1373 err = mach_msg (&msg.hdr, MACH_RCV_MSG | MACH_RCV_INTERRUPT,
1374 0, sizeof (struct msg), inf->event_port,
1375 MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
1377 /* Re-suspend the task. */
1380 if (err == EMACH_RCV_INTERRUPTED)
1381 inf_debug (inf, "interrupted");
1383 error ("Couldn't wait for an event: %s", strerror (err));
1387 mach_msg_header_t hdr;
1388 mach_msg_type_t err_type;
1393 inf_debug (inf, "event: msgid = %d", msg.hdr.msgh_id);
1395 /* Handle what we got. */
1396 if (! notify_server (&msg.hdr, &reply.hdr)
1397 && ! exc_server (&msg.hdr, &reply.hdr)
1398 && ! process_reply_server (&msg.hdr, &reply.hdr)
1399 && ! msg_reply_server (&msg.hdr, &reply.hdr))
1400 /* Whatever it is, it's something strange. */
1401 error ("Got a strange event, msg id = %d.", msg.hdr.msgh_id);
1404 error ("Handling event, msgid = %d: %s",
1405 msg.hdr.msgh_id, strerror (reply.err));
1408 if (inf->pending_execs)
1409 /* We're waiting for the inferior to finish execing. */
1411 struct inf_wait *w = &inf->wait;
1412 enum target_waitkind kind = w->status.kind;
1414 if (kind == TARGET_WAITKIND_SPURIOUS)
1415 /* Since gdb is actually counting the number of times the inferior
1416 stops, expecting one stop per exec, we only return major events
1420 inf_debug (inf, "pending_execs = %d, ignoring minor event",
1421 inf->pending_execs);
1423 else if (kind == TARGET_WAITKIND_STOPPED
1424 && w->status.value.sig == TARGET_SIGNAL_TRAP)
1425 /* Ah hah! A SIGTRAP from the inferior while starting up probably
1426 means we've succesfully completed an exec! */
1428 #if 0 /* do we need this? */
1429 if (--inf->pending_execs == 0)
1432 prune_threads (1); /* Get rid of the old shell threads */
1433 renumber_threads (0); /* Give our threads reasonable names. */
1436 inf_debug (inf, "pending exec completed, pending_execs => %d",
1437 inf->pending_execs);
1441 if (inf->wait.suppress)
1442 /* Some totally spurious event happened that we don't consider
1443 worth returning to gdb. Just keep waiting. */
1445 inf_debug (inf, "suppressing return, rewaiting...");
1450 /* Pass back out our results. */
1451 bcopy (&inf->wait.status, status, sizeof (*status));
1453 thread = inf->wait.thread;
1457 thread = inf_tid_to_thread (inf, tid);
1459 if (!thread || thread->port == MACH_PORT_NULL)
1460 /* TID is dead; try and find a new thread. */
1461 if (inf_update_procs (inf) && inf->threads)
1462 tid = inf->threads->tid; /* The first available thread. */
1464 tid = inferior_pid; /* let wait_for_inferior handle exit case */
1466 if (thread && tid >= 0 && status->kind != TARGET_WAITKIND_SPURIOUS
1467 && inf->pause_sc == 0 && thread->pause_sc == 0)
1468 /* If something actually happened to THREAD, make sure we suspend it. */
1471 inf_update_suspends (inf);
1474 inf_debug (inf, "returning tid = %d, status = %s (%d)", tid,
1475 status->kind == TARGET_WAITKIND_EXITED ? "EXITED"
1476 : status->kind == TARGET_WAITKIND_STOPPED ? "STOPPED"
1477 : status->kind == TARGET_WAITKIND_SIGNALLED ? "SIGNALLED"
1478 : status->kind == TARGET_WAITKIND_LOADED ? "LOADED"
1479 : status->kind == TARGET_WAITKIND_SPURIOUS ? "SPURIOUS"
1481 status->value.integer);
1486 /* The rpc handler called by exc_server. */
1488 S_exception_raise_request (mach_port_t port, mach_port_t reply_port,
1489 thread_t thread_port, task_t task_port,
1490 int exception, int code, int subcode)
1492 struct inf *inf = waiting_inf;
1493 struct proc *thread = inf_port_to_thread (inf, thread_port);
1495 inf_debug (waiting_inf,
1496 "thread = %d, task = %d, exc = %d, code = %d, subcode = %d",
1497 thread_port, task_port, exception, code);
1500 /* We don't know about thread? */
1502 inf_update_procs (inf);
1503 thread = inf_port_to_thread (inf, thread_port);
1505 /* Give up, the generating thread is gone. */
1509 mach_port_deallocate (mach_task_self (), thread_port);
1510 mach_port_deallocate (mach_task_self (), task_port);
1512 if (! thread->aborted)
1513 /* THREAD hasn't been aborted since this exception happened (abortion
1514 clears any exception state), so it must be real. */
1516 /* Store away the details; this will destroy any previous info. */
1517 inf->wait.thread = thread;
1519 inf->wait.status.kind = TARGET_WAITKIND_STOPPED;
1521 if (exception == EXC_BREAKPOINT)
1522 /* GDB likes to get SIGTRAP for breakpoints. */
1524 inf->wait.status.value.sig = TARGET_SIGNAL_TRAP;
1525 mach_port_deallocate (mach_task_self (), reply_port);
1528 /* Record the exception so that we can forward it later. */
1530 if (thread->exc_port == port)
1532 inf_debug (waiting_inf, "Handler is thread exeption port <%d>",
1533 thread->saved_exc_port);
1534 inf->wait.exc.handler = thread->saved_exc_port;
1538 inf_debug (waiting_inf, "Handler is task exeption port <%d>",
1539 inf->task->saved_exc_port);
1540 inf->wait.exc.handler = inf->task->saved_exc_port;
1541 assert (inf->task->exc_port == port);
1543 if (inf->wait.exc.handler != MACH_PORT_NULL)
1544 /* Add a reference to the exception handler. */
1545 mach_port_mod_refs (mach_task_self (),
1546 inf->wait.exc.handler, MACH_PORT_RIGHT_SEND,
1549 inf->wait.exc.exception = exception;
1550 inf->wait.exc.code = code;
1551 inf->wait.exc.subcode = subcode;
1552 inf->wait.exc.reply = reply_port;
1554 /* Exceptions are encoded in the signal space by putting them after
1555 _NSIG; this assumes they're positive (and not extremely large)! */
1556 inf->wait.status.value.sig =
1557 target_signal_from_host (_NSIG + exception);
1561 /* A supppressed exception, which ignore. */
1563 inf->wait.suppress = 1;
1564 mach_port_deallocate (mach_task_self (), reply_port);
1570 /* Fill in INF's wait field after a task has died without giving us more
1571 detailed information. */
1573 inf_task_died_status (struct inf *inf)
1575 warning ("Pid %d died with unknown exit status, using SIGKILL.", inf->pid);
1576 inf->wait.status.kind = TARGET_WAITKIND_SIGNALLED;
1577 inf->wait.status.value.sig = TARGET_SIGNAL_KILL;
1580 /* Notify server routines. The only real one is dead name notification. */
1582 do_mach_notify_dead_name (mach_port_t notify, mach_port_t dead_port)
1584 struct inf *inf = waiting_inf;
1586 inf_debug (waiting_inf, "port = %d", dead_port);
1588 if (inf->task && inf->task->port == dead_port)
1590 proc_debug (inf->task, "is dead");
1591 inf->task->port = MACH_PORT_NULL;
1592 if (proc_wait_pid == inf->pid)
1593 /* We have a wait outstanding on the process, which will return more
1594 detailed information, so delay until we get that. */
1595 inf->wait.suppress = 1;
1597 /* We never waited for the process (maybe it wasn't a child), so just
1598 pretend it got a SIGKILL. */
1599 inf_task_died_status (inf);
1603 struct proc *thread = inf_port_to_thread (inf, dead_port);
1606 proc_debug (thread, "is dead");
1607 thread->port = MACH_PORT_NULL;
1611 mach_port_deallocate (mach_task_self (), dead_port);
1612 inf->threads_up_to_date = 0; /* Just in case */
1620 warning ("illegal rpc: %s", fun);
1625 do_mach_notify_no_senders (mach_port_t notify, mach_port_mscount_t count)
1627 return ill_rpc (__FUNCTION__);
1631 do_mach_notify_port_deleted (mach_port_t notify, mach_port_t name)
1633 return ill_rpc (__FUNCTION__);
1637 do_mach_notify_msg_accepted (mach_port_t notify, mach_port_t name)
1639 return ill_rpc (__FUNCTION__);
1643 do_mach_notify_port_destroyed (mach_port_t notify, mach_port_t name)
1645 return ill_rpc (__FUNCTION__);
1649 do_mach_notify_send_once (mach_port_t notify)
1651 return ill_rpc (__FUNCTION__);
1654 /* Process_reply server routines. We only use process_wait_reply. */
1657 S_proc_wait_reply (mach_port_t reply, error_t err,
1658 int status, int sigcode, rusage_t rusage, pid_t pid)
1660 struct inf *inf = waiting_inf;
1662 inf_debug (inf, "err = %s, pid = %d, status = 0x%x, sigcode = %d",
1663 err ? strerror (err) : "0", pid, status, sigcode);
1665 if (err && proc_wait_pid && (!inf->task || !inf->task->port))
1666 /* Ack. The task has died, but the task-died notification code didn't
1667 tell anyone because it thought a more detailed reply from the
1668 procserver was forthcoming. However, we now learn that won't
1669 happen... So we have to act like the task just died, and this time,
1671 inf_task_died_status (inf);
1673 if (--proc_waits_pending == 0)
1674 /* PROC_WAIT_PID represents the most recent wait. We will always get
1675 replies in order because the proc server is single threaded. */
1678 inf_debug (inf, "waits pending now: %d", proc_waits_pending);
1684 warning ("Can't wait for pid %d: %s", inf->pid, strerror (err));
1687 /* Since we can't see the inferior's signals, don't trap them. */
1688 inf_set_traced (inf, 0);
1691 else if (pid == inf->pid)
1693 store_waitstatus (&inf->wait.status, status);
1694 if (inf->wait.status.kind == TARGET_WAITKIND_STOPPED)
1695 /* The process has sent us a signal, and stopped itself in a sane
1696 state pending our actions. */
1698 inf_debug (inf, "process has stopped itself");
1703 inf->wait.suppress = 1; /* Something odd happened. Ignore. */
1709 S_proc_setmsgport_reply (mach_port_t reply, error_t err,
1710 mach_port_t old_msg_port)
1712 return ill_rpc (__FUNCTION__);
1716 S_proc_getmsgport_reply (mach_port_t reply, error_t err, mach_port_t msg_port)
1718 return ill_rpc (__FUNCTION__);
1721 /* Msg_reply server routines. We only use msg_sig_post_untraced_reply. */
1724 S_msg_sig_post_untraced_reply (mach_port_t reply, error_t err)
1726 struct inf *inf = waiting_inf;
1729 /* EBUSY is what we get when the crash server has grabbed control of the
1730 process and doesn't like what signal we tried to send it. Just act
1731 like the process stopped (using a signal of 0 should mean that the
1732 *next* time the user continues, it will pass signal 0, which the crash
1733 server should like). */
1735 inf->wait.status.kind = TARGET_WAITKIND_STOPPED;
1736 inf->wait.status.value.sig = TARGET_SIGNAL_0;
1739 warning ("Signal delivery failed: %s", strerror (err));
1742 /* We only get this reply when we've posted a signal to a process which we
1743 thought was stopped, and which we expected to continue after the signal.
1744 Given that the signal has failed for some reason, it's reasonable to
1745 assume it's still stopped. */
1748 inf->wait.suppress = 1;
1754 S_msg_sig_post_reply (mach_port_t reply, error_t err)
1756 return ill_rpc (__FUNCTION__);
1759 /* Returns the number of messages queued for the receive right PORT. */
1760 static mach_port_msgcount_t
1761 port_msgs_queued (mach_port_t port)
1763 struct mach_port_status status;
1765 mach_port_get_receive_status (mach_task_self (), port, &status);
1770 return status.mps_msgcount;
1773 /* Resume execution of the inferior process.
1775 If STEP is nonzero, single-step it.
1776 If SIGNAL is nonzero, give it that signal.
1779 -1 true Single step the current thread allowing other threads to run.
1780 -1 false Continue the current thread allowing other threads to run.
1781 X true Single step the given thread, don't allow any others to run.
1782 X false Continue the given thread, do not allow any others to run.
1783 (Where X, of course, is anything except -1)
1785 Note that a resume may not `take' if there are pending exceptions/&c
1786 still unprocessed from the last resume we did (any given resume may result
1787 in multiple events returned by wait).
1790 gnu_resume (int tid, int step, enum target_signal sig)
1792 struct proc *step_thread = 0;
1793 struct inf *inf = current_inferior;
1795 inf_debug (inf, "tid = %d, step = %d, sig = %d", tid, step, sig);
1797 if (sig != TARGET_SIGNAL_0 || inf->stopped)
1798 inf_signal (inf, sig);
1799 else if (inf->wait.exc.reply != MACH_PORT_NULL)
1800 /* We received an exception to which we have chosen not to forward, so
1801 abort the faulting thread, which will perhaps retake it. */
1803 proc_abort (inf->wait.thread, 1);
1804 warning ("Aborting %s with unforwarded exception %s.",
1805 proc_string (inf->wait.thread),
1806 target_signal_to_name (inf->wait.status.value.sig));
1809 if (port_msgs_queued (inf->event_port))
1810 /* If there are still messages in our event queue, don't bother resuming
1811 the process, as we're just going to stop it right away anyway. */
1814 inf_update_procs (inf);
1817 /* Allow all threads to run, except perhaps single-stepping one. */
1819 inf_debug (inf, "running all threads; tid = %d", inferior_pid);
1820 tid = inferior_pid; /* What to step. */
1821 inf_set_threads_resume_sc (inf, 0, 1);
1824 /* Just allow a single thread to run. */
1826 struct proc *thread = inf_tid_to_thread (inf, tid);
1828 error ("Can't run single thread id %d: no such thread!");
1829 inf_debug (inf, "running one thread: %d/%d", inf->pid, thread->tid);
1830 inf_set_threads_resume_sc (inf, thread, 0);
1835 step_thread = inf_tid_to_thread (inf, tid);
1837 warning ("Can't step thread id %d: no such thread.", tid);
1839 inf_debug (inf, "stepping thread: %d/%d", inf->pid, step_thread->tid);
1841 if (step_thread != inf->step_thread)
1842 inf_set_step_thread (inf, step_thread);
1844 inf_debug (inf, "here we go...");
1849 gnu_kill_inferior ()
1851 struct proc *task = current_inferior->task;
1854 proc_debug (task, "terminating...");
1855 task_terminate (task->port);
1856 inf_set_task (current_inferior, MACH_PORT_NULL);
1858 target_mourn_inferior ();
1861 /* Clean up after the inferior dies. */
1864 gnu_mourn_inferior ()
1866 inf_debug (current_inferior, "rip");
1867 inf_detach (current_inferior);
1868 unpush_target (&gnu_ops);
1869 generic_mourn_inferior ();
1872 /* Fork an inferior process, and start debugging it. */
1874 /* Set INFERIOR_PID to the first thread available in the child, if any. */
1876 inf_pick_first_thread ()
1878 if (current_inferior->task && current_inferior->threads)
1879 /* The first thread. */
1880 return current_inferior->threads->tid;
1882 /* What may be the next thread. */
1883 return next_thread_id;
1889 if (! current_inferior)
1890 current_inferior = make_inf ();
1891 return current_inferior;
1895 gnu_create_inferior (exec_file, allargs, env)
1900 struct inf *inf = cur_inf ();
1904 /* We're in the child; make this process stop as soon as it execs. */
1905 inf_debug (inf, "tracing self");
1906 if (ptrace (PTRACE_TRACEME) != 0)
1907 error ("ptrace (PTRACE_TRACEME) failed!");
1909 int attach_to_child (int pid)
1911 /* Attach to the now stopped child, which is actually a shell... */
1912 inf_debug (inf, "attaching to child: %d", pid);
1914 inf_attach (inf, pid);
1917 push_target (&gnu_ops);
1919 inf->pending_execs = 2;
1922 /* Now let the child run again, knowing that it will stop immediately
1923 because of the ptrace. */
1925 inferior_pid = inf_pick_first_thread ();
1927 startup_inferior (inf->pending_execs);
1929 return inferior_pid;
1932 inf_debug (inf, "creating inferior");
1934 fork_inferior (exec_file, allargs, env, trace_me, attach_to_child, NULL);
1936 inf_update_signal_thread (inf);
1937 inf_set_traced (inf, inf->want_signals);
1939 /* Execing the process will have trashed our exception ports; steal them
1940 back (or make sure they're restored if the user wants that). */
1941 if (inf->want_exceptions)
1942 inf_steal_exc_ports (inf);
1944 inf_restore_exc_ports (inf);
1947 proceed ((CORE_ADDR) -1, 0, 0);
1950 /* Mark our target-struct as eligible for stray "run" and "attach"
1958 #ifdef ATTACH_DETACH
1960 /* Attach to process PID, then initialize for debugging it
1961 and wait for the trace-trap that results from attaching. */
1963 gnu_attach (args, from_tty)
1969 struct inf *inf = cur_inf ();
1972 error_no_arg ("PID to attach");
1976 if (pid == getpid()) /* Trying to masturbate? */
1977 error ("I refuse to debug myself!");
1981 exec_file = (char *) get_exec_file (0);
1984 printf_unfiltered ("Attaching to program `%s', pid %d\n",
1987 printf_unfiltered ("Attaching to pid %d\n", pid);
1989 gdb_flush (gdb_stdout);
1992 inf_debug (inf, "attaching to pid: %d", pid);
1994 inf_attach (inf, pid);
1995 inf_update_procs (inf);
1997 inferior_pid = inf_pick_first_thread ();
2000 push_target (&gnu_ops);
2002 inf_update_signal_thread (inf);
2003 inf_set_traced (inf, inf->want_signals);
2005 /* If the process was stopped before we attached, make it continue the next
2006 time the user does a continue. */
2007 inf_validate_stopped (inf);
2009 #if 0 /* Do we need this? Actually I can see where it
2010 might be helpful here, but it's just cosmetic.
2011 Let's come back to it later. XXX Fix me. */
2012 renumber_threads (0); /* Give our threads reasonable names. */
2016 /* Take a program previously attached to and detaches it.
2017 The program resumes execution and will no longer stop
2018 on signals, etc. We'd better not have left any breakpoints
2019 in the program or it'll die when it hits one. For this
2020 to work, it may be necessary for the process to have been
2021 previously attached. It *might* work if the program was
2022 started via fork. */
2024 gnu_detach (args, from_tty)
2030 char *exec_file = get_exec_file (0);
2032 printf_unfiltered ("Detaching from program `%s' pid %d\n",
2033 exec_file, current_inferior->pid);
2035 printf_unfiltered ("Detaching from pid %d\n", current_inferior->pid);
2036 gdb_flush (gdb_stdout);
2039 inf_detach (current_inferior);
2043 unpush_target (&gnu_ops); /* Pop out of handling an inferior */
2045 #endif /* ATTACH_DETACH */
2048 gnu_terminal_init_inferior ()
2050 assert (current_inferior);
2051 terminal_init_inferior_with_pgrp (current_inferior->pid);
2054 /* Get ready to modify the registers array. On machines which store
2055 individual registers, this doesn't need to do anything. On machines
2056 which store all the registers in one fell swoop, this makes sure
2057 that registers contains all the registers from the program being
2061 gnu_prepare_to_store ()
2063 #ifdef CHILD_PREPARE_TO_STORE
2064 CHILD_PREPARE_TO_STORE ();
2069 gnu_open (arg, from_tty)
2073 error ("Use the \"run\" command to start a Unix child process.");
2079 error ("to_stop target function not implemented");
2083 gnu_thread_alive (int tid)
2085 inf_update_procs (current_inferior);
2086 return !!inf_tid_to_thread (current_inferior, tid);
2090 * Read inferior task's LEN bytes from ADDR and copy it to MYADDR
2091 * in gdb's address space.
2093 * Return 0 on failure; number of bytes read otherwise.
2096 gnu_read_inferior (task, addr, myaddr, length)
2103 vm_address_t low_address = (vm_address_t) trunc_page (addr);
2104 vm_size_t aligned_length =
2105 (vm_size_t) round_page (addr+length) - low_address;
2109 /* Get memory from inferior with page aligned addresses */
2110 err = vm_read (task, low_address, aligned_length, &copied, ©_count);
2114 err = hurd_safe_copyin (myaddr, (void*)addr - low_address + copied, length);
2117 warning ("Read from inferior faulted: %s", strerror (err));
2121 err = vm_deallocate (mach_task_self (), copied, copy_count);
2123 warning ("gnu_read_inferior vm_deallocate failed: %s", strerror (err));
2128 #define CHK_GOTO_OUT(str,ret) \
2129 do if (ret != KERN_SUCCESS) { errstr = #str; goto out; } while(0)
2131 struct vm_region_list {
2132 struct vm_region_list *next;
2133 vm_prot_t protection;
2138 struct obstack region_obstack;
2141 * Write gdb's LEN bytes from MYADDR and copy it to ADDR
2142 * in inferior task's address space.
2145 gnu_write_inferior (task, addr, myaddr, length)
2152 vm_address_t low_address = (vm_address_t) trunc_page (addr);
2153 vm_size_t aligned_length =
2154 (vm_size_t) round_page (addr+length) - low_address;
2159 char *errstr = "Bug in gnu_write_inferior";
2161 struct vm_region_list *region_element;
2162 struct vm_region_list *region_head = (struct vm_region_list *)NULL;
2164 /* Get memory from inferior with page aligned addresses */
2165 err = vm_read (task,
2170 CHK_GOTO_OUT ("gnu_write_inferior vm_read failed", err);
2174 err = hurd_safe_copyout ((void*)addr - low_address + copied, myaddr, length);
2175 CHK_GOTO_OUT ("Write to inferior faulted", err);
2177 obstack_init (®ion_obstack);
2179 /* Do writes atomically.
2180 * First check for holes and unwritable memory.
2183 vm_size_t remaining_length = aligned_length;
2184 vm_address_t region_address = low_address;
2186 struct vm_region_list *scan;
2188 while(region_address < low_address + aligned_length)
2190 vm_prot_t protection;
2191 vm_prot_t max_protection;
2192 vm_inherit_t inheritance;
2194 mach_port_t object_name;
2196 vm_size_t region_length = remaining_length;
2197 vm_address_t old_address = region_address;
2199 err = vm_region (task,
2208 CHK_GOTO_OUT ("vm_region failed", err);
2210 /* Check for holes in memory */
2211 if (old_address != region_address)
2213 warning ("No memory at 0x%x. Nothing written",
2220 if (!(max_protection & VM_PROT_WRITE))
2222 warning ("Memory at address 0x%x is unwritable. Nothing written",
2229 /* Chain the regions for later use */
2231 (struct vm_region_list *)
2232 obstack_alloc (®ion_obstack, sizeof (struct vm_region_list));
2234 region_element->protection = protection;
2235 region_element->start = region_address;
2236 region_element->length = region_length;
2238 /* Chain the regions along with protections */
2239 region_element->next = region_head;
2240 region_head = region_element;
2242 region_address += region_length;
2243 remaining_length = remaining_length - region_length;
2246 /* If things fail after this, we give up.
2247 * Somebody is messing up inferior_task's mappings.
2250 /* Enable writes to the chained vm regions */
2251 for (scan = region_head; scan; scan = scan->next)
2253 boolean_t protection_changed = FALSE;
2255 if (!(scan->protection & VM_PROT_WRITE))
2257 err = vm_protect (task,
2261 scan->protection | VM_PROT_WRITE);
2262 CHK_GOTO_OUT ("vm_protect: enable write failed", err);
2266 err = vm_write (task,
2270 CHK_GOTO_OUT ("vm_write failed", err);
2272 /* Set up the original region protections, if they were changed */
2273 for (scan = region_head; scan; scan = scan->next)
2275 boolean_t protection_changed = FALSE;
2277 if (!(scan->protection & VM_PROT_WRITE))
2279 err = vm_protect (task,
2284 CHK_GOTO_OUT ("vm_protect: enable write failed", err);
2292 obstack_free (®ion_obstack, 0);
2294 (void) vm_deallocate (mach_task_self (),
2299 if (err != KERN_SUCCESS)
2301 warning ("%s: %s", errstr, mach_error_string (err));
2308 /* Return 0 on failure, number of bytes handled otherwise. */
2310 gnu_xfer_memory (memaddr, myaddr, len, write, target)
2315 struct target_ops *target; /* IGNORED */
2320 ? (current_inferior->task ? current_inferior->task->port : 0)
2323 if (task == MACH_PORT_NULL)
2327 inf_debug (current_inferior, "%s %p[%d] %s %p",
2328 write ? "writing" : "reading", memaddr, len,
2329 write ? "<--" : "-->", myaddr);
2331 return gnu_write_inferior (task, memaddr, myaddr, len);
2333 return gnu_read_inferior (task, memaddr, myaddr, len);
2337 extern void gnu_store_registers (int regno);
2338 extern void gnu_fetch_registers (int regno);
2340 struct target_ops gnu_ops = {
2341 "GNU", /* to_shortname */
2342 "GNU Hurd process", /* to_longname */
2343 "GNU Hurd process", /* to_doc */
2344 gnu_open, /* to_open */
2346 gnu_attach, /* to_attach */
2347 gnu_detach, /* to_detach */
2348 gnu_resume, /* to_resume */
2349 gnu_wait, /* to_wait */
2350 gnu_fetch_registers, /* to_fetch_registers */
2351 gnu_store_registers, /* to_store_registers */
2352 gnu_prepare_to_store, /* to_prepare_to_store */
2353 gnu_xfer_memory, /* to_xfer_memory */
2354 0, /* to_files_info */
2355 memory_insert_breakpoint, /* to_insert_breakpoint */
2356 memory_remove_breakpoint, /* to_remove_breakpoint */
2357 gnu_terminal_init_inferior, /* to_terminal_init */
2358 terminal_inferior, /* to_terminal_inferior */
2359 terminal_ours_for_output, /* to_terminal_ours_for_output */
2360 terminal_ours, /* to_terminal_ours */
2361 child_terminal_info, /* to_terminal_info */
2362 gnu_kill_inferior, /* to_kill */
2364 0, /* to_lookup_symbol */
2366 gnu_create_inferior, /* to_create_inferior */
2367 gnu_mourn_inferior, /* to_mourn_inferior */
2368 gnu_can_run, /* to_can_run */
2369 0, /* to_notice_signals */
2370 gnu_thread_alive, /* to_thread_alive */
2371 gnu_stop, /* to_stop */
2372 process_stratum, /* to_stratum */
2374 1, /* to_has_all_memory */
2375 1, /* to_has_memory */
2376 1, /* to_has_stack */
2377 1, /* to_has_registers */
2378 1, /* to_has_execution */
2380 0, /* sections_end */
2381 OPS_MAGIC /* to_magic */
2384 /* Return printable description of proc. */
2385 char *proc_string (struct proc *proc)
2387 static char tid_str[80];
2388 if (proc_is_task (proc))
2389 sprintf (tid_str, "process %d", proc->inf->pid);
2391 sprintf (tid_str, "thread %d.%d",
2394 pid_to_thread_id (proc->tid)
2403 gnu_target_pid_to_str (int tid)
2405 struct inf *inf = current_inferior;
2406 struct proc *thread = inf_tid_to_thread (inf, tid);
2409 return proc_string (thread);
2412 static char tid_str[80];
2413 sprintf (tid_str, "bogus thread id %d", tid);
2418 /* User task commands. */
2420 struct cmd_list_element *set_task_cmd_list = 0;
2421 struct cmd_list_element *show_task_cmd_list = 0;
2422 /* User thread commands. */
2424 /* Commands with a prefix of `set/show thread'. */
2425 extern struct cmd_list_element *thread_cmd_list;
2426 struct cmd_list_element *set_thread_cmd_list = NULL;
2427 struct cmd_list_element *show_thread_cmd_list = NULL;
2429 /* Commands with a prefix of `set/show thread default'. */
2430 struct cmd_list_element *set_thread_default_cmd_list = NULL;
2431 struct cmd_list_element *show_thread_default_cmd_list = NULL;
2434 set_thread_cmd (char *args, int from_tty)
2436 printf_unfiltered ("\"set thread\" must be followed by the name of a thread
2437 property, or \"default\".\n");
2441 show_thread_cmd (char *args, int from_tty)
2443 printf_unfiltered ("\"show thread\" must be followed by the name of a thread property, or \"default\".\n");
2447 set_thread_default_cmd (char *args, int from_tty)
2449 printf_unfiltered ("\"set thread default\" must be followed by the name of a thread property.\n");
2453 show_thread_default_cmd (char *args, int from_tty)
2455 printf_unfiltered ("\"show thread default\" must be followed by the name of a thread property.\n");
2459 parse_int_arg (char *args, char *cmd_prefix)
2464 int val = strtoul (args, &arg_end, 10);
2465 if (*args && *arg_end == '\0')
2468 error ("Illegal argument for \"%s\" command, should be an integer.", cmd_prefix);
2472 _parse_bool_arg (char *args, char *t_val, char *f_val, char *cmd_prefix)
2474 if (!args || strcmp (args, t_val) == 0)
2476 else if (strcmp (args, f_val) == 0)
2479 error ("Illegal argument for \"%s\" command, should be \"%s\" or \"%s\".",
2480 cmd_prefix, t_val, f_val);
2483 #define parse_bool_arg(args, cmd_prefix) \
2484 _parse_bool_arg (args, "on", "off", cmd_prefix)
2487 check_empty (char *args, char *cmd_prefix)
2490 error ("Garbage after \"%s\" command: `%s'", cmd_prefix, args);
2493 /* Returns the alive thread named by INFERIOR_PID, or signals an error. */
2494 static struct proc *
2497 struct inf *inf = cur_inf ();
2498 struct proc *thread = inf_tid_to_thread (inf, inferior_pid);
2500 error ("No current thread.");
2504 /* Returns the current inferior, but signals an error if it has no task. */
2508 struct inf *inf = cur_inf ();
2510 error ("No current process.");
2515 set_task_pause_cmd (char *args, int from_tty)
2517 struct inf *inf = cur_inf ();
2518 int old_sc = inf->pause_sc;
2520 inf->pause_sc = parse_bool_arg (args, "set task pause");
2522 if (old_sc == 0 && inf->pause_sc != 0)
2523 /* If the task is currently unsuspended, immediately suspend it,
2524 otherwise wait until the next time it gets control. */
2529 show_task_pause_cmd (char *args, int from_tty)
2531 struct inf *inf = cur_inf ();
2532 check_empty (args, "show task pause");
2533 printf_unfiltered ("The inferior task %s suspended while gdb has control.\n",
2535 ? (inf->pause_sc == 0 ? "isn't" : "is")
2536 : (inf->pause_sc == 0 ? "won't be" : "will be"));
2540 set_task_detach_sc_cmd (char *args, int from_tty)
2542 cur_inf ()->detach_sc = parse_int_arg (args, "set task detach-suspend-count");
2546 show_task_detach_sc_cmd (char *args, int from_tty)
2548 check_empty (args, "show task detach-suspend-count");
2549 printf_unfiltered ("The inferior task will be left with a suspend count of %d when detaching.\n",
2550 cur_inf ()->detach_sc);
2554 set_thread_default_pause_cmd (char *args, int from_tty)
2556 struct inf *inf = cur_inf ();
2557 inf->default_thread_pause_sc =
2558 parse_bool_arg (args, "set thread default pause") ? 0 : 1;
2562 show_thread_default_pause_cmd (char *args, int from_tty)
2564 struct inf *inf = cur_inf ();
2565 int sc = inf->default_thread_pause_sc;
2566 check_empty (args, "show thread default pause");
2567 printf_unfiltered ("New threads %s suspended while gdb has control%s.\n",
2568 sc ? "are" : "aren't",
2569 !sc && inf->pause_sc ? " (but the task is)" : "");
2573 set_thread_default_run_cmd (char *args, int from_tty)
2575 struct inf *inf = cur_inf ();
2576 inf->default_thread_run_sc =
2577 parse_bool_arg (args, "set thread default run") ? 0 : 1;
2581 show_thread_default_run_cmd (char *args, int from_tty)
2583 struct inf *inf = cur_inf ();
2584 check_empty (args, "show thread default run");
2585 printf_unfiltered ("New threads %s allowed to run.\n",
2586 inf->default_thread_run_sc == 0 ? "are" : "aren't");
2590 set_thread_default_detach_sc_cmd (char *args, int from_tty)
2592 cur_inf ()->default_thread_detach_sc =
2593 parse_int_arg (args, "set thread default detach-suspend-count");
2597 show_thread_default_detach_sc_cmd (char *args, int from_tty)
2599 check_empty (args, "show thread default detach-suspend-count");
2600 printf_unfiltered ("New threads will get a detach-suspend-count of %d.\n",
2601 cur_inf ()->default_thread_detach_sc);
2604 /* Steal a send right called NAME in the inferior task, and make it PROC's
2605 saved exception port. */
2607 steal_exc_port (struct proc *proc, mach_port_t name)
2611 mach_msg_type_name_t port_type;
2613 if (!proc || !proc->inf->task)
2614 error ("No inferior task.");
2616 err = mach_port_extract_right (proc->inf->task->port,
2617 name, MACH_MSG_TYPE_COPY_SEND,
2620 error ("Couldn't extract send right %d from inferior: %s",
2621 name, strerror (err));
2623 if (proc->saved_exc_port)
2624 /* Get rid of our reference to the old one. */
2625 mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
2627 proc->saved_exc_port = port;
2629 if (! proc->exc_port)
2630 /* If PROC is a thread, we may not have set its exception port before.
2631 We can't use proc_steal_exc_port because it also sets saved_exc_port. */
2633 proc->exc_port = proc->inf->event_port;
2634 err = proc_set_exception_port (proc, proc->exc_port);
2635 error ("Can't set exception port for %s: %s",
2636 proc_string (proc), strerror (err));
2641 set_task_exc_port_cmd (char *args, int from_tty)
2643 struct inf *inf = cur_inf ();
2645 error ("No argument to \"set task exception-port\" command.");
2646 steal_exc_port (inf->task, parse_and_eval_address (args));
2650 set_stopped_cmd (char *args, int from_tty)
2652 cur_inf ()->stopped = _parse_bool_arg (args, "yes", "no", "set stopped");
2656 show_stopped_cmd (char *args, int from_tty)
2658 struct inf *inf = active_inf ();
2659 check_empty (args, "show stopped");
2660 printf_unfiltered ("The inferior process %s stopped.\n",
2661 inf->stopped ? "is" : "isn't");
2665 set_sig_thread_cmd (char *args, int from_tty)
2668 struct inf *inf = cur_inf ();
2670 if (!args || (! isdigit (*args) && strcmp (args, "none") != 0))
2671 error ("Illegal argument to \"set signal-thread\" command.\n"
2672 "Should be an integer thread ID, or `none'.");
2674 if (strcmp (args, "none") == 0)
2675 inf->signal_thread = 0;
2678 int tid = thread_id_to_pid (atoi (args));
2680 error ("Thread ID %s not known. Use the \"info threads\" command to\n"
2681 "see the IDs of currently known threads.", args);
2682 inf->signal_thread = inf_tid_to_thread (inf, tid);
2687 show_sig_thread_cmd (char *args, int from_tty)
2689 struct inf *inf = active_inf ();
2690 check_empty (args, "show signal-thread");
2691 if (inf->signal_thread)
2692 printf_unfiltered ("The signal thread is %s.\n",
2693 proc_string (inf->signal_thread));
2695 printf_unfiltered ("There is no signal thread.\n");
2699 set_signals_cmd (char *args, int from_tty)
2702 struct inf *inf = cur_inf ();
2704 inf->want_signals = parse_bool_arg (args, "set signals");
2706 if (inf->task && inf->want_signals != inf->traced)
2707 /* Make this take effect immediately in a running process. */
2708 inf_set_traced (inf, inf->want_signals);
2712 show_signals_cmd (char *args, int from_tty)
2714 struct inf *inf = cur_inf ();
2715 check_empty (args, "show signals");
2716 printf_unfiltered ("The inferior process's signals %s intercepted.\n",
2718 ? (inf->traced ? "are" : "aren't")
2719 : (inf->want_signals ? "will be" : "won't be"));
2723 set_exceptions_cmd (char *args, int from_tty)
2725 struct inf *inf = cur_inf ();
2726 int val = parse_bool_arg (args, "set exceptions");
2728 if (inf->task && inf->want_exceptions != val)
2729 /* Make this take effect immediately in a running process. */
2732 inf->want_exceptions = val;
2736 show_exceptions_cmd (char *args, int from_tty)
2738 struct inf *inf = cur_inf ();
2739 check_empty (args, "show exceptions");
2740 printf_unfiltered ("Exceptions in the inferior %s trapped.\n",
2742 ? (inf->want_exceptions ? "are" : "aren't")
2743 : (inf->want_exceptions ? "will be" : "won't be"));
2747 set_task_cmd (char *args, int from_tty)
2749 printf_unfiltered ("\"set task\" must be followed by the name of a task property.\n");
2753 show_task_cmd (char *args, int from_tty)
2755 struct inf *inf = cur_inf ();
2757 check_empty (args, "show task");
2759 show_signals_cmd (0, from_tty);
2760 show_exceptions_cmd (0, from_tty);
2761 show_task_pause_cmd (0, from_tty);
2763 if (inf->pause_sc == 0)
2764 show_thread_default_pause_cmd (0, from_tty);
2765 show_thread_default_run_cmd (0, from_tty);
2769 show_stopped_cmd (0, from_tty);
2770 show_sig_thread_cmd (0, from_tty);
2773 if (inf->detach_sc != 0)
2774 show_task_detach_sc_cmd (0, from_tty);
2775 if (inf->default_thread_detach_sc != 0)
2776 show_thread_default_detach_sc_cmd (0, from_tty);
2780 set_noninvasive_cmd (char *args, int from_tty)
2782 /* Invert the sense of the arg for each component. */
2783 char *inv_args = parse_bool_arg (args, "set noninvasive") ? "off" : "on";
2785 set_task_pause_cmd (inv_args, from_tty);
2786 set_signals_cmd (inv_args, from_tty);
2787 set_exceptions_cmd (inv_args, from_tty);
2791 info_port_rights (char *args, mach_port_type_t only)
2793 struct inf *inf = active_inf ();
2794 value_ptr vmark = value_mark ();
2797 /* Explicit list of port rights. */
2801 value_ptr val = parse_to_comma_and_eval (&args);
2802 long right = value_as_long (val);
2804 print_port_info (right, 0, inf->task->port, PORTINFO_DETAILS,
2807 error ("%ld: %s.", right, strerror (err));
2811 /* Print all of them. */
2814 print_task_ports_info (inf->task->port, only, PORTINFO_DETAILS,
2817 error ("%s.", strerror (err));
2820 value_free_to_mark (vmark);
2824 info_send_rights_cmd (char *args, int from_tty)
2826 info_port_rights (args, MACH_PORT_TYPE_SEND);
2829 info_recv_rights_cmd (char *args, int from_tty)
2831 info_port_rights (args, MACH_PORT_TYPE_RECEIVE);
2834 info_port_sets_cmd (char *args, int from_tty)
2836 info_port_rights (args, MACH_PORT_TYPE_PORT_SET);
2839 info_dead_names_cmd (char *args, int from_tty)
2841 info_port_rights (args, MACH_PORT_TYPE_DEAD_NAME);
2844 info_port_rights_cmd (char *args, int from_tty)
2846 info_port_rights (args, ~0);
2849 static void add_task_commands ()
2851 add_cmd ("pause", class_run, set_thread_default_pause_cmd,
2852 "Set whether the new threads are suspended while gdb has control.\n"
2853 "This property normally has no effect because the whole task is\n"
2854 "suspended, however, that may be disabled with \"set task pause off\".\n"
2855 "The default value is \"off\".",
2856 &set_thread_default_cmd_list);
2857 add_cmd ("pause", no_class, show_thread_default_pause_cmd,
2858 "Show whether new threads are suspended while gdb has control.",
2859 &show_thread_default_cmd_list);
2860 add_cmd ("run", class_run, set_thread_default_run_cmd,
2861 "Set whether new threads are allowed to run (once gdb has noticed them).",
2862 &set_thread_default_cmd_list);
2863 add_cmd ("run", no_class, show_thread_default_run_cmd,
2864 "Show whether new threads are allowed to run (once gdb has noticed
2866 &show_thread_default_cmd_list);
2867 add_cmd ("detach-suspend-count", class_run, set_thread_default_detach_sc_cmd,
2868 "Set the default detach-suspend-count value for new threads.",
2869 &set_thread_default_cmd_list);
2870 add_cmd ("detach-suspend-count", no_class, show_thread_default_detach_sc_cmd,
2871 "Show the default detach-suspend-count value for new threads.",
2872 &show_thread_default_cmd_list);
2874 add_cmd ("signals", class_run, set_signals_cmd,
2875 "Set whether the inferior process's signals will be intercepted.\n"
2876 "Mach exceptions (such as breakpoint traps) are not affected.",
2878 add_alias_cmd ("sigs", "signals", class_run, 1, &setlist);
2879 add_cmd ("signals", no_class, show_signals_cmd,
2880 "Show whether the inferior process's signals will be intercepted.",
2882 add_alias_cmd ("sigs", "signals", no_class, 1, &showlist);
2884 add_cmd ("signal-thread", class_run, set_sig_thread_cmd,
2885 "Set the thread that gdb thinks is the libc signal thread.\n"
2886 "This thread is run when delivering a signal to a non-stopped process.",
2888 add_alias_cmd ("sigthread", "signal-thread", class_run, 1, &setlist);
2889 add_cmd ("signal-thread", no_class, show_sig_thread_cmd,
2890 "Set the thread that gdb thinks is the libc signal thread.",
2892 add_alias_cmd ("sigthread", "signal-thread", no_class, 1, &showlist);
2894 add_cmd ("stopped", class_run, set_stopped_cmd,
2895 "Set whether gdb thinks the inferior process is stopped as with SIGSTOP.\n"
2896 "Stopped process will be continued by sending them a signal.",
2898 add_cmd ("stopped", no_class, show_signals_cmd,
2899 "Show whether gdb thinks the inferior process is stopped as with SIGSTOP.",
2902 add_cmd ("exceptions", class_run, set_exceptions_cmd,
2903 "Set whether exceptions in the inferior process will be trapped.\n"
2904 "When exceptions are turned off, neither breakpoints nor single-stepping\n"
2907 /* Allow `set exc' despite conflict with `set exception-port'. */
2908 add_alias_cmd ("exc", "exceptions", class_run, 1, &setlist);
2909 add_cmd ("exceptions", no_class, show_exceptions_cmd,
2910 "Show whether exceptions in the inferior process will be trapped.",
2913 add_prefix_cmd ("task", no_class, set_task_cmd,
2914 "Command prefix for setting task attributes.",
2915 &set_task_cmd_list, "set task ", 0, &setlist);
2916 add_prefix_cmd ("task", no_class, show_task_cmd,
2917 "Command prefix for showing task attributes.",
2918 &show_task_cmd_list, "show task ", 0, &showlist);
2920 add_cmd ("pause", class_run, set_task_pause_cmd,
2921 "Set whether the task is suspended while gdb has control.\n"
2922 "A value of \"on\" takes effect immediately, otherwise nothing\n"
2923 "happens until the next time the program is continued.\n"
2924 "When setting this to \"off\", \"set thread default pause on\"\n"
2925 "can be used to pause individual threads by default instead.",
2926 &set_task_cmd_list);
2927 add_cmd ("pause", no_class, show_task_pause_cmd,
2928 "Show whether the task is suspended while gdb has control.",
2929 &show_task_cmd_list);
2930 add_cmd ("detach-suspend-count", class_run, set_task_detach_sc_cmd,
2931 "Set the suspend count will leave on the thread when detaching.",
2932 &set_task_cmd_list);
2933 add_cmd ("detach-suspend-count", no_class, show_task_detach_sc_cmd,
2934 "Show the suspend count will leave on the thread when detaching.",
2935 &show_task_cmd_list);
2937 add_cmd ("exception-port", no_class, set_task_exc_port_cmd,
2938 "Set the task exception port to which we forward exceptions.\n"
2939 "The argument should be the value of the send right in the task.",
2940 &set_task_cmd_list);
2941 add_alias_cmd ("excp", "exception-port", no_class, 1, &set_task_cmd_list);
2942 add_alias_cmd ("exc-port", "exception-port", no_class, 1, &set_task_cmd_list);
2944 /* A convenient way of turning on all options require to noninvasively
2945 debug running tasks. */
2946 add_cmd ("noninvasive", no_class, set_noninvasive_cmd,
2947 "Set task options so that we interfere as little as possible.\n"
2948 "This is the same as setting `task pause', `exceptions', and"
2949 "`signals' to the opposite value.",
2952 /* Commands to show information about the task's ports. */
2953 add_cmd ("send-rights", class_info, info_send_rights_cmd,
2954 "Show information about the task's send rights",
2956 add_cmd ("receive-rights", class_info, info_recv_rights_cmd,
2957 "Show information about the task's receive rights",
2959 add_cmd ("port-rights", class_info, info_send_rights_cmd,
2960 "Show information about the task's port rights",
2962 add_cmd ("port-sets", class_info, info_port_sets_cmd,
2963 "Show information about the task's port sets",
2965 add_cmd ("dead-names", class_info, info_dead_names_cmd,
2966 "Show information about the task's dead names",
2968 add_info_alias ("ports", "port-rights", 1);
2969 add_info_alias ("port", "port-rights", 1);
2970 add_info_alias ("psets", "port-sets", 1);
2975 set_thread_pause_cmd (char *args, int from_tty)
2977 struct proc *thread = cur_thread ();
2978 int old_sc = thread->pause_sc;
2979 thread->pause_sc = parse_bool_arg (args, "set thread pause");
2980 if (old_sc == 0 && thread->pause_sc != 0 && thread->inf->pause_sc == 0)
2981 /* If the task is currently unsuspended, immediately suspend it,
2982 otherwise wait until the next time it gets control. */
2983 inf_suspend (thread->inf);
2987 show_thread_pause_cmd (char *args, int from_tty)
2989 struct proc *thread = cur_thread ();
2990 int sc = thread->pause_sc;
2991 check_empty (args, "show task pause");
2992 printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n",
2993 proc_string (thread),
2994 sc ? "is" : "isn't",
2995 !sc && thread->inf->pause_sc ? " (but the task is)" : "");
2999 set_thread_run_cmd (char *args, int from_tty)
3001 struct proc *thread = cur_thread ();
3002 thread->run_sc = parse_bool_arg (args, "set thread run") ? 0 : 1;
3006 show_thread_run_cmd (char *args, int from_tty)
3008 struct proc *thread = cur_thread ();
3009 check_empty (args, "show thread run");
3010 printf_unfiltered ("Thread %s %s allowed to run.",
3011 proc_string (thread),
3012 thread->run_sc == 0 ? "is" : "isn't");
3016 set_thread_detach_sc_cmd (char *args, int from_tty)
3018 cur_thread ()->detach_sc = parse_int_arg (args, "set thread detach-suspend-count");
3022 show_thread_detach_sc_cmd (char *args, int from_tty)
3024 struct proc *thread = cur_thread ();
3025 check_empty (args, "show thread detach-suspend-count");
3026 printf_unfiltered ("Thread %s will be left with a suspend count of %d when detaching.\n",
3027 proc_string (thread),
3032 set_thread_exc_port_cmd (char *args, int from_tty)
3034 struct proc *thread = cur_thread ();
3036 error ("No argument to \"set thread exception-port\" command.");
3037 steal_exc_port (thread, parse_and_eval_address (args));
3042 show_thread_cmd (char *args, int from_tty)
3044 struct proc *thread = cur_thread ();
3045 check_empty (args, "show thread");
3046 show_thread_run_cmd (0, from_tty);
3047 show_thread_pause_cmd (0, from_tty);
3048 if (thread->detach_sc != 0)
3049 show_thread_detach_sc_cmd (0, from_tty);
3054 thread_takeover_sc_cmd (char *args, int from_tty)
3056 struct proc *thread = cur_thread ();
3057 thread_basic_info_data_t _info;
3058 thread_basic_info_t info = &_info;
3059 mach_msg_type_number_t info_len = THREAD_BASIC_INFO_COUNT;
3061 thread_info (thread->port, THREAD_BASIC_INFO, (int *)&info, &info_len);
3063 error ("%s.", strerror (err));
3064 thread->sc = info->suspend_count;
3066 printf_unfiltered ("Suspend count was %d.\n", thread->sc);
3068 vm_deallocate (mach_task_self (), (vm_address_t)info, info_len * sizeof (int));
3071 add_thread_commands ()
3073 add_prefix_cmd ("thread", no_class, set_thread_cmd,
3074 "Command prefix for setting thread properties.",
3075 &set_thread_cmd_list, "set thread ", 0, &setlist);
3076 add_prefix_cmd ("default", no_class, show_thread_cmd,
3077 "Command prefix for setting default thread properties.",
3078 &set_thread_default_cmd_list, "set thread default ", 0,
3079 &set_thread_cmd_list);
3080 add_prefix_cmd ("thread", no_class, set_thread_default_cmd,
3081 "Command prefix for showing thread properties.",
3082 &show_thread_cmd_list, "show thread ", 0, &showlist);
3083 add_prefix_cmd ("default", no_class, show_thread_default_cmd,
3084 "Command prefix for showing default thread properties.",
3085 &show_thread_default_cmd_list, "show thread default ", 0,
3086 &show_thread_cmd_list);
3088 add_cmd ("pause", class_run, set_thread_pause_cmd,
3089 "Set whether the current thread is suspended while gdb has control.\n"
3090 "A value of \"on\" takes effect immediately, otherwise nothing\n"
3091 "happens until the next time the program is continued. This\n"
3092 "property normally has no effect because the whole task is suspended,\n"
3093 "however, that may be disabled with \"set task pause off\".\n"
3094 "The default value is \"off\".",
3095 &set_thread_cmd_list);
3096 add_cmd ("pause", no_class, show_thread_pause_cmd,
3097 "Show whether the current thread is suspended while gdb has control.",
3098 &show_thread_cmd_list);
3100 add_cmd ("run", class_run, set_thread_run_cmd,
3101 "Set whether the current thread is allowed to run.",
3102 &set_thread_cmd_list);
3103 add_cmd ("run", no_class, show_thread_run_cmd,
3104 "Show whether the current thread is allowed to run.",
3105 &show_thread_cmd_list);
3107 add_cmd ("detach-suspend-count", class_run, set_thread_detach_sc_cmd,
3108 "Set the suspend count will leave on the thread when detaching.\n"
3109 "Note that this is relative to suspend count when gdb noticed the thread;\n"
3110 "use the `thread takeover-suspend-count' to force it to an absolute value.",
3111 &set_thread_cmd_list);
3112 add_cmd ("detach-suspend-count", no_class, show_thread_detach_sc_cmd,
3113 "Show the suspend count will leave on the thread when detaching."
3114 "Note that this is relative to suspend count when gdb noticed the thread;\n"
3115 "use the `thread takeover-suspend-count' to force it to an absolute value.",
3116 &show_thread_cmd_list);
3118 add_cmd ("exception-port", no_class, set_thread_exc_port_cmd,
3119 "Set the exception port to which we forward exceptions for the\n"
3120 "current thread, overriding the task exception port.\n"
3121 "The argument should be the value of the send right in the task.",
3122 &set_thread_cmd_list);
3123 add_alias_cmd ("excp", "exception-port", no_class, 1, &set_thread_cmd_list);
3124 add_alias_cmd ("exc-port", "exception-port", no_class, 1, &set_thread_cmd_list);
3126 add_cmd ("takeover-suspend-count", no_class, thread_takeover_sc_cmd,
3127 "Force the threads absolute suspend-count to be gdb's.\n"
3128 "Prior to giving this command, gdb's thread suspend-counts are relative to\n"
3129 "the thread's initial suspend-count when gdb notices the threads.",
3134 _initialize_gnu_nat ()
3136 proc_server = getproc ();
3138 add_target (&gnu_ops);
3140 add_task_commands ();
3141 add_thread_commands ();
3143 #if MAINTENANCE_CMDS
3144 add_set_cmd ("gnu-debug", class_maintenance,
3145 var_boolean, (char *)&gnu_debug_flag,
3146 "Set debugging output for the gnu backend.", &maintenancelist);
3150 #ifdef FLUSH_INFERIOR_CACHE
3152 /* When over-writing code on some machines the I-Cache must be flushed
3153 explicitly, because it is not kept coherent by the lazy hardware.
3154 This definitely includes breakpoints, for instance, or else we
3155 end up looping in mysterious Bpt traps */
3158 flush_inferior_icache(pc, amount)
3161 vm_machine_attribute_val_t flush = MATTR_VAL_ICACHE_FLUSH;
3164 ret = vm_machine_attribute (current_inferior->task->port,
3169 if (ret != KERN_SUCCESS)
3170 warning ("Error flushing inferior's cache : %s", strerror (ret));
3172 #endif FLUSH_INFERIOR_CACHE