GDB (xrefs)

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