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 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 2 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, write to the Free Software
22 Foundation, Inc., 51 Franklin Street, Fifth Floor,
23 Boston, MA 02110-1301, USA. */
29 #include <sys/debug.h>
30 #include <sys/procfs.h>
31 #include <sys/neutrino.h>
32 #include <sys/syspage.h>
33 #include "gdb_dirent.h"
34 #include <sys/netmgr.h>
36 #include "exceptions.h"
37 #include "gdb_string.h"
42 #include "gdbthread.h"
49 #define _DEBUG_FLAG_TRACE (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\
50 _DEBUG_FLAG_TRACE_WR|_DEBUG_FLAG_TRACE_MODIFY)
52 static struct target_ops procfs_ops
;
56 static void (*ofunc
) ();
58 static procfs_run run
;
60 static void procfs_open (char *, int);
62 static int procfs_can_run (void);
64 static ptid_t
procfs_wait (ptid_t
, struct target_waitstatus
*);
66 static int procfs_xfer_memory (CORE_ADDR
, char *, int, int,
67 struct mem_attrib
*attrib
,
70 static void procfs_fetch_registers (int);
72 static void notice_signals (void);
74 static void init_procfs_ops (void);
76 static ptid_t
do_attach (ptid_t ptid
);
78 static int procfs_can_use_hw_breakpoint (int, int, int);
80 static int procfs_insert_hw_watchpoint (CORE_ADDR addr
, int len
, int type
);
82 static int procfs_remove_hw_watchpoint (CORE_ADDR addr
, int len
, int type
);
84 static int procfs_stopped_by_watchpoint (void);
86 /* These two globals are only ever set in procfs_open(), but are
87 referenced elsewhere. 'nto_procfs_node' is a flag used to say
88 whether we are local, or we should get the current node descriptor
89 for the remote QNX node. */
90 static char nto_procfs_path
[PATH_MAX
] = { "/proc" };
91 static unsigned nto_procfs_node
= ND_LOCAL_NODE
;
93 /* Return the current QNX Node, or error out. This is a simple
94 wrapper for the netmgr_strtond() function. The reason this
95 is required is because QNX node descriptors are transient so
96 we have to re-acquire them every time. */
102 if (ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) == 0)
103 return ND_LOCAL_NODE
;
105 node
= netmgr_strtond (nto_procfs_path
, 0);
107 error (_("Lost the QNX node. Debug session probably over."));
112 static enum gdb_osabi
113 procfs_is_nto_target (bfd
*abfd
)
115 return GDB_OSABI_QNXNTO
;
118 /* This is called when we call 'target procfs <arg>' from the (gdb) prompt.
119 For QNX6 (nto), the only valid arg will be a QNX node string,
120 eg: "/net/some_node". If arg is not a valid QNX node, we will
123 procfs_open (char *arg
, int from_tty
)
129 procfs_sysinfo
*sysinfo
;
131 nto_is_nto_target
= procfs_is_nto_target
;
133 /* Set the default node used for spawning to this one,
134 and only override it if there is a valid arg. */
136 nto_procfs_node
= ND_LOCAL_NODE
;
137 nodestr
= arg
? xstrdup (arg
) : arg
;
143 nto_procfs_node
= netmgr_strtond (nodestr
, &endstr
);
144 if (nto_procfs_node
== -1)
146 if (errno
== ENOTSUP
)
147 printf_filtered ("QNX Net Manager not found.\n");
148 printf_filtered ("Invalid QNX node %s: error %d (%s).\n", nodestr
,
149 errno
, safe_strerror (errno
));
152 nto_procfs_node
= ND_LOCAL_NODE
;
156 if (*(endstr
- 1) == '/')
162 snprintf (nto_procfs_path
, PATH_MAX
- 1, "%s%s", nodestr
? nodestr
: "",
167 fd
= open (nto_procfs_path
, O_RDONLY
);
170 printf_filtered ("Error opening %s : %d (%s)\n", nto_procfs_path
, errno
,
171 safe_strerror (errno
));
172 error (_("Invalid procfs arg"));
175 sysinfo
= (void *) buffer
;
176 if (devctl (fd
, DCMD_PROC_SYSINFO
, sysinfo
, sizeof buffer
, 0) != EOK
)
178 printf_filtered ("Error getting size: %d (%s)\n", errno
,
179 safe_strerror (errno
));
181 error (_("Devctl failed."));
185 total_size
= sysinfo
->total_size
;
186 sysinfo
= alloca (total_size
);
189 printf_filtered ("Memory error: %d (%s)\n", errno
,
190 safe_strerror (errno
));
192 error (_("alloca failed."));
196 if (devctl (fd
, DCMD_PROC_SYSINFO
, sysinfo
, total_size
, 0) != EOK
)
198 printf_filtered ("Error getting sysinfo: %d (%s)\n", errno
,
199 safe_strerror (errno
));
201 error (_("Devctl failed."));
206 nto_map_arch_to_cputype (TARGET_ARCHITECTURE
->arch_name
))
209 error (_("Invalid target CPU."));
215 printf_filtered ("Debugging using %s\n", nto_procfs_path
);
219 procfs_set_thread (ptid_t ptid
)
223 tid
= ptid_get_tid (ptid
);
224 devctl (ctl_fd
, DCMD_PROC_CURTHREAD
, &tid
, sizeof (tid
), 0);
227 /* Return nonzero if the thread TH is still alive. */
229 procfs_thread_alive (ptid_t ptid
)
233 tid
= ptid_get_tid (ptid
);
234 if (devctl (ctl_fd
, DCMD_PROC_CURTHREAD
, &tid
, sizeof (tid
), 0) == EOK
)
240 procfs_find_new_threads (void)
242 procfs_status status
;
249 pid
= ptid_get_pid (inferior_ptid
);
251 for (status
.tid
= 1;; ++status
.tid
)
253 if (devctl (ctl_fd
, DCMD_PROC_TIDSTATUS
, &status
, sizeof (status
), 0)
254 != EOK
&& status
.tid
!= 0)
256 ptid
= ptid_build (pid
, 0, status
.tid
);
257 if (!in_thread_list (ptid
))
264 procfs_pidlist (char *args
, int from_tty
)
267 struct dirent
*dirp
= NULL
;
270 procfs_info
*pidinfo
= NULL
;
271 procfs_debuginfo
*info
= NULL
;
272 procfs_status
*status
= NULL
;
273 pid_t num_threads
= 0;
277 dp
= opendir (nto_procfs_path
);
280 fprintf_unfiltered (gdb_stderr
, "failed to opendir \"%s\" - %d (%s)",
281 nto_procfs_path
, errno
, safe_strerror (errno
));
285 /* Start scan at first pid. */
290 /* Get the right pid and procfs path for the pid. */
299 snprintf (buf
, 511, "%s/%s/as", nto_procfs_path
, dirp
->d_name
);
300 pid
= atoi (dirp
->d_name
);
304 /* Open the procfs path. */
305 fd
= open (buf
, O_RDONLY
);
308 fprintf_unfiltered (gdb_stderr
, "failed to open %s - %d (%s)\n",
309 buf
, errno
, safe_strerror (errno
));
314 pidinfo
= (procfs_info
*) buf
;
315 if (devctl (fd
, DCMD_PROC_INFO
, pidinfo
, sizeof (buf
), 0) != EOK
)
317 fprintf_unfiltered (gdb_stderr
,
318 "devctl DCMD_PROC_INFO failed - %d (%s)\n",
319 errno
, safe_strerror (errno
));
322 num_threads
= pidinfo
->num_threads
;
324 info
= (procfs_debuginfo
*) buf
;
325 if (devctl (fd
, DCMD_PROC_MAPDEBUG_BASE
, info
, sizeof (buf
), 0) != EOK
)
326 strcpy (name
, "unavailable");
328 strcpy (name
, info
->path
);
330 /* Collect state info on all the threads. */
331 status
= (procfs_status
*) buf
;
332 for (status
->tid
= 1; status
->tid
<= num_threads
; status
->tid
++)
334 if (devctl (fd
, DCMD_PROC_TIDSTATUS
, status
, sizeof (buf
), 0) != EOK
337 if (status
->tid
!= 0)
338 printf_filtered ("%s - %d/%d\n", name
, pid
, status
->tid
);
342 while (dirp
!= NULL
);
350 procfs_meminfo (char *args
, int from_tty
)
352 procfs_mapinfo
*mapinfos
= NULL
;
353 static int num_mapinfos
= 0;
354 procfs_mapinfo
*mapinfo_p
, *mapinfo_p2
;
355 int flags
= ~0, err
, num
, i
, j
;
359 procfs_debuginfo info
;
360 char buff
[_POSIX_PATH_MAX
];
368 unsigned debug_vaddr
;
369 unsigned long long offset
;
374 unsigned long long ino
;
381 /* Get the number of map entrys. */
382 err
= devctl (ctl_fd
, DCMD_PROC_MAPINFO
, NULL
, 0, &num
);
385 printf ("failed devctl num mapinfos - %d (%s)\n", err
,
386 safe_strerror (err
));
390 mapinfos
= xmalloc (num
* sizeof (procfs_mapinfo
));
393 mapinfo_p
= mapinfos
;
395 /* Fill the map entrys. */
396 err
= devctl (ctl_fd
, DCMD_PROC_MAPINFO
, mapinfo_p
, num
397 * sizeof (procfs_mapinfo
), &num
);
400 printf ("failed devctl mapinfos - %d (%s)\n", err
, safe_strerror (err
));
405 num
= min (num
, num_mapinfos
);
407 /* Run through the list of mapinfos, and store the data and text info
408 so we can print it at the bottom of the loop. */
409 for (mapinfo_p
= mapinfos
, i
= 0; i
< num
; i
++, mapinfo_p
++)
411 if (!(mapinfo_p
->flags
& flags
))
414 if (mapinfo_p
->ino
== 0) /* Already visited. */
417 map
.info
.vaddr
= mapinfo_p
->vaddr
;
419 err
= devctl (ctl_fd
, DCMD_PROC_MAPDEBUG
, &map
, sizeof (map
), 0);
423 memset (&printme
, 0, sizeof printme
);
424 printme
.dev
= mapinfo_p
->dev
;
425 printme
.ino
= mapinfo_p
->ino
;
426 printme
.text
.addr
= mapinfo_p
->vaddr
;
427 printme
.text
.size
= mapinfo_p
->size
;
428 printme
.text
.flags
= mapinfo_p
->flags
;
429 printme
.text
.offset
= mapinfo_p
->offset
;
430 printme
.text
.debug_vaddr
= map
.info
.vaddr
;
431 strcpy (printme
.name
, map
.info
.path
);
433 /* Check for matching data. */
434 for (mapinfo_p2
= mapinfos
, j
= 0; j
< num
; j
++, mapinfo_p2
++)
436 if (mapinfo_p2
->vaddr
!= mapinfo_p
->vaddr
437 && mapinfo_p2
->ino
== mapinfo_p
->ino
438 && mapinfo_p2
->dev
== mapinfo_p
->dev
)
440 map
.info
.vaddr
= mapinfo_p2
->vaddr
;
442 devctl (ctl_fd
, DCMD_PROC_MAPDEBUG
, &map
, sizeof (map
), 0);
446 if (strcmp (map
.info
.path
, printme
.name
))
449 /* Lower debug_vaddr is always text, if nessessary, swap. */
450 if ((int) map
.info
.vaddr
< (int) printme
.text
.debug_vaddr
)
452 memcpy (&(printme
.data
), &(printme
.text
),
453 sizeof (printme
.data
));
454 printme
.text
.addr
= mapinfo_p2
->vaddr
;
455 printme
.text
.size
= mapinfo_p2
->size
;
456 printme
.text
.flags
= mapinfo_p2
->flags
;
457 printme
.text
.offset
= mapinfo_p2
->offset
;
458 printme
.text
.debug_vaddr
= map
.info
.vaddr
;
462 printme
.data
.addr
= mapinfo_p2
->vaddr
;
463 printme
.data
.size
= mapinfo_p2
->size
;
464 printme
.data
.flags
= mapinfo_p2
->flags
;
465 printme
.data
.offset
= mapinfo_p2
->offset
;
466 printme
.data
.debug_vaddr
= map
.info
.vaddr
;
473 printf_filtered ("%s\n", printme
.name
);
474 printf_filtered ("\ttext=%08x bytes @ 0x%08x\n", printme
.text
.size
,
476 printf_filtered ("\t\tflags=%08x\n", printme
.text
.flags
);
477 printf_filtered ("\t\tdebug=%08x\n", printme
.text
.debug_vaddr
);
478 printf_filtered ("\t\toffset=%016llx\n", printme
.text
.offset
);
479 if (printme
.data
.size
)
481 printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme
.data
.size
,
483 printf_filtered ("\t\tflags=%08x\n", printme
.data
.flags
);
484 printf_filtered ("\t\tdebug=%08x\n", printme
.data
.debug_vaddr
);
485 printf_filtered ("\t\toffset=%016llx\n", printme
.data
.offset
);
487 printf_filtered ("\tdev=0x%x\n", printme
.dev
);
488 printf_filtered ("\tino=0x%x\n", (unsigned int) printme
.ino
);
494 /* Print status information about what we're accessing. */
496 procfs_files_info (struct target_ops
*ignore
)
498 printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
499 attach_flag
? "attached" : "child",
500 target_pid_to_str (inferior_ptid
), nto_procfs_path
);
503 /* Mark our target-struct as eligible for stray "run" and "attach" commands. */
505 procfs_can_run (void)
510 /* Attach to process PID, then initialize for debugging it. */
512 procfs_attach (char *args
, int from_tty
)
518 error_no_arg (_("process-id to attach"));
522 if (pid
== getpid ())
523 error (_("Attaching GDB to itself is not a good idea..."));
527 exec_file
= (char *) get_exec_file (0);
530 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
531 target_pid_to_str (pid_to_ptid (pid
)));
533 printf_unfiltered ("Attaching to %s\n",
534 target_pid_to_str (pid_to_ptid (pid
)));
536 gdb_flush (gdb_stdout
);
538 inferior_ptid
= do_attach (pid_to_ptid (pid
));
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
);
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 inferior_ptid
;
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 (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 ((char *) ®
.greg
);
731 if (devctl (ctl_fd
, DCMD_PROC_GETFPREG
, ®
, sizeof (reg
), ®size
)
733 nto_supply_fpregset ((char *) ®
.fpreg
);
734 if (devctl (ctl_fd
, DCMD_PROC_GETALTREG
, ®
, sizeof (reg
), ®size
)
736 nto_supply_altregset ((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
, char *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
;
843 if (ptid_equal (inferior_ptid
, null_ptid
))
846 procfs_set_thread (ptid_equal (ptid
, minus_one_ptid
) ? inferior_ptid
:
849 run
.flags
= _DEBUG_RUN_FAULT
| _DEBUG_RUN_TRACE
;
851 run
.flags
|= _DEBUG_RUN_STEP
;
853 sigemptyset ((sigset_t
*) &run
.fault
);
854 sigaddset ((sigset_t
*) &run
.fault
, FLTBPT
);
855 sigaddset ((sigset_t
*) &run
.fault
, FLTTRACE
);
856 sigaddset ((sigset_t
*) &run
.fault
, FLTILL
);
857 sigaddset ((sigset_t
*) &run
.fault
, FLTPRIV
);
858 sigaddset ((sigset_t
*) &run
.fault
, FLTBOUNDS
);
859 sigaddset ((sigset_t
*) &run
.fault
, FLTIOVF
);
860 sigaddset ((sigset_t
*) &run
.fault
, FLTIZDIV
);
861 sigaddset ((sigset_t
*) &run
.fault
, FLTFPE
);
862 /* Peter V will be changing this at some point. */
863 sigaddset ((sigset_t
*) &run
.fault
, FLTPAGE
);
865 run
.flags
|= _DEBUG_RUN_ARM
;
867 sigemptyset (&run
.trace
);
869 signal_to_pass
= target_signal_to_host (signo
);
873 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
874 signal_to_pass
= target_signal_to_host (signo
);
875 if (status
.why
& (_DEBUG_WHY_SIGNALLED
| _DEBUG_WHY_FAULTED
))
877 if (signal_to_pass
!= status
.info
.si_signo
)
879 SignalKill (nto_node (), PIDGET (inferior_ptid
), 0,
880 signal_to_pass
, 0, 0);
881 run
.flags
|= _DEBUG_RUN_CLRFLT
| _DEBUG_RUN_CLRSIG
;
883 else /* Let it kill the program without telling us. */
884 sigdelset (&run
.trace
, signal_to_pass
);
888 run
.flags
|= _DEBUG_RUN_CLRSIG
| _DEBUG_RUN_CLRFLT
;
890 errno
= devctl (ctl_fd
, DCMD_PROC_RUN
, &run
, sizeof (run
), 0);
893 perror ("run error!\n");
899 procfs_mourn_inferior (void)
901 if (!ptid_equal (inferior_ptid
, null_ptid
))
903 SignalKill (nto_node (), PIDGET (inferior_ptid
), 0, SIGKILL
, 0, 0);
906 inferior_ptid
= null_ptid
;
908 unpush_target (&procfs_ops
);
909 generic_mourn_inferior ();
913 /* This function breaks up an argument string into an argument
914 vector suitable for passing to execvp().
915 E.g., on "run a b c d" this routine would get as input
916 the string "a b c d", and as output it would fill in argv with
917 the four arguments "a", "b", "c", "d". The only additional
918 functionality is simple quoting. The gdb command:
920 will fill in argv with the three args "a", "b c d", "e". */
922 breakup_args (char *scratch
, char **argv
)
924 char *pp
, *cp
= scratch
;
929 /* Scan past leading separators. */
931 while (*cp
== ' ' || *cp
== '\t' || *cp
== '\n')
934 /* Break if at end of string. */
942 quoting
= strchr (cp
, '"') ? 1 : 0;
947 /* Scan for next arg separator. */
950 cp
= strchr (pp
, '"');
951 if ((cp
== NULL
) || (!quoting
))
952 cp
= strchr (pp
, ' ');
954 cp
= strchr (pp
, '\t');
956 cp
= strchr (pp
, '\n');
958 /* No separators => end of string => break. */
965 /* Replace the separator with a terminator. */
969 /* Execv requires a null-terminated arg vector. */
974 procfs_create_inferior (char *exec_file
, char *allargs
, char **env
,
977 struct inheritance inherit
;
981 const char *in
= "", *out
= "", *err
= "";
984 const char *inferior_io_terminal
= get_inferior_io_terminal ();
986 argv
= xmalloc (((strlen (allargs
) + 1) / (unsigned) 2 + 2) *
988 argv
[0] = get_exec_file (1);
997 args
= xstrdup (allargs
);
998 breakup_args (args
, exec_file
? &argv
[1] : &argv
[0]);
1000 argv
= nto_parse_redirection (argv
, &in
, &out
, &err
);
1002 fds
[0] = STDIN_FILENO
;
1003 fds
[1] = STDOUT_FILENO
;
1004 fds
[2] = STDERR_FILENO
;
1006 /* If the user specified I/O via gdb's --tty= arg, use it, but only
1007 if the i/o is not also being specified via redirection. */
1008 if (inferior_io_terminal
)
1011 in
= inferior_io_terminal
;
1013 out
= inferior_io_terminal
;
1015 err
= inferior_io_terminal
;
1020 fd
= open (in
, O_RDONLY
);
1028 fd
= open (out
, O_WRONLY
);
1036 fd
= open (err
, O_WRONLY
);
1043 /* Clear any pending SIGUSR1's but keep the behavior the same. */
1044 signal (SIGUSR1
, signal (SIGUSR1
, SIG_IGN
));
1047 sigaddset (&set
, SIGUSR1
);
1048 sigprocmask (SIG_UNBLOCK
, &set
, NULL
);
1050 memset (&inherit
, 0, sizeof (inherit
));
1052 if (ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) != 0)
1054 inherit
.nd
= nto_node ();
1055 inherit
.flags
|= SPAWN_SETND
;
1056 inherit
.flags
&= ~SPAWN_EXEC
;
1058 inherit
.flags
|= SPAWN_SETGROUP
| SPAWN_HOLD
;
1059 inherit
.pgroup
= SPAWN_NEWPGROUP
;
1060 pid
= spawnp (argv
[0], 3, fds
, &inherit
, argv
,
1061 ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) == 0 ? env
: 0);
1064 sigprocmask (SIG_BLOCK
, &set
, NULL
);
1067 error (_("Error spawning %s: %d (%s)"), argv
[0], errno
,
1068 safe_strerror (errno
));
1070 if (fds
[0] != STDIN_FILENO
)
1072 if (fds
[1] != STDOUT_FILENO
)
1074 if (fds
[2] != STDERR_FILENO
)
1077 inferior_ptid
= do_attach (pid_to_ptid (pid
));
1080 flags
= _DEBUG_FLAG_KLC
; /* Kill-on-Last-Close flag. */
1081 errn
= devctl (ctl_fd
, DCMD_PROC_SET_FLAG
, &flags
, sizeof (flags
), 0);
1084 /* FIXME: expected warning? */
1085 /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
1086 errn, strerror(errn) ); */
1088 push_target (&procfs_ops
);
1089 target_terminal_init ();
1091 if (exec_bfd
!= NULL
1092 || (symfile_objfile
!= NULL
&& symfile_objfile
->obfd
!= NULL
))
1093 solib_create_inferior_hook ();
1100 devctl (ctl_fd
, DCMD_PROC_STOP
, NULL
, 0, 0);
1104 procfs_kill_inferior (void)
1106 target_mourn_inferior ();
1109 /* Store register REGNO, or all registers if REGNO == -1, from the contents
1112 procfs_prepare_to_store (void)
1116 /* Fill buf with regset and return devctl cmd to do the setting. Return
1117 -1 if we fail to get the regset. Store size of regset in regsize. */
1119 get_regset (int regset
, char *buf
, int bufsize
, int *regsize
)
1121 int dev_get
, dev_set
;
1124 case NTO_REG_GENERAL
:
1125 dev_get
= DCMD_PROC_GETGREG
;
1126 dev_set
= DCMD_PROC_SETGREG
;
1130 dev_get
= DCMD_PROC_GETFPREG
;
1131 dev_set
= DCMD_PROC_SETFPREG
;
1135 dev_get
= DCMD_PROC_GETALTREG
;
1136 dev_set
= DCMD_PROC_SETALTREG
;
1139 case NTO_REG_SYSTEM
:
1143 if (devctl (ctl_fd
, dev_get
, &buf
, bufsize
, regsize
) != EOK
)
1150 procfs_store_registers (int regno
)
1156 procfs_altreg altreg
;
1160 int len
, regset
, regsize
, dev_set
, err
;
1163 if (ptid_equal (inferior_ptid
, null_ptid
))
1165 procfs_set_thread (inferior_ptid
);
1169 for (regset
= NTO_REG_GENERAL
; regset
< NTO_REG_END
; regset
++)
1171 dev_set
= get_regset (regset
, (char *) ®
,
1172 sizeof (reg
), ®size
);
1176 if (nto_regset_fill (regset
, (char *) ®
) == -1)
1179 err
= devctl (ctl_fd
, dev_set
, ®
, regsize
, 0);
1181 fprintf_unfiltered (gdb_stderr
,
1182 "Warning unable to write regset %d: %s\n",
1183 regno
, safe_strerror (err
));
1188 regset
= nto_regset_id (regno
);
1192 dev_set
= get_regset (regset
, (char *) ®
, sizeof (reg
), ®size
);
1196 len
= nto_register_area (regno
, regset
, &off
);
1201 regcache_raw_collect (current_regcache
, regno
, (char *) ®
+ off
);
1203 err
= devctl (ctl_fd
, dev_set
, ®
, regsize
, 0);
1205 fprintf_unfiltered (gdb_stderr
,
1206 "Warning unable to write regset %d: %s\n", regno
,
1207 safe_strerror (err
));
1212 notice_signals (void)
1216 for (signo
= 1; signo
< NSIG
; signo
++)
1218 if (signal_stop_state (target_signal_from_host (signo
)) == 0
1219 && signal_print_state (target_signal_from_host (signo
)) == 0
1220 && signal_pass_state (target_signal_from_host (signo
)) == 1)
1221 sigdelset (&run
.trace
, signo
);
1223 sigaddset (&run
.trace
, signo
);
1227 /* When the user changes the state of gdb's signal handling via the
1228 "handle" command, this function gets called to see if any change
1229 in the /proc interface is required. It is also called internally
1230 by other /proc interface functions to initialize the state of
1231 the traced signal set. */
1233 procfs_notice_signals (ptid_t ptid
)
1235 sigemptyset (&run
.trace
);
1239 static struct tidinfo
*
1240 procfs_thread_info (pid_t pid
, short tid
)
1247 procfs_pid_to_str (ptid_t ptid
)
1249 static char buf
[1024];
1251 struct tidinfo
*tip
;
1253 pid
= ptid_get_pid (ptid
);
1254 tid
= ptid_get_tid (ptid
);
1256 n
= snprintf (buf
, 1023, "process %d", pid
);
1259 tip
= procfs_thread_info (pid
, tid
);
1261 snprintf (&buf
[n
], 1023, " (state = 0x%02x)", tip
->state
);
1268 init_procfs_ops (void)
1270 procfs_ops
.to_shortname
= "procfs";
1271 procfs_ops
.to_longname
= "QNX Neutrino procfs child process";
1273 "QNX Neutrino procfs child process (started by the \"run\" command).\n\
1274 target procfs <node>";
1275 procfs_ops
.to_open
= procfs_open
;
1276 procfs_ops
.to_attach
= procfs_attach
;
1277 procfs_ops
.to_post_attach
= procfs_post_attach
;
1278 procfs_ops
.to_detach
= procfs_detach
;
1279 procfs_ops
.to_resume
= procfs_resume
;
1280 procfs_ops
.to_wait
= procfs_wait
;
1281 procfs_ops
.to_fetch_registers
= procfs_fetch_registers
;
1282 procfs_ops
.to_store_registers
= procfs_store_registers
;
1283 procfs_ops
.to_prepare_to_store
= procfs_prepare_to_store
;
1284 procfs_ops
.deprecated_xfer_memory
= procfs_xfer_memory
;
1285 procfs_ops
.to_files_info
= procfs_files_info
;
1286 procfs_ops
.to_insert_breakpoint
= procfs_insert_breakpoint
;
1287 procfs_ops
.to_remove_breakpoint
= procfs_remove_breakpoint
;
1288 procfs_ops
.to_can_use_hw_breakpoint
= procfs_can_use_hw_breakpoint
;
1289 procfs_ops
.to_insert_hw_breakpoint
= procfs_insert_hw_breakpoint
;
1290 procfs_ops
.to_remove_hw_breakpoint
= procfs_remove_breakpoint
;
1291 procfs_ops
.to_insert_watchpoint
= procfs_insert_hw_watchpoint
;
1292 procfs_ops
.to_remove_watchpoint
= procfs_remove_hw_watchpoint
;
1293 procfs_ops
.to_stopped_by_watchpoint
= procfs_stopped_by_watchpoint
;
1294 procfs_ops
.to_terminal_init
= terminal_init_inferior
;
1295 procfs_ops
.to_terminal_inferior
= terminal_inferior
;
1296 procfs_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1297 procfs_ops
.to_terminal_ours
= terminal_ours
;
1298 procfs_ops
.to_terminal_info
= child_terminal_info
;
1299 procfs_ops
.to_kill
= procfs_kill_inferior
;
1300 procfs_ops
.to_create_inferior
= procfs_create_inferior
;
1301 procfs_ops
.to_mourn_inferior
= procfs_mourn_inferior
;
1302 procfs_ops
.to_can_run
= procfs_can_run
;
1303 procfs_ops
.to_notice_signals
= procfs_notice_signals
;
1304 procfs_ops
.to_thread_alive
= procfs_thread_alive
;
1305 procfs_ops
.to_find_new_threads
= procfs_find_new_threads
;
1306 procfs_ops
.to_pid_to_str
= procfs_pid_to_str
;
1307 procfs_ops
.to_stop
= procfs_stop
;
1308 procfs_ops
.to_stratum
= process_stratum
;
1309 procfs_ops
.to_has_all_memory
= 1;
1310 procfs_ops
.to_has_memory
= 1;
1311 procfs_ops
.to_has_stack
= 1;
1312 procfs_ops
.to_has_registers
= 1;
1313 procfs_ops
.to_has_execution
= 1;
1314 procfs_ops
.to_magic
= OPS_MAGIC
;
1315 procfs_ops
.to_have_continuable_watchpoint
= 1;
1318 #define OSTYPE_NTO 1
1321 _initialize_procfs (void)
1326 add_target (&procfs_ops
);
1328 /* We use SIGUSR1 to gain control after we block waiting for a process.
1329 We use sigwaitevent to wait. */
1331 sigaddset (&set
, SIGUSR1
);
1332 sigprocmask (SIG_BLOCK
, &set
, NULL
);
1334 /* Set up trace and fault sets, as gdb expects them. */
1335 sigemptyset (&run
.trace
);
1337 /* Stuff some information. */
1338 nto_cpuinfo_flags
= SYSPAGE_ENTRY (cpuinfo
)->flags
;
1339 nto_cpuinfo_valid
= 1;
1341 add_info ("pidlist", procfs_pidlist
, _("pidlist"));
1342 add_info ("meminfo", procfs_meminfo
, _("memory information"));
1344 nto_is_nto_target
= procfs_is_nto_target
;
1349 procfs_hw_watchpoint (int addr
, int len
, int type
)
1356 brk
.type
= _DEBUG_BREAK_RD
;
1358 case 2: /* Read/Write. */
1359 brk
.type
= _DEBUG_BREAK_RW
;
1361 default: /* Modify. */
1362 /* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason. */
1363 brk
.type
= _DEBUG_BREAK_RW
;
1365 brk
.type
|= _DEBUG_BREAK_HW
; /* Always ask for HW. */
1369 errno
= devctl (ctl_fd
, DCMD_PROC_BREAK
, &brk
, sizeof (brk
), 0);
1372 perror ("Failed to set hardware watchpoint");
1379 procfs_can_use_hw_breakpoint (int type
, int cnt
, int othertype
)
1385 procfs_remove_hw_watchpoint (CORE_ADDR addr
, int len
, int type
)
1387 return procfs_hw_watchpoint (addr
, -1, type
);
1391 procfs_insert_hw_watchpoint (CORE_ADDR addr
, int len
, int type
)
1393 return procfs_hw_watchpoint (addr
, len
, type
);
1397 procfs_stopped_by_watchpoint (void)