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 (struct regcache
*, 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 (gdbarch_bfd_arch_info
207 (current_gdbarch
)->arch_name
))
210 error (_("Invalid target CPU."));
216 printf_filtered ("Debugging using %s\n", nto_procfs_path
);
220 procfs_set_thread (ptid_t ptid
)
224 tid
= ptid_get_tid (ptid
);
225 devctl (ctl_fd
, DCMD_PROC_CURTHREAD
, &tid
, sizeof (tid
), 0);
228 /* Return nonzero if the thread TH is still alive. */
230 procfs_thread_alive (ptid_t ptid
)
234 tid
= ptid_get_tid (ptid
);
235 if (devctl (ctl_fd
, DCMD_PROC_CURTHREAD
, &tid
, sizeof (tid
), 0) == EOK
)
241 procfs_find_new_threads (void)
243 procfs_status status
;
250 pid
= ptid_get_pid (inferior_ptid
);
252 for (status
.tid
= 1;; ++status
.tid
)
254 if (devctl (ctl_fd
, DCMD_PROC_TIDSTATUS
, &status
, sizeof (status
), 0)
255 != EOK
&& status
.tid
!= 0)
257 ptid
= ptid_build (pid
, 0, status
.tid
);
258 if (!in_thread_list (ptid
))
265 procfs_pidlist (char *args
, int from_tty
)
268 struct dirent
*dirp
= NULL
;
271 procfs_info
*pidinfo
= NULL
;
272 procfs_debuginfo
*info
= NULL
;
273 procfs_status
*status
= NULL
;
274 pid_t num_threads
= 0;
278 dp
= opendir (nto_procfs_path
);
281 fprintf_unfiltered (gdb_stderr
, "failed to opendir \"%s\" - %d (%s)",
282 nto_procfs_path
, errno
, safe_strerror (errno
));
286 /* Start scan at first pid. */
291 /* Get the right pid and procfs path for the pid. */
300 snprintf (buf
, 511, "%s/%s/as", nto_procfs_path
, dirp
->d_name
);
301 pid
= atoi (dirp
->d_name
);
305 /* Open the procfs path. */
306 fd
= open (buf
, O_RDONLY
);
309 fprintf_unfiltered (gdb_stderr
, "failed to open %s - %d (%s)\n",
310 buf
, errno
, safe_strerror (errno
));
315 pidinfo
= (procfs_info
*) buf
;
316 if (devctl (fd
, DCMD_PROC_INFO
, pidinfo
, sizeof (buf
), 0) != EOK
)
318 fprintf_unfiltered (gdb_stderr
,
319 "devctl DCMD_PROC_INFO failed - %d (%s)\n",
320 errno
, safe_strerror (errno
));
323 num_threads
= pidinfo
->num_threads
;
325 info
= (procfs_debuginfo
*) buf
;
326 if (devctl (fd
, DCMD_PROC_MAPDEBUG_BASE
, info
, sizeof (buf
), 0) != EOK
)
327 strcpy (name
, "unavailable");
329 strcpy (name
, info
->path
);
331 /* Collect state info on all the threads. */
332 status
= (procfs_status
*) buf
;
333 for (status
->tid
= 1; status
->tid
<= num_threads
; status
->tid
++)
335 if (devctl (fd
, DCMD_PROC_TIDSTATUS
, status
, sizeof (buf
), 0) != EOK
338 if (status
->tid
!= 0)
339 printf_filtered ("%s - %d/%d\n", name
, pid
, status
->tid
);
343 while (dirp
!= NULL
);
351 procfs_meminfo (char *args
, int from_tty
)
353 procfs_mapinfo
*mapinfos
= NULL
;
354 static int num_mapinfos
= 0;
355 procfs_mapinfo
*mapinfo_p
, *mapinfo_p2
;
356 int flags
= ~0, err
, num
, i
, j
;
360 procfs_debuginfo info
;
361 char buff
[_POSIX_PATH_MAX
];
369 unsigned debug_vaddr
;
370 unsigned long long offset
;
375 unsigned long long ino
;
382 /* Get the number of map entrys. */
383 err
= devctl (ctl_fd
, DCMD_PROC_MAPINFO
, NULL
, 0, &num
);
386 printf ("failed devctl num mapinfos - %d (%s)\n", err
,
387 safe_strerror (err
));
391 mapinfos
= xmalloc (num
* sizeof (procfs_mapinfo
));
394 mapinfo_p
= mapinfos
;
396 /* Fill the map entrys. */
397 err
= devctl (ctl_fd
, DCMD_PROC_MAPINFO
, mapinfo_p
, num
398 * sizeof (procfs_mapinfo
), &num
);
401 printf ("failed devctl mapinfos - %d (%s)\n", err
, safe_strerror (err
));
406 num
= min (num
, num_mapinfos
);
408 /* Run through the list of mapinfos, and store the data and text info
409 so we can print it at the bottom of the loop. */
410 for (mapinfo_p
= mapinfos
, i
= 0; i
< num
; i
++, mapinfo_p
++)
412 if (!(mapinfo_p
->flags
& flags
))
415 if (mapinfo_p
->ino
== 0) /* Already visited. */
418 map
.info
.vaddr
= mapinfo_p
->vaddr
;
420 err
= devctl (ctl_fd
, DCMD_PROC_MAPDEBUG
, &map
, sizeof (map
), 0);
424 memset (&printme
, 0, sizeof printme
);
425 printme
.dev
= mapinfo_p
->dev
;
426 printme
.ino
= mapinfo_p
->ino
;
427 printme
.text
.addr
= mapinfo_p
->vaddr
;
428 printme
.text
.size
= mapinfo_p
->size
;
429 printme
.text
.flags
= mapinfo_p
->flags
;
430 printme
.text
.offset
= mapinfo_p
->offset
;
431 printme
.text
.debug_vaddr
= map
.info
.vaddr
;
432 strcpy (printme
.name
, map
.info
.path
);
434 /* Check for matching data. */
435 for (mapinfo_p2
= mapinfos
, j
= 0; j
< num
; j
++, mapinfo_p2
++)
437 if (mapinfo_p2
->vaddr
!= mapinfo_p
->vaddr
438 && mapinfo_p2
->ino
== mapinfo_p
->ino
439 && mapinfo_p2
->dev
== mapinfo_p
->dev
)
441 map
.info
.vaddr
= mapinfo_p2
->vaddr
;
443 devctl (ctl_fd
, DCMD_PROC_MAPDEBUG
, &map
, sizeof (map
), 0);
447 if (strcmp (map
.info
.path
, printme
.name
))
450 /* Lower debug_vaddr is always text, if nessessary, swap. */
451 if ((int) map
.info
.vaddr
< (int) printme
.text
.debug_vaddr
)
453 memcpy (&(printme
.data
), &(printme
.text
),
454 sizeof (printme
.data
));
455 printme
.text
.addr
= mapinfo_p2
->vaddr
;
456 printme
.text
.size
= mapinfo_p2
->size
;
457 printme
.text
.flags
= mapinfo_p2
->flags
;
458 printme
.text
.offset
= mapinfo_p2
->offset
;
459 printme
.text
.debug_vaddr
= map
.info
.vaddr
;
463 printme
.data
.addr
= mapinfo_p2
->vaddr
;
464 printme
.data
.size
= mapinfo_p2
->size
;
465 printme
.data
.flags
= mapinfo_p2
->flags
;
466 printme
.data
.offset
= mapinfo_p2
->offset
;
467 printme
.data
.debug_vaddr
= map
.info
.vaddr
;
474 printf_filtered ("%s\n", printme
.name
);
475 printf_filtered ("\ttext=%08x bytes @ 0x%08x\n", printme
.text
.size
,
477 printf_filtered ("\t\tflags=%08x\n", printme
.text
.flags
);
478 printf_filtered ("\t\tdebug=%08x\n", printme
.text
.debug_vaddr
);
479 printf_filtered ("\t\toffset=%016llx\n", printme
.text
.offset
);
480 if (printme
.data
.size
)
482 printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme
.data
.size
,
484 printf_filtered ("\t\tflags=%08x\n", printme
.data
.flags
);
485 printf_filtered ("\t\tdebug=%08x\n", printme
.data
.debug_vaddr
);
486 printf_filtered ("\t\toffset=%016llx\n", printme
.data
.offset
);
488 printf_filtered ("\tdev=0x%x\n", printme
.dev
);
489 printf_filtered ("\tino=0x%x\n", (unsigned int) printme
.ino
);
495 /* Print status information about what we're accessing. */
497 procfs_files_info (struct target_ops
*ignore
)
499 printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
500 attach_flag
? "attached" : "child",
501 target_pid_to_str (inferior_ptid
), nto_procfs_path
);
504 /* Mark our target-struct as eligible for stray "run" and "attach" commands. */
506 procfs_can_run (void)
511 /* Attach to process PID, then initialize for debugging it. */
513 procfs_attach (char *args
, int from_tty
)
519 error_no_arg (_("process-id to attach"));
523 if (pid
== getpid ())
524 error (_("Attaching GDB to itself is not a good idea..."));
528 exec_file
= (char *) get_exec_file (0);
531 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
532 target_pid_to_str (pid_to_ptid (pid
)));
534 printf_unfiltered ("Attaching to %s\n",
535 target_pid_to_str (pid_to_ptid (pid
)));
537 gdb_flush (gdb_stdout
);
539 inferior_ptid
= do_attach (pid_to_ptid (pid
));
540 push_target (&procfs_ops
);
544 procfs_post_attach (pid_t pid
)
547 solib_create_inferior_hook ();
551 do_attach (ptid_t ptid
)
553 procfs_status status
;
554 struct sigevent event
;
557 snprintf (path
, PATH_MAX
- 1, "%s/%d/as", nto_procfs_path
, PIDGET (ptid
));
558 ctl_fd
= open (path
, O_RDWR
);
560 error (_("Couldn't open proc file %s, error %d (%s)"), path
, errno
,
561 safe_strerror (errno
));
562 if (devctl (ctl_fd
, DCMD_PROC_STOP
, &status
, sizeof (status
), 0) != EOK
)
563 error (_("Couldn't stop process"));
565 /* Define a sigevent for process stopped notification. */
566 event
.sigev_notify
= SIGEV_SIGNAL_THREAD
;
567 event
.sigev_signo
= SIGUSR1
;
568 event
.sigev_code
= 0;
569 event
.sigev_value
.sival_ptr
= NULL
;
570 event
.sigev_priority
= -1;
571 devctl (ctl_fd
, DCMD_PROC_EVENT
, &event
, sizeof (event
), 0);
573 if (devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0) == EOK
574 && status
.flags
& _DEBUG_FLAG_STOPPED
)
575 SignalKill (nto_node (), PIDGET (ptid
), 0, SIGCONT
, 0, 0);
577 nto_init_solib_absolute_prefix ();
581 /* Ask the user what to do when an interrupt is received. */
583 interrupt_query (void)
585 target_terminal_ours ();
587 if (query ("Interrupted while waiting for the program.\n\
588 Give up (and stop debugging it)? "))
590 target_mourn_inferior ();
591 deprecated_throw_reason (RETURN_QUIT
);
594 target_terminal_inferior ();
597 /* The user typed ^C twice. */
599 nto_interrupt_twice (int signo
)
601 signal (signo
, ofunc
);
603 signal (signo
, nto_interrupt_twice
);
607 nto_interrupt (int signo
)
609 /* If this doesn't work, try more severe steps. */
610 signal (signo
, nto_interrupt_twice
);
616 procfs_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
620 procfs_status status
;
621 static int exit_signo
= 0; /* To track signals that cause termination. */
623 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
625 if (ptid_equal (inferior_ptid
, null_ptid
))
627 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
628 ourstatus
->value
.sig
= TARGET_SIGNAL_0
;
634 sigaddset (&set
, SIGUSR1
);
636 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
637 while (!(status
.flags
& _DEBUG_FLAG_ISTOP
))
639 ofunc
= (void (*)()) signal (SIGINT
, nto_interrupt
);
640 sigwaitinfo (&set
, &info
);
641 signal (SIGINT
, ofunc
);
642 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
645 if (status
.flags
& _DEBUG_FLAG_SSTEP
)
647 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
648 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
650 /* Was it a breakpoint? */
651 else if (status
.flags
& _DEBUG_FLAG_TRACE
)
653 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
654 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
656 else if (status
.flags
& _DEBUG_FLAG_ISTOP
)
660 case _DEBUG_WHY_SIGNALLED
:
661 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
662 ourstatus
->value
.sig
=
663 target_signal_from_host (status
.info
.si_signo
);
666 case _DEBUG_WHY_FAULTED
:
667 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
668 if (status
.info
.si_signo
== SIGTRAP
)
670 ourstatus
->value
.sig
= 0;
675 ourstatus
->value
.sig
=
676 target_signal_from_host (status
.info
.si_signo
);
677 exit_signo
= ourstatus
->value
.sig
;
681 case _DEBUG_WHY_TERMINATED
:
685 waitpid (PIDGET (inferior_ptid
), &waitval
, WNOHANG
);
688 /* Abnormal death. */
689 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
690 ourstatus
->value
.sig
= exit_signo
;
695 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
696 ourstatus
->value
.integer
= WEXITSTATUS (waitval
);
702 case _DEBUG_WHY_REQUESTED
:
703 /* We are assuming a requested stop is due to a SIGINT. */
704 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
705 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
711 return inferior_ptid
;
714 /* Read the current values of the inferior's registers, both the
715 general register set and floating point registers (if supported)
716 and update gdb's idea of their current values. */
718 procfs_fetch_registers (struct regcache
*regcache
, int regno
)
724 procfs_altreg altreg
;
729 procfs_set_thread (inferior_ptid
);
730 if (devctl (ctl_fd
, DCMD_PROC_GETGREG
, ®
, sizeof (reg
), ®size
) == EOK
)
731 nto_supply_gregset (regcache
, (char *) ®
.greg
);
732 if (devctl (ctl_fd
, DCMD_PROC_GETFPREG
, ®
, sizeof (reg
), ®size
)
734 nto_supply_fpregset (regcache
, (char *) ®
.fpreg
);
735 if (devctl (ctl_fd
, DCMD_PROC_GETALTREG
, ®
, sizeof (reg
), ®size
)
737 nto_supply_altregset (regcache
, (char *) ®
.altreg
);
740 /* Copy LEN bytes to/from inferior's memory starting at MEMADDR
741 from/to debugger memory starting at MYADDR. Copy from inferior
742 if DOWRITE is zero or to inferior if DOWRITE is nonzero.
744 Returns the length copied, which is either the LEN argument or
745 zero. This xfer function does not do partial moves, since procfs_ops
746 doesn't allow memory operations to cross below us in the target stack
749 procfs_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int dowrite
,
750 struct mem_attrib
*attrib
, struct target_ops
*target
)
754 if (lseek (ctl_fd
, (off_t
) memaddr
, SEEK_SET
) == (off_t
) memaddr
)
757 nbytes
= write (ctl_fd
, myaddr
, len
);
759 nbytes
= read (ctl_fd
, myaddr
, len
);
766 /* Take a program previously attached to and detaches it.
767 The program resumes execution and will no longer stop
768 on signals, etc. We'd better not have left any breakpoints
769 in the program or it'll die when it hits one. */
771 procfs_detach (char *args
, int from_tty
)
777 char *exec_file
= get_exec_file (0);
780 printf_unfiltered ("Detaching from program: %s %s\n",
781 exec_file
, target_pid_to_str (inferior_ptid
));
782 gdb_flush (gdb_stdout
);
785 siggnal
= atoi (args
);
788 SignalKill (nto_node (), PIDGET (inferior_ptid
), 0, siggnal
, 0, 0);
793 inferior_ptid
= null_ptid
;
795 unpush_target (&procfs_ops
); /* Pop out of handling an inferior. */
799 procfs_breakpoint (CORE_ADDR addr
, int type
, int size
)
806 errno
= devctl (ctl_fd
, DCMD_PROC_BREAK
, &brk
, sizeof (brk
), 0);
813 procfs_insert_breakpoint (struct bp_target_info
*bp_tgt
)
815 return procfs_breakpoint (bp_tgt
->placed_address
, _DEBUG_BREAK_EXEC
, 0);
819 procfs_remove_breakpoint (struct bp_target_info
*bp_tgt
)
821 return procfs_breakpoint (bp_tgt
->placed_address
, _DEBUG_BREAK_EXEC
, -1);
825 procfs_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
827 return procfs_breakpoint (bp_tgt
->placed_address
,
828 _DEBUG_BREAK_EXEC
| _DEBUG_BREAK_HW
, 0);
832 procfs_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
834 return procfs_breakpoint (bp_tgt
->placed_address
,
835 _DEBUG_BREAK_EXEC
| _DEBUG_BREAK_HW
, -1);
839 procfs_resume (ptid_t ptid
, int step
, enum target_signal signo
)
842 procfs_status status
;
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 ((sigset_t
*) &run
.fault
);
855 sigaddset ((sigset_t
*) &run
.fault
, FLTBPT
);
856 sigaddset ((sigset_t
*) &run
.fault
, FLTTRACE
);
857 sigaddset ((sigset_t
*) &run
.fault
, FLTILL
);
858 sigaddset ((sigset_t
*) &run
.fault
, FLTPRIV
);
859 sigaddset ((sigset_t
*) &run
.fault
, FLTBOUNDS
);
860 sigaddset ((sigset_t
*) &run
.fault
, FLTIOVF
);
861 sigaddset ((sigset_t
*) &run
.fault
, FLTIZDIV
);
862 sigaddset ((sigset_t
*) &run
.fault
, FLTFPE
);
863 /* Peter V will be changing this at some point. */
864 sigaddset ((sigset_t
*) &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 ();
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)