OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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