OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [gnu-nat.c] - Blame information for rev 227

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.