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