GDB (xrefs)
Loading...
Searching...
No Matches
nto-procfs.c
Go to the documentation of this file.
1/* Machine independent support for QNX Neutrino /proc (process file system)
2 for GDB. Written by Colin Burgess at QNX Software Systems Limited.
3
4 Copyright (C) 2003-2023 Free Software Foundation, Inc.
5
6 Contributed by QNX Software Systems Ltd.
7
8 This file is part of GDB.
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 "defs.h"
24
25#include <fcntl.h>
26#include <spawn.h>
27#include <sys/debug.h>
28#include <sys/procfs.h>
29#include <sys/neutrino.h>
30#include <sys/syspage.h>
31#include <dirent.h>
32#include <sys/netmgr.h>
33#include <sys/auxv.h>
34
35#include "gdbcore.h"
36#include "inferior.h"
37#include "target.h"
38#include "objfiles.h"
39#include "gdbthread.h"
40#include "nto-tdep.h"
41#include "command.h"
42#include "regcache.h"
43#include "solib.h"
44#include "inf-child.h"
45#include "gdbsupport/filestuff.h"
46#include "gdbsupport/scoped_fd.h"
47
48#define NULL_PID 0
49#define _DEBUG_FLAG_TRACE (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\
50 _DEBUG_FLAG_TRACE_WR|_DEBUG_FLAG_TRACE_MODIFY)
51
53
54static sighandler_t ofunc;
55
56static procfs_run run;
57
58/* Create the "native" and "procfs" targets. */
59
61{
62 void open (const char *arg, int from_tty) override;
63
64 void attach (const char *, int) override = 0;
65
66 void post_attach (int);
67
68 void detach (inferior *, int) override;
69
70 void resume (ptid_t, int, enum gdb_signal) override;
71
72 ptid_t wait (ptid_t, struct target_waitstatus *, target_wait_flags) override;
73
74 void fetch_registers (struct regcache *, int) override;
75 void store_registers (struct regcache *, int) override;
76
78 const char *annex,
79 gdb_byte *readbuf,
80 const gdb_byte *writebuf,
81 ULONGEST offset, ULONGEST len,
82 ULONGEST *xfered_len) override;
83
84 void files_info () override;
85
86 int insert_breakpoint (struct gdbarch *, struct bp_target_info *) override;
87
88 int remove_breakpoint (struct gdbarch *, struct bp_target_info *,
89 enum remove_bp_reason) override;
90
91 int can_use_hw_breakpoint (enum bptype, int, int) override;
92
93 int insert_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;
94
95 int remove_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;
96
97 int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
98 struct expression *) override;
99
100 int remove_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
101 struct expression *) override;
102
103 bool stopped_by_watchpoint () override;
104
105 void kill () override;
106
107 void create_inferior (const char *, const std::string &,
108 char **, int) override;
109
110 void mourn_inferior () override;
111
112 void pass_signals (gdb::array_view<const unsigned char>) override;
113
114 bool thread_alive (ptid_t ptid) override;
115
116 void update_thread_list () override;
117
118 std::string pid_to_str (ptid_t) override;
119
120 void interrupt () override;
121
122 const char *extra_thread_info (struct thread_info *) override;
123
124 const char *pid_to_exec_file (int pid) override;
125};
126
127/* For "target native". */
128
130 "native",
131 N_("QNX Neutrino local process"),
132 N_("QNX Neutrino local process (started by the \"run\" command).")
133};
134
136{
137 const target_info &info () const override
138 { return nto_native_target_info; }
139};
140
141/* For "target procfs <node>". */
142
144 "procfs",
145 N_("QNX Neutrino local or remote process"),
146 N_("QNX Neutrino process. target procfs NODE")
147};
148
150{
151 const target_info &info () const override
152 { return nto_procfs_target_info; }
153};
154
155static ptid_t do_attach (ptid_t ptid);
156
157/* These two globals are only ever set in procfs_open_1, but are
158 referenced elsewhere. 'nto_procfs_node' is a flag used to say
159 whether we are local, or we should get the current node descriptor
160 for the remote QNX node. */
161static char *nodestr;
162static unsigned nto_procfs_node = ND_LOCAL_NODE;
163
164/* Return the current QNX Node, or error out. This is a simple
165 wrapper for the netmgr_strtond() function. The reason this
166 is required is because QNX node descriptors are transient so
167 we have to re-acquire them every time. */
168static unsigned
170{
171 unsigned node;
172
173 if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0
174 || nodestr == NULL)
175 return ND_LOCAL_NODE;
176
177 node = netmgr_strtond (nodestr, 0);
178 if (node == -1)
179 error (_("Lost the QNX node. Debug session probably over."));
180
181 return (node);
182}
183
184static enum gdb_osabi
186{
187 return GDB_OSABI_QNXNTO;
188}
189
190/* This is called when we call 'target native' or 'target procfs
191 <arg>' from the (gdb) prompt. For QNX6 (nto), the only valid arg
192 will be a QNX node string, eg: "/net/some_node". If arg is not a
193 valid QNX node, we will default to local. */
194void
195nto_procfs_target::open (const char *arg, int from_tty)
196{
197 char *endstr;
198 char buffer[50];
199 int total_size;
200 procfs_sysinfo *sysinfo;
201 char nto_procfs_path[PATH_MAX];
202
203 /* Offer to kill previous inferiors before opening this target. */
204 target_preopen (from_tty);
205
207
208 /* Set the default node used for spawning to this one,
209 and only override it if there is a valid arg. */
210
211 xfree (nodestr);
212 nodestr = NULL;
213
214 nto_procfs_node = ND_LOCAL_NODE;
215 nodestr = (arg != NULL) ? xstrdup (arg) : NULL;
216
217 if (nodestr)
218 {
219 nto_procfs_node = netmgr_strtond (nodestr, &endstr);
220 if (nto_procfs_node == -1)
221 {
222 if (errno == ENOTSUP)
223 gdb_printf ("QNX Net Manager not found.\n");
224 gdb_printf ("Invalid QNX node %s: error %d (%s).\n", nodestr,
225 errno, safe_strerror (errno));
226 xfree (nodestr);
227 nodestr = NULL;
228 nto_procfs_node = ND_LOCAL_NODE;
229 }
230 else if (*endstr)
231 {
232 if (*(endstr - 1) == '/')
233 *(endstr - 1) = 0;
234 else
235 *endstr = 0;
236 }
237 }
238 snprintf (nto_procfs_path, PATH_MAX - 1, "%s%s",
239 (nodestr != NULL) ? nodestr : "", "/proc");
240
241 scoped_fd fd (open (nto_procfs_path, O_RDONLY));
242 if (fd.get () == -1)
243 {
244 gdb_printf ("Error opening %s : %d (%s)\n", nto_procfs_path, errno,
245 safe_strerror (errno));
246 error (_("Invalid procfs arg"));
247 }
248
249 sysinfo = (void *) buffer;
250 if (devctl (fd.get (), DCMD_PROC_SYSINFO, sysinfo, sizeof buffer, 0) != EOK)
251 {
252 gdb_printf ("Error getting size: %d (%s)\n", errno,
253 safe_strerror (errno));
254 error (_("Devctl failed."));
255 }
256 else
257 {
258 total_size = sysinfo->total_size;
259 sysinfo = alloca (total_size);
260 if (sysinfo == NULL)
261 {
262 gdb_printf ("Memory error: %d (%s)\n", errno,
263 safe_strerror (errno));
264 error (_("alloca failed."));
265 }
266 else
267 {
268 if (devctl (fd.get (), DCMD_PROC_SYSINFO, sysinfo, total_size, 0)
269 != EOK)
270 {
271 gdb_printf ("Error getting sysinfo: %d (%s)\n", errno,
272 safe_strerror (errno));
273 error (_("Devctl failed."));
274 }
275 else
276 {
277 if (sysinfo->type !=
279 (target_gdbarch ())->arch_name))
280 error (_("Invalid target CPU."));
281 }
282 }
283 }
284
285 inf_child_target::open (arg, from_tty);
286 gdb_printf ("Debugging using %s\n", nto_procfs_path);
287}
288
289static void
290procfs_set_thread (ptid_t ptid)
291{
292 pid_t tid;
293
294 tid = ptid.tid ();
295 devctl (ctl_fd, DCMD_PROC_CURTHREAD, &tid, sizeof (tid), 0);
296}
297
298/* Return true if the thread TH is still alive. */
299
300bool
302{
303 pid_t tid;
304 pid_t pid;
305 procfs_status status;
306 int err;
307
308 tid = ptid.tid ();
309 pid = ptid.pid ();
310
311 if (kill (pid, 0) == -1)
312 return false;
313
314 status.tid = tid;
315 if ((err = devctl (ctl_fd, DCMD_PROC_TIDSTATUS,
316 &status, sizeof (status), 0)) != EOK)
317 return false;
318
319 /* Thread is alive or dead but not yet joined,
320 or dead and there is an alive (or dead unjoined) thread with
321 higher tid.
322
323 If the tid is not the same as requested, requested tid is dead. */
324 return (status.tid == tid) && (status.state != STATE_DEAD);
325}
326
327static void
329 const char *newname)
330{
332
333 gdb_assert (newname != NULL);
334 gdb_assert (new_thread != NULL);
335
336 if (pti)
337 {
338 pti = new nto_thread_info;
339 new_thread->priv.reset (pti);
340 }
341
342 pti->name = newname;
343}
344
345static void
347 pthread_t tid, int state, int flags)
348{
349 procfs_info pidinfo;
350 struct _thread_name *tn;
351 procfs_threadctl tctl;
352
353#if _NTO_VERSION > 630
354 gdb_assert (new_thread != NULL);
355
356 if (devctl (ctl_fd, DCMD_PROC_INFO, &pidinfo,
357 sizeof(pidinfo), 0) != EOK)
358 return;
359
360 memset (&tctl, 0, sizeof (tctl));
361 tctl.cmd = _NTO_TCTL_NAME;
362 tn = (struct _thread_name *) (&tctl.data);
363
364 /* Fetch name for the given thread. */
365 tctl.tid = tid;
366 tn->name_buf_len = sizeof (tctl.data) - sizeof (*tn);
367 tn->new_name_len = -1; /* Getting, not setting. */
368 if (devctl (ctl_fd, DCMD_PROC_THREADCTL, &tctl, sizeof (tctl), NULL) != EOK)
369 tn->name_buf[0] = '\0';
370
371 tn->name_buf[_NTO_THREAD_NAME_MAX] = '\0';
372
374
376 pti->tid = tid;
377 pti->state = state;
378 pti->flags = flags;
379#endif /* _NTO_VERSION */
380}
381
382void
384{
385 procfs_status status;
386 pid_t pid;
387 ptid_t ptid;
388 pthread_t tid;
389 struct thread_info *new_thread;
390
391 if (ctl_fd == -1)
392 return;
393
394 prune_threads ();
395
397
398 status.tid = 1;
399
400 for (tid = 1;; ++tid)
401 {
402 if (status.tid == tid
403 && (devctl (ctl_fd, DCMD_PROC_TIDSTATUS, &status, sizeof (status), 0)
404 != EOK))
405 break;
406 if (status.tid != tid)
407 /* The reason why this would not be equal is that devctl might have
408 returned different tid, meaning the requested tid no longer exists
409 (e.g. thread exited). */
410 continue;
411 ptid = ptid_t (pid, 0, tid);
412 new_thread = this->find_thread (ptid);
413 if (!new_thread)
414 new_thread = add_thread (ptid);
416 status.tid++;
417 }
418 return;
419}
420
421static void
422procfs_pidlist (const char *args, int from_tty)
423{
424 struct dirent *dirp = NULL;
425 char buf[PATH_MAX];
426 procfs_info *pidinfo = NULL;
427 procfs_debuginfo *info = NULL;
428 procfs_status *status = NULL;
429 pid_t num_threads = 0;
430 pid_t pid;
431 char name[512];
432 char procfs_dir[PATH_MAX];
433
434 snprintf (procfs_dir, sizeof (procfs_dir), "%s%s",
435 (nodestr != NULL) ? nodestr : "", "/proc");
436
437 gdb_dir_up dp (opendir (procfs_dir));
438 if (dp == NULL)
439 {
440 gdb_printf (gdb_stderr, "failed to opendir \"%s\" - %d (%s)",
441 procfs_dir, errno, safe_strerror (errno));
442 return;
443 }
444
445 /* Start scan at first pid. */
446 rewinddir (dp.get ());
447
448 do
449 {
450 /* Get the right pid and procfs path for the pid. */
451 do
452 {
453 dirp = readdir (dp.get ());
454 if (dirp == NULL)
455 return;
456 snprintf (buf, sizeof (buf), "%s%s/%s/as",
457 (nodestr != NULL) ? nodestr : "",
458 "/proc", dirp->d_name);
459 pid = atoi (dirp->d_name);
460 }
461 while (pid == 0);
462
463 /* Open the procfs path. */
464 scoped_fd fd (open (buf, O_RDONLY));
465 if (fd.get () == -1)
466 {
467 gdb_printf (gdb_stderr, "failed to open %s - %d (%s)\n",
468 buf, errno, safe_strerror (errno));
469 continue;
470 }
471
472 pidinfo = (procfs_info *) buf;
473 if (devctl (fd.get (), DCMD_PROC_INFO, pidinfo, sizeof (buf), 0) != EOK)
474 {
476 "devctl DCMD_PROC_INFO failed - %d (%s)\n",
477 errno, safe_strerror (errno));
478 break;
479 }
480 num_threads = pidinfo->num_threads;
481
482 info = (procfs_debuginfo *) buf;
483 if (devctl (fd.get (), DCMD_PROC_MAPDEBUG_BASE, info, sizeof (buf), 0)
484 != EOK)
485 strcpy (name, "unavailable");
486 else
487 strcpy (name, info->path);
488
489 /* Collect state info on all the threads. */
490 status = (procfs_status *) buf;
491 for (status->tid = 1; status->tid <= num_threads; status->tid++)
492 {
493 const int err
494 = devctl (fd.get (), DCMD_PROC_TIDSTATUS, status, sizeof (buf), 0);
495 gdb_printf ("%s - %d", name, pid);
496 if (err == EOK && status->tid != 0)
497 gdb_printf ("/%d\n", status->tid);
498 else
499 {
500 gdb_printf ("\n");
501 break;
502 }
503 }
504 }
505 while (dirp != NULL);
506}
507
508static void
509procfs_meminfo (const char *args, int from_tty)
510{
511 procfs_mapinfo *mapinfos = NULL;
512 static int num_mapinfos = 0;
513 procfs_mapinfo *mapinfo_p, *mapinfo_p2;
514 int flags = ~0, err, num, i, j;
515
516 struct
517 {
518 procfs_debuginfo info;
519 char buff[_POSIX_PATH_MAX];
520 } map;
521
522 struct info
523 {
524 unsigned addr;
525 unsigned size;
526 unsigned flags;
527 unsigned debug_vaddr;
528 unsigned long long offset;
529 };
530
531 struct printinfo
532 {
533 unsigned long long ino;
534 unsigned dev;
535 struct info text;
536 struct info data;
537 char name[256];
538 } printme;
539
540 /* Get the number of map entrys. */
541 err = devctl (ctl_fd, DCMD_PROC_MAPINFO, NULL, 0, &num);
542 if (err != EOK)
543 {
544 printf ("failed devctl num mapinfos - %d (%s)\n", err,
545 safe_strerror (err));
546 return;
547 }
548
549 mapinfos = XNEWVEC (procfs_mapinfo, num);
550
551 num_mapinfos = num;
552 mapinfo_p = mapinfos;
553
554 /* Fill the map entrys. */
555 err = devctl (ctl_fd, DCMD_PROC_MAPINFO, mapinfo_p, num
556 * sizeof (procfs_mapinfo), &num);
557 if (err != EOK)
558 {
559 printf ("failed devctl mapinfos - %d (%s)\n", err, safe_strerror (err));
560 xfree (mapinfos);
561 return;
562 }
563
564 num = std::min (num, num_mapinfos);
565
566 /* Run through the list of mapinfos, and store the data and text info
567 so we can print it at the bottom of the loop. */
568 for (mapinfo_p = mapinfos, i = 0; i < num; i++, mapinfo_p++)
569 {
570 if (!(mapinfo_p->flags & flags))
571 mapinfo_p->ino = 0;
572
573 if (mapinfo_p->ino == 0) /* Already visited. */
574 continue;
575
576 map.info.vaddr = mapinfo_p->vaddr;
577
578 err = devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0);
579 if (err != EOK)
580 continue;
581
582 memset (&printme, 0, sizeof printme);
583 printme.dev = mapinfo_p->dev;
584 printme.ino = mapinfo_p->ino;
585 printme.text.addr = mapinfo_p->vaddr;
586 printme.text.size = mapinfo_p->size;
587 printme.text.flags = mapinfo_p->flags;
588 printme.text.offset = mapinfo_p->offset;
589 printme.text.debug_vaddr = map.info.vaddr;
590 strcpy (printme.name, map.info.path);
591
592 /* Check for matching data. */
593 for (mapinfo_p2 = mapinfos, j = 0; j < num; j++, mapinfo_p2++)
594 {
595 if (mapinfo_p2->vaddr != mapinfo_p->vaddr
596 && mapinfo_p2->ino == mapinfo_p->ino
597 && mapinfo_p2->dev == mapinfo_p->dev)
598 {
599 map.info.vaddr = mapinfo_p2->vaddr;
600 err =
601 devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0);
602 if (err != EOK)
603 continue;
604
605 if (strcmp (map.info.path, printme.name))
606 continue;
607
608 /* Lower debug_vaddr is always text, if necessary, swap. */
609 if ((int) map.info.vaddr < (int) printme.text.debug_vaddr)
610 {
611 memcpy (&(printme.data), &(printme.text),
612 sizeof (printme.data));
613 printme.text.addr = mapinfo_p2->vaddr;
614 printme.text.size = mapinfo_p2->size;
615 printme.text.flags = mapinfo_p2->flags;
616 printme.text.offset = mapinfo_p2->offset;
617 printme.text.debug_vaddr = map.info.vaddr;
618 }
619 else
620 {
621 printme.data.addr = mapinfo_p2->vaddr;
622 printme.data.size = mapinfo_p2->size;
623 printme.data.flags = mapinfo_p2->flags;
624 printme.data.offset = mapinfo_p2->offset;
625 printme.data.debug_vaddr = map.info.vaddr;
626 }
627 mapinfo_p2->ino = 0;
628 }
629 }
630 mapinfo_p->ino = 0;
631
632 gdb_printf ("%s\n", printme.name);
633 gdb_printf ("\ttext=%08x bytes @ 0x%08x\n", printme.text.size,
634 printme.text.addr);
635 gdb_printf ("\t\tflags=%08x\n", printme.text.flags);
636 gdb_printf ("\t\tdebug=%08x\n", printme.text.debug_vaddr);
637 gdb_printf ("\t\toffset=%s\n", phex (printme.text.offset, 8));
638 if (printme.data.size)
639 {
640 gdb_printf ("\tdata=%08x bytes @ 0x%08x\n", printme.data.size,
641 printme.data.addr);
642 gdb_printf ("\t\tflags=%08x\n", printme.data.flags);
643 gdb_printf ("\t\tdebug=%08x\n", printme.data.debug_vaddr);
644 gdb_printf ("\t\toffset=%s\n", phex (printme.data.offset, 8));
645 }
646 gdb_printf ("\tdev=0x%x\n", printme.dev);
647 gdb_printf ("\tino=0x%x\n", (unsigned int) printme.ino);
648 }
649 xfree (mapinfos);
650 return;
651}
652
653/* Print status information about what we're accessing. */
654void
656{
657 struct inferior *inf = current_inferior ();
658
659 gdb_printf ("\tUsing the running image of %s %s via %s.\n",
660 inf->attach_flag ? "attached" : "child",
661 target_pid_to_str (ptid_t (inf->pid)).c_str (),
662 (nodestr != NULL) ? nodestr : "local node");
663}
664
665/* Target to_pid_to_exec_file implementation. */
666
667const char *
669{
670 int proc_fd;
671 static char proc_path[PATH_MAX];
672 ssize_t rd;
673
674 /* Read exe file name. */
675 snprintf (proc_path, sizeof (proc_path), "%s/proc/%d/exefile",
676 (nodestr != NULL) ? nodestr : "", pid);
677 proc_fd = open (proc_path, O_RDONLY);
678 if (proc_fd == -1)
679 return NULL;
680
681 rd = read (proc_fd, proc_path, sizeof (proc_path) - 1);
682 close (proc_fd);
683 if (rd <= 0)
684 {
685 proc_path[0] = '\0';
686 return NULL;
687 }
688 proc_path[rd] = '\0';
689 return proc_path;
690}
691
692/* Attach to process PID, then initialize for debugging it. */
693void
694nto_procfs_target::attach (const char *args, int from_tty)
695{
696 int pid;
697 struct inferior *inf;
698
699 pid = parse_pid_to_attach (args);
700
701 if (pid == getpid ())
702 error (_("Attaching GDB to itself is not a good idea..."));
703
704 target_announce_attach (from_tty, pid);
705
706 ptid_t ptid = do_attach (ptid_t (pid));
709 inf->attach_flag = true;
710
711 if (!inf->target_is_pushed (ops))
712 inf->push_target (ops);
713
715
716 switch_to_thread (this->find_thread (ptid));
717}
718
719void
725
726static ptid_t
727do_attach (ptid_t ptid)
728{
729 procfs_status status;
730 struct sigevent event;
731 char path[PATH_MAX];
732
733 snprintf (path, PATH_MAX - 1, "%s%s/%d/as",
734 (nodestr != NULL) ? nodestr : "", "/proc", ptid.pid ());
735 ctl_fd = open (path, O_RDWR);
736 if (ctl_fd == -1)
737 error (_("Couldn't open proc file %s, error %d (%s)"), path, errno,
738 safe_strerror (errno));
739 if (devctl (ctl_fd, DCMD_PROC_STOP, &status, sizeof (status), 0) != EOK)
740 error (_("Couldn't stop process"));
741
742 /* Define a sigevent for process stopped notification. */
743 event.sigev_notify = SIGEV_SIGNAL_THREAD;
744 event.sigev_signo = SIGUSR1;
745 event.sigev_code = 0;
746 event.sigev_value.sival_ptr = NULL;
747 event.sigev_priority = -1;
748 devctl (ctl_fd, DCMD_PROC_EVENT, &event, sizeof (event), 0);
749
750 if (devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0) == EOK
751 && status.flags & _DEBUG_FLAG_STOPPED)
752 SignalKill (nto_node (), ptid.pid (), 0, SIGCONT, 0, 0);
754 return ptid_t (ptid.pid (), 0, status.tid);
755}
756
757/* Ask the user what to do when an interrupt is received. */
758static void
760{
761 if (query (_("Interrupted while waiting for the program.\n\
762Give up (and stop debugging it)? ")))
763 {
765 quit ();
766 }
767}
768
769/* The user typed ^C twice. */
770static void
772{
773 signal (signo, ofunc);
775 signal (signo, nto_handle_sigint_twice);
776}
777
778static void
780{
781 /* If this doesn't work, try more severe steps. */
782 signal (signo, nto_handle_sigint_twice);
783
785}
786
787sptid_t
788nto_procfs_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
789 target_wait_flags options)
790{
791 sigset_t set;
792 siginfo_t info;
793 procfs_status status;
794 static int exit_signo = 0; /* To track signals that cause termination. */
795
796 ourstatus->set_spurious ();
797
798 if (inferior_ptid == null_ptid)
799 {
800 ourstatus->set_stopped (GDB_SIGNAL_0);
801 exit_signo = 0;
802 return null_ptid;
803 }
804
805 sigemptyset (&set);
806 sigaddset (&set, SIGUSR1);
807
808 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
809 while (!(status.flags & _DEBUG_FLAG_ISTOP))
810 {
811 ofunc = signal (SIGINT, nto_handle_sigint);
812 sigwaitinfo (&set, &info);
813 signal (SIGINT, ofunc);
814 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
815 }
816
817 nto_inferior_data (NULL)->stopped_flags = status.flags;
819
820 if (status.flags & _DEBUG_FLAG_SSTEP)
821 ourstatus->set_stopped (GDB_SIGNAL_TRAP);
822 /* Was it a breakpoint? */
823 else if (status.flags & _DEBUG_FLAG_TRACE)
824 ourstatus->set_stopped (GDB_SIGNAL_TRAP);
825 else if (status.flags & _DEBUG_FLAG_ISTOP)
826 {
827 switch (status.why)
828 {
829 case _DEBUG_WHY_SIGNALLED:
830 ourstatus->set_stopped (gdb_signal_from_host (status.info.si_signo));
831 exit_signo = 0;
832 break;
833 case _DEBUG_WHY_FAULTED:
834 if (status.info.si_signo == SIGTRAP)
835 {
836 ourstatus->set_stopped (0);
837 exit_signo = 0;
838 }
839 else
840 {
841 ourstatus->set_stopped
842 (gdb_signal_from_host (status.info.si_signo));
843 exit_signo = ourstatus->sig ();
844 }
845 break;
846
847 case _DEBUG_WHY_TERMINATED:
848 {
849 int waitval = 0;
850
851 waitpid (inferior_ptid.pid (), &waitval, WNOHANG);
852 if (exit_signo)
853 {
854 /* Abnormal death. */
855 ourstatus->set_signalled (exit_signo);
856 }
857 else
858 {
859 /* Normal death. */
860 ourstatus->set_exited (WEXITSTATUS (waitval));
861 }
862 exit_signo = 0;
863 break;
864 }
865
866 case _DEBUG_WHY_REQUESTED:
867 /* We are assuming a requested stop is due to a SIGINT. */
868 ourstatus->set_stopped (GDB_SIGNAL_INT);
869 exit_signo = 0;
870 break;
871 }
872 }
873
874 return ptid_t (status.pid, 0, status.tid);
875}
876
877/* Read the current values of the inferior's registers, both the
878 general register set and floating point registers (if supported)
879 and update gdb's idea of their current values. */
880void
882{
883 union
884 {
885 procfs_greg greg;
886 procfs_fpreg fpreg;
887 procfs_altreg altreg;
888 }
889 reg;
890 int regsize;
891
893 if (devctl (ctl_fd, DCMD_PROC_GETGREG, &reg, sizeof (reg), &regsize) == EOK)
894 nto_supply_gregset (regcache, (char *) &reg.greg);
895 if (devctl (ctl_fd, DCMD_PROC_GETFPREG, &reg, sizeof (reg), &regsize)
896 == EOK)
897 nto_supply_fpregset (regcache, (char *) &reg.fpreg);
898 if (devctl (ctl_fd, DCMD_PROC_GETALTREG, &reg, sizeof (reg), &regsize)
899 == EOK)
900 nto_supply_altregset (regcache, (char *) &reg.altreg);
901}
902
903/* Helper for procfs_xfer_partial that handles memory transfers.
904 Arguments are like target_xfer_partial. */
905
906static enum target_xfer_status
907procfs_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
908 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
909{
910 int nbytes;
911
912 if (lseek (ctl_fd, (off_t) memaddr, SEEK_SET) != (off_t) memaddr)
913 return TARGET_XFER_E_IO;
914
915 if (writebuf != NULL)
916 nbytes = write (ctl_fd, writebuf, len);
917 else
918 nbytes = read (ctl_fd, readbuf, len);
919 if (nbytes <= 0)
920 return TARGET_XFER_E_IO;
921 *xfered_len = nbytes;
922 return TARGET_XFER_OK;
923}
924
925/* Target to_xfer_partial implementation. */
926
929 const char *annex, gdb_byte *readbuf,
930 const gdb_byte *writebuf, ULONGEST offset,
931 ULONGEST len, ULONGEST *xfered_len)
932{
933 switch (object)
934 {
936 return procfs_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
938 if (readbuf != NULL)
939 {
940 int err;
941 CORE_ADDR initial_stack;
942 debug_process_t procinfo;
943 /* For 32-bit architecture, size of auxv_t is 8 bytes. */
944 const unsigned int sizeof_auxv_t = sizeof (auxv_t);
945 const unsigned int sizeof_tempbuf = 20 * sizeof_auxv_t;
946 int tempread;
947 gdb_byte *const tempbuf = alloca (sizeof_tempbuf);
948
949 if (tempbuf == NULL)
950 return TARGET_XFER_E_IO;
951
952 err = devctl (ctl_fd, DCMD_PROC_INFO, &procinfo,
953 sizeof procinfo, 0);
954 if (err != EOK)
955 return TARGET_XFER_E_IO;
956
957 initial_stack = procinfo.initial_stack;
958
959 /* procfs is always 'self-hosted', no byte-order manipulation. */
960 tempread = nto_read_auxv_from_initial_stack (initial_stack, tempbuf,
961 sizeof_tempbuf,
962 sizeof (auxv_t));
963 tempread = std::min (tempread, len) - offset;
964 memcpy (readbuf, tempbuf + offset, tempread);
965 *xfered_len = tempread;
966 return tempread ? TARGET_XFER_OK : TARGET_XFER_EOF;
967 }
968 /* Fallthru */
969 default:
970 return this->beneath ()->xfer_partial (object, annex,
971 readbuf, writebuf, offset, len,
972 xfered_len);
973 }
974}
975
976/* Take a program previously attached to and detaches it.
977 The program resumes execution and will no longer stop
978 on signals, etc. We'd better not have left any breakpoints
979 in the program or it'll die when it hits one. */
980void
982{
984
985 if (siggnal)
986 SignalKill (nto_node (), inf->pid, 0, 0, 0, 0);
987
988 close (ctl_fd);
989 ctl_fd = -1;
990
994 inf_child_maybe_unpush_target (ops);
995}
996
997static int
998procfs_breakpoint (CORE_ADDR addr, int type, int size)
999{
1000 procfs_break brk;
1001
1002 brk.type = type;
1003 brk.addr = addr;
1004 brk.size = size;
1005 errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
1006 if (errno != EOK)
1007 return 1;
1008 return 0;
1009}
1010
1011int
1013 struct bp_target_info *bp_tgt)
1014{
1015 bp_tgt->placed_address = bp_tgt->reqstd_address;
1016 return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, 0);
1017}
1018
1019int
1021 struct bp_target_info *bp_tgt,
1022 enum remove_bp_reason reason)
1023{
1024 return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, -1);
1025}
1026
1027int
1029 struct bp_target_info *bp_tgt)
1030{
1031 bp_tgt->placed_address = bp_tgt->reqstd_address;
1032 return procfs_breakpoint (bp_tgt->placed_address,
1033 _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, 0);
1034}
1035
1036int
1038 struct bp_target_info *bp_tgt)
1039{
1040 return procfs_breakpoint (bp_tgt->placed_address,
1041 _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, -1);
1042}
1043
1044void
1045nto_procfs_target::resume (ptid_t ptid, int step, enum gdb_signal signo)
1046{
1047 int signal_to_pass;
1048 procfs_status status;
1049 sigset_t *run_fault = (sigset_t *) (void *) &run.fault;
1050
1051 if (inferior_ptid == null_ptid)
1052 return;
1053
1054 procfs_set_thread (ptid == minus_one_ptid ? inferior_ptid :
1055 ptid);
1056
1057 run.flags = _DEBUG_RUN_FAULT | _DEBUG_RUN_TRACE;
1058 if (step)
1059 run.flags |= _DEBUG_RUN_STEP;
1060
1061 sigemptyset (run_fault);
1062 sigaddset (run_fault, FLTBPT);
1063 sigaddset (run_fault, FLTTRACE);
1064 sigaddset (run_fault, FLTILL);
1065 sigaddset (run_fault, FLTPRIV);
1066 sigaddset (run_fault, FLTBOUNDS);
1067 sigaddset (run_fault, FLTIOVF);
1068 sigaddset (run_fault, FLTIZDIV);
1069 sigaddset (run_fault, FLTFPE);
1070 /* Peter V will be changing this at some point. */
1071 sigaddset (run_fault, FLTPAGE);
1072
1073 run.flags |= _DEBUG_RUN_ARM;
1074
1075 signal_to_pass = gdb_signal_to_host (signo);
1076
1077 if (signal_to_pass)
1078 {
1079 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
1080 signal_to_pass = gdb_signal_to_host (signo);
1081 if (status.why & (_DEBUG_WHY_SIGNALLED | _DEBUG_WHY_FAULTED))
1082 {
1083 if (signal_to_pass != status.info.si_signo)
1084 {
1085 SignalKill (nto_node (), inferior_ptid.pid (), 0,
1086 signal_to_pass, 0, 0);
1087 run.flags |= _DEBUG_RUN_CLRFLT | _DEBUG_RUN_CLRSIG;
1088 }
1089 else /* Let it kill the program without telling us. */
1090 sigdelset (&run.trace, signal_to_pass);
1091 }
1092 }
1093 else
1094 run.flags |= _DEBUG_RUN_CLRSIG | _DEBUG_RUN_CLRFLT;
1095
1096 errno = devctl (ctl_fd, DCMD_PROC_RUN, &run, sizeof (run), 0);
1097 if (errno != EOK)
1098 {
1099 perror (_("run error!\n"));
1100 return;
1101 }
1102}
1103
1104void
1106{
1107 if (inferior_ptid != null_ptid)
1108 {
1109 SignalKill (nto_node (), inferior_ptid.pid (), 0, SIGKILL, 0, 0);
1110 close (ctl_fd);
1111 }
1114 inf_child_mourn_inferior (ops);
1115}
1116
1117/* This function breaks up an argument string into an argument
1118 vector suitable for passing to execvp().
1119 E.g., on "run a b c d" this routine would get as input
1120 the string "a b c d", and as output it would fill in argv with
1121 the four arguments "a", "b", "c", "d". The only additional
1122 functionality is simple quoting. The gdb command:
1123 run a "b c d" f
1124 will fill in argv with the three args "a", "b c d", "e". */
1125static void
1126breakup_args (char *scratch, char **argv)
1127{
1128 char *pp, *cp = scratch;
1129 char quoting = 0;
1130
1131 for (;;)
1132 {
1133 /* Scan past leading separators. */
1134 quoting = 0;
1135 while (*cp == ' ' || *cp == '\t' || *cp == '\n')
1136 cp++;
1137
1138 /* Break if at end of string. */
1139 if (*cp == '\0')
1140 break;
1141
1142 /* Take an arg. */
1143 if (*cp == '"')
1144 {
1145 cp++;
1146 quoting = strchr (cp, '"') ? 1 : 0;
1147 }
1148
1149 *argv++ = cp;
1150
1151 /* Scan for next arg separator. */
1152 pp = cp;
1153 if (quoting)
1154 cp = strchr (pp, '"');
1155 if ((cp == NULL) || (!quoting))
1156 cp = strchr (pp, ' ');
1157 if (cp == NULL)
1158 cp = strchr (pp, '\t');
1159 if (cp == NULL)
1160 cp = strchr (pp, '\n');
1161
1162 /* No separators => end of string => break. */
1163 if (cp == NULL)
1164 {
1165 pp = cp;
1166 break;
1167 }
1168
1169 /* Replace the separator with a terminator. */
1170 *cp++ = '\0';
1171 }
1172
1173 /* Execv requires a null-terminated arg vector. */
1174 *argv = NULL;
1175}
1176
1177void
1179 const std::string &allargs,
1180 char **env, int from_tty)
1181{
1182 struct inheritance inherit;
1183 pid_t pid;
1184 int flags, errn;
1185 char **argv, *args;
1186 const char *in = "", *out = "", *err = "";
1187 int fd, fds[3];
1188 sigset_t set;
1189 struct inferior *inf;
1190
1191 argv = xmalloc ((allargs.size () / (unsigned) 2 + 2) *
1192 sizeof (*argv));
1193 argv[0] = const_cast<char *> (get_exec_file (1));
1194 if (!argv[0])
1195 {
1196 if (exec_file)
1197 argv[0] = exec_file;
1198 else
1199 return;
1200 }
1201
1202 args = xstrdup (allargs.c_str ());
1203 breakup_args (args, (exec_file != NULL) ? &argv[1] : &argv[0]);
1204
1205 argv = nto_parse_redirection (argv, &in, &out, &err);
1206
1207 fds[0] = STDIN_FILENO;
1208 fds[1] = STDOUT_FILENO;
1209 fds[2] = STDERR_FILENO;
1210
1211 /* If the user specified I/O via gdb's --tty= arg, use it, but only
1212 if the i/o is not also being specified via redirection. */
1213 const char *inferior_tty = current_inferior ()->tty ();
1214 if (inferior_tty != nullptr)
1215 {
1216 if (!in[0])
1217 in = inferior_tty;
1218 if (!out[0])
1219 out = inferior_tty;
1220 if (!err[0])
1221 err = inferior_tty;
1222 }
1223
1224 if (in[0])
1225 {
1226 fd = open (in, O_RDONLY);
1227 if (fd == -1)
1228 perror (in);
1229 else
1230 fds[0] = fd;
1231 }
1232 if (out[0])
1233 {
1234 fd = open (out, O_WRONLY);
1235 if (fd == -1)
1236 perror (out);
1237 else
1238 fds[1] = fd;
1239 }
1240 if (err[0])
1241 {
1242 fd = open (err, O_WRONLY);
1243 if (fd == -1)
1244 perror (err);
1245 else
1246 fds[2] = fd;
1247 }
1248
1249 /* Clear any pending SIGUSR1's but keep the behavior the same. */
1250 signal (SIGUSR1, signal (SIGUSR1, SIG_IGN));
1251
1252 sigemptyset (&set);
1253 sigaddset (&set, SIGUSR1);
1254 sigprocmask (SIG_UNBLOCK, &set, NULL);
1255
1256 memset (&inherit, 0, sizeof (inherit));
1257
1258 if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) != 0)
1259 {
1260 inherit.nd = nto_node ();
1261 inherit.flags |= SPAWN_SETND;
1262 inherit.flags &= ~SPAWN_EXEC;
1263 }
1264 inherit.flags |= SPAWN_SETGROUP | SPAWN_HOLD;
1265 inherit.pgroup = SPAWN_NEWPGROUP;
1266 pid = spawnp (argv[0], 3, fds, &inherit, argv,
1267 ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0 ? env : 0);
1268 xfree (args);
1269
1270 sigprocmask (SIG_BLOCK, &set, NULL);
1271
1272 if (pid == -1)
1273 error (_("Error spawning %s: %d (%s)"), argv[0], errno,
1274 safe_strerror (errno));
1275
1276 if (fds[0] != STDIN_FILENO)
1277 close (fds[0]);
1278 if (fds[1] != STDOUT_FILENO)
1279 close (fds[1]);
1280 if (fds[2] != STDERR_FILENO)
1281 close (fds[2]);
1282
1283 ptid_t ptid = do_attach (ptid_t (pid));
1285 switch_to_thread (this->find_thread (ptid));
1286
1287 inf = current_inferior ();
1289 inf->attach_flag = false;
1290
1291 flags = _DEBUG_FLAG_KLC; /* Kill-on-Last-Close flag. */
1292 errn = devctl (ctl_fd, DCMD_PROC_SET_FLAG, &flags, sizeof (flags), 0);
1293 if (errn != EOK)
1294 {
1295 /* FIXME: expected warning? */
1296 /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
1297 errn, safe_strerror(errn) ); */
1298 }
1299 if (!inf->target_is_pushed (ops))
1300 inf->push_target (ops);
1302
1303 if (current_program_space->exec_bfd () != NULL
1307}
1308
1309void
1311{
1312 devctl (ctl_fd, DCMD_PROC_STOP, NULL, 0, 0);
1313}
1314
1315void
1320
1321/* Fill buf with regset and return devctl cmd to do the setting. Return
1322 -1 if we fail to get the regset. Store size of regset in regsize. */
1323static int
1324get_regset (int regset, char *buf, int bufsize, int *regsize)
1325{
1326 int dev_get, dev_set;
1327 switch (regset)
1328 {
1329 case NTO_REG_GENERAL:
1330 dev_get = DCMD_PROC_GETGREG;
1331 dev_set = DCMD_PROC_SETGREG;
1332 break;
1333
1334 case NTO_REG_FLOAT:
1335 dev_get = DCMD_PROC_GETFPREG;
1336 dev_set = DCMD_PROC_SETFPREG;
1337 break;
1338
1339 case NTO_REG_ALT:
1340 dev_get = DCMD_PROC_GETALTREG;
1341 dev_set = DCMD_PROC_SETALTREG;
1342 break;
1343
1344 case NTO_REG_SYSTEM:
1345 default:
1346 return -1;
1347 }
1348 if (devctl (ctl_fd, dev_get, buf, bufsize, regsize) != EOK)
1349 return -1;
1350
1351 return dev_set;
1352}
1353
1354void
1356{
1357 union
1358 {
1359 procfs_greg greg;
1360 procfs_fpreg fpreg;
1361 procfs_altreg altreg;
1362 }
1363 reg;
1364 unsigned off;
1365 int len, regset, regsize, dev_set, err;
1366 char *data;
1367 ptid_t ptid = regcache->ptid ();
1368
1369 if (ptid == null_ptid)
1370 return;
1371 procfs_set_thread (ptid);
1372
1373 if (regno == -1)
1374 {
1376 {
1377 dev_set = get_regset (regset, (char *) &reg,
1378 sizeof (reg), &regsize);
1379 if (dev_set == -1)
1380 continue;
1381
1382 if (nto_regset_fill (regcache, regset, (char *) &reg) == -1)
1383 continue;
1384
1385 err = devctl (ctl_fd, dev_set, &reg, regsize, 0);
1386 if (err != EOK)
1388 "Warning unable to write regset %d: %s\n",
1389 regno, safe_strerror (err));
1390 }
1391 }
1392 else
1393 {
1394 regset = nto_regset_id (regno);
1395 if (regset == -1)
1396 return;
1397
1398 dev_set = get_regset (regset, (char *) &reg, sizeof (reg), &regsize);
1399 if (dev_set == -1)
1400 return;
1401
1402 len = nto_register_area (regcache->arch (),
1403 regno, regset, &off);
1404
1405 if (len < 1)
1406 return;
1407
1408 regcache->raw_collect (regno, (char *) &reg + off);
1409
1410 err = devctl (ctl_fd, dev_set, &reg, regsize, 0);
1411 if (err != EOK)
1413 "Warning unable to write regset %d: %s\n", regno,
1414 safe_strerror (err));
1415 }
1416}
1417
1418/* Set list of signals to be handled in the target. */
1419
1420void
1422 (gdb::array_view<const unsigned char> pass_signals)
1423{
1424 int signo;
1425
1426 sigfillset (&run.trace);
1427
1428 for (signo = 1; signo < NSIG; signo++)
1429 {
1430 int target_signo = gdb_signal_from_host (signo);
1431 if (target_signo < pass_signals.size () && pass_signals[target_signo])
1432 sigdelset (&run.trace, signo);
1433 }
1434}
1435
1436std::string
1438{
1439 int pid, tid;
1440 struct tidinfo *tip;
1441
1442 pid = ptid.pid ();
1443 tid = ptid.tid ();
1444
1445#if 0 /* NYI */
1446 tip = procfs_thread_info (pid, tid);
1447 if (tip != NULL)
1448 snprintf (&buf[n], 1023, " (state = 0x%02x)", tip->state);
1449#endif
1450
1451 return string_printf ("process %d", pid);
1452}
1453
1454/* to_can_run implementation for "target procfs". Note this really
1455 means "can this target be the default run target", which there can
1456 be only one, and we make it be "target native" like other ports.
1457 "target procfs <node>" wouldn't make sense as default run target, as
1458 it needs <node>. */
1459
1460int
1462{
1463 return 0;
1464}
1465
1466/* "target procfs". */
1468
1469/* "target native". */
1471
1472/* Create the "native" and "procfs" targets. */
1473
1474static void
1476{
1477 /* Register "target native". This is the default run target. */
1480
1481 /* Register "target procfs <node>". */
1483}
1484
1485#define OSTYPE_NTO 1
1486
1487void _initialize_procfs ();
1488void
1490{
1491 sigset_t set;
1492
1494
1495 /* We use SIGUSR1 to gain control after we block waiting for a process.
1496 We use sigwaitevent to wait. */
1497 sigemptyset (&set);
1498 sigaddset (&set, SIGUSR1);
1499 sigprocmask (SIG_BLOCK, &set, NULL);
1500
1501 /* Initially, make sure all signals are reported. */
1502 sigfillset (&run.trace);
1503
1504 /* Stuff some information. */
1505 nto_cpuinfo_flags = SYSPAGE_ENTRY (cpuinfo)->flags;
1507
1508 add_info ("pidlist", procfs_pidlist, _("pidlist"));
1509 add_info ("meminfo", procfs_meminfo, _("memory information"));
1510
1512}
1513
1514
1515static int
1516procfs_hw_watchpoint (int addr, int len, enum target_hw_bp_type type)
1517{
1518 procfs_break brk;
1519
1520 switch (type)
1521 {
1522 case hw_read:
1523 brk.type = _DEBUG_BREAK_RD;
1524 break;
1525 case hw_access:
1526 brk.type = _DEBUG_BREAK_RW;
1527 break;
1528 default: /* Modify. */
1529/* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason. */
1530 brk.type = _DEBUG_BREAK_RW;
1531 }
1532 brk.type |= _DEBUG_BREAK_HW; /* Always ask for HW. */
1533 brk.addr = addr;
1534 brk.size = len;
1535
1536 errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
1537 if (errno != EOK)
1538 {
1539 perror (_("Failed to set hardware watchpoint"));
1540 return -1;
1541 }
1542 return 0;
1543}
1544
1545bool
1547 int cnt, int othertype)
1548{
1549 return 1;
1550}
1551
1552int
1553nto_procfs_target::remove_hw_watchpoint (CORE_ADDR addr, int len,
1554 enum target_hw_bp_type type,
1555 struct expression *cond)
1556{
1557 return procfs_hw_watchpoint (addr, -1, type);
1558}
1559
1560int
1561nto_procfs_target::insert_hw_watchpoint (CORE_ADDR addr, int len,
1562 enum target_hw_bp_type type,
1563 struct expression *cond)
1564{
1565 return procfs_hw_watchpoint (addr, len, type);
1566}
1567
1568bool
1570{
1571 /* NOTE: nto_stopped_by_watchpoint will be called ONLY while we are
1572 stopped due to a SIGTRAP. This assumes gdb works in 'all-stop' mode;
1573 future gdb versions will likely run in 'non-stop' mode in which case
1574 we will have to store/examine statuses per thread in question.
1575 Until then, this will work fine. */
1576
1577 struct inferior *inf = current_inferior ();
1578 struct nto_inferior_data *inf_data;
1579
1580 gdb_assert (inf != NULL);
1581
1582 inf_data = nto_inferior_data (inf);
1583
1584 return inf_data->stopped_flags
1585 & (_DEBUG_FLAG_TRACE_RD
1586 | _DEBUG_FLAG_TRACE_WR
1587 | _DEBUG_FLAG_TRACE_MODIFY);
1588}
const char *const name
void * xmalloc(YYSIZE_T)
void xfree(void *)
struct gdbarch * target_gdbarch(void)
bptype
Definition breakpoint.h:84
remove_bp_reason
Definition breakpoint.h:64
static struct obstack tempbuf
Definition c-exp.c:4839
bool can_run() override
Definition inf-child.c:206
void close() override
Definition inf-child.c:183
const target_info & info() const override
Definition inf-child.c:49
int pid
Definition inferior.h:561
const std::string & args() const
Definition inferior.h:533
const std::string & tty()
Definition inferior.c:163
const target_info & info() const override
Definition nto-procfs.c:137
thread_info * find_thread(ptid_t ptid)
gdbarch * arch() const
Definition regcache.c:231
void raw_collect(int regnum, void *buf) const override
Definition regcache.c:1127
ptid_t ptid() const
Definition regcache.h:408
static void init()
Definition target.c:942
enum thread_state state
Definition gdbthread.h:339
private_thread_info_up priv
Definition gdbthread.h:528
struct cmd_list_element * add_info(const char *name, cmd_simple_func_ftype *fun, const char *doc)
const char * get_exec_file(int err)
Definition corefile.c:150
void quit(void)
Definition utils.c:634
#define SEEK_SET
Definition defs.h:101
ssize_t read(int fd, void *buf, size_t count)
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
Definition gdbarch.c:1387
struct thread_info * add_thread(process_stratum_target *targ, ptid_t ptid)
Definition thread.c:336
void switch_to_thread(struct thread_info *thr)
Definition thread.c:1360
void prune_threads(void)
Definition thread.c:737
void switch_to_no_thread()
Definition thread.c:1345
void init_thread_list(void)
Definition thread.c:257
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t err
Definition gnu-nat.c:1789
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 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
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition gnu-nat.c:1790
size_t size
Definition go32-nat.c:239
void inf_child_open_target(const char *arg, int from_tty)
Definition inf-child.c:152
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 update_thread_private_data(struct thread_info *new_thread, pthread_t tid, int state, int flags)
Definition nto-procfs.c:346
static void update_thread_private_data_name(struct thread_info *new_thread, const char *newname)
Definition nto-procfs.c:328
void _initialize_procfs()
static void interrupt_query(void)
Definition nto-procfs.c:759
static int get_regset(int regset, char *buf, int bufsize, int *regsize)
static void procfs_set_thread(ptid_t ptid)
Definition nto-procfs.c:290
static void breakup_args(char *scratch, char **argv)
static void nto_handle_sigint_twice(int signo)
Definition nto-procfs.c:771
static nto_procfs_target_native nto_native_ops
static sighandler_t ofunc
Definition nto-procfs.c:54
static void procfs_pidlist(const char *args, int from_tty)
Definition nto-procfs.c:422
#define _DEBUG_FLAG_TRACE
Definition nto-procfs.c:49
static unsigned nto_procfs_node
Definition nto-procfs.c:162
static enum target_xfer_status procfs_xfer_memory(gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
Definition nto-procfs.c:907
static void init_procfs_targets(void)
static enum gdb_osabi procfs_is_nto_target(bfd *abfd)
Definition nto-procfs.c:185
int ctl_fd
Definition nto-procfs.c:52
static nto_procfs_target_procfs nto_procfs_ops
static int procfs_breakpoint(CORE_ADDR addr, int type, int size)
Definition nto-procfs.c:998
static const target_info nto_native_target_info
Definition nto-procfs.c:129
static int procfs_hw_watchpoint(int addr, int len, enum target_hw_bp_type type)
static procfs_run run
Definition nto-procfs.c:56
static const target_info nto_procfs_target_info
Definition nto-procfs.c:143
static unsigned nto_node(void)
Definition nto-procfs.c:169
static void procfs_meminfo(const char *args, int from_tty)
Definition nto-procfs.c:509
static void nto_handle_sigint(int signo)
Definition nto-procfs.c:779
static char * nodestr
Definition nto-procfs.c:161
static ptid_t do_attach(ptid_t ptid)
Definition nto-procfs.c:727
LONGEST nto_read_auxv_from_initial_stack(CORE_ADDR initial_stack, gdb_byte *readbuf, LONGEST len, size_t sizeof_auxv_t)
Definition nto-tdep.c:421
void nto_init_solib_absolute_prefix(void)
Definition nto-tdep.c:157
char ** nto_parse_redirection(char *pargv[], const char **pin, const char **pout, const char **perr)
Definition nto-tdep.c:192
struct nto_inferior_data * nto_inferior_data(struct inferior *const inferior)
Definition nto-tdep.c:506
int nto_map_arch_to_cputype(const char *arch)
Definition nto-tdep.c:77
#define nto_regset_id
Definition nto-tdep.h:84
#define nto_supply_fpregset
Definition nto-tdep.h:88
#define nto_cpuinfo_flags
Definition nto-tdep.h:80
#define nto_register_area
Definition nto-tdep.h:94
#define nto_supply_gregset
Definition nto-tdep.h:86
#define nto_regset_fill
Definition nto-tdep.h:96
@ NTO_REG_FLOAT
Definition nto-tdep.h:125
@ NTO_REG_SYSTEM
Definition nto-tdep.h:126
@ NTO_REG_ALT
Definition nto-tdep.h:127
@ NTO_REG_GENERAL
Definition nto-tdep.h:124
@ NTO_REG_END
Definition nto-tdep.h:128
static nto_thread_info * get_nto_thread_info(thread_info *thread)
Definition nto-tdep.h:147
#define nto_cpuinfo_valid
Definition nto-tdep.h:82
#define nto_supply_altregset
Definition nto-tdep.h:90
#define nto_is_nto_target
Definition nto-tdep.h:101
gdb_osabi
Definition osabi.h:25
@ GDB_OSABI_QNXNTO
Definition osabi.h:38
struct procinfo procinfo
struct program_space * current_program_space
Definition progspace.c:40
enum var_types type
Definition scm-param.c:142
void solib_create_inferior_hook(int from_tty)
Definition solib.c:1252
CORE_ADDR placed_address
Definition breakpoint.h:266
CORE_ADDR reqstd_address
Definition breakpoint.h:269
Definition gnu-nat.c:153
pid_t pid
Definition gnu-nat.c:165
CORE_ADDR stopped_pc
Definition nto-tdep.h:159
unsigned int stopped_flags
Definition nto-tdep.h:156
const target_info & info() const override
Definition nto-procfs.c:151
ptid_t wait(ptid_t, struct target_waitstatus *, target_wait_flags) override
Definition nto-procfs.c:788
void attach(const char *, int) override=0
Definition nto-procfs.c:694
void detach(inferior *, int) override
Definition nto-procfs.c:981
int can_use_hw_breakpoint(enum bptype, int, int) override
int insert_hw_breakpoint(struct gdbarch *, struct bp_target_info *) override
void update_thread_list() override
Definition nto-procfs.c:383
std::string pid_to_str(ptid_t) override
int remove_hw_breakpoint(struct gdbarch *, struct bp_target_info *) override
void mourn_inferior() override
void interrupt() override
int remove_watchpoint(CORE_ADDR, int, enum target_hw_bp_type, struct expression *) override
void post_attach(int)
Definition nto-procfs.c:720
void store_registers(struct regcache *, int) override
int remove_breakpoint(struct gdbarch *, struct bp_target_info *, enum remove_bp_reason) override
void fetch_registers(struct regcache *, int) override
Definition nto-procfs.c:881
bool thread_alive(ptid_t ptid) override
Definition nto-procfs.c:301
const char * pid_to_exec_file(int pid) override
Definition nto-procfs.c:668
bool stopped_by_watchpoint() override
const char * extra_thread_info(struct thread_info *) override
void pass_signals(gdb::array_view< const unsigned char >) override
int insert_watchpoint(CORE_ADDR, int, enum target_hw_bp_type, struct expression *) override
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 nto-procfs.c:928
void files_info() override
Definition nto-procfs.c:655
int insert_breakpoint(struct gdbarch *, struct bp_target_info *) override
void kill() override
void open(const char *arg, int from_tty) override
Definition nto-procfs.c:195
void resume(ptid_t, int, enum gdb_signal) override
void create_inferior(const char *, const std::string &, char **, int) override
std::string name
Definition nto-tdep.h:143
unsigned char state
Definition nto-tdep.h:141
unsigned char flags
Definition nto-tdep.h:142
gdb_bfd_ref_ptr obfd
Definition objfiles.h:740
bfd * exec_bfd() const
Definition progspace.h:268
struct objfile * symfile_object_file
Definition progspace.h:357
target_ops * beneath() const
Definition target.c:3041
virtual 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) TARGET_DEFAULT_RETURN(TARGET_XFER_E_IO)
target_waitstatus & set_exited(int exit_status)
Definition waitstatus.h:222
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
void target_announce_detach(int from_tty)
Definition target.c:3622
void target_interrupt()
Definition target.c:3798
void add_target(const target_info &t, target_open_ftype *func, completer_ftype *completer)
Definition target.c:868
void set_native_target(target_ops *target)
Definition target.c:2874
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_preopen(int from_tty)
Definition target.c:2495
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
static struct thread_info * new_thread(struct inferior *inf, ptid_t ptid)
Definition thread.c:269
int query(const char *ctlstr,...)
Definition utils.c:943
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
#define gdb_stderr
Definition utils.h:187