Kill pthread_ops_hack
[external/binutils.git] / gdb / gnu-nat.c
1 /* Interface GDB to the GNU Hurd.
2    Copyright (C) 1992, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2006, 2007,
3    2008 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    Written by Miles Bader <miles@gnu.ai.mit.edu>
8
9    Some code and ideas from m3-nat.c by Jukka Virtanen <jtv@hut.fi>
10
11    This program is free software; you can redistribute it and/or modify
12    it under the terms of the GNU General Public License as published by
13    the Free Software Foundation; either version 3 of the License, or
14    (at your option) any later version.
15
16    This program is distributed in the hope that it will be useful,
17    but WITHOUT ANY WARRANTY; without even the implied warranty of
18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19    GNU General Public License for more details.
20
21    You should have received a copy of the GNU General Public License
22    along with this program.  If not, see <http://www.gnu.org/licenses/>.
23  */
24
25 #include <ctype.h>
26 #include <errno.h>
27 #include <limits.h>
28 #include <setjmp.h>
29 #include <signal.h>
30 #include <stdio.h>
31 #include "gdb_string.h"
32 #include <sys/ptrace.h>
33
34 #include <mach.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>
40
41 #include <hurd.h>
42 #include <hurd/interrupt.h>
43 #include <hurd/msg.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.  */
48 #undef _process_user_
49 #include <hurd/process_request.h>
50 #include <hurd/signal.h>
51 #include <hurd/sigpreempt.h>
52
53 #include <portinfo.h>
54
55 #include "defs.h"
56 #include "inferior.h"
57 #include "symtab.h"
58 #include "value.h"
59 #include "language.h"
60 #include "target.h"
61 #include "gdb_wait.h"
62 #include "gdbcmd.h"
63 #include "gdbcore.h"
64 #include "gdbthread.h"
65 #include "gdb_assert.h"
66 #include "gdb_obstack.h"
67
68 #include "gnu-nat.h"
69
70 #include "exc_request_S.h"
71 #include "notify_S.h"
72 #include "process_reply_S.h"
73 #include "msg_reply_S.h"
74 #include "exc_request_U.h"
75 #include "msg_U.h"
76
77 static process_t proc_server = MACH_PORT_NULL;
78
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;
82
83 /* The number of wait requests we've sent, and expect replies from.  */
84 int proc_waits_pending = 0;
85
86 int gnu_debug_flag = 0;
87
88 /* Forward decls */
89
90 extern struct target_ops gnu_ops;
91
92 struct inf *make_inf ();
93 void inf_clear_wait (struct inf *inf);
94 void inf_cleanup (struct inf *inf);
95 void inf_startup (struct inf *inf, int pid);
96 int inf_update_suspends (struct inf *inf);
97 void inf_set_pid (struct inf *inf, pid_t pid);
98 void inf_validate_procs (struct inf *inf);
99 void inf_steal_exc_ports (struct inf *inf);
100 void inf_restore_exc_ports (struct inf *inf);
101 struct proc *inf_tid_to_proc (struct inf *inf, int tid);
102 void inf_set_threads_resume_sc (struct inf *inf,
103                                 struct proc *run_thread,
104                                 int run_others);
105 int inf_set_threads_resume_sc_for_signal_thread (struct inf *inf);
106 void inf_suspend (struct inf *inf);
107 void inf_resume (struct inf *inf);
108 void inf_set_step_thread (struct inf *inf, struct proc *proc);
109 void inf_detach (struct inf *inf);
110 void inf_attach (struct inf *inf, int pid);
111 void inf_signal (struct inf *inf, enum target_signal sig);
112 void inf_continue (struct inf *inf);
113
114 #define inf_debug(_inf, msg, args...) \
115   do { struct inf *__inf = (_inf); \
116        debug ("{inf %d %p}: " msg, __inf->pid, __inf , ##args); } while (0)
117
118 void proc_abort (struct proc *proc, int force);
119 struct proc *make_proc (struct inf *inf, mach_port_t port, int tid);
120 struct proc *_proc_free (struct proc *proc);
121 int proc_update_sc (struct proc *proc);
122 error_t proc_get_exception_port (struct proc *proc, mach_port_t * port);
123 error_t proc_set_exception_port (struct proc *proc, mach_port_t port);
124 static mach_port_t _proc_get_exc_port (struct proc *proc);
125 void proc_steal_exc_port (struct proc *proc, mach_port_t exc_port);
126 void proc_restore_exc_port (struct proc *proc);
127 int proc_trace (struct proc *proc, int set);
128
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)
136
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) \
142    ? ({ error_t __e; \
143         inf_resume (inf); \
144         __e = INF_MSGPORT_RPC (inf, rpc_expr); \
145         inf_suspend (inf); \
146         __e; }) \
147    : EIEIO)
148
149 \f
150 /* The state passed by an exception message.  */
151 struct exc_state
152   {
153     int exception;              /* The exception code */
154     int code, subcode;
155     mach_port_t handler;        /* The real exception port to handle this. */
156     mach_port_t reply;          /* The reply port from the exception call. */
157   };
158
159 /* The results of the last wait an inf did. */
160 struct inf_wait
161   {
162     struct target_waitstatus status;    /* The status returned to gdb.  */
163     struct exc_state exc;       /* The exception that caused us to return. */
164     struct proc *thread;        /* The thread in question.  */
165     int suppress;               /* Something trivial happened.  */
166   };
167
168 /* The state of an inferior.  */
169 struct inf
170   {
171     /* Fields describing the current inferior.  */
172
173     struct proc *task;          /* The mach task.   */
174     struct proc *threads;       /* A linked list of all threads in TASK.  */
175
176     /* True if THREADS needn't be validated by querying the task.  We assume that
177        we and the task in question are the only ones frobbing the thread list,
178        so as long as we don't let any code run, we don't have to worry about
179        THREADS changing.  */
180     int threads_up_to_date;
181
182     pid_t pid;                  /* The real system PID. */
183
184     struct inf_wait wait;       /* What to return from target_wait.  */
185
186     /* One thread proc in INF may be in `single-stepping mode'.  This is it.  */
187     struct proc *step_thread;
188
189     /* The thread we think is the signal thread.  */
190     struct proc *signal_thread;
191
192     mach_port_t event_port;     /* Where we receive various msgs.  */
193
194     /* True if we think at least one thread in the inferior could currently be
195        running.  */
196     unsigned int running:1;
197
198     /* True if the process has stopped (in the proc server sense).  Note that
199        since a proc server `stop' leaves the signal thread running, the inf can
200        be RUNNING && STOPPED...  */
201     unsigned int stopped:1;
202
203     /* True if the inferior has no message port.  */
204     unsigned int nomsg:1;
205
206     /* True if the inferior is traced.  */
207     unsigned int traced:1;
208
209     /* True if we shouldn't try waiting for the inferior, usually because we
210        can't for some reason.  */
211     unsigned int no_wait:1;
212
213     /* When starting a new inferior, we don't try to validate threads until all
214        the proper execs have been done.  This is a count of how many execs we
215        expect to happen.  */
216     unsigned pending_execs;
217
218     /* Fields describing global state */
219
220     /* The task suspend count used when gdb has control.  This is normally 1 to
221        make things easier for us, but sometimes (like when attaching to vital
222        system servers) it may be desirable to let the task continue to run
223        (pausing individual threads as necessary).  */
224     int pause_sc;
225
226     /* The task suspend count left when detaching from a task.  */
227     int detach_sc;
228
229     /* The initial values used for the run_sc and pause_sc of newly discovered
230        threads -- see the definition of those fields in struct proc.  */
231     int default_thread_run_sc;
232     int default_thread_pause_sc;
233     int default_thread_detach_sc;
234
235     /* True if the process should be traced when started/attached.  Newly
236        started processes *must* be traced at first to exec them properly, but
237        if this is false, tracing is turned off as soon it has done so.  */
238     int want_signals;
239
240     /* True if exceptions from the inferior process should be trapped.  This
241        must be on to use breakpoints.  */
242     int want_exceptions;
243   };
244
245
246 int
247 __proc_pid (struct proc *proc)
248 {
249   return proc->inf->pid;
250 }
251
252 \f
253 /* Update PROC's real suspend count to match it's desired one.  Returns true
254    if we think PROC is now in a runnable state.  */
255 int
256 proc_update_sc (struct proc *proc)
257 {
258   int running;
259   int err = 0;
260   int delta = proc->sc - proc->cur_sc;
261
262   if (delta)
263     proc_debug (proc, "sc: %d --> %d", proc->cur_sc, proc->sc);
264
265   if (proc->sc == 0 && proc->state_changed)
266     /* Since PROC may start running, we must write back any state changes. */
267     {
268       gdb_assert (proc_is_thread (proc));
269       proc_debug (proc, "storing back changed thread state");
270       err = thread_set_state (proc->port, THREAD_STATE_FLAVOR,
271                          (thread_state_t) &proc->state, THREAD_STATE_SIZE);
272       if (!err)
273         proc->state_changed = 0;
274     }
275
276   if (delta > 0)
277     {
278       while (delta-- > 0 && !err)
279         {
280           if (proc_is_task (proc))
281             err = task_suspend (proc->port);
282           else
283             err = thread_suspend (proc->port);
284         }
285     }
286   else
287     {
288       while (delta++ < 0 && !err)
289         {
290           if (proc_is_task (proc))
291             err = task_resume (proc->port);
292           else
293             err = thread_resume (proc->port);
294         }
295     }
296   if (!err)
297     proc->cur_sc = proc->sc;
298
299   /* If we got an error, then the task/thread has disappeared.  */
300   running = !err && proc->sc == 0;
301
302   proc_debug (proc, "is %s", err ? "dead" : running ? "running" : "suspended");
303   if (err)
304     proc_debug (proc, "err = %s", safe_strerror (err));
305
306   if (running)
307     {
308       proc->aborted = 0;
309       proc->state_valid = proc->state_changed = 0;
310       proc->fetched_regs = 0;
311     }
312
313   return running;
314 }
315
316 \f
317 /* Thread_abort is called on PROC if needed.  PROC must be a thread proc.
318    If PROC is deemed `precious', then nothing is done unless FORCE is true.
319    In particular, a thread is precious if it's running (in which case forcing
320    it includes suspending it first), or if it has an exception pending.  */
321 void
322 proc_abort (struct proc *proc, int force)
323 {
324   gdb_assert (proc_is_thread (proc));
325
326   if (!proc->aborted)
327     {
328       struct inf *inf = proc->inf;
329       int running = (proc->cur_sc == 0 && inf->task->cur_sc == 0);
330
331       if (running && force)
332         {
333           proc->sc = 1;
334           inf_update_suspends (proc->inf);
335           running = 0;
336           warning (_("Stopped %s."), proc_string (proc));
337         }
338       else if (proc == inf->wait.thread && inf->wait.exc.reply && !force)
339         /* An exception is pending on PROC, which don't mess with.  */
340         running = 1;
341
342       if (!running)
343         /* We only abort the thread if it's not actually running.  */
344         {
345           thread_abort (proc->port);
346           proc_debug (proc, "aborted");
347           proc->aborted = 1;
348         }
349       else
350         proc_debug (proc, "not aborting");
351     }
352 }
353
354 /* Make sure that the state field in PROC is up to date, and return a pointer
355    to it, or 0 if something is wrong.  If WILL_MODIFY is true, makes sure
356    that the thread is stopped and aborted first, and sets the state_changed
357    field in PROC to true.  */
358 thread_state_t
359 proc_get_state (struct proc *proc, int will_modify)
360 {
361   int was_aborted = proc->aborted;
362
363   proc_debug (proc, "updating state info%s",
364               will_modify ? " (with intention to modify)" : "");
365
366   proc_abort (proc, will_modify);
367
368   if (!was_aborted && proc->aborted)
369     /* PROC's state may have changed since we last fetched it.  */
370     proc->state_valid = 0;
371
372   if (!proc->state_valid)
373     {
374       mach_msg_type_number_t state_size = THREAD_STATE_SIZE;
375       error_t err =
376       thread_get_state (proc->port, THREAD_STATE_FLAVOR,
377                         (thread_state_t) &proc->state, &state_size);
378       proc_debug (proc, "getting thread state");
379       proc->state_valid = !err;
380     }
381
382   if (proc->state_valid)
383     {
384       if (will_modify)
385         proc->state_changed = 1;
386       return (thread_state_t) &proc->state;
387     }
388   else
389     return 0;
390 }
391
392 \f
393 /* Set PORT to PROC's exception port.  */
394 error_t
395 proc_get_exception_port (struct proc * proc, mach_port_t * port)
396 {
397   if (proc_is_task (proc))
398     return task_get_exception_port (proc->port, port);
399   else
400     return thread_get_exception_port (proc->port, port);
401 }
402
403 /* Set PROC's exception port to PORT.  */
404 error_t
405 proc_set_exception_port (struct proc * proc, mach_port_t port)
406 {
407   proc_debug (proc, "setting exception port: %d", port);
408   if (proc_is_task (proc))
409     return task_set_exception_port (proc->port, port);
410   else
411     return thread_set_exception_port (proc->port, port);
412 }
413
414 /* Get PROC's exception port, cleaning up a bit if proc has died.  */
415 static mach_port_t
416 _proc_get_exc_port (struct proc *proc)
417 {
418   mach_port_t exc_port;
419   error_t err = proc_get_exception_port (proc, &exc_port);
420
421   if (err)
422     /* PROC must be dead.  */
423     {
424       if (proc->exc_port)
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;
430     }
431
432   return exc_port;
433 }
434
435 /* Replace PROC's exception port with EXC_PORT, unless it's already been
436    done.  Stash away any existing exception port so we can restore it later. */
437 void
438 proc_steal_exc_port (struct proc *proc, mach_port_t exc_port)
439 {
440   mach_port_t cur_exc_port = _proc_get_exc_port (proc);
441
442   if (cur_exc_port)
443     {
444       error_t err = 0;
445
446       proc_debug (proc, "inserting exception port: %d", exc_port);
447
448       if (cur_exc_port != exc_port)
449         /* Put in our exception port.  */
450         err = proc_set_exception_port (proc, exc_port);
451
452       if (err || cur_exc_port == proc->exc_port)
453         /* We previously set the exception port, and it's still set.  So we
454            just keep the old saved port which is what the proc set.  */
455         {
456           if (cur_exc_port)
457             mach_port_deallocate (mach_task_self (), cur_exc_port);
458         }
459       else
460         /* Keep a copy of PROC's old exception port so it can be restored. */
461         {
462           if (proc->saved_exc_port)
463             mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
464           proc->saved_exc_port = cur_exc_port;
465         }
466
467       proc_debug (proc, "saved exception port: %d", proc->saved_exc_port);
468
469       if (!err)
470         proc->exc_port = exc_port;
471       else
472         warning (_("Error setting exception port for %s: %s"),
473                  proc_string (proc), safe_strerror (err));
474     }
475 }
476
477 /* If we previously replaced PROC's exception port, put back what we
478    found there at the time, unless *our* exception port has since been
479    overwritten, in which case who knows what's going on.  */
480 void
481 proc_restore_exc_port (struct proc *proc)
482 {
483   mach_port_t cur_exc_port = _proc_get_exc_port (proc);
484
485   if (cur_exc_port)
486     {
487       error_t err = 0;
488
489       proc_debug (proc, "restoring real exception port");
490
491       if (proc->exc_port == cur_exc_port)
492         /* Our's is still there.  */
493         err = proc_set_exception_port (proc, proc->saved_exc_port);
494
495       if (proc->saved_exc_port)
496         mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
497       proc->saved_exc_port = MACH_PORT_NULL;
498
499       if (!err)
500         proc->exc_port = MACH_PORT_NULL;
501       else
502         warning (_("Error setting exception port for %s: %s"),
503                  proc_string (proc), safe_strerror (err));
504     }
505 }
506
507 \f
508 /* Turns hardware tracing in PROC on or off when SET is true or false,
509    respectively.  Returns true on success.  */
510 int
511 proc_trace (struct proc *proc, int set)
512 {
513   thread_state_t state = proc_get_state (proc, 1);
514
515   if (!state)
516     return 0;                   /* the thread must be dead.  */
517
518   proc_debug (proc, "tracing %s", set ? "on" : "off");
519
520   if (set)
521     {
522       /* XXX We don't get the exception unless the thread has its own
523          exception port???? */
524       if (proc->exc_port == MACH_PORT_NULL)
525         proc_steal_exc_port (proc, proc->inf->event_port);
526       THREAD_STATE_SET_TRACED (state);
527     }
528   else
529     THREAD_STATE_CLEAR_TRACED (state);
530
531   return 1;
532 }
533
534 \f
535 /* A variable from which to assign new TIDs.  */
536 static int next_thread_id = 1;
537
538 /* Returns a new proc structure with the given fields.  Also adds a
539    notification for PORT becoming dead to be sent to INF's notify port.  */
540 struct proc *
541 make_proc (struct inf *inf, mach_port_t port, int tid)
542 {
543   error_t err;
544   mach_port_t prev_port = MACH_PORT_NULL;
545   struct proc *proc = xmalloc (sizeof (struct proc));
546
547   proc->port = port;
548   proc->tid = tid;
549   proc->inf = inf;
550   proc->next = 0;
551   proc->saved_exc_port = MACH_PORT_NULL;
552   proc->exc_port = MACH_PORT_NULL;
553
554   proc->sc = 0;
555   proc->cur_sc = 0;
556
557   /* Note that these are all the values for threads; the task simply uses the
558      corresponding field in INF directly.  */
559   proc->run_sc = inf->default_thread_run_sc;
560   proc->pause_sc = inf->default_thread_pause_sc;
561   proc->detach_sc = inf->default_thread_detach_sc;
562   proc->resume_sc = proc->run_sc;
563
564   proc->aborted = 0;
565   proc->dead = 0;
566   proc->state_valid = 0;
567   proc->state_changed = 0;
568
569   proc_debug (proc, "is new");
570
571   /* Get notified when things die.  */
572   err =
573     mach_port_request_notification (mach_task_self (), port,
574                                     MACH_NOTIFY_DEAD_NAME, 1,
575                                     inf->event_port,
576                                     MACH_MSG_TYPE_MAKE_SEND_ONCE,
577                                     &prev_port);
578   if (err)
579     warning (_("Couldn't request notification for port %d: %s"),
580              port, safe_strerror (err));
581   else
582     {
583       proc_debug (proc, "notifications to: %d", inf->event_port);
584       if (prev_port != MACH_PORT_NULL)
585         mach_port_deallocate (mach_task_self (), prev_port);
586     }
587
588   if (inf->want_exceptions)
589     {
590       if (proc_is_task (proc))
591         /* Make the task exception port point to us.  */
592         proc_steal_exc_port (proc, inf->event_port);
593       else
594         /* Just clear thread exception ports -- they default to the
595            task one.  */
596         proc_steal_exc_port (proc, MACH_PORT_NULL);
597     }
598
599   return proc;
600 }
601
602 /* Frees PROC and any resources it uses, and returns the value of PROC's 
603    next field.  */
604 struct proc *
605 _proc_free (struct proc *proc)
606 {
607   struct inf *inf = proc->inf;
608   struct proc *next = proc->next;
609
610   proc_debug (proc, "freeing...");
611
612   if (proc == inf->step_thread)
613     /* Turn off single stepping.  */
614     inf_set_step_thread (inf, 0);
615   if (proc == inf->wait.thread)
616     inf_clear_wait (inf);
617   if (proc == inf->signal_thread)
618     inf->signal_thread = 0;
619
620   if (proc->port != MACH_PORT_NULL)
621     {
622       if (proc->exc_port != MACH_PORT_NULL)
623         /* Restore the original exception port.  */
624         proc_restore_exc_port (proc);
625       if (proc->cur_sc != 0)
626         /* Resume the thread/task.  */
627         {
628           proc->sc = 0;
629           proc_update_sc (proc);
630         }
631       mach_port_deallocate (mach_task_self (), proc->port);
632     }
633
634   xfree (proc);
635   return next;
636 }
637
638 \f
639 struct inf *
640 make_inf (void)
641 {
642   struct inf *inf = xmalloc (sizeof (struct inf));
643
644   inf->task = 0;
645   inf->threads = 0;
646   inf->threads_up_to_date = 0;
647   inf->pid = 0;
648   inf->wait.status.kind = TARGET_WAITKIND_SPURIOUS;
649   inf->wait.thread = 0;
650   inf->wait.exc.handler = MACH_PORT_NULL;
651   inf->wait.exc.reply = MACH_PORT_NULL;
652   inf->step_thread = 0;
653   inf->signal_thread = 0;
654   inf->event_port = MACH_PORT_NULL;
655   inf->running = 0;
656   inf->stopped = 0;
657   inf->nomsg = 1;
658   inf->traced = 0;
659   inf->no_wait = 0;
660   inf->pending_execs = 0;
661   inf->pause_sc = 1;
662   inf->detach_sc = 0;
663   inf->default_thread_run_sc = 0;
664   inf->default_thread_pause_sc = 0;
665   inf->default_thread_detach_sc = 0;
666   inf->want_signals = 1;        /* By default */
667   inf->want_exceptions = 1;     /* By default */
668
669   return inf;
670 }
671
672 /* Clear INF's target wait status.  */
673 void
674 inf_clear_wait (struct inf *inf)
675 {
676   inf_debug (inf, "clearing wait");
677   inf->wait.status.kind = TARGET_WAITKIND_SPURIOUS;
678   inf->wait.thread = 0;
679   inf->wait.suppress = 0;
680   if (inf->wait.exc.handler != MACH_PORT_NULL)
681     {
682       mach_port_deallocate (mach_task_self (), inf->wait.exc.handler);
683       inf->wait.exc.handler = MACH_PORT_NULL;
684     }
685   if (inf->wait.exc.reply != MACH_PORT_NULL)
686     {
687       mach_port_deallocate (mach_task_self (), inf->wait.exc.reply);
688       inf->wait.exc.reply = MACH_PORT_NULL;
689     }
690 }
691
692 \f
693 void
694 inf_cleanup (struct inf *inf)
695 {
696   inf_debug (inf, "cleanup");
697
698   inf_clear_wait (inf);
699
700   inf_set_pid (inf, -1);
701   inf->pid = 0;
702   inf->running = 0;
703   inf->stopped = 0;
704   inf->nomsg = 1;
705   inf->traced = 0;
706   inf->no_wait = 0;
707   inf->pending_execs = 0;
708
709   if (inf->event_port)
710     {
711       mach_port_destroy (mach_task_self (), inf->event_port);
712       inf->event_port = MACH_PORT_NULL;
713     }
714 }
715
716 void
717 inf_startup (struct inf *inf, int pid)
718 {
719   error_t err;
720
721   inf_debug (inf, "startup: pid = %d", pid);
722
723   inf_cleanup (inf);
724
725   /* Make the port on which we receive all events.  */
726   err = mach_port_allocate (mach_task_self (),
727                             MACH_PORT_RIGHT_RECEIVE, &inf->event_port);
728   if (err)
729     error (_("Error allocating event port: %s"), safe_strerror (err));
730
731   /* Make a send right for it, so we can easily copy it for other people.  */
732   mach_port_insert_right (mach_task_self (), inf->event_port,
733                           inf->event_port, MACH_MSG_TYPE_MAKE_SEND);
734   inf_set_pid (inf, pid);
735 }
736
737 \f
738 /* Close current process, if any, and attach INF to process PORT.  */
739 void
740 inf_set_pid (struct inf *inf, pid_t pid)
741 {
742   task_t task_port;
743   struct proc *task = inf->task;
744
745   inf_debug (inf, "setting pid: %d", pid);
746
747   if (pid < 0)
748     task_port = MACH_PORT_NULL;
749   else
750     {
751       error_t err = proc_pid2task (proc_server, pid, &task_port);
752       if (err)
753         error (_("Error getting task for pid %d: %s"), pid, safe_strerror (err));
754     }
755
756   inf_debug (inf, "setting task: %d", task_port);
757
758   if (inf->pause_sc)
759     task_suspend (task_port);
760
761   if (task && task->port != task_port)
762     {
763       inf->task = 0;
764       inf_validate_procs (inf); /* Trash all the threads. */
765       _proc_free (task);        /* And the task. */
766     }
767
768   if (task_port != MACH_PORT_NULL)
769     {
770       inf->task = make_proc (inf, task_port, PROC_TID_TASK);
771       inf->threads_up_to_date = 0;
772     }
773
774   if (inf->task)
775     {
776       inf->pid = pid;
777       if (inf->pause_sc)
778         /* Reflect task_suspend above.  */
779         inf->task->sc = inf->task->cur_sc = 1;
780     }
781   else
782     inf->pid = -1;
783 }
784
785 \f
786 /* Validates INF's stopped, nomsg and traced field from the actual
787    proc server state.  Note that the traced field is only updated from
788    the proc server state if we do not have a message port.  If we do
789    have a message port we'd better look at the tracemask itself.  */
790 static void
791 inf_validate_procinfo (struct inf *inf)
792 {
793   char *noise;
794   mach_msg_type_number_t noise_len = 0;
795   struct procinfo *pi;
796   mach_msg_type_number_t pi_len = 0;
797   int info_flags = 0;
798   error_t err =
799   proc_getprocinfo (proc_server, inf->pid, &info_flags,
800                     (procinfo_t *) &pi, &pi_len, &noise, &noise_len);
801
802   if (!err)
803     {
804       inf->stopped = !!(pi->state & PI_STOPPED);
805       inf->nomsg = !!(pi->state & PI_NOMSG);
806       if (inf->nomsg)
807         inf->traced = !!(pi->state & PI_TRACED);
808       vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len);
809       if (noise_len > 0)
810         vm_deallocate (mach_task_self (), (vm_address_t) noise, noise_len);
811     }
812 }
813
814 /* Validates INF's task suspend count.  If it's higher than we expect,
815    verify with the user before `stealing' the extra count.  */
816 static void
817 inf_validate_task_sc (struct inf *inf)
818 {
819   char *noise;
820   mach_msg_type_number_t noise_len = 0;
821   struct procinfo *pi;
822   mach_msg_type_number_t pi_len = 0;
823   int info_flags = PI_FETCH_TASKINFO;
824   int suspend_count = -1;
825   error_t err;
826
827  retry:
828   err = proc_getprocinfo (proc_server, inf->pid, &info_flags,
829                           (procinfo_t *) &pi, &pi_len, &noise, &noise_len);
830   if (err)
831     {
832       inf->task->dead = 1; /* oh well */
833       return;
834     }
835
836   if (inf->task->cur_sc < pi->taskinfo.suspend_count && suspend_count == -1)
837     {
838       /* The proc server might have suspended the task while stopping
839          it.  This happens when the task is handling a traced signal.
840          Refetch the suspend count.  The proc server should be
841          finished stopping the task by now.  */
842       suspend_count = pi->taskinfo.suspend_count;
843       goto retry;
844     }
845
846   suspend_count = pi->taskinfo.suspend_count;
847
848   vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len);
849   if (noise_len > 0)
850     vm_deallocate (mach_task_self (), (vm_address_t) pi, pi_len);
851
852   if (inf->task->cur_sc < suspend_count)
853     {
854       int abort;
855
856       target_terminal_ours ();  /* Allow I/O.  */
857       abort = !query ("Pid %d has an additional task suspend count of %d;"
858                       " clear it? ", inf->pid,
859                       suspend_count - inf->task->cur_sc);
860       target_terminal_inferior ();      /* Give it back to the child.  */
861
862       if (abort)
863         error (_("Additional task suspend count left untouched."));
864
865       inf->task->cur_sc = suspend_count;
866     }
867 }
868
869 /* Turns tracing for INF on or off, depending on ON, unless it already
870    is.  If INF is running, the resume_sc count of INF's threads will
871    be modified, and the signal thread will briefly be run to change
872    the trace state.  */
873 void
874 inf_set_traced (struct inf *inf, int on)
875 {
876   if (on == inf->traced)
877     return;
878   
879   if (inf->task && !inf->task->dead)
880     /* Make it take effect immediately.  */
881     {
882       sigset_t mask = on ? ~(sigset_t) 0 : 0;
883       error_t err =
884         INF_RESUME_MSGPORT_RPC (inf, msg_set_init_int (msgport, refport,
885                                                        INIT_TRACEMASK, mask));
886       if (err == EIEIO)
887         {
888           if (on)
889             warning (_("Can't modify tracing state for pid %d: %s"),
890                      inf->pid, "No signal thread");
891           inf->traced = on;
892         }
893       else if (err)
894         warning (_("Can't modify tracing state for pid %d: %s"),
895                  inf->pid, safe_strerror (err));
896       else
897         inf->traced = on;
898     }
899   else
900     inf->traced = on;
901 }
902
903 \f
904 /* Makes all the real suspend count deltas of all the procs in INF
905    match the desired values.  Careful to always do thread/task suspend
906    counts in the safe order.  Returns true if at least one thread is
907    thought to be running. */
908 int
909 inf_update_suspends (struct inf *inf)
910 {
911   struct proc *task = inf->task;
912   /* We don't have to update INF->threads even though we're iterating over it
913      because we'll change a thread only if it already has an existing proc
914      entry.  */
915
916   inf_debug (inf, "updating suspend counts");
917
918   if (task)
919     {
920       struct proc *thread;
921       int task_running = (task->sc == 0), thread_running = 0;
922
923       if (task->sc > task->cur_sc)
924         /* The task is becoming _more_ suspended; do before any threads.  */
925         task_running = proc_update_sc (task);
926
927       if (inf->pending_execs)
928         /* When we're waiting for an exec, things may be happening behind our
929            back, so be conservative.  */
930         thread_running = 1;
931
932       /* Do all the thread suspend counts.  */
933       for (thread = inf->threads; thread; thread = thread->next)
934         thread_running |= proc_update_sc (thread);
935
936       if (task->sc != task->cur_sc)
937         /* We didn't do the task first, because we wanted to wait for the
938            threads; do it now.  */
939         task_running = proc_update_sc (task);
940
941       inf_debug (inf, "%srunning...",
942                  (thread_running && task_running) ? "" : "not ");
943
944       inf->running = thread_running && task_running;
945
946       /* Once any thread has executed some code, we can't depend on the
947          threads list any more.  */
948       if (inf->running)
949         inf->threads_up_to_date = 0;
950
951       return inf->running;
952     }
953
954   return 0;
955 }
956
957 \f
958 /* Converts a GDB pid to a struct proc.  */
959 struct proc *
960 inf_tid_to_thread (struct inf *inf, int tid)
961 {
962   struct proc *thread = inf->threads;
963
964   while (thread)
965     if (thread->tid == tid)
966       return thread;
967     else
968       thread = thread->next;
969   return 0;
970 }
971
972 /* Converts a thread port to a struct proc.  */
973 struct proc *
974 inf_port_to_thread (struct inf *inf, mach_port_t port)
975 {
976   struct proc *thread = inf->threads;
977   while (thread)
978     if (thread->port == port)
979       return thread;
980     else
981       thread = thread->next;
982   return 0;
983 }
984
985 \f
986 /* Make INF's list of threads be consistent with reality of TASK.  */
987 void
988 inf_validate_procs (struct inf *inf)
989 {
990   thread_array_t threads;
991   mach_msg_type_number_t num_threads, i;
992   struct proc *task = inf->task;
993
994   /* If no threads are currently running, this function will guarantee that
995      things are up to date.  The exception is if there are zero threads --
996      then it is almost certainly in an odd state, and probably some outside
997      agent will create threads.  */
998   inf->threads_up_to_date = inf->threads ? !inf->running : 0;
999
1000   if (task)
1001     {
1002       error_t err = task_threads (task->port, &threads, &num_threads);
1003       inf_debug (inf, "fetching threads");
1004       if (err)
1005         /* TASK must be dead.  */
1006         {
1007           task->dead = 1;
1008           task = 0;
1009         }
1010     }
1011
1012   if (!task)
1013     {
1014       num_threads = 0;
1015       inf_debug (inf, "no task");
1016     }
1017
1018   {
1019     /* Make things normally linear.  */
1020     mach_msg_type_number_t search_start = 0;
1021     /* Which thread in PROCS corresponds to each task thread, & the task.  */
1022     struct proc *matched[num_threads + 1];
1023     /* The last thread in INF->threads, so we can add to the end.  */
1024     struct proc *last = 0;
1025     /* The current thread we're considering. */
1026     struct proc *thread = inf->threads;
1027
1028     memset (matched, 0, sizeof (matched));
1029
1030     while (thread)
1031       {
1032         mach_msg_type_number_t left;
1033
1034         for (i = search_start, left = num_threads; left; i++, left--)
1035           {
1036             if (i >= num_threads)
1037               i -= num_threads; /* I wrapped around.  */
1038             if (thread->port == threads[i])
1039               /* We already know about this thread.  */
1040               {
1041                 matched[i] = thread;
1042                 last = thread;
1043                 thread = thread->next;
1044                 search_start++;
1045                 break;
1046               }
1047           }
1048
1049         if (!left)
1050           {
1051             proc_debug (thread, "died!");
1052             thread->port = MACH_PORT_NULL;
1053             thread = _proc_free (thread);       /* THREAD is dead.  */
1054             if (last)
1055               last->next = thread;
1056             else
1057               inf->threads = thread;
1058           }
1059       }
1060
1061     for (i = 0; i < num_threads; i++)
1062       {
1063         if (matched[i])
1064           /* Throw away the duplicate send right.  */
1065           mach_port_deallocate (mach_task_self (), threads[i]);
1066         else
1067           /* THREADS[I] is a thread we don't know about yet!  */
1068           {
1069             ptid_t ptid;
1070
1071             thread = make_proc (inf, threads[i], next_thread_id++);
1072             if (last)
1073               last->next = thread;
1074             else
1075               inf->threads = thread;
1076             last = thread;
1077             proc_debug (thread, "new thread: %d", threads[i]);
1078
1079             ptid = ptid_build (inf->pid, 0, thread->tid);
1080
1081             /* Tell GDB's generic thread code.  */
1082
1083             if (ptid_equal (inferior_ptid, pid_to_ptid (inf->pid)))
1084               /* This is the first time we're hearing about thread
1085                  ids, after a fork-child.  */
1086               thread_change_ptid (inferior_ptid, ptid);
1087             else if (inf->pending_execs != 0)
1088               /* This is a shell thread.  */
1089               add_thread_silent (ptid);
1090             else
1091               add_thread (ptid);
1092           }
1093       }
1094
1095     vm_deallocate (mach_task_self (),
1096                    (vm_address_t) threads, (num_threads * sizeof (thread_t)));
1097   }
1098 }
1099
1100 \f
1101 /* Makes sure that INF's thread list is synced with the actual process.  */
1102 int
1103 inf_update_procs (struct inf *inf)
1104 {
1105   if (!inf->task)
1106     return 0;
1107   if (!inf->threads_up_to_date)
1108     inf_validate_procs (inf);
1109   return !!inf->task;
1110 }
1111
1112 /* Sets the resume_sc of each thread in inf.  That of RUN_THREAD is set to 0,
1113    and others are set to their run_sc if RUN_OTHERS is true, and otherwise
1114    their pause_sc.  */
1115 void
1116 inf_set_threads_resume_sc (struct inf *inf,
1117                            struct proc *run_thread, int run_others)
1118 {
1119   struct proc *thread;
1120   inf_update_procs (inf);
1121   for (thread = inf->threads; thread; thread = thread->next)
1122     if (thread == run_thread)
1123       thread->resume_sc = 0;
1124     else if (run_others)
1125       thread->resume_sc = thread->run_sc;
1126     else
1127       thread->resume_sc = thread->pause_sc;
1128 }
1129
1130 \f
1131 /* Cause INF to continue execution immediately; individual threads may still
1132    be suspended (but their suspend counts will be updated).  */
1133 void
1134 inf_resume (struct inf *inf)
1135 {
1136   struct proc *thread;
1137
1138   inf_update_procs (inf);
1139
1140   for (thread = inf->threads; thread; thread = thread->next)
1141     thread->sc = thread->resume_sc;
1142
1143   if (inf->task)
1144     {
1145       if (!inf->pending_execs)
1146         /* Try to make sure our task count is correct -- in the case where
1147            we're waiting for an exec though, things are too volatile, so just
1148            assume things will be reasonable (which they usually will be).  */
1149         inf_validate_task_sc (inf);
1150       inf->task->sc = 0;
1151     }
1152
1153   inf_update_suspends (inf);
1154 }
1155
1156 /* Cause INF to stop execution immediately; individual threads may still
1157    be running.  */
1158 void
1159 inf_suspend (struct inf *inf)
1160 {
1161   struct proc *thread;
1162
1163   inf_update_procs (inf);
1164
1165   for (thread = inf->threads; thread; thread = thread->next)
1166     thread->sc = thread->pause_sc;
1167
1168   if (inf->task)
1169     inf->task->sc = inf->pause_sc;
1170
1171   inf_update_suspends (inf);
1172 }
1173
1174 \f
1175 /* INF has one thread PROC that is in single-stepping mode.  This
1176    function changes it to be PROC, changing any old step_thread to be
1177    a normal one.  A PROC of 0 clears any existing value.  */
1178 void
1179 inf_set_step_thread (struct inf *inf, struct proc *thread)
1180 {
1181   gdb_assert (!thread || proc_is_thread (thread));
1182
1183   if (thread)
1184     inf_debug (inf, "setting step thread: %d/%d", inf->pid, thread->tid);
1185   else
1186     inf_debug (inf, "clearing step thread");
1187
1188   if (inf->step_thread != thread)
1189     {
1190       if (inf->step_thread && inf->step_thread->port != MACH_PORT_NULL)
1191         if (!proc_trace (inf->step_thread, 0))
1192           return;
1193       if (thread && proc_trace (thread, 1))
1194         inf->step_thread = thread;
1195       else
1196         inf->step_thread = 0;
1197     }
1198 }
1199
1200 \f
1201 /* Set up the thread resume_sc's so that only the signal thread is running
1202    (plus whatever other thread are set to always run).  Returns true if we
1203    did so, or false if we can't find a signal thread.  */
1204 int
1205 inf_set_threads_resume_sc_for_signal_thread (struct inf *inf)
1206 {
1207   if (inf->signal_thread)
1208     {
1209       inf_set_threads_resume_sc (inf, inf->signal_thread, 0);
1210       return 1;
1211     }
1212   else
1213     return 0;
1214 }
1215
1216 static void
1217 inf_update_signal_thread (struct inf *inf)
1218 {
1219   /* XXX for now we assume that if there's a msgport, the 2nd thread is
1220      the signal thread.  */
1221   inf->signal_thread = inf->threads ? inf->threads->next : 0;
1222 }
1223
1224 \f
1225 /* Detachs from INF's inferior task, letting it run once again...  */
1226 void
1227 inf_detach (struct inf *inf)
1228 {
1229   struct proc *task = inf->task;
1230
1231   inf_debug (inf, "detaching...");
1232
1233   inf_clear_wait (inf);
1234   inf_set_step_thread (inf, 0);
1235
1236   if (task)
1237     {
1238       struct proc *thread;
1239
1240       inf_validate_procinfo (inf);
1241
1242       inf_set_traced (inf, 0);
1243       if (inf->stopped)
1244         {
1245           if (inf->nomsg)
1246             inf_continue (inf);
1247           else
1248             inf_signal (inf, TARGET_SIGNAL_0);
1249         }
1250
1251       proc_restore_exc_port (task);
1252       task->sc = inf->detach_sc;
1253
1254       for (thread = inf->threads; thread; thread = thread->next)
1255         {
1256           proc_restore_exc_port (thread);
1257           thread->sc = thread->detach_sc;
1258         }
1259
1260       inf_update_suspends (inf);
1261     }
1262
1263   inf_cleanup (inf);
1264 }
1265
1266 /* Attaches INF to the process with process id PID, returning it in a
1267    suspended state suitable for debugging.  */
1268 void
1269 inf_attach (struct inf *inf, int pid)
1270 {
1271   inf_debug (inf, "attaching: %d", pid);
1272
1273   if (inf->pid)
1274     inf_detach (inf);
1275
1276   inf_startup (inf, pid);
1277 }
1278
1279 \f
1280 /* Makes sure that we've got our exception ports entrenched in the process. */
1281 void
1282 inf_steal_exc_ports (struct inf *inf)
1283 {
1284   struct proc *thread;
1285
1286   inf_debug (inf, "stealing exception ports");
1287
1288   inf_set_step_thread (inf, 0); /* The step thread is special. */
1289
1290   proc_steal_exc_port (inf->task, inf->event_port);
1291   for (thread = inf->threads; thread; thread = thread->next)
1292     proc_steal_exc_port (thread, MACH_PORT_NULL);
1293 }
1294
1295 /* Makes sure the process has its own exception ports.  */
1296 void
1297 inf_restore_exc_ports (struct inf *inf)
1298 {
1299   struct proc *thread;
1300
1301   inf_debug (inf, "restoring exception ports");
1302
1303   inf_set_step_thread (inf, 0); /* The step thread is special. */
1304
1305   proc_restore_exc_port (inf->task);
1306   for (thread = inf->threads; thread; thread = thread->next)
1307     proc_restore_exc_port (thread);
1308 }
1309
1310 \f
1311 /* Deliver signal SIG to INF.  If INF is stopped, delivering a signal, even
1312    signal 0, will continue it.  INF is assumed to be in a paused state, and
1313    the resume_sc's of INF's threads may be affected.  */
1314 void
1315 inf_signal (struct inf *inf, enum target_signal sig)
1316 {
1317   error_t err = 0;
1318   int host_sig = target_signal_to_host (sig);
1319
1320 #define NAME target_signal_to_name (sig)
1321
1322   if (host_sig >= _NSIG)
1323     /* A mach exception.  Exceptions are encoded in the signal space by
1324        putting them after _NSIG; this assumes they're positive (and not
1325        extremely large)!  */
1326     {
1327       struct inf_wait *w = &inf->wait;
1328       if (w->status.kind == TARGET_WAITKIND_STOPPED
1329           && w->status.value.sig == sig
1330           && w->thread && !w->thread->aborted)
1331         /* We're passing through the last exception we received.  This is
1332            kind of bogus, because exceptions are per-thread whereas gdb
1333            treats signals as per-process.  We just forward the exception to
1334            the correct handler, even it's not for the same thread as TID --
1335            i.e., we pretend it's global.  */
1336         {
1337           struct exc_state *e = &w->exc;
1338           inf_debug (inf, "passing through exception:"
1339                      " task = %d, thread = %d, exc = %d"
1340                      ", code = %d, subcode = %d",
1341                      w->thread->port, inf->task->port,
1342                      e->exception, e->code, e->subcode);
1343           err =
1344             exception_raise_request (e->handler,
1345                                      e->reply, MACH_MSG_TYPE_MOVE_SEND_ONCE,
1346                                      w->thread->port, inf->task->port,
1347                                      e->exception, e->code, e->subcode);
1348         }
1349       else
1350         error (_("Can't forward spontaneous exception (%s)."), NAME);
1351     }
1352   else
1353     /* A Unix signal.  */
1354   if (inf->stopped)
1355     /* The process is stopped and expecting a signal.  Just send off a
1356        request and let it get handled when we resume everything.  */
1357     {
1358       inf_debug (inf, "sending %s to stopped process", NAME);
1359       err =
1360         INF_MSGPORT_RPC (inf,
1361                          msg_sig_post_untraced_request (msgport,
1362                                                         inf->event_port,
1363                                                MACH_MSG_TYPE_MAKE_SEND_ONCE,
1364                                                         host_sig, 0,
1365                                                         refport));
1366       if (!err)
1367         /* Posting an untraced signal automatically continues it.
1368            We clear this here rather than when we get the reply
1369            because we'd rather assume it's not stopped when it
1370            actually is, than the reverse.  */
1371         inf->stopped = 0;
1372     }
1373   else
1374     /* It's not expecting it.  We have to let just the signal thread
1375        run, and wait for it to get into a reasonable state before we
1376        can continue the rest of the process.  When we finally resume the
1377        process the signal we request will be the very first thing that
1378        happens. */
1379     {
1380       inf_debug (inf, "sending %s to unstopped process"
1381                  " (so resuming signal thread)", NAME);
1382       err =
1383         INF_RESUME_MSGPORT_RPC (inf,
1384                                 msg_sig_post_untraced (msgport, host_sig,
1385                                                        0, refport));
1386     }
1387
1388   if (err == EIEIO)
1389     /* Can't do too much... */
1390     warning (_("Can't deliver signal %s: No signal thread."), NAME);
1391   else if (err)
1392     warning (_("Delivering signal %s: %s"), NAME, safe_strerror (err));
1393
1394 #undef NAME
1395 }
1396
1397 \f
1398 /* Continue INF without delivering a signal.  This is meant to be used
1399    when INF does not have a message port.  */
1400 void
1401 inf_continue (struct inf *inf)
1402 {
1403   process_t proc;
1404   error_t err = proc_pid2proc (proc_server, inf->pid, &proc);
1405
1406   if (!err)
1407     {
1408       inf_debug (inf, "continuing process");
1409
1410       err = proc_mark_cont (proc);
1411       if (!err)
1412         {
1413           struct proc *thread;
1414
1415           for (thread = inf->threads; thread; thread = thread->next)
1416             thread_resume (thread->port);
1417
1418           inf->stopped = 0;
1419         }
1420     }
1421
1422   if (err)
1423     warning (_("Can't continue process: %s"), safe_strerror (err));
1424 }
1425
1426 \f
1427 /* The inferior used for all gdb target ops.  */
1428 struct inf *gnu_current_inf = 0;
1429
1430 /* The inferior being waited for by gnu_wait.  Since GDB is decidely not
1431    multi-threaded, we don't bother to lock this.  */
1432 struct inf *waiting_inf;
1433
1434 /* Wait for something to happen in the inferior, returning what in STATUS. */
1435 static ptid_t
1436 gnu_wait (ptid_t ptid, struct target_waitstatus *status)
1437 {
1438   struct msg
1439     {
1440       mach_msg_header_t hdr;
1441       mach_msg_type_t type;
1442       int data[8000];
1443     } msg;
1444   error_t err;
1445   struct proc *thread;
1446   struct inf *inf = gnu_current_inf;
1447
1448   extern int exc_server (mach_msg_header_t *, mach_msg_header_t *);
1449   extern int msg_reply_server (mach_msg_header_t *, mach_msg_header_t *);
1450   extern int notify_server (mach_msg_header_t *, mach_msg_header_t *);
1451   extern int process_reply_server (mach_msg_header_t *, mach_msg_header_t *);
1452
1453   gdb_assert (inf->task);
1454
1455   if (!inf->threads && !inf->pending_execs)
1456     /* No threads!  Assume that maybe some outside agency is frobbing our
1457        task, and really look for new threads.  If we can't find any, just tell
1458        the user to try again later.  */
1459     {
1460       inf_validate_procs (inf);
1461       if (!inf->threads && !inf->task->dead)
1462         error (_("There are no threads; try again later."));
1463     }
1464
1465   waiting_inf = inf;
1466
1467   inf_debug (inf, "waiting for: %s", target_pid_to_str (ptid));
1468
1469 rewait:
1470   if (proc_wait_pid != inf->pid && !inf->no_wait)
1471     /* Always get information on events from the proc server.  */
1472     {
1473       inf_debug (inf, "requesting wait on pid %d", inf->pid);
1474
1475       if (proc_wait_pid)
1476         /* The proc server is single-threaded, and only allows a single
1477            outstanding wait request, so we have to cancel the previous one. */
1478         {
1479           inf_debug (inf, "cancelling previous wait on pid %d", proc_wait_pid);
1480           interrupt_operation (proc_server, 0);
1481         }
1482
1483       err =
1484         proc_wait_request (proc_server, inf->event_port, inf->pid, WUNTRACED);
1485       if (err)
1486         warning (_("wait request failed: %s"), safe_strerror (err));
1487       else
1488         {
1489           inf_debug (inf, "waits pending: %d", proc_waits_pending);
1490           proc_wait_pid = inf->pid;
1491           /* Even if proc_waits_pending was > 0 before, we still won't
1492              get any other replies, because it was either from a
1493              different INF, or a different process attached to INF --
1494              and the event port, which is the wait reply port, changes
1495              when you switch processes. */
1496           proc_waits_pending = 1;
1497         }
1498     }
1499
1500   inf_clear_wait (inf);
1501
1502   /* What can happen? (1) Dead name notification; (2) Exceptions arrive;
1503      (3) wait reply from the proc server.  */
1504
1505   inf_debug (inf, "waiting for an event...");
1506   err = mach_msg (&msg.hdr, MACH_RCV_MSG | MACH_RCV_INTERRUPT,
1507                   0, sizeof (struct msg), inf->event_port,
1508                   MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
1509
1510   /* Re-suspend the task.  */
1511   inf_suspend (inf);
1512
1513   if (!inf->task && inf->pending_execs)
1514     /* When doing an exec, it's possible that the old task wasn't reused
1515        (e.g., setuid execs).  So if the task seems to have disappeared,
1516        attempt to refetch it, as the pid should still be the same.  */
1517     inf_set_pid (inf, inf->pid);
1518
1519   if (err == EMACH_RCV_INTERRUPTED)
1520     inf_debug (inf, "interrupted");
1521   else if (err)
1522     error (_("Couldn't wait for an event: %s"), safe_strerror (err));
1523   else
1524     {
1525       struct
1526         {
1527           mach_msg_header_t hdr;
1528           mach_msg_type_t err_type;
1529           kern_return_t err;
1530           char noise[200];
1531         }
1532       reply;
1533
1534       inf_debug (inf, "event: msgid = %d", msg.hdr.msgh_id);
1535
1536       /* Handle what we got.  */
1537       if (!notify_server (&msg.hdr, &reply.hdr)
1538           && !exc_server (&msg.hdr, &reply.hdr)
1539           && !process_reply_server (&msg.hdr, &reply.hdr)
1540           && !msg_reply_server (&msg.hdr, &reply.hdr))
1541         /* Whatever it is, it's something strange.  */
1542         error (_("Got a strange event, msg id = %d."), msg.hdr.msgh_id);
1543
1544       if (reply.err)
1545         error (_("Handling event, msgid = %d: %s"),
1546                msg.hdr.msgh_id, safe_strerror (reply.err));
1547     }
1548
1549   if (inf->pending_execs)
1550     /* We're waiting for the inferior to finish execing.  */
1551     {
1552       struct inf_wait *w = &inf->wait;
1553       enum target_waitkind kind = w->status.kind;
1554
1555       if (kind == TARGET_WAITKIND_SPURIOUS)
1556         /* Since gdb is actually counting the number of times the inferior
1557            stops, expecting one stop per exec, we only return major events
1558            while execing.  */
1559         {
1560           w->suppress = 1;
1561           inf_debug (inf, "pending_execs = %d, ignoring minor event",
1562                      inf->pending_execs);
1563         }
1564       else if (kind == TARGET_WAITKIND_STOPPED
1565                && w->status.value.sig == TARGET_SIGNAL_TRAP)
1566         /* Ah hah!  A SIGTRAP from the inferior while starting up probably
1567            means we've succesfully completed an exec!  */
1568         {
1569           if (--inf->pending_execs == 0)
1570             /* We're done!  */
1571             {
1572 #if 0                           /* do we need this? */
1573               prune_threads (1);        /* Get rid of the old shell threads */
1574               renumber_threads (0);     /* Give our threads reasonable names. */
1575 #endif
1576             }
1577           inf_debug (inf, "pending exec completed, pending_execs => %d",
1578                      inf->pending_execs);
1579         }
1580       else if (kind == TARGET_WAITKIND_STOPPED)
1581         /* It's possible that this signal is because of a crashed process
1582            being handled by the hurd crash server; in this case, the process
1583            will have an extra task suspend, which we need to know about.
1584            Since the code in inf_resume that normally checks for this is
1585            disabled while INF->pending_execs, we do the check here instead.  */
1586         inf_validate_task_sc (inf);
1587     }
1588
1589   if (inf->wait.suppress)
1590     /* Some totally spurious event happened that we don't consider
1591        worth returning to gdb.  Just keep waiting.  */
1592     {
1593       inf_debug (inf, "suppressing return, rewaiting...");
1594       inf_resume (inf);
1595       goto rewait;
1596     }
1597
1598   /* Pass back out our results.  */
1599   memcpy (status, &inf->wait.status, sizeof (*status));
1600
1601   thread = inf->wait.thread;
1602   if (thread)
1603     ptid = ptid_build (inf->pid, 0, thread->tid);
1604   else if (ptid_equal (ptid, minus_one_ptid))
1605     thread = inf_tid_to_thread (inf, -1);
1606   else
1607     thread = inf_tid_to_thread (inf, ptid_get_tid (ptid));
1608
1609   if (!thread || thread->port == MACH_PORT_NULL)
1610     {
1611       /* TID is dead; try and find a new thread.  */
1612       if (inf_update_procs (inf) && inf->threads)
1613         ptid = ptid_build (inf->pid, 0, inf->threads->tid); /* The first available thread.  */
1614       else
1615         ptid = inferior_ptid;   /* let wait_for_inferior handle exit case */
1616     }
1617
1618   if (thread
1619       && !ptid_equal (ptid, minus_one_ptid)
1620       && status->kind != TARGET_WAITKIND_SPURIOUS
1621       && inf->pause_sc == 0 && thread->pause_sc == 0)
1622     /* If something actually happened to THREAD, make sure we
1623        suspend it.  */
1624     {
1625       thread->sc = 1;
1626       inf_update_suspends (inf);
1627     }
1628
1629   inf_debug (inf, "returning ptid = %s, status = %s (%d)",
1630              target_pid_to_str (ptid),
1631              status->kind == TARGET_WAITKIND_EXITED ? "EXITED"
1632              : status->kind == TARGET_WAITKIND_STOPPED ? "STOPPED"
1633              : status->kind == TARGET_WAITKIND_SIGNALLED ? "SIGNALLED"
1634              : status->kind == TARGET_WAITKIND_LOADED ? "LOADED"
1635              : status->kind == TARGET_WAITKIND_SPURIOUS ? "SPURIOUS"
1636              : "?",
1637              status->value.integer);
1638
1639   return ptid;
1640 }
1641
1642 \f
1643 /* The rpc handler called by exc_server.  */
1644 error_t
1645 S_exception_raise_request (mach_port_t port, mach_port_t reply_port,
1646                            thread_t thread_port, task_t task_port,
1647                            int exception, int code, int subcode)
1648 {
1649   struct inf *inf = waiting_inf;
1650   struct proc *thread = inf_port_to_thread (inf, thread_port);
1651
1652   inf_debug (waiting_inf,
1653              "thread = %d, task = %d, exc = %d, code = %d, subcode = %d",
1654              thread_port, task_port, exception, code, subcode);
1655
1656   if (!thread)
1657     /* We don't know about thread?  */
1658     {
1659       inf_update_procs (inf);
1660       thread = inf_port_to_thread (inf, thread_port);
1661       if (!thread)
1662         /* Give up, the generating thread is gone.  */
1663         return 0;
1664     }
1665
1666   mach_port_deallocate (mach_task_self (), thread_port);
1667   mach_port_deallocate (mach_task_self (), task_port);
1668
1669   if (!thread->aborted)
1670     /* THREAD hasn't been aborted since this exception happened (abortion
1671        clears any exception state), so it must be real.  */
1672     {
1673       /* Store away the details; this will destroy any previous info.  */
1674       inf->wait.thread = thread;
1675
1676       inf->wait.status.kind = TARGET_WAITKIND_STOPPED;
1677
1678       if (exception == EXC_BREAKPOINT)
1679         /* GDB likes to get SIGTRAP for breakpoints.  */
1680         {
1681           inf->wait.status.value.sig = TARGET_SIGNAL_TRAP;
1682           mach_port_deallocate (mach_task_self (), reply_port);
1683         }
1684       else
1685         /* Record the exception so that we can forward it later.  */
1686         {
1687           if (thread->exc_port == port)
1688             {
1689               inf_debug (waiting_inf, "Handler is thread exception port <%d>",
1690                          thread->saved_exc_port);
1691               inf->wait.exc.handler = thread->saved_exc_port;
1692             }
1693           else
1694             {
1695               inf_debug (waiting_inf, "Handler is task exception port <%d>",
1696                          inf->task->saved_exc_port);
1697               inf->wait.exc.handler = inf->task->saved_exc_port;
1698               gdb_assert (inf->task->exc_port == port);
1699             }
1700           if (inf->wait.exc.handler != MACH_PORT_NULL)
1701             /* Add a reference to the exception handler. */
1702             mach_port_mod_refs (mach_task_self (),
1703                                 inf->wait.exc.handler, MACH_PORT_RIGHT_SEND,
1704                                 1);
1705
1706           inf->wait.exc.exception = exception;
1707           inf->wait.exc.code = code;
1708           inf->wait.exc.subcode = subcode;
1709           inf->wait.exc.reply = reply_port;
1710
1711           /* Exceptions are encoded in the signal space by putting them after
1712              _NSIG; this assumes they're positive (and not extremely large)! */
1713           inf->wait.status.value.sig =
1714             target_signal_from_host (_NSIG + exception);
1715         }
1716     }
1717   else
1718     /* A supppressed exception, which ignore.  */
1719     {
1720       inf->wait.suppress = 1;
1721       mach_port_deallocate (mach_task_self (), reply_port);
1722     }
1723
1724   return 0;
1725 }
1726
1727 \f
1728 /* Fill in INF's wait field after a task has died without giving us more
1729    detailed information.  */
1730 void
1731 inf_task_died_status (struct inf *inf)
1732 {
1733   warning (_("Pid %d died with unknown exit status, using SIGKILL."), inf->pid);
1734   inf->wait.status.kind = TARGET_WAITKIND_SIGNALLED;
1735   inf->wait.status.value.sig = TARGET_SIGNAL_KILL;
1736 }
1737
1738 /* Notify server routines.  The only real one is dead name notification.  */
1739 error_t
1740 do_mach_notify_dead_name (mach_port_t notify, mach_port_t dead_port)
1741 {
1742   struct inf *inf = waiting_inf;
1743
1744   inf_debug (waiting_inf, "port = %d", dead_port);
1745
1746   if (inf->task && inf->task->port == dead_port)
1747     {
1748       proc_debug (inf->task, "is dead");
1749       inf->task->port = MACH_PORT_NULL;
1750       if (proc_wait_pid == inf->pid)
1751         /* We have a wait outstanding on the process, which will return more
1752            detailed information, so delay until we get that.  */
1753         inf->wait.suppress = 1;
1754       else
1755         /* We never waited for the process (maybe it wasn't a child), so just
1756            pretend it got a SIGKILL.  */
1757         inf_task_died_status (inf);
1758     }
1759   else
1760     {
1761       struct proc *thread = inf_port_to_thread (inf, dead_port);
1762       if (thread)
1763         {
1764           proc_debug (thread, "is dead");
1765           thread->port = MACH_PORT_NULL;
1766         }
1767
1768       if (inf->task->dead)
1769         /* Since the task is dead, its threads are dying with it.  */
1770         inf->wait.suppress = 1;
1771     }
1772
1773   mach_port_deallocate (mach_task_self (), dead_port);
1774   inf->threads_up_to_date = 0;  /* Just in case */
1775
1776   return 0;
1777 }
1778
1779 \f
1780 static error_t
1781 ill_rpc (char *fun)
1782 {
1783   warning (_("illegal rpc: %s"), fun);
1784   return 0;
1785 }
1786
1787 error_t
1788 do_mach_notify_no_senders (mach_port_t notify, mach_port_mscount_t count)
1789 {
1790   return ill_rpc ("do_mach_notify_no_senders");
1791 }
1792
1793 error_t
1794 do_mach_notify_port_deleted (mach_port_t notify, mach_port_t name)
1795 {
1796   return ill_rpc ("do_mach_notify_port_deleted");
1797 }
1798
1799 error_t
1800 do_mach_notify_msg_accepted (mach_port_t notify, mach_port_t name)
1801 {
1802   return ill_rpc ("do_mach_notify_msg_accepted");
1803 }
1804
1805 error_t
1806 do_mach_notify_port_destroyed (mach_port_t notify, mach_port_t name)
1807 {
1808   return ill_rpc ("do_mach_notify_port_destroyed");
1809 }
1810
1811 error_t
1812 do_mach_notify_send_once (mach_port_t notify)
1813 {
1814   return ill_rpc ("do_mach_notify_send_once");
1815 }
1816
1817 \f
1818 /* Process_reply server routines.  We only use process_wait_reply.  */
1819
1820 error_t
1821 S_proc_wait_reply (mach_port_t reply, error_t err,
1822                    int status, int sigcode, rusage_t rusage, pid_t pid)
1823 {
1824   struct inf *inf = waiting_inf;
1825
1826   inf_debug (inf, "err = %s, pid = %d, status = 0x%x, sigcode = %d",
1827              err ? safe_strerror (err) : "0", pid, status, sigcode);
1828
1829   if (err && proc_wait_pid && (!inf->task || !inf->task->port))
1830     /* Ack.  The task has died, but the task-died notification code didn't
1831        tell anyone because it thought a more detailed reply from the
1832        procserver was forthcoming.  However, we now learn that won't
1833        happen...  So we have to act like the task just died, and this time,
1834        tell the world.  */
1835     inf_task_died_status (inf);
1836
1837   if (--proc_waits_pending == 0)
1838     /* PROC_WAIT_PID represents the most recent wait.  We will always get
1839        replies in order because the proc server is single threaded.  */
1840     proc_wait_pid = 0;
1841
1842   inf_debug (inf, "waits pending now: %d", proc_waits_pending);
1843
1844   if (err)
1845     {
1846       if (err != EINTR)
1847         {
1848           warning (_("Can't wait for pid %d: %s"), inf->pid, safe_strerror (err));
1849           inf->no_wait = 1;
1850
1851           /* Since we can't see the inferior's signals, don't trap them.  */
1852           inf_set_traced (inf, 0);
1853         }
1854     }
1855   else if (pid == inf->pid)
1856     {
1857       store_waitstatus (&inf->wait.status, status);
1858       if (inf->wait.status.kind == TARGET_WAITKIND_STOPPED)
1859         /* The process has sent us a signal, and stopped itself in a sane
1860            state pending our actions.  */
1861         {
1862           inf_debug (inf, "process has stopped itself");
1863           inf->stopped = 1;
1864         }
1865     }
1866   else
1867     inf->wait.suppress = 1;     /* Something odd happened.  Ignore.  */
1868
1869   return 0;
1870 }
1871
1872 error_t
1873 S_proc_setmsgport_reply (mach_port_t reply, error_t err,
1874                          mach_port_t old_msg_port)
1875 {
1876   return ill_rpc ("S_proc_setmsgport_reply");
1877 }
1878
1879 error_t
1880 S_proc_getmsgport_reply (mach_port_t reply, error_t err, mach_port_t msg_port)
1881 {
1882   return ill_rpc ("S_proc_getmsgport_reply");
1883 }
1884
1885 \f
1886 /* Msg_reply server routines.  We only use msg_sig_post_untraced_reply.  */
1887
1888 error_t
1889 S_msg_sig_post_untraced_reply (mach_port_t reply, error_t err)
1890 {
1891   struct inf *inf = waiting_inf;
1892
1893   if (err == EBUSY)
1894     /* EBUSY is what we get when the crash server has grabbed control of the
1895        process and doesn't like what signal we tried to send it.  Just act
1896        like the process stopped (using a signal of 0 should mean that the
1897        *next* time the user continues, it will pass signal 0, which the crash
1898        server should like).  */
1899     {
1900       inf->wait.status.kind = TARGET_WAITKIND_STOPPED;
1901       inf->wait.status.value.sig = TARGET_SIGNAL_0;
1902     }
1903   else if (err)
1904     warning (_("Signal delivery failed: %s"), safe_strerror (err));
1905
1906   if (err)
1907     /* We only get this reply when we've posted a signal to a process which we
1908        thought was stopped, and which we expected to continue after the signal.
1909        Given that the signal has failed for some reason, it's reasonable to
1910        assume it's still stopped.  */
1911     inf->stopped = 1;
1912   else
1913     inf->wait.suppress = 1;
1914
1915   return 0;
1916 }
1917
1918 error_t
1919 S_msg_sig_post_reply (mach_port_t reply, error_t err)
1920 {
1921   return ill_rpc ("S_msg_sig_post_reply");
1922 }
1923
1924 \f
1925 /* Returns the number of messages queued for the receive right PORT.  */
1926 static mach_port_msgcount_t
1927 port_msgs_queued (mach_port_t port)
1928 {
1929   struct mach_port_status status;
1930   error_t err =
1931   mach_port_get_receive_status (mach_task_self (), port, &status);
1932
1933   if (err)
1934     return 0;
1935   else
1936     return status.mps_msgcount;
1937 }
1938
1939 \f
1940 /* Resume execution of the inferior process.
1941
1942    If STEP is nonzero, single-step it.
1943    If SIGNAL is nonzero, give it that signal.
1944
1945    TID  STEP:
1946    -1   true   Single step the current thread allowing other threads to run.
1947    -1   false  Continue the current thread allowing other threads to run.
1948    X    true   Single step the given thread, don't allow any others to run.
1949    X    false  Continue the given thread, do not allow any others to run.
1950    (Where X, of course, is anything except -1)
1951
1952    Note that a resume may not `take' if there are pending exceptions/&c
1953    still unprocessed from the last resume we did (any given resume may result
1954    in multiple events returned by wait).
1955  */
1956 static void
1957 gnu_resume (ptid_t ptid, int step, enum target_signal sig)
1958 {
1959   struct proc *step_thread = 0;
1960   int resume_all;
1961   struct inf *inf = gnu_current_inf;
1962
1963   inf_debug (inf, "ptid = %s, step = %d, sig = %d",
1964              target_pid_to_str (ptid), step, sig);
1965
1966   inf_validate_procinfo (inf);
1967
1968   if (sig != TARGET_SIGNAL_0 || inf->stopped)
1969     {
1970       if (sig == TARGET_SIGNAL_0 && inf->nomsg)
1971         inf_continue (inf);
1972       else
1973         inf_signal (inf, sig);
1974     }
1975   else if (inf->wait.exc.reply != MACH_PORT_NULL)
1976     /* We received an exception to which we have chosen not to forward, so
1977        abort the faulting thread, which will perhaps retake it.  */
1978     {
1979       proc_abort (inf->wait.thread, 1);
1980       warning (_("Aborting %s with unforwarded exception %s."),
1981                proc_string (inf->wait.thread),
1982                target_signal_to_name (inf->wait.status.value.sig));
1983     }
1984
1985   if (port_msgs_queued (inf->event_port))
1986     /* If there are still messages in our event queue, don't bother resuming
1987        the process, as we're just going to stop it right away anyway. */
1988     return;
1989
1990   inf_update_procs (inf);
1991
1992   /* A specific PTID means `step only this process id'.  */
1993   resume_all = ptid_equal (ptid, minus_one_ptid);
1994
1995   if (resume_all)
1996     /* Allow all threads to run, except perhaps single-stepping one.  */
1997     {
1998       inf_debug (inf, "running all threads; tid = %d", PIDGET (inferior_ptid));
1999       ptid = inferior_ptid;     /* What to step. */
2000       inf_set_threads_resume_sc (inf, 0, 1);
2001     }
2002   else
2003     /* Just allow a single thread to run.  */
2004     {
2005       struct proc *thread = inf_tid_to_thread (inf, ptid_get_tid (ptid));
2006       if (!thread)
2007         error (_("Can't run single thread id %s: no such thread!"),
2008                target_pid_to_str (ptid));
2009       inf_debug (inf, "running one thread: %s", target_pid_to_str (ptid));
2010       inf_set_threads_resume_sc (inf, thread, 0);
2011     }
2012
2013   if (step)
2014     {
2015       step_thread = inf_tid_to_thread (inf, ptid_get_tid (ptid));
2016       if (!step_thread)
2017         warning (_("Can't step thread id %s: no such thread."),
2018                  target_pid_to_str (ptid));
2019       else
2020         inf_debug (inf, "stepping thread: %s", target_pid_to_str (ptid));
2021     }
2022   if (step_thread != inf->step_thread)
2023     inf_set_step_thread (inf, step_thread);
2024
2025   inf_debug (inf, "here we go...");
2026   inf_resume (inf);
2027 }
2028
2029 \f
2030 static void
2031 gnu_kill_inferior (void)
2032 {
2033   struct proc *task = gnu_current_inf->task;
2034   if (task)
2035     {
2036       proc_debug (task, "terminating...");
2037       task_terminate (task->port);
2038       inf_set_pid (gnu_current_inf, -1);
2039     }
2040   target_mourn_inferior ();
2041 }
2042
2043 /* Clean up after the inferior dies.  */
2044 static void
2045 gnu_mourn_inferior (struct target_ops *ops)
2046 {
2047   inf_debug (gnu_current_inf, "rip");
2048   inf_detach (gnu_current_inf);
2049   unpush_target (&gnu_ops);
2050   generic_mourn_inferior ();
2051 }
2052
2053 \f
2054 /* Fork an inferior process, and start debugging it.  */
2055
2056 /* Set INFERIOR_PID to the first thread available in the child, if any.  */
2057 static int
2058 inf_pick_first_thread (void)
2059 {
2060   if (gnu_current_inf->task && gnu_current_inf->threads)
2061     /* The first thread.  */
2062     return gnu_current_inf->threads->tid;
2063   else
2064     /* What may be the next thread.  */
2065     return next_thread_id;
2066 }
2067
2068 static struct inf *
2069 cur_inf (void)
2070 {
2071   if (!gnu_current_inf)
2072     gnu_current_inf = make_inf ();
2073   return gnu_current_inf;
2074 }
2075
2076 static void
2077 gnu_create_inferior (struct target_ops *ops, 
2078                      char *exec_file, char *allargs, char **env,
2079                      int from_tty)
2080 {
2081   struct inf *inf = cur_inf ();
2082
2083   void trace_me ()
2084   {
2085     /* We're in the child; make this process stop as soon as it execs.  */
2086     inf_debug (inf, "tracing self");
2087     if (ptrace (PTRACE_TRACEME) != 0)
2088       error (_("ptrace (PTRACE_TRACEME) failed!"));
2089   }
2090   void attach_to_child (int pid)
2091   {
2092     /* Attach to the now stopped child, which is actually a shell...  */
2093     inf_debug (inf, "attaching to child: %d", pid);
2094
2095     inf_attach (inf, pid);
2096
2097     push_target (&gnu_ops);
2098
2099     inf->pending_execs = 2;
2100     inf->nomsg = 1;
2101     inf->traced = 1;
2102
2103     /* Now let the child run again, knowing that it will stop immediately
2104        because of the ptrace. */
2105     inf_resume (inf);
2106
2107     /* We now have thread info.  */
2108     thread_change_ptid (inferior_ptid,
2109                         ptid_build (inf->pid, 0, inf_pick_first_thread ()));
2110
2111     startup_inferior (inf->pending_execs);
2112   }
2113
2114   inf_debug (inf, "creating inferior");
2115
2116   fork_inferior (exec_file, allargs, env, trace_me, attach_to_child,
2117                  NULL, NULL);
2118
2119   inf_validate_procinfo (inf);
2120   inf_update_signal_thread (inf);
2121   inf_set_traced (inf, inf->want_signals);
2122
2123   /* Execing the process will have trashed our exception ports; steal them
2124      back (or make sure they're restored if the user wants that).  */
2125   if (inf->want_exceptions)
2126     inf_steal_exc_ports (inf);
2127   else
2128     inf_restore_exc_ports (inf);
2129 }
2130
2131 /* Mark our target-struct as eligible for stray "run" and "attach"
2132    commands.  */
2133 static int
2134 gnu_can_run (void)
2135 {
2136   return 1;
2137 }
2138
2139 \f
2140 /* Attach to process PID, then initialize for debugging it
2141    and wait for the trace-trap that results from attaching.  */
2142 static void
2143 gnu_attach (struct target_ops *ops, char *args, int from_tty)
2144 {
2145   int pid;
2146   char *exec_file;
2147   struct inf *inf = cur_inf ();
2148   struct inferior *inferior;
2149
2150   if (!args)
2151     error_no_arg (_("process-id to attach"));
2152
2153   pid = atoi (args);
2154
2155   if (pid == getpid ())         /* Trying to masturbate? */
2156     error (_("I refuse to debug myself!"));
2157
2158   if (from_tty)
2159     {
2160       exec_file = (char *) get_exec_file (0);
2161
2162       if (exec_file)
2163         printf_unfiltered ("Attaching to program `%s', pid %d\n",
2164                            exec_file, pid);
2165       else
2166         printf_unfiltered ("Attaching to pid %d\n", pid);
2167
2168       gdb_flush (gdb_stdout);
2169     }
2170
2171   inf_debug (inf, "attaching to pid: %d", pid);
2172
2173   inf_attach (inf, pid);
2174
2175   push_target (&gnu_ops);
2176
2177   inferior = add_inferior (pid);
2178   inferior->attach_flag = 1;
2179
2180   inf_update_procs (inf);
2181
2182   inferior_ptid = ptid_build (pid, 0, inf_pick_first_thread ());
2183
2184   /* We have to initialize the terminal settings now, since the code
2185      below might try to restore them.  */
2186   target_terminal_init ();
2187
2188   /* If the process was stopped before we attached, make it continue the next
2189      time the user does a continue.  */
2190   inf_validate_procinfo (inf);
2191
2192   inf_update_signal_thread (inf);
2193   inf_set_traced (inf, inf->want_signals);
2194
2195 #if 0                           /* Do we need this? */
2196   renumber_threads (0);         /* Give our threads reasonable names. */
2197 #endif
2198 }
2199
2200 \f
2201 /* Take a program previously attached to and detaches it.
2202    The program resumes execution and will no longer stop
2203    on signals, etc.  We'd better not have left any breakpoints
2204    in the program or it'll die when it hits one.  For this
2205    to work, it may be necessary for the process to have been
2206    previously attached.  It *might* work if the program was
2207    started via fork.  */
2208 static void
2209 gnu_detach (struct target_ops *ops, char *args, int from_tty)
2210 {
2211   int pid;
2212
2213   if (from_tty)
2214     {
2215       char *exec_file = get_exec_file (0);
2216       if (exec_file)
2217         printf_unfiltered ("Detaching from program `%s' pid %d\n",
2218                            exec_file, gnu_current_inf->pid);
2219       else
2220         printf_unfiltered ("Detaching from pid %d\n", gnu_current_inf->pid);
2221       gdb_flush (gdb_stdout);
2222     }
2223
2224   pid = gnu_current_inf->pid;
2225
2226   inf_detach (gnu_current_inf);
2227
2228   inferior_ptid = null_ptid;
2229   detach_inferior (pid);
2230
2231   unpush_target (&gnu_ops);     /* Pop out of handling an inferior */
2232 }
2233 \f
2234 static void
2235 gnu_terminal_init_inferior (void)
2236 {
2237   gdb_assert (gnu_current_inf);
2238   terminal_init_inferior_with_pgrp (gnu_current_inf->pid);
2239 }
2240
2241 /* Get ready to modify the registers array.  On machines which store
2242    individual registers, this doesn't need to do anything.  On machines
2243    which store all the registers in one fell swoop, this makes sure
2244    that registers contains all the registers from the program being
2245    debugged.  */
2246 static void
2247 gnu_prepare_to_store (struct regcache *regcache)
2248 {
2249 }
2250
2251 static void
2252 gnu_open (char *arg, int from_tty)
2253 {
2254   error (_("Use the \"run\" command to start a Unix child process."));
2255 }
2256
2257 static void
2258 gnu_stop (ptid_t ptid)
2259 {
2260   error (_("to_stop target function not implemented"));
2261 }
2262
2263 static int
2264 gnu_thread_alive (ptid_t ptid)
2265 {
2266   inf_update_procs (gnu_current_inf);
2267   return !!inf_tid_to_thread (gnu_current_inf,
2268                               ptid_get_tid (ptid));
2269 }
2270
2271 \f
2272 /* Read inferior task's LEN bytes from ADDR and copy it to MYADDR in
2273    gdb's address space.  Return 0 on failure; number of bytes read
2274    otherwise.  */
2275 int
2276 gnu_read_inferior (task_t task, CORE_ADDR addr, char *myaddr, int length)
2277 {
2278   error_t err;
2279   vm_address_t low_address = (vm_address_t) trunc_page (addr);
2280   vm_size_t aligned_length =
2281   (vm_size_t) round_page (addr + length) - low_address;
2282   pointer_t copied;
2283   int copy_count;
2284
2285   /* Get memory from inferior with page aligned addresses */
2286   err = vm_read (task, low_address, aligned_length, &copied, &copy_count);
2287   if (err)
2288     return 0;
2289
2290   err = hurd_safe_copyin (myaddr, (void *) (addr - low_address + copied), length);
2291   if (err)
2292     {
2293       warning (_("Read from inferior faulted: %s"), safe_strerror (err));
2294       length = 0;
2295     }
2296
2297   err = vm_deallocate (mach_task_self (), copied, copy_count);
2298   if (err)
2299     warning (_("gnu_read_inferior vm_deallocate failed: %s"), safe_strerror (err));
2300
2301   return length;
2302 }
2303
2304 #define CHK_GOTO_OUT(str,ret) \
2305   do if (ret != KERN_SUCCESS) { errstr = #str; goto out; } while(0)
2306
2307 struct vm_region_list
2308 {
2309   struct vm_region_list *next;
2310   vm_prot_t protection;
2311   vm_address_t start;
2312   vm_size_t length;
2313 };
2314
2315 struct obstack region_obstack;
2316
2317 /* Write gdb's LEN bytes from MYADDR and copy it to ADDR in inferior
2318    task's address space.  */
2319 int
2320 gnu_write_inferior (task_t task, CORE_ADDR addr, char *myaddr, int length)
2321 {
2322   error_t err = 0;
2323   vm_address_t low_address = (vm_address_t) trunc_page (addr);
2324   vm_size_t aligned_length =
2325   (vm_size_t) round_page (addr + length) - low_address;
2326   pointer_t copied;
2327   int copy_count;
2328   int deallocate = 0;
2329
2330   char *errstr = "Bug in gnu_write_inferior";
2331
2332   struct vm_region_list *region_element;
2333   struct vm_region_list *region_head = (struct vm_region_list *) NULL;
2334
2335   /* Get memory from inferior with page aligned addresses */
2336   err = vm_read (task,
2337                  low_address,
2338                  aligned_length,
2339                  &copied,
2340                  &copy_count);
2341   CHK_GOTO_OUT ("gnu_write_inferior vm_read failed", err);
2342
2343   deallocate++;
2344
2345   err = hurd_safe_copyout ((void *) (addr - low_address + copied),
2346                            myaddr, length);
2347   CHK_GOTO_OUT ("Write to inferior faulted", err);
2348
2349   obstack_init (&region_obstack);
2350
2351   /* Do writes atomically.
2352      First check for holes and unwritable memory.  */
2353   {
2354     vm_size_t remaining_length = aligned_length;
2355     vm_address_t region_address = low_address;
2356
2357     struct vm_region_list *scan;
2358
2359     while (region_address < low_address + aligned_length)
2360       {
2361         vm_prot_t protection;
2362         vm_prot_t max_protection;
2363         vm_inherit_t inheritance;
2364         boolean_t shared;
2365         mach_port_t object_name;
2366         vm_offset_t offset;
2367         vm_size_t region_length = remaining_length;
2368         vm_address_t old_address = region_address;
2369
2370         err = vm_region (task,
2371                          &region_address,
2372                          &region_length,
2373                          &protection,
2374                          &max_protection,
2375                          &inheritance,
2376                          &shared,
2377                          &object_name,
2378                          &offset);
2379         CHK_GOTO_OUT ("vm_region failed", err);
2380
2381         /* Check for holes in memory */
2382         if (old_address != region_address)
2383           {
2384             warning (_("No memory at 0x%x. Nothing written"),
2385                      old_address);
2386             err = KERN_SUCCESS;
2387             length = 0;
2388             goto out;
2389           }
2390
2391         if (!(max_protection & VM_PROT_WRITE))
2392           {
2393             warning (_("Memory at address 0x%x is unwritable. Nothing written"),
2394                      old_address);
2395             err = KERN_SUCCESS;
2396             length = 0;
2397             goto out;
2398           }
2399
2400         /* Chain the regions for later use */
2401         region_element =
2402           (struct vm_region_list *)
2403           obstack_alloc (&region_obstack, sizeof (struct vm_region_list));
2404
2405         region_element->protection = protection;
2406         region_element->start = region_address;
2407         region_element->length = region_length;
2408
2409         /* Chain the regions along with protections */
2410         region_element->next = region_head;
2411         region_head = region_element;
2412
2413         region_address += region_length;
2414         remaining_length = remaining_length - region_length;
2415       }
2416
2417     /* If things fail after this, we give up.
2418        Somebody is messing up inferior_task's mappings.  */
2419
2420     /* Enable writes to the chained vm regions */
2421     for (scan = region_head; scan; scan = scan->next)
2422       {
2423         if (!(scan->protection & VM_PROT_WRITE))
2424           {
2425             err = vm_protect (task,
2426                               scan->start,
2427                               scan->length,
2428                               FALSE,
2429                               scan->protection | VM_PROT_WRITE);
2430             CHK_GOTO_OUT ("vm_protect: enable write failed", err);
2431           }
2432       }
2433
2434     err = vm_write (task,
2435                     low_address,
2436                     copied,
2437                     aligned_length);
2438     CHK_GOTO_OUT ("vm_write failed", err);
2439
2440     /* Set up the original region protections, if they were changed */
2441     for (scan = region_head; scan; scan = scan->next)
2442       {
2443         if (!(scan->protection & VM_PROT_WRITE))
2444           {
2445             err = vm_protect (task,
2446                               scan->start,
2447                               scan->length,
2448                               FALSE,
2449                               scan->protection);
2450             CHK_GOTO_OUT ("vm_protect: enable write failed", err);
2451           }
2452       }
2453   }
2454
2455 out:
2456   if (deallocate)
2457     {
2458       obstack_free (&region_obstack, 0);
2459
2460       (void) vm_deallocate (mach_task_self (),
2461                             copied,
2462                             copy_count);
2463     }
2464
2465   if (err != KERN_SUCCESS)
2466     {
2467       warning (_("%s: %s"), errstr, mach_error_string (err));
2468       return 0;
2469     }
2470
2471   return length;
2472 }
2473
2474 \f
2475 /* Return 0 on failure, number of bytes handled otherwise.  TARGET
2476    is ignored. */
2477 static int
2478 gnu_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
2479                  struct mem_attrib *attrib,
2480                  struct target_ops *target)
2481 {
2482   task_t task = (gnu_current_inf
2483                  ? (gnu_current_inf->task
2484                     ? gnu_current_inf->task->port : 0)
2485                  : 0);
2486
2487   if (task == MACH_PORT_NULL)
2488     return 0;
2489   else
2490     {
2491       inf_debug (gnu_current_inf, "%s %p[%d] %s %p",
2492                  write ? "writing" : "reading", (void *) memaddr, len,
2493                  write ? "<--" : "-->", myaddr);
2494       if (write)
2495         return gnu_write_inferior (task, memaddr, myaddr, len);
2496       else
2497         return gnu_read_inferior (task, memaddr, myaddr, len);
2498     }
2499 }
2500
2501 /* Call FUNC on each memory region in the task.  */
2502 static int
2503 gnu_find_memory_regions (int (*func) (CORE_ADDR,
2504                                       unsigned long,
2505                                       int, int, int,
2506                                       void *),
2507                          void *data)
2508 {
2509   error_t err;
2510   task_t task;
2511   vm_address_t region_address, last_region_address, last_region_end;
2512   vm_prot_t last_protection;
2513
2514   if (gnu_current_inf == 0 || gnu_current_inf->task == 0)
2515     return 0;
2516   task = gnu_current_inf->task->port;
2517   if (task == MACH_PORT_NULL)
2518     return 0;
2519
2520   region_address = last_region_address = last_region_end = VM_MIN_ADDRESS;
2521   last_protection = VM_PROT_NONE;
2522   while (region_address < VM_MAX_ADDRESS)
2523     {
2524       vm_prot_t protection;
2525       vm_prot_t max_protection;
2526       vm_inherit_t inheritance;
2527       boolean_t shared;
2528       mach_port_t object_name;
2529       vm_offset_t offset;
2530       vm_size_t region_length = VM_MAX_ADDRESS - region_address;
2531       vm_address_t old_address = region_address;
2532
2533       err = vm_region (task,
2534                        &region_address,
2535                        &region_length,
2536                        &protection,
2537                        &max_protection,
2538                        &inheritance,
2539                        &shared,
2540                        &object_name,
2541                        &offset);
2542       if (err == KERN_NO_SPACE)
2543         break;
2544       if (err != KERN_SUCCESS)
2545         {
2546           warning (_("vm_region failed: %s"), mach_error_string (err));
2547           return -1;
2548         }
2549
2550       if (protection == last_protection && region_address == last_region_end)
2551         /* This region is contiguous with and indistinguishable from
2552            the previous one, so we just extend that one.  */
2553         last_region_end = region_address += region_length;
2554       else
2555         {
2556           /* This region is distinct from the last one we saw, so report
2557              that previous one.  */
2558           if (last_protection != VM_PROT_NONE)
2559             (*func) (last_region_address,
2560                      last_region_end - last_region_address,
2561                      last_protection & VM_PROT_READ,
2562                      last_protection & VM_PROT_WRITE,
2563                      last_protection & VM_PROT_EXECUTE,
2564                      data);
2565           last_region_address = region_address;
2566           last_region_end = region_address += region_length;
2567           last_protection = protection;
2568         }
2569     }
2570
2571   /* Report the final region.  */
2572   if (last_region_end > last_region_address && last_protection != VM_PROT_NONE)
2573     (*func) (last_region_address, last_region_end - last_region_address,
2574              last_protection & VM_PROT_READ,
2575              last_protection & VM_PROT_WRITE,
2576              last_protection & VM_PROT_EXECUTE,
2577              data);
2578
2579   return 0;
2580 }
2581
2582 \f
2583 /* Return printable description of proc.  */
2584 char *
2585 proc_string (struct proc *proc)
2586 {
2587   static char tid_str[80];
2588   if (proc_is_task (proc))
2589     sprintf (tid_str, "process %d", proc->inf->pid);
2590   else
2591     sprintf (tid_str, "Thread %d.%d",
2592              proc->inf->pid, proc->tid);
2593   return tid_str;
2594 }
2595
2596 static char *
2597 gnu_pid_to_str (ptid_t ptid)
2598 {
2599   struct inf *inf = gnu_current_inf;
2600   int tid = ptid_get_tid (ptid);
2601   struct proc *thread = inf_tid_to_thread (inf, tid);
2602
2603   if (thread)
2604     return proc_string (thread);
2605   else
2606     {
2607       static char tid_str[80];
2608       sprintf (tid_str, "bogus thread id %d", tid);
2609       return tid_str;
2610     }
2611 }
2612
2613 \f
2614 extern void gnu_store_registers (struct regcache *regcache, int regno);
2615 extern void gnu_fetch_registers (struct regcache *regcache, int regno);
2616
2617 struct target_ops gnu_ops;
2618
2619 static void
2620 init_gnu_ops (void)
2621 {
2622   gnu_ops.to_shortname = "GNU";         /* to_shortname */
2623   gnu_ops.to_longname = "GNU Hurd process"; /* to_longname */
2624   gnu_ops.to_doc = "GNU Hurd process";  /* to_doc */
2625   gnu_ops.to_open = gnu_open;           /* to_open */
2626   gnu_ops.to_attach = gnu_attach;       /* to_attach */
2627   gnu_ops.to_attach_no_wait = 1;        /* to_attach_no_wait */
2628   gnu_ops.to_detach = gnu_detach;       /* to_detach */
2629   gnu_ops.to_resume = gnu_resume;       /* to_resume */
2630   gnu_ops.to_wait = gnu_wait;           /* to_wait */
2631   gnu_ops.to_fetch_registers = gnu_fetch_registers;    /* to_fetch_registers */
2632   gnu_ops.to_store_registers = gnu_store_registers;    /* to_store_registers */
2633   gnu_ops.to_prepare_to_store = gnu_prepare_to_store; /* to_prepare_to_store */
2634   gnu_ops.deprecated_xfer_memory = gnu_xfer_memory;
2635   gnu_ops.to_find_memory_regions = gnu_find_memory_regions;
2636   gnu_ops.to_insert_breakpoint = memory_insert_breakpoint;
2637   gnu_ops.to_remove_breakpoint = memory_remove_breakpoint;
2638   gnu_ops.to_terminal_init = gnu_terminal_init_inferior;
2639   gnu_ops.to_terminal_inferior = terminal_inferior;
2640   gnu_ops.to_terminal_ours_for_output = terminal_ours_for_output;
2641   gnu_ops.to_terminal_save_ours = terminal_save_ours;
2642   gnu_ops.to_terminal_ours = terminal_ours;
2643   gnu_ops.to_terminal_info = child_terminal_info;
2644   gnu_ops.to_kill = gnu_kill_inferior;  /* to_kill */
2645   gnu_ops.to_create_inferior = gnu_create_inferior; /* to_create_inferior */
2646   gnu_ops.to_mourn_inferior = gnu_mourn_inferior;       /* to_mourn_inferior */
2647   gnu_ops.to_can_run = gnu_can_run;     /* to_can_run */
2648   gnu_ops.to_thread_alive = gnu_thread_alive;   /* to_thread_alive */
2649   gnu_ops.to_pid_to_str = gnu_pid_to_str;   /* to_pid_to_str */
2650   gnu_ops.to_stop = gnu_stop;   /* to_stop */
2651   gnu_ops.to_stratum = process_stratum;         /* to_stratum */
2652   gnu_ops.to_has_all_memory = 1;        /* to_has_all_memory */
2653   gnu_ops.to_has_memory = 1;            /* to_has_memory */
2654   gnu_ops.to_has_stack = 1;             /* to_has_stack */
2655   gnu_ops.to_has_registers = 1;         /* to_has_registers */
2656   gnu_ops.to_has_execution = 1;         /* to_has_execution */
2657   gnu_ops.to_magic = OPS_MAGIC;         /* to_magic */
2658 }                               /* init_gnu_ops */
2659
2660 \f
2661 /* User task commands.  */
2662
2663 struct cmd_list_element *set_task_cmd_list = 0;
2664 struct cmd_list_element *show_task_cmd_list = 0;
2665 /* User thread commands.  */
2666
2667 /* Commands with a prefix of `set/show thread'.  */
2668 extern struct cmd_list_element *thread_cmd_list;
2669 struct cmd_list_element *set_thread_cmd_list = NULL;
2670 struct cmd_list_element *show_thread_cmd_list = NULL;
2671
2672 /* Commands with a prefix of `set/show thread default'.  */
2673 struct cmd_list_element *set_thread_default_cmd_list = NULL;
2674 struct cmd_list_element *show_thread_default_cmd_list = NULL;
2675
2676 static void
2677 set_thread_cmd (char *args, int from_tty)
2678 {
2679   printf_unfiltered ("\"set thread\" must be followed by the name of a thread property, or \"default\".\n");
2680 }
2681
2682 static void
2683 show_thread_cmd (char *args, int from_tty)
2684 {
2685   printf_unfiltered ("\"show thread\" must be followed by the name of a thread property, or \"default\".\n");
2686 }
2687
2688 static void
2689 set_thread_default_cmd (char *args, int from_tty)
2690 {
2691   printf_unfiltered ("\"set thread default\" must be followed by the name of a thread property.\n");
2692 }
2693
2694 static void
2695 show_thread_default_cmd (char *args, int from_tty)
2696 {
2697   printf_unfiltered ("\"show thread default\" must be followed by the name of a thread property.\n");
2698 }
2699
2700 static int
2701 parse_int_arg (char *args, char *cmd_prefix)
2702 {
2703   if (args)
2704     {
2705       char *arg_end;
2706       int val = strtoul (args, &arg_end, 10);
2707       if (*args && *arg_end == '\0')
2708         return val;
2709     }
2710   error (_("Illegal argument for \"%s\" command, should be an integer."), cmd_prefix);
2711 }
2712
2713 static int
2714 _parse_bool_arg (char *args, char *t_val, char *f_val, char *cmd_prefix)
2715 {
2716   if (!args || strcmp (args, t_val) == 0)
2717     return 1;
2718   else if (strcmp (args, f_val) == 0)
2719     return 0;
2720   else
2721     error (_("Illegal argument for \"%s\" command, should be \"%s\" or \"%s\"."),
2722            cmd_prefix, t_val, f_val);
2723 }
2724
2725 #define parse_bool_arg(args, cmd_prefix) \
2726   _parse_bool_arg (args, "on", "off", cmd_prefix)
2727
2728 static void
2729 check_empty (char *args, char *cmd_prefix)
2730 {
2731   if (args)
2732     error (_("Garbage after \"%s\" command: `%s'"), cmd_prefix, args);
2733 }
2734
2735 /* Returns the alive thread named by INFERIOR_PID, or signals an error.  */
2736 static struct proc *
2737 cur_thread (void)
2738 {
2739   struct inf *inf = cur_inf ();
2740   struct proc *thread = inf_tid_to_thread (inf,
2741                                            ptid_get_tid (inferior_ptid));
2742   if (!thread)
2743     error (_("No current thread."));
2744   return thread;
2745 }
2746
2747 /* Returns the current inferior, but signals an error if it has no task.  */
2748 static struct inf *
2749 active_inf (void)
2750 {
2751   struct inf *inf = cur_inf ();
2752   if (!inf->task)
2753     error (_("No current process."));
2754   return inf;
2755 }
2756
2757 \f
2758 static void
2759 set_task_pause_cmd (char *args, int from_tty)
2760 {
2761   struct inf *inf = cur_inf ();
2762   int old_sc = inf->pause_sc;
2763
2764   inf->pause_sc = parse_bool_arg (args, "set task pause");
2765
2766   if (old_sc == 0 && inf->pause_sc != 0)
2767     /* If the task is currently unsuspended, immediately suspend it,
2768        otherwise wait until the next time it gets control.  */
2769     inf_suspend (inf);
2770 }
2771
2772 static void
2773 show_task_pause_cmd (char *args, int from_tty)
2774 {
2775   struct inf *inf = cur_inf ();
2776   check_empty (args, "show task pause");
2777   printf_unfiltered ("The inferior task %s suspended while gdb has control.\n",
2778                      inf->task
2779                      ? (inf->pause_sc == 0 ? "isn't" : "is")
2780                      : (inf->pause_sc == 0 ? "won't be" : "will be"));
2781 }
2782
2783 static void
2784 set_task_detach_sc_cmd (char *args, int from_tty)
2785 {
2786   cur_inf ()->detach_sc = parse_int_arg (args, "set task detach-suspend-count");
2787 }
2788
2789 static void
2790 show_task_detach_sc_cmd (char *args, int from_tty)
2791 {
2792   check_empty (args, "show task detach-suspend-count");
2793   printf_unfiltered ("The inferior task will be left with a suspend count of %d when detaching.\n",
2794                      cur_inf ()->detach_sc);
2795 }
2796
2797 \f
2798 static void
2799 set_thread_default_pause_cmd (char *args, int from_tty)
2800 {
2801   struct inf *inf = cur_inf ();
2802   inf->default_thread_pause_sc =
2803     parse_bool_arg (args, "set thread default pause") ? 0 : 1;
2804 }
2805
2806 static void
2807 show_thread_default_pause_cmd (char *args, int from_tty)
2808 {
2809   struct inf *inf = cur_inf ();
2810   int sc = inf->default_thread_pause_sc;
2811   check_empty (args, "show thread default pause");
2812   printf_unfiltered ("New threads %s suspended while gdb has control%s.\n",
2813                      sc ? "are" : "aren't",
2814                      !sc && inf->pause_sc ? " (but the task is)" : "");
2815 }
2816
2817 static void
2818 set_thread_default_run_cmd (char *args, int from_tty)
2819 {
2820   struct inf *inf = cur_inf ();
2821   inf->default_thread_run_sc =
2822     parse_bool_arg (args, "set thread default run") ? 0 : 1;
2823 }
2824
2825 static void
2826 show_thread_default_run_cmd (char *args, int from_tty)
2827 {
2828   struct inf *inf = cur_inf ();
2829   check_empty (args, "show thread default run");
2830   printf_unfiltered ("New threads %s allowed to run.\n",
2831                      inf->default_thread_run_sc == 0 ? "are" : "aren't");
2832 }
2833
2834 static void
2835 set_thread_default_detach_sc_cmd (char *args, int from_tty)
2836 {
2837   cur_inf ()->default_thread_detach_sc =
2838     parse_int_arg (args, "set thread default detach-suspend-count");
2839 }
2840
2841 static void
2842 show_thread_default_detach_sc_cmd (char *args, int from_tty)
2843 {
2844   check_empty (args, "show thread default detach-suspend-count");
2845   printf_unfiltered ("New threads will get a detach-suspend-count of %d.\n",
2846                      cur_inf ()->default_thread_detach_sc);
2847 }
2848
2849 \f
2850 /* Steal a send right called NAME in the inferior task, and make it PROC's
2851    saved exception port.  */
2852 static void
2853 steal_exc_port (struct proc *proc, mach_port_t name)
2854 {
2855   error_t err;
2856   mach_port_t port;
2857   mach_msg_type_name_t port_type;
2858
2859   if (!proc || !proc->inf->task)
2860     error (_("No inferior task."));
2861
2862   err = mach_port_extract_right (proc->inf->task->port,
2863                                  name, MACH_MSG_TYPE_COPY_SEND,
2864                                  &port, &port_type);
2865   if (err)
2866     error (_("Couldn't extract send right %d from inferior: %s"),
2867            name, safe_strerror (err));
2868
2869   if (proc->saved_exc_port)
2870     /* Get rid of our reference to the old one.  */
2871     mach_port_deallocate (mach_task_self (), proc->saved_exc_port);
2872
2873   proc->saved_exc_port = port;
2874
2875   if (!proc->exc_port)
2876     /* If PROC is a thread, we may not have set its exception port before.
2877        We can't use proc_steal_exc_port because it also sets saved_exc_port. */
2878     {
2879       proc->exc_port = proc->inf->event_port;
2880       err = proc_set_exception_port (proc, proc->exc_port);
2881       error (_("Can't set exception port for %s: %s"),
2882              proc_string (proc), safe_strerror (err));
2883     }
2884 }
2885
2886 static void
2887 set_task_exc_port_cmd (char *args, int from_tty)
2888 {
2889   struct inf *inf = cur_inf ();
2890   if (!args)
2891     error (_("No argument to \"set task exception-port\" command."));
2892   steal_exc_port (inf->task, parse_and_eval_address (args));
2893 }
2894
2895 static void
2896 set_stopped_cmd (char *args, int from_tty)
2897 {
2898   cur_inf ()->stopped = _parse_bool_arg (args, "yes", "no", "set stopped");
2899 }
2900
2901 static void
2902 show_stopped_cmd (char *args, int from_tty)
2903 {
2904   struct inf *inf = active_inf ();
2905   check_empty (args, "show stopped");
2906   printf_unfiltered ("The inferior process %s stopped.\n",
2907                      inf->stopped ? "is" : "isn't");
2908 }
2909
2910 static void
2911 set_sig_thread_cmd (char *args, int from_tty)
2912 {
2913   struct inf *inf = cur_inf ();
2914
2915   if (!args || (!isdigit (*args) && strcmp (args, "none") != 0))
2916     error (_("Illegal argument to \"set signal-thread\" command.\n"
2917            "Should be an integer thread ID, or `none'."));
2918
2919   if (strcmp (args, "none") == 0)
2920     inf->signal_thread = 0;
2921   else
2922     {
2923       int tid = ptid_get_tid (thread_id_to_pid (atoi (args)));
2924       if (tid < 0)
2925         error (_("Thread ID %s not known.  Use the \"info threads\" command to\n"
2926                "see the IDs of currently known threads."), args);
2927       inf->signal_thread = inf_tid_to_thread (inf, tid);
2928     }
2929 }
2930
2931 static void
2932 show_sig_thread_cmd (char *args, int from_tty)
2933 {
2934   struct inf *inf = active_inf ();
2935   check_empty (args, "show signal-thread");
2936   if (inf->signal_thread)
2937     printf_unfiltered ("The signal thread is %s.\n",
2938                        proc_string (inf->signal_thread));
2939   else
2940     printf_unfiltered ("There is no signal thread.\n");
2941 }
2942
2943 \f
2944 static void
2945 set_signals_cmd (char *args, int from_tty)
2946 {
2947   struct inf *inf = cur_inf ();
2948
2949   inf->want_signals = parse_bool_arg (args, "set signals");
2950
2951   if (inf->task && inf->want_signals != inf->traced)
2952     /* Make this take effect immediately in a running process.  */
2953     inf_set_traced (inf, inf->want_signals);
2954 }
2955
2956 static void
2957 show_signals_cmd (char *args, int from_tty)
2958 {
2959   struct inf *inf = cur_inf ();
2960   check_empty (args, "show signals");
2961   printf_unfiltered ("The inferior process's signals %s intercepted.\n",
2962                      inf->task
2963                      ? (inf->traced ? "are" : "aren't")
2964                      : (inf->want_signals ? "will be" : "won't be"));
2965 }
2966
2967 static void
2968 set_exceptions_cmd (char *args, int from_tty)
2969 {
2970   struct inf *inf = cur_inf ();
2971   int val = parse_bool_arg (args, "set exceptions");
2972
2973   if (inf->task && inf->want_exceptions != val)
2974     /* Make this take effect immediately in a running process.  */
2975     /* XXX */ ;
2976
2977   inf->want_exceptions = val;
2978 }
2979
2980 static void
2981 show_exceptions_cmd (char *args, int from_tty)
2982 {
2983   struct inf *inf = cur_inf ();
2984   check_empty (args, "show exceptions");
2985   printf_unfiltered ("Exceptions in the inferior %s trapped.\n",
2986                      inf->task
2987                      ? (inf->want_exceptions ? "are" : "aren't")
2988                      : (inf->want_exceptions ? "will be" : "won't be"));
2989 }
2990
2991 \f
2992 static void
2993 set_task_cmd (char *args, int from_tty)
2994 {
2995   printf_unfiltered ("\"set task\" must be followed by the name"
2996                      " of a task property.\n");
2997 }
2998
2999 static void
3000 show_task_cmd (char *args, int from_tty)
3001 {
3002   struct inf *inf = cur_inf ();
3003
3004   check_empty (args, "show task");
3005
3006   show_signals_cmd (0, from_tty);
3007   show_exceptions_cmd (0, from_tty);
3008   show_task_pause_cmd (0, from_tty);
3009
3010   if (inf->pause_sc == 0)
3011     show_thread_default_pause_cmd (0, from_tty);
3012   show_thread_default_run_cmd (0, from_tty);
3013
3014   if (inf->task)
3015     {
3016       show_stopped_cmd (0, from_tty);
3017       show_sig_thread_cmd (0, from_tty);
3018     }
3019
3020   if (inf->detach_sc != 0)
3021     show_task_detach_sc_cmd (0, from_tty);
3022   if (inf->default_thread_detach_sc != 0)
3023     show_thread_default_detach_sc_cmd (0, from_tty);
3024 }
3025
3026 \f
3027 static void
3028 set_noninvasive_cmd (char *args, int from_tty)
3029 {
3030   /* Invert the sense of the arg for each component.  */
3031   char *inv_args = parse_bool_arg (args, "set noninvasive") ? "off" : "on";
3032
3033   set_task_pause_cmd (inv_args, from_tty);
3034   set_signals_cmd (inv_args, from_tty);
3035   set_exceptions_cmd (inv_args, from_tty);
3036 }
3037
3038 \f
3039 static void
3040 info_port_rights (char *args, mach_port_type_t only)
3041 {
3042   struct inf *inf = active_inf ();
3043   struct value *vmark = value_mark ();
3044
3045   if (args)
3046     /* Explicit list of port rights.  */
3047     {
3048       while (*args)
3049         {
3050           struct value *val = parse_to_comma_and_eval (&args);
3051           long right = value_as_long (val);
3052           error_t err =
3053           print_port_info (right, 0, inf->task->port, PORTINFO_DETAILS,
3054                            stdout);
3055           if (err)
3056             error (_("%ld: %s."), right, safe_strerror (err));
3057         }
3058     }
3059   else
3060     /* Print all of them.  */
3061     {
3062       error_t err =
3063       print_task_ports_info (inf->task->port, only, PORTINFO_DETAILS,
3064                              stdout);
3065       if (err)
3066         error (_("%s."), safe_strerror (err));
3067     }
3068
3069   value_free_to_mark (vmark);
3070 }
3071
3072 static void
3073 info_send_rights_cmd (char *args, int from_tty)
3074 {
3075   info_port_rights (args, MACH_PORT_TYPE_SEND);
3076 }
3077
3078 static void
3079 info_recv_rights_cmd (char *args, int from_tty)
3080 {
3081   info_port_rights (args, MACH_PORT_TYPE_RECEIVE);
3082 }
3083
3084 static void
3085 info_port_sets_cmd (char *args, int from_tty)
3086 {
3087   info_port_rights (args, MACH_PORT_TYPE_PORT_SET);
3088 }
3089
3090 static void
3091 info_dead_names_cmd (char *args, int from_tty)
3092 {
3093   info_port_rights (args, MACH_PORT_TYPE_DEAD_NAME);
3094 }
3095
3096 static void
3097 info_port_rights_cmd (char *args, int from_tty)
3098 {
3099   info_port_rights (args, ~0);
3100 }
3101
3102 \f
3103 static void
3104 add_task_commands (void)
3105 {
3106   add_cmd ("pause", class_run, set_thread_default_pause_cmd, _("\
3107 Set whether the new threads are suspended while gdb has control.\n\
3108 This property normally has no effect because the whole task is\n\
3109 suspended, however, that may be disabled with \"set task pause off\".\n\
3110 The default value is \"off\"."),
3111            &set_thread_default_cmd_list);
3112   add_cmd ("pause", no_class, show_thread_default_pause_cmd, _("\
3113 Show whether new threads are suspended while gdb has control."),
3114            &show_thread_default_cmd_list);
3115   
3116   add_cmd ("run", class_run, set_thread_default_run_cmd, _("\
3117 Set whether new threads are allowed to run (once gdb has noticed them)."),
3118            &set_thread_default_cmd_list);
3119   add_cmd ("run", no_class, show_thread_default_run_cmd, _("\
3120 Show whether new threads are allowed to run (once gdb has noticed them)."),
3121            &show_thread_default_cmd_list);
3122   
3123   add_cmd ("detach-suspend-count", class_run, set_thread_default_detach_sc_cmd,
3124            _("Set the default detach-suspend-count value for new threads."),
3125            &set_thread_default_cmd_list);
3126   add_cmd ("detach-suspend-count", no_class, show_thread_default_detach_sc_cmd,
3127            _("Show the default detach-suspend-count value for new threads."),
3128            &show_thread_default_cmd_list);
3129
3130   add_cmd ("signals", class_run, set_signals_cmd, _("\
3131 Set whether the inferior process's signals will be intercepted.\n\
3132 Mach exceptions (such as breakpoint traps) are not affected."),
3133            &setlist);
3134   add_alias_cmd ("sigs", "signals", class_run, 1, &setlist);
3135   add_cmd ("signals", no_class, show_signals_cmd, _("\
3136 Show whether the inferior process's signals will be intercepted."),
3137            &showlist);
3138   add_alias_cmd ("sigs", "signals", no_class, 1, &showlist);
3139
3140   add_cmd ("signal-thread", class_run, set_sig_thread_cmd, _("\
3141 Set the thread that gdb thinks is the libc signal thread.\n\
3142 This thread is run when delivering a signal to a non-stopped process."),
3143            &setlist);
3144   add_alias_cmd ("sigthread", "signal-thread", class_run, 1, &setlist);
3145   add_cmd ("signal-thread", no_class, show_sig_thread_cmd, _("\
3146 Set the thread that gdb thinks is the libc signal thread."),
3147            &showlist);
3148   add_alias_cmd ("sigthread", "signal-thread", no_class, 1, &showlist);
3149
3150   add_cmd ("stopped", class_run, set_stopped_cmd, _("\
3151 Set whether gdb thinks the inferior process is stopped as with SIGSTOP.\n\
3152 Stopped process will be continued by sending them a signal."),
3153            &setlist);
3154   add_cmd ("stopped", no_class, show_signals_cmd, _("\
3155 Show whether gdb thinks the inferior process is stopped as with SIGSTOP."),
3156            &showlist);
3157
3158   add_cmd ("exceptions", class_run, set_exceptions_cmd, _("\
3159 Set whether exceptions in the inferior process will be trapped.\n\
3160 When exceptions are turned off, neither breakpoints nor single-stepping\n\
3161 will work."),
3162            &setlist);
3163   /* Allow `set exc' despite conflict with `set exception-port'.  */
3164   add_alias_cmd ("exc", "exceptions", class_run, 1, &setlist);
3165   add_cmd ("exceptions", no_class, show_exceptions_cmd, _("\
3166 Show whether exceptions in the inferior process will be trapped."),
3167            &showlist);
3168
3169   add_prefix_cmd ("task", no_class, set_task_cmd,
3170                   _("Command prefix for setting task attributes."),
3171                   &set_task_cmd_list, "set task ", 0, &setlist);
3172   add_prefix_cmd ("task", no_class, show_task_cmd,
3173                   _("Command prefix for showing task attributes."),
3174                   &show_task_cmd_list, "show task ", 0, &showlist);
3175
3176   add_cmd ("pause", class_run, set_task_pause_cmd, _("\
3177 Set whether the task is suspended while gdb has control.\n\
3178 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3179 until the next time the program is continued.\n\
3180 When setting this to \"off\", \"set thread default pause on\" can be\n\
3181 used to pause individual threads by default instead."),
3182            &set_task_cmd_list);
3183   add_cmd ("pause", no_class, show_task_pause_cmd,
3184            _("Show whether the task is suspended while gdb has control."),
3185            &show_task_cmd_list);
3186
3187   add_cmd ("detach-suspend-count", class_run, set_task_detach_sc_cmd,
3188            _("Set the suspend count will leave on the thread when detaching."),
3189            &set_task_cmd_list);
3190   add_cmd ("detach-suspend-count", no_class, show_task_detach_sc_cmd,
3191            _("Show the suspend count will leave on the thread when detaching."),
3192            &show_task_cmd_list);
3193
3194   add_cmd ("exception-port", no_class, set_task_exc_port_cmd, _("\
3195 Set the task exception port to which we forward exceptions.\n\
3196 The argument should be the value of the send right in the task."),
3197            &set_task_cmd_list);
3198   add_alias_cmd ("excp", "exception-port", no_class, 1, &set_task_cmd_list);
3199   add_alias_cmd ("exc-port", "exception-port", no_class, 1,
3200                  &set_task_cmd_list);
3201
3202   /* A convenient way of turning on all options require to noninvasively
3203      debug running tasks.  */
3204   add_cmd ("noninvasive", no_class, set_noninvasive_cmd, _("\
3205 Set task options so that we interfere as little as possible.\n\
3206 This is the same as setting `task pause', `exceptions', and\n\
3207 `signals' to the opposite value."),
3208            &setlist);
3209
3210   /* Commands to show information about the task's ports.  */
3211   add_cmd ("send-rights", class_info, info_send_rights_cmd,
3212            _("Show information about the task's send rights"),
3213            &infolist);
3214   add_cmd ("receive-rights", class_info, info_recv_rights_cmd,
3215            _("Show information about the task's receive rights"),
3216            &infolist);
3217   add_cmd ("port-rights", class_info, info_port_rights_cmd,
3218            _("Show information about the task's port rights"),
3219            &infolist);
3220   add_cmd ("port-sets", class_info, info_port_sets_cmd,
3221            _("Show information about the task's port sets"),
3222            &infolist);
3223   add_cmd ("dead-names", class_info, info_dead_names_cmd,
3224            _("Show information about the task's dead names"),
3225            &infolist);
3226   add_info_alias ("ports", "port-rights", 1);
3227   add_info_alias ("port", "port-rights", 1);
3228   add_info_alias ("psets", "port-sets", 1);
3229 }
3230
3231 \f
3232 static void
3233 set_thread_pause_cmd (char *args, int from_tty)
3234 {
3235   struct proc *thread = cur_thread ();
3236   int old_sc = thread->pause_sc;
3237   thread->pause_sc = parse_bool_arg (args, "set thread pause");
3238   if (old_sc == 0 && thread->pause_sc != 0 && thread->inf->pause_sc == 0)
3239     /* If the task is currently unsuspended, immediately suspend it,
3240        otherwise wait until the next time it gets control.  */
3241     inf_suspend (thread->inf);
3242 }
3243
3244 static void
3245 show_thread_pause_cmd (char *args, int from_tty)
3246 {
3247   struct proc *thread = cur_thread ();
3248   int sc = thread->pause_sc;
3249   check_empty (args, "show task pause");
3250   printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n",
3251                      proc_string (thread),
3252                      sc ? "is" : "isn't",
3253                      !sc && thread->inf->pause_sc ? " (but the task is)" : "");
3254 }
3255
3256 static void
3257 set_thread_run_cmd (char *args, int from_tty)
3258 {
3259   struct proc *thread = cur_thread ();
3260   thread->run_sc = parse_bool_arg (args, "set thread run") ? 0 : 1;
3261 }
3262
3263 static void
3264 show_thread_run_cmd (char *args, int from_tty)
3265 {
3266   struct proc *thread = cur_thread ();
3267   check_empty (args, "show thread run");
3268   printf_unfiltered ("Thread %s %s allowed to run.",
3269                      proc_string (thread),
3270                      thread->run_sc == 0 ? "is" : "isn't");
3271 }
3272
3273 static void
3274 set_thread_detach_sc_cmd (char *args, int from_tty)
3275 {
3276   cur_thread ()->detach_sc = parse_int_arg (args,
3277                                             "set thread detach-suspend-count");
3278 }
3279
3280 static void
3281 show_thread_detach_sc_cmd (char *args, int from_tty)
3282 {
3283   struct proc *thread = cur_thread ();
3284   check_empty (args, "show thread detach-suspend-count");
3285   printf_unfiltered ("Thread %s will be left with a suspend count"
3286                      " of %d when detaching.\n",
3287                      proc_string (thread),
3288                      thread->detach_sc);
3289 }
3290
3291 static void
3292 set_thread_exc_port_cmd (char *args, int from_tty)
3293 {
3294   struct proc *thread = cur_thread ();
3295   if (!args)
3296     error (_("No argument to \"set thread exception-port\" command."));
3297   steal_exc_port (thread, parse_and_eval_address (args));
3298 }
3299
3300 #if 0
3301 static void
3302 show_thread_cmd (char *args, int from_tty)
3303 {
3304   struct proc *thread = cur_thread ();
3305   check_empty (args, "show thread");
3306   show_thread_run_cmd (0, from_tty);
3307   show_thread_pause_cmd (0, from_tty);
3308   if (thread->detach_sc != 0)
3309     show_thread_detach_sc_cmd (0, from_tty);
3310 }
3311 #endif
3312
3313 static void
3314 thread_takeover_sc_cmd (char *args, int from_tty)
3315 {
3316   struct proc *thread = cur_thread ();
3317   thread_basic_info_data_t _info;
3318   thread_basic_info_t info = &_info;
3319   mach_msg_type_number_t info_len = THREAD_BASIC_INFO_COUNT;
3320   error_t err =
3321   thread_info (thread->port, THREAD_BASIC_INFO, (int *) &info, &info_len);
3322   if (err)
3323     error (("%s."), safe_strerror (err));
3324   thread->sc = info->suspend_count;
3325   if (from_tty)
3326     printf_unfiltered ("Suspend count was %d.\n", thread->sc);
3327   if (info != &_info)
3328     vm_deallocate (mach_task_self (), (vm_address_t) info,
3329                    info_len * sizeof (int));
3330 }
3331
3332 \f
3333 static void
3334 add_thread_commands (void)
3335 {
3336   add_prefix_cmd ("thread", no_class, set_thread_cmd,
3337                   _("Command prefix for setting thread properties."),
3338                   &set_thread_cmd_list, "set thread ", 0, &setlist);
3339   add_prefix_cmd ("default", no_class, show_thread_cmd,
3340                   _("Command prefix for setting default thread properties."),
3341                   &set_thread_default_cmd_list, "set thread default ", 0,
3342                   &set_thread_cmd_list);
3343   add_prefix_cmd ("thread", no_class, set_thread_default_cmd,
3344                   _("Command prefix for showing thread properties."),
3345                   &show_thread_cmd_list, "show thread ", 0, &showlist);
3346   add_prefix_cmd ("default", no_class, show_thread_default_cmd,
3347                   _("Command prefix for showing default thread properties."),
3348                   &show_thread_default_cmd_list, "show thread default ", 0,
3349                   &show_thread_cmd_list);
3350
3351   add_cmd ("pause", class_run, set_thread_pause_cmd, _("\
3352 Set whether the current thread is suspended while gdb has control.\n\
3353 A value of \"on\" takes effect immediately, otherwise nothing happens\n\
3354 until the next time the program is continued.  This property normally\n\
3355 has no effect because the whole task is suspended, however, that may\n\
3356 be disabled with \"set task pause off\".\n\
3357 The default value is \"off\"."),
3358            &set_thread_cmd_list);
3359   add_cmd ("pause", no_class, show_thread_pause_cmd, _("\
3360 Show whether the current thread is suspended while gdb has control."),
3361            &show_thread_cmd_list);
3362
3363   add_cmd ("run", class_run, set_thread_run_cmd,
3364            _("Set whether the current thread is allowed to run."),
3365            &set_thread_cmd_list);
3366   add_cmd ("run", no_class, show_thread_run_cmd,
3367            _("Show whether the current thread is allowed to run."),
3368            &show_thread_cmd_list);
3369
3370   add_cmd ("detach-suspend-count", class_run, set_thread_detach_sc_cmd, _("\
3371 Set the suspend count will leave on the thread when detaching.\n\
3372 Note that this is relative to suspend count when gdb noticed the thread;\n\
3373 use the `thread takeover-suspend-count' to force it to an absolute value."),
3374            &set_thread_cmd_list);
3375   add_cmd ("detach-suspend-count", no_class, show_thread_detach_sc_cmd, _("\
3376 Show the suspend count will leave on the thread when detaching.\n\
3377 Note that this is relative to suspend count when gdb noticed the thread;\n\
3378 use the `thread takeover-suspend-count' to force it to an absolute value."),
3379            &show_thread_cmd_list);
3380
3381   add_cmd ("exception-port", no_class, set_thread_exc_port_cmd, _("\
3382 Set the thread exception port to which we forward exceptions.\n\
3383 This overrides the task exception port.\n\
3384 The argument should be the value of the send right in the task."),
3385            &set_thread_cmd_list);
3386   add_alias_cmd ("excp", "exception-port", no_class, 1, &set_thread_cmd_list);
3387   add_alias_cmd ("exc-port", "exception-port", no_class, 1,
3388                  &set_thread_cmd_list);
3389
3390   add_cmd ("takeover-suspend-count", no_class, thread_takeover_sc_cmd, _("\
3391 Force the threads absolute suspend-count to be gdb's.\n\
3392 Prior to giving this command, gdb's thread suspend-counts are relative\n\
3393 to the thread's initial suspend-count when gdb notices the threads."),
3394            &thread_cmd_list);
3395 }
3396
3397 \f
3398 void
3399 _initialize_gnu_nat (void)
3400 {
3401   proc_server = getproc ();
3402   
3403   init_gnu_ops ();
3404   add_target (&gnu_ops);
3405
3406   add_task_commands ();
3407   add_thread_commands ();
3408   deprecated_add_set_cmd ("gnu-debug", class_maintenance,
3409                           var_boolean, (char *) &gnu_debug_flag,
3410                           "Set debugging output for the gnu backend.",
3411                           &maintenancelist);
3412 }
3413 \f
3414 #ifdef  FLUSH_INFERIOR_CACHE
3415
3416 /* When over-writing code on some machines the I-Cache must be flushed
3417    explicitly, because it is not kept coherent by the lazy hardware.
3418    This definitely includes breakpoints, for instance, or else we
3419    end up looping in mysterious Bpt traps */
3420
3421 void
3422 flush_inferior_icache (CORE_ADDR pc, int amount)
3423 {
3424   vm_machine_attribute_val_t flush = MATTR_VAL_ICACHE_FLUSH;
3425   error_t ret;
3426
3427   ret = vm_machine_attribute (gnu_current_inf->task->port,
3428                               pc,
3429                               amount,
3430                               MATTR_CACHE,
3431                               &flush);
3432   if (ret != KERN_SUCCESS)
3433     warning (_("Error flushing inferior's cache : %s"), safe_strerror (ret));
3434 }
3435 #endif /* FLUSH_INFERIOR_CACHE */