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