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

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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