1 /* Machine independent support for QNX Neutrino /proc (process file system)
2 for GDB. Written by Colin Burgess at QNX Software Systems Limited.
4 Copyright (C) 2003, 2006, 2007, 2008 Free Software Foundation, Inc.
6 Contributed by QNX Software Systems Ltd.
8 This file is part of GDB.
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.
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.
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/>. */
27 #include <sys/debug.h>
28 #include <sys/procfs.h>
29 #include <sys/neutrino.h>
30 #include <sys/syspage.h>
31 #include "gdb_dirent.h"
32 #include <sys/netmgr.h>
34 #include "exceptions.h"
35 #include "gdb_string.h"
40 #include "gdbthread.h"
47 #define _DEBUG_FLAG_TRACE (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\
48 _DEBUG_FLAG_TRACE_WR|_DEBUG_FLAG_TRACE_MODIFY)
50 static struct target_ops procfs_ops;
54 static void (*ofunc) ();
56 static procfs_run run;
58 static void procfs_open (char *, int);
60 static int procfs_can_run (void);
62 static ptid_t procfs_wait (ptid_t, struct target_waitstatus *);
64 static int procfs_xfer_memory (CORE_ADDR, gdb_byte *, int, int,
65 struct mem_attrib *attrib,
68 static void procfs_fetch_registers (struct regcache *, int);
70 static void notice_signals (void);
72 static void init_procfs_ops (void);
74 static ptid_t do_attach (ptid_t ptid);
76 static int procfs_can_use_hw_breakpoint (int, int, int);
78 static int procfs_insert_hw_watchpoint (CORE_ADDR addr, int len, int type);
80 static int procfs_remove_hw_watchpoint (CORE_ADDR addr, int len, int type);
82 static int procfs_stopped_by_watchpoint (void);
84 /* These two globals are only ever set in procfs_open(), but are
85 referenced elsewhere. 'nto_procfs_node' is a flag used to say
86 whether we are local, or we should get the current node descriptor
87 for the remote QNX node. */
88 static char nto_procfs_path[PATH_MAX] = { "/proc" };
89 static unsigned nto_procfs_node = ND_LOCAL_NODE;
91 /* Return the current QNX Node, or error out. This is a simple
92 wrapper for the netmgr_strtond() function. The reason this
93 is required is because QNX node descriptors are transient so
94 we have to re-acquire them every time. */
100 if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0)
101 return ND_LOCAL_NODE;
103 node = netmgr_strtond (nto_procfs_path, 0);
105 error (_("Lost the QNX node. Debug session probably over."));
110 static enum gdb_osabi
111 procfs_is_nto_target (bfd *abfd)
113 return GDB_OSABI_QNXNTO;
116 /* This is called when we call 'target procfs <arg>' from the (gdb) prompt.
117 For QNX6 (nto), the only valid arg will be a QNX node string,
118 eg: "/net/some_node". If arg is not a valid QNX node, we will
121 procfs_open (char *arg, int from_tty)
127 procfs_sysinfo *sysinfo;
129 nto_is_nto_target = procfs_is_nto_target;
131 /* Set the default node used for spawning to this one,
132 and only override it if there is a valid arg. */
134 nto_procfs_node = ND_LOCAL_NODE;
135 nodestr = arg ? xstrdup (arg) : arg;
141 nto_procfs_node = netmgr_strtond (nodestr, &endstr);
142 if (nto_procfs_node == -1)
144 if (errno == ENOTSUP)
145 printf_filtered ("QNX Net Manager not found.\n");
146 printf_filtered ("Invalid QNX node %s: error %d (%s).\n", nodestr,
147 errno, safe_strerror (errno));
150 nto_procfs_node = ND_LOCAL_NODE;
154 if (*(endstr - 1) == '/')
160 snprintf (nto_procfs_path, PATH_MAX - 1, "%s%s", nodestr ? nodestr : "",
165 fd = open (nto_procfs_path, O_RDONLY);
168 printf_filtered ("Error opening %s : %d (%s)\n", nto_procfs_path, errno,
169 safe_strerror (errno));
170 error (_("Invalid procfs arg"));
173 sysinfo = (void *) buffer;
174 if (devctl (fd, DCMD_PROC_SYSINFO, sysinfo, sizeof buffer, 0) != EOK)
176 printf_filtered ("Error getting size: %d (%s)\n", errno,
177 safe_strerror (errno));
179 error (_("Devctl failed."));
183 total_size = sysinfo->total_size;
184 sysinfo = alloca (total_size);
187 printf_filtered ("Memory error: %d (%s)\n", errno,
188 safe_strerror (errno));
190 error (_("alloca failed."));
194 if (devctl (fd, DCMD_PROC_SYSINFO, sysinfo, total_size, 0) != EOK)
196 printf_filtered ("Error getting sysinfo: %d (%s)\n", errno,
197 safe_strerror (errno));
199 error (_("Devctl failed."));
204 nto_map_arch_to_cputype (gdbarch_bfd_arch_info
205 (current_gdbarch)->arch_name))
208 error (_("Invalid target CPU."));
214 printf_filtered ("Debugging using %s\n", nto_procfs_path);
218 procfs_set_thread (ptid_t ptid)
222 tid = ptid_get_tid (ptid);
223 devctl (ctl_fd, DCMD_PROC_CURTHREAD, &tid, sizeof (tid), 0);
226 /* Return nonzero if the thread TH is still alive. */
228 procfs_thread_alive (ptid_t ptid)
232 tid = ptid_get_tid (ptid);
233 if (devctl (ctl_fd, DCMD_PROC_CURTHREAD, &tid, sizeof (tid), 0) == EOK)
239 procfs_find_new_threads (void)
241 procfs_status status;
248 pid = ptid_get_pid (inferior_ptid);
250 for (status.tid = 1;; ++status.tid)
252 if (devctl (ctl_fd, DCMD_PROC_TIDSTATUS, &status, sizeof (status), 0)
253 != EOK && status.tid != 0)
255 ptid = ptid_build (pid, 0, status.tid);
256 if (!in_thread_list (ptid))
263 procfs_pidlist (char *args, int from_tty)
266 struct dirent *dirp = NULL;
269 procfs_info *pidinfo = NULL;
270 procfs_debuginfo *info = NULL;
271 procfs_status *status = NULL;
272 pid_t num_threads = 0;
276 dp = opendir (nto_procfs_path);
279 fprintf_unfiltered (gdb_stderr, "failed to opendir \"%s\" - %d (%s)",
280 nto_procfs_path, errno, safe_strerror (errno));
284 /* Start scan at first pid. */
289 /* Get the right pid and procfs path for the pid. */
298 snprintf (buf, 511, "%s/%s/as", nto_procfs_path, dirp->d_name);
299 pid = atoi (dirp->d_name);
303 /* Open the procfs path. */
304 fd = open (buf, O_RDONLY);
307 fprintf_unfiltered (gdb_stderr, "failed to open %s - %d (%s)\n",
308 buf, errno, safe_strerror (errno));
313 pidinfo = (procfs_info *) buf;
314 if (devctl (fd, DCMD_PROC_INFO, pidinfo, sizeof (buf), 0) != EOK)
316 fprintf_unfiltered (gdb_stderr,
317 "devctl DCMD_PROC_INFO failed - %d (%s)\n",
318 errno, safe_strerror (errno));
321 num_threads = pidinfo->num_threads;
323 info = (procfs_debuginfo *) buf;
324 if (devctl (fd, DCMD_PROC_MAPDEBUG_BASE, info, sizeof (buf), 0) != EOK)
325 strcpy (name, "unavailable");
327 strcpy (name, info->path);
329 /* Collect state info on all the threads. */
330 status = (procfs_status *) buf;
331 for (status->tid = 1; status->tid <= num_threads; status->tid++)
333 if (devctl (fd, DCMD_PROC_TIDSTATUS, status, sizeof (buf), 0) != EOK
336 if (status->tid != 0)
337 printf_filtered ("%s - %d/%d\n", name, pid, status->tid);
341 while (dirp != NULL);
349 procfs_meminfo (char *args, int from_tty)
351 procfs_mapinfo *mapinfos = NULL;
352 static int num_mapinfos = 0;
353 procfs_mapinfo *mapinfo_p, *mapinfo_p2;
354 int flags = ~0, err, num, i, j;
358 procfs_debuginfo info;
359 char buff[_POSIX_PATH_MAX];
367 unsigned debug_vaddr;
368 unsigned long long offset;
373 unsigned long long ino;
380 /* Get the number of map entrys. */
381 err = devctl (ctl_fd, DCMD_PROC_MAPINFO, NULL, 0, &num);
384 printf ("failed devctl num mapinfos - %d (%s)\n", err,
385 safe_strerror (err));
389 mapinfos = xmalloc (num * sizeof (procfs_mapinfo));
392 mapinfo_p = mapinfos;
394 /* Fill the map entrys. */
395 err = devctl (ctl_fd, DCMD_PROC_MAPINFO, mapinfo_p, num
396 * sizeof (procfs_mapinfo), &num);
399 printf ("failed devctl mapinfos - %d (%s)\n", err, safe_strerror (err));
404 num = min (num, num_mapinfos);
406 /* Run through the list of mapinfos, and store the data and text info
407 so we can print it at the bottom of the loop. */
408 for (mapinfo_p = mapinfos, i = 0; i < num; i++, mapinfo_p++)
410 if (!(mapinfo_p->flags & flags))
413 if (mapinfo_p->ino == 0) /* Already visited. */
416 map.info.vaddr = mapinfo_p->vaddr;
418 err = devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0);
422 memset (&printme, 0, sizeof printme);
423 printme.dev = mapinfo_p->dev;
424 printme.ino = mapinfo_p->ino;
425 printme.text.addr = mapinfo_p->vaddr;
426 printme.text.size = mapinfo_p->size;
427 printme.text.flags = mapinfo_p->flags;
428 printme.text.offset = mapinfo_p->offset;
429 printme.text.debug_vaddr = map.info.vaddr;
430 strcpy (printme.name, map.info.path);
432 /* Check for matching data. */
433 for (mapinfo_p2 = mapinfos, j = 0; j < num; j++, mapinfo_p2++)
435 if (mapinfo_p2->vaddr != mapinfo_p->vaddr
436 && mapinfo_p2->ino == mapinfo_p->ino
437 && mapinfo_p2->dev == mapinfo_p->dev)
439 map.info.vaddr = mapinfo_p2->vaddr;
441 devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0);
445 if (strcmp (map.info.path, printme.name))
448 /* Lower debug_vaddr is always text, if nessessary, swap. */
449 if ((int) map.info.vaddr < (int) printme.text.debug_vaddr)
451 memcpy (&(printme.data), &(printme.text),
452 sizeof (printme.data));
453 printme.text.addr = mapinfo_p2->vaddr;
454 printme.text.size = mapinfo_p2->size;
455 printme.text.flags = mapinfo_p2->flags;
456 printme.text.offset = mapinfo_p2->offset;
457 printme.text.debug_vaddr = map.info.vaddr;
461 printme.data.addr = mapinfo_p2->vaddr;
462 printme.data.size = mapinfo_p2->size;
463 printme.data.flags = mapinfo_p2->flags;
464 printme.data.offset = mapinfo_p2->offset;
465 printme.data.debug_vaddr = map.info.vaddr;
472 printf_filtered ("%s\n", printme.name);
473 printf_filtered ("\ttext=%08x bytes @ 0x%08x\n", printme.text.size,
475 printf_filtered ("\t\tflags=%08x\n", printme.text.flags);
476 printf_filtered ("\t\tdebug=%08x\n", printme.text.debug_vaddr);
477 printf_filtered ("\t\toffset=%016llx\n", printme.text.offset);
478 if (printme.data.size)
480 printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme.data.size,
482 printf_filtered ("\t\tflags=%08x\n", printme.data.flags);
483 printf_filtered ("\t\tdebug=%08x\n", printme.data.debug_vaddr);
484 printf_filtered ("\t\toffset=%016llx\n", printme.data.offset);
486 printf_filtered ("\tdev=0x%x\n", printme.dev);
487 printf_filtered ("\tino=0x%x\n", (unsigned int) printme.ino);
493 /* Print status information about what we're accessing. */
495 procfs_files_info (struct target_ops *ignore)
497 printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
498 attach_flag ? "attached" : "child",
499 target_pid_to_str (inferior_ptid), nto_procfs_path);
502 /* Mark our target-struct as eligible for stray "run" and "attach" commands. */
504 procfs_can_run (void)
509 /* Attach to process PID, then initialize for debugging it. */
511 procfs_attach (char *args, int from_tty)
517 error_no_arg (_("process-id to attach"));
521 if (pid == getpid ())
522 error (_("Attaching GDB to itself is not a good idea..."));
526 exec_file = (char *) get_exec_file (0);
529 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
530 target_pid_to_str (pid_to_ptid (pid)));
532 printf_unfiltered ("Attaching to %s\n",
533 target_pid_to_str (pid_to_ptid (pid)));
535 gdb_flush (gdb_stdout);
537 inferior_ptid = do_attach (pid_to_ptid (pid));
538 procfs_find_new_threads ();
539 push_target (&procfs_ops);
543 procfs_post_attach (pid_t pid)
546 solib_create_inferior_hook ();
550 do_attach (ptid_t ptid)
552 procfs_status status;
553 struct sigevent event;
556 snprintf (path, PATH_MAX - 1, "%s/%d/as", nto_procfs_path, PIDGET (ptid));
557 ctl_fd = open (path, O_RDWR);
559 error (_("Couldn't open proc file %s, error %d (%s)"), path, errno,
560 safe_strerror (errno));
561 if (devctl (ctl_fd, DCMD_PROC_STOP, &status, sizeof (status), 0) != EOK)
562 error (_("Couldn't stop process"));
564 /* Define a sigevent for process stopped notification. */
565 event.sigev_notify = SIGEV_SIGNAL_THREAD;
566 event.sigev_signo = SIGUSR1;
567 event.sigev_code = 0;
568 event.sigev_value.sival_ptr = NULL;
569 event.sigev_priority = -1;
570 devctl (ctl_fd, DCMD_PROC_EVENT, &event, sizeof (event), 0);
572 if (devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0) == EOK
573 && status.flags & _DEBUG_FLAG_STOPPED)
574 SignalKill (nto_node (), PIDGET (ptid), 0, SIGCONT, 0, 0);
576 nto_init_solib_absolute_prefix ();
580 /* Ask the user what to do when an interrupt is received. */
582 interrupt_query (void)
584 target_terminal_ours ();
586 if (query ("Interrupted while waiting for the program.\n\
587 Give up (and stop debugging it)? "))
589 target_mourn_inferior ();
590 deprecated_throw_reason (RETURN_QUIT);
593 target_terminal_inferior ();
596 /* The user typed ^C twice. */
598 nto_interrupt_twice (int signo)
600 signal (signo, ofunc);
602 signal (signo, nto_interrupt_twice);
606 nto_interrupt (int signo)
608 /* If this doesn't work, try more severe steps. */
609 signal (signo, nto_interrupt_twice);
611 target_stop (inferior_ptid);
615 procfs_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
619 procfs_status status;
620 static int exit_signo = 0; /* To track signals that cause termination. */
622 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
624 if (ptid_equal (inferior_ptid, null_ptid))
626 ourstatus->kind = TARGET_WAITKIND_STOPPED;
627 ourstatus->value.sig = TARGET_SIGNAL_0;
633 sigaddset (&set, SIGUSR1);
635 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
636 while (!(status.flags & _DEBUG_FLAG_ISTOP))
638 ofunc = (void (*)()) signal (SIGINT, nto_interrupt);
639 sigwaitinfo (&set, &info);
640 signal (SIGINT, ofunc);
641 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
644 if (status.flags & _DEBUG_FLAG_SSTEP)
646 ourstatus->kind = TARGET_WAITKIND_STOPPED;
647 ourstatus->value.sig = TARGET_SIGNAL_TRAP;
649 /* Was it a breakpoint? */
650 else if (status.flags & _DEBUG_FLAG_TRACE)
652 ourstatus->kind = TARGET_WAITKIND_STOPPED;
653 ourstatus->value.sig = TARGET_SIGNAL_TRAP;
655 else if (status.flags & _DEBUG_FLAG_ISTOP)
659 case _DEBUG_WHY_SIGNALLED:
660 ourstatus->kind = TARGET_WAITKIND_STOPPED;
661 ourstatus->value.sig =
662 target_signal_from_host (status.info.si_signo);
665 case _DEBUG_WHY_FAULTED:
666 ourstatus->kind = TARGET_WAITKIND_STOPPED;
667 if (status.info.si_signo == SIGTRAP)
669 ourstatus->value.sig = 0;
674 ourstatus->value.sig =
675 target_signal_from_host (status.info.si_signo);
676 exit_signo = ourstatus->value.sig;
680 case _DEBUG_WHY_TERMINATED:
684 waitpid (PIDGET (inferior_ptid), &waitval, WNOHANG);
687 /* Abnormal death. */
688 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
689 ourstatus->value.sig = exit_signo;
694 ourstatus->kind = TARGET_WAITKIND_EXITED;
695 ourstatus->value.integer = WEXITSTATUS (waitval);
701 case _DEBUG_WHY_REQUESTED:
702 /* We are assuming a requested stop is due to a SIGINT. */
703 ourstatus->kind = TARGET_WAITKIND_STOPPED;
704 ourstatus->value.sig = TARGET_SIGNAL_INT;
710 return ptid_build (status.pid, 0, status.tid);
713 /* Read the current values of the inferior's registers, both the
714 general register set and floating point registers (if supported)
715 and update gdb's idea of their current values. */
717 procfs_fetch_registers (struct regcache *regcache, int regno)
723 procfs_altreg altreg;
728 procfs_set_thread (inferior_ptid);
729 if (devctl (ctl_fd, DCMD_PROC_GETGREG, ®, sizeof (reg), ®size) == EOK)
730 nto_supply_gregset (regcache, (char *) ®.greg);
731 if (devctl (ctl_fd, DCMD_PROC_GETFPREG, ®, sizeof (reg), ®size)
733 nto_supply_fpregset (regcache, (char *) ®.fpreg);
734 if (devctl (ctl_fd, DCMD_PROC_GETALTREG, ®, sizeof (reg), ®size)
736 nto_supply_altregset (regcache, (char *) ®.altreg);
739 /* Copy LEN bytes to/from inferior's memory starting at MEMADDR
740 from/to debugger memory starting at MYADDR. Copy from inferior
741 if DOWRITE is zero or to inferior if DOWRITE is nonzero.
743 Returns the length copied, which is either the LEN argument or
744 zero. This xfer function does not do partial moves, since procfs_ops
745 doesn't allow memory operations to cross below us in the target stack
748 procfs_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int dowrite,
749 struct mem_attrib *attrib, struct target_ops *target)
753 if (lseek (ctl_fd, (off_t) memaddr, SEEK_SET) == (off_t) memaddr)
756 nbytes = write (ctl_fd, myaddr, len);
758 nbytes = read (ctl_fd, myaddr, len);
765 /* Take a program previously attached to and detaches it.
766 The program resumes execution and will no longer stop
767 on signals, etc. We'd better not have left any breakpoints
768 in the program or it'll die when it hits one. */
770 procfs_detach (char *args, int from_tty)
776 char *exec_file = get_exec_file (0);
779 printf_unfiltered ("Detaching from program: %s %s\n",
780 exec_file, target_pid_to_str (inferior_ptid));
781 gdb_flush (gdb_stdout);
784 siggnal = atoi (args);
787 SignalKill (nto_node (), PIDGET (inferior_ptid), 0, siggnal, 0, 0);
792 inferior_ptid = null_ptid;
794 unpush_target (&procfs_ops); /* Pop out of handling an inferior. */
798 procfs_breakpoint (CORE_ADDR addr, int type, int size)
805 errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
812 procfs_insert_breakpoint (struct bp_target_info *bp_tgt)
814 return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, 0);
818 procfs_remove_breakpoint (struct bp_target_info *bp_tgt)
820 return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, -1);
824 procfs_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
826 return procfs_breakpoint (bp_tgt->placed_address,
827 _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, 0);
831 procfs_remove_hw_breakpoint (struct bp_target_info *bp_tgt)
833 return procfs_breakpoint (bp_tgt->placed_address,
834 _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, -1);
838 procfs_resume (ptid_t ptid, int step, enum target_signal signo)
841 procfs_status status;
842 sigset_t *run_fault = (sigset_t *) (void *) &run.fault;
844 if (ptid_equal (inferior_ptid, null_ptid))
847 procfs_set_thread (ptid_equal (ptid, minus_one_ptid) ? inferior_ptid :
850 run.flags = _DEBUG_RUN_FAULT | _DEBUG_RUN_TRACE;
852 run.flags |= _DEBUG_RUN_STEP;
854 sigemptyset (run_fault);
855 sigaddset (run_fault, FLTBPT);
856 sigaddset (run_fault, FLTTRACE);
857 sigaddset (run_fault, FLTILL);
858 sigaddset (run_fault, FLTPRIV);
859 sigaddset (run_fault, FLTBOUNDS);
860 sigaddset (run_fault, FLTIOVF);
861 sigaddset (run_fault, FLTIZDIV);
862 sigaddset (run_fault, FLTFPE);
863 /* Peter V will be changing this at some point. */
864 sigaddset (run_fault, FLTPAGE);
866 run.flags |= _DEBUG_RUN_ARM;
868 sigemptyset (&run.trace);
870 signal_to_pass = target_signal_to_host (signo);
874 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
875 signal_to_pass = target_signal_to_host (signo);
876 if (status.why & (_DEBUG_WHY_SIGNALLED | _DEBUG_WHY_FAULTED))
878 if (signal_to_pass != status.info.si_signo)
880 SignalKill (nto_node (), PIDGET (inferior_ptid), 0,
881 signal_to_pass, 0, 0);
882 run.flags |= _DEBUG_RUN_CLRFLT | _DEBUG_RUN_CLRSIG;
884 else /* Let it kill the program without telling us. */
885 sigdelset (&run.trace, signal_to_pass);
889 run.flags |= _DEBUG_RUN_CLRSIG | _DEBUG_RUN_CLRFLT;
891 errno = devctl (ctl_fd, DCMD_PROC_RUN, &run, sizeof (run), 0);
894 perror ("run error!\n");
900 procfs_mourn_inferior (void)
902 if (!ptid_equal (inferior_ptid, null_ptid))
904 SignalKill (nto_node (), PIDGET (inferior_ptid), 0, SIGKILL, 0, 0);
907 inferior_ptid = null_ptid;
909 unpush_target (&procfs_ops);
910 generic_mourn_inferior ();
914 /* This function breaks up an argument string into an argument
915 vector suitable for passing to execvp().
916 E.g., on "run a b c d" this routine would get as input
917 the string "a b c d", and as output it would fill in argv with
918 the four arguments "a", "b", "c", "d". The only additional
919 functionality is simple quoting. The gdb command:
921 will fill in argv with the three args "a", "b c d", "e". */
923 breakup_args (char *scratch, char **argv)
925 char *pp, *cp = scratch;
930 /* Scan past leading separators. */
932 while (*cp == ' ' || *cp == '\t' || *cp == '\n')
935 /* Break if at end of string. */
943 quoting = strchr (cp, '"') ? 1 : 0;
948 /* Scan for next arg separator. */
951 cp = strchr (pp, '"');
952 if ((cp == NULL) || (!quoting))
953 cp = strchr (pp, ' ');
955 cp = strchr (pp, '\t');
957 cp = strchr (pp, '\n');
959 /* No separators => end of string => break. */
966 /* Replace the separator with a terminator. */
970 /* Execv requires a null-terminated arg vector. */
975 procfs_create_inferior (char *exec_file, char *allargs, char **env,
978 struct inheritance inherit;
982 const char *in = "", *out = "", *err = "";
985 const char *inferior_io_terminal = get_inferior_io_terminal ();
987 argv = xmalloc (((strlen (allargs) + 1) / (unsigned) 2 + 2) *
989 argv[0] = get_exec_file (1);
998 args = xstrdup (allargs);
999 breakup_args (args, exec_file ? &argv[1] : &argv[0]);
1001 argv = nto_parse_redirection (argv, &in, &out, &err);
1003 fds[0] = STDIN_FILENO;
1004 fds[1] = STDOUT_FILENO;
1005 fds[2] = STDERR_FILENO;
1007 /* If the user specified I/O via gdb's --tty= arg, use it, but only
1008 if the i/o is not also being specified via redirection. */
1009 if (inferior_io_terminal)
1012 in = inferior_io_terminal;
1014 out = inferior_io_terminal;
1016 err = inferior_io_terminal;
1021 fd = open (in, O_RDONLY);
1029 fd = open (out, O_WRONLY);
1037 fd = open (err, O_WRONLY);
1044 /* Clear any pending SIGUSR1's but keep the behavior the same. */
1045 signal (SIGUSR1, signal (SIGUSR1, SIG_IGN));
1048 sigaddset (&set, SIGUSR1);
1049 sigprocmask (SIG_UNBLOCK, &set, NULL);
1051 memset (&inherit, 0, sizeof (inherit));
1053 if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) != 0)
1055 inherit.nd = nto_node ();
1056 inherit.flags |= SPAWN_SETND;
1057 inherit.flags &= ~SPAWN_EXEC;
1059 inherit.flags |= SPAWN_SETGROUP | SPAWN_HOLD;
1060 inherit.pgroup = SPAWN_NEWPGROUP;
1061 pid = spawnp (argv[0], 3, fds, &inherit, argv,
1062 ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0 ? env : 0);
1065 sigprocmask (SIG_BLOCK, &set, NULL);
1068 error (_("Error spawning %s: %d (%s)"), argv[0], errno,
1069 safe_strerror (errno));
1071 if (fds[0] != STDIN_FILENO)
1073 if (fds[1] != STDOUT_FILENO)
1075 if (fds[2] != STDERR_FILENO)
1078 inferior_ptid = do_attach (pid_to_ptid (pid));
1081 flags = _DEBUG_FLAG_KLC; /* Kill-on-Last-Close flag. */
1082 errn = devctl (ctl_fd, DCMD_PROC_SET_FLAG, &flags, sizeof (flags), 0);
1085 /* FIXME: expected warning? */
1086 /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
1087 errn, strerror(errn) ); */
1089 push_target (&procfs_ops);
1090 target_terminal_init ();
1092 if (exec_bfd != NULL
1093 || (symfile_objfile != NULL && symfile_objfile->obfd != NULL))
1094 solib_create_inferior_hook ();
1099 procfs_stop (ptid_t ptid)
1101 devctl (ctl_fd, DCMD_PROC_STOP, NULL, 0, 0);
1105 procfs_kill_inferior (void)
1107 target_mourn_inferior ();
1110 /* Store register REGNO, or all registers if REGNO == -1, from the contents
1113 procfs_prepare_to_store (struct regcache *regcache)
1117 /* Fill buf with regset and return devctl cmd to do the setting. Return
1118 -1 if we fail to get the regset. Store size of regset in regsize. */
1120 get_regset (int regset, char *buf, int bufsize, int *regsize)
1122 int dev_get, dev_set;
1125 case NTO_REG_GENERAL:
1126 dev_get = DCMD_PROC_GETGREG;
1127 dev_set = DCMD_PROC_SETGREG;
1131 dev_get = DCMD_PROC_GETFPREG;
1132 dev_set = DCMD_PROC_SETFPREG;
1136 dev_get = DCMD_PROC_GETALTREG;
1137 dev_set = DCMD_PROC_SETALTREG;
1140 case NTO_REG_SYSTEM:
1144 if (devctl (ctl_fd, dev_get, &buf, bufsize, regsize) != EOK)
1151 procfs_store_registers (struct regcache *regcache, int regno)
1157 procfs_altreg altreg;
1161 int len, regset, regsize, dev_set, err;
1164 if (ptid_equal (inferior_ptid, null_ptid))
1166 procfs_set_thread (inferior_ptid);
1170 for (regset = NTO_REG_GENERAL; regset < NTO_REG_END; regset++)
1172 dev_set = get_regset (regset, (char *) ®,
1173 sizeof (reg), ®size);
1177 if (nto_regset_fill (regcache, regset, (char *) ®) == -1)
1180 err = devctl (ctl_fd, dev_set, ®, regsize, 0);
1182 fprintf_unfiltered (gdb_stderr,
1183 "Warning unable to write regset %d: %s\n",
1184 regno, safe_strerror (err));
1189 regset = nto_regset_id (regno);
1193 dev_set = get_regset (regset, (char *) ®, sizeof (reg), ®size);
1197 len = nto_register_area (regno, regset, &off);
1202 regcache_raw_collect (regcache, regno, (char *) ® + off);
1204 err = devctl (ctl_fd, dev_set, ®, regsize, 0);
1206 fprintf_unfiltered (gdb_stderr,
1207 "Warning unable to write regset %d: %s\n", regno,
1208 safe_strerror (err));
1213 notice_signals (void)
1217 for (signo = 1; signo < NSIG; signo++)
1219 if (signal_stop_state (target_signal_from_host (signo)) == 0
1220 && signal_print_state (target_signal_from_host (signo)) == 0
1221 && signal_pass_state (target_signal_from_host (signo)) == 1)
1222 sigdelset (&run.trace, signo);
1224 sigaddset (&run.trace, signo);
1228 /* When the user changes the state of gdb's signal handling via the
1229 "handle" command, this function gets called to see if any change
1230 in the /proc interface is required. It is also called internally
1231 by other /proc interface functions to initialize the state of
1232 the traced signal set. */
1234 procfs_notice_signals (ptid_t ptid)
1236 sigemptyset (&run.trace);
1240 static struct tidinfo *
1241 procfs_thread_info (pid_t pid, short tid)
1248 procfs_pid_to_str (ptid_t ptid)
1250 static char buf[1024];
1252 struct tidinfo *tip;
1254 pid = ptid_get_pid (ptid);
1255 tid = ptid_get_tid (ptid);
1257 n = snprintf (buf, 1023, "process %d", pid);
1260 tip = procfs_thread_info (pid, tid);
1262 snprintf (&buf[n], 1023, " (state = 0x%02x)", tip->state);
1269 init_procfs_ops (void)
1271 procfs_ops.to_shortname = "procfs";
1272 procfs_ops.to_longname = "QNX Neutrino procfs child process";
1274 "QNX Neutrino procfs child process (started by the \"run\" command).\n\
1275 target procfs <node>";
1276 procfs_ops.to_open = procfs_open;
1277 procfs_ops.to_attach = procfs_attach;
1278 procfs_ops.to_post_attach = procfs_post_attach;
1279 procfs_ops.to_detach = procfs_detach;
1280 procfs_ops.to_resume = procfs_resume;
1281 procfs_ops.to_wait = procfs_wait;
1282 procfs_ops.to_fetch_registers = procfs_fetch_registers;
1283 procfs_ops.to_store_registers = procfs_store_registers;
1284 procfs_ops.to_prepare_to_store = procfs_prepare_to_store;
1285 procfs_ops.deprecated_xfer_memory = procfs_xfer_memory;
1286 procfs_ops.to_files_info = procfs_files_info;
1287 procfs_ops.to_insert_breakpoint = procfs_insert_breakpoint;
1288 procfs_ops.to_remove_breakpoint = procfs_remove_breakpoint;
1289 procfs_ops.to_can_use_hw_breakpoint = procfs_can_use_hw_breakpoint;
1290 procfs_ops.to_insert_hw_breakpoint = procfs_insert_hw_breakpoint;
1291 procfs_ops.to_remove_hw_breakpoint = procfs_remove_breakpoint;
1292 procfs_ops.to_insert_watchpoint = procfs_insert_hw_watchpoint;
1293 procfs_ops.to_remove_watchpoint = procfs_remove_hw_watchpoint;
1294 procfs_ops.to_stopped_by_watchpoint = procfs_stopped_by_watchpoint;
1295 procfs_ops.to_terminal_init = terminal_init_inferior;
1296 procfs_ops.to_terminal_inferior = terminal_inferior;
1297 procfs_ops.to_terminal_ours_for_output = terminal_ours_for_output;
1298 procfs_ops.to_terminal_ours = terminal_ours;
1299 procfs_ops.to_terminal_info = child_terminal_info;
1300 procfs_ops.to_kill = procfs_kill_inferior;
1301 procfs_ops.to_create_inferior = procfs_create_inferior;
1302 procfs_ops.to_mourn_inferior = procfs_mourn_inferior;
1303 procfs_ops.to_can_run = procfs_can_run;
1304 procfs_ops.to_notice_signals = procfs_notice_signals;
1305 procfs_ops.to_thread_alive = procfs_thread_alive;
1306 procfs_ops.to_find_new_threads = procfs_find_new_threads;
1307 procfs_ops.to_pid_to_str = procfs_pid_to_str;
1308 procfs_ops.to_stop = procfs_stop;
1309 procfs_ops.to_stratum = process_stratum;
1310 procfs_ops.to_has_all_memory = 1;
1311 procfs_ops.to_has_memory = 1;
1312 procfs_ops.to_has_stack = 1;
1313 procfs_ops.to_has_registers = 1;
1314 procfs_ops.to_has_execution = 1;
1315 procfs_ops.to_magic = OPS_MAGIC;
1316 procfs_ops.to_have_continuable_watchpoint = 1;
1319 #define OSTYPE_NTO 1
1322 _initialize_procfs (void)
1327 add_target (&procfs_ops);
1329 /* We use SIGUSR1 to gain control after we block waiting for a process.
1330 We use sigwaitevent to wait. */
1332 sigaddset (&set, SIGUSR1);
1333 sigprocmask (SIG_BLOCK, &set, NULL);
1335 /* Set up trace and fault sets, as gdb expects them. */
1336 sigemptyset (&run.trace);
1338 /* Stuff some information. */
1339 nto_cpuinfo_flags = SYSPAGE_ENTRY (cpuinfo)->flags;
1340 nto_cpuinfo_valid = 1;
1342 add_info ("pidlist", procfs_pidlist, _("pidlist"));
1343 add_info ("meminfo", procfs_meminfo, _("memory information"));
1345 nto_is_nto_target = procfs_is_nto_target;
1350 procfs_hw_watchpoint (int addr, int len, int type)
1357 brk.type = _DEBUG_BREAK_RD;
1359 case 2: /* Read/Write. */
1360 brk.type = _DEBUG_BREAK_RW;
1362 default: /* Modify. */
1363 /* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason. */
1364 brk.type = _DEBUG_BREAK_RW;
1366 brk.type |= _DEBUG_BREAK_HW; /* Always ask for HW. */
1370 errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
1373 perror ("Failed to set hardware watchpoint");
1380 procfs_can_use_hw_breakpoint (int type, int cnt, int othertype)
1386 procfs_remove_hw_watchpoint (CORE_ADDR addr, int len, int type)
1388 return procfs_hw_watchpoint (addr, -1, type);
1392 procfs_insert_hw_watchpoint (CORE_ADDR addr, int len, int type)
1394 return procfs_hw_watchpoint (addr, len, type);
1398 procfs_stopped_by_watchpoint (void)