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