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