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