GDB (xrefs)

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