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 2003 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., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, 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"
48 #define _DEBUG_FLAG_TRACE (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\
49 _DEBUG_FLAG_TRACE_WR|_DEBUG_FLAG_TRACE_MODIFY)
51 static struct target_ops procfs_ops
;
55 static void (*ofunc
) ();
57 static procfs_run run
;
59 static void procfs_open (char *, int);
61 static int procfs_can_run (void);
63 static ptid_t
procfs_wait (ptid_t
, struct target_waitstatus
*);
65 static int procfs_xfer_memory (CORE_ADDR
, char *, int, int,
66 struct mem_attrib
*attrib
,
69 static void procfs_fetch_registers (int);
71 static void notice_signals (void);
73 static void init_procfs_ops (void);
75 static ptid_t
do_attach (ptid_t ptid
);
77 static int procfs_can_use_hw_breakpoint (int, int, int);
79 static int procfs_insert_hw_breakpoint (CORE_ADDR
, char *);
81 static int procfs_remove_hw_breakpoint (CORE_ADDR addr
, char *);
83 static int procfs_insert_hw_watchpoint (CORE_ADDR addr
, int len
, int type
);
85 static int procfs_remove_hw_watchpoint (CORE_ADDR addr
, int len
, int type
);
87 static int procfs_stopped_by_watchpoint (void);
89 /* These two globals are only ever set in procfs_open(), but are
90 referenced elsewhere. 'nto_procfs_node' is a flag used to say
91 whether we are local, or we should get the current node descriptor
92 for the remote QNX node. */
93 static char nto_procfs_path
[PATH_MAX
] = { "/proc" };
94 static unsigned nto_procfs_node
= ND_LOCAL_NODE
;
96 /* Return the current QNX Node, or error out. This is a simple
97 wrapper for the netmgr_strtond() function. The reason this
98 is required is because QNX node descriptors are transient so
99 we have to re-acquire them every time. */
105 if (ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) == 0)
106 return ND_LOCAL_NODE
;
108 node
= netmgr_strtond (nto_procfs_path
, 0);
110 error (_("Lost the QNX node. Debug session probably over."));
115 static enum gdb_osabi
116 procfs_is_nto_target (bfd
*abfd
)
118 return GDB_OSABI_QNXNTO
;
121 /* This is called when we call 'target procfs <arg>' from the (gdb) prompt.
122 For QNX6 (nto), the only valid arg will be a QNX node string,
123 eg: "/net/some_node". If arg is not a valid QNX node, we will
126 procfs_open (char *arg
, int from_tty
)
132 procfs_sysinfo
*sysinfo
;
134 nto_is_nto_target
= procfs_is_nto_target
;
136 /* Set the default node used for spawning to this one,
137 and only override it if there is a valid arg. */
139 nto_procfs_node
= ND_LOCAL_NODE
;
140 nodestr
= arg
? xstrdup (arg
) : arg
;
146 nto_procfs_node
= netmgr_strtond (nodestr
, &endstr
);
147 if (nto_procfs_node
== -1)
149 if (errno
== ENOTSUP
)
150 printf_filtered ("QNX Net Manager not found.\n");
151 printf_filtered ("Invalid QNX node %s: error %d (%s).\n", nodestr
,
152 errno
, safe_strerror (errno
));
155 nto_procfs_node
= ND_LOCAL_NODE
;
159 if (*(endstr
- 1) == '/')
165 snprintf (nto_procfs_path
, PATH_MAX
- 1, "%s%s", nodestr
? nodestr
: "",
170 fd
= open (nto_procfs_path
, O_RDONLY
);
173 printf_filtered ("Error opening %s : %d (%s)\n", nto_procfs_path
, errno
,
174 safe_strerror (errno
));
175 error (_("Invalid procfs arg"));
178 sysinfo
= (void *) buffer
;
179 if (devctl (fd
, DCMD_PROC_SYSINFO
, sysinfo
, sizeof buffer
, 0) != EOK
)
181 printf_filtered ("Error getting size: %d (%s)\n", errno
,
182 safe_strerror (errno
));
184 error (_("Devctl failed."));
188 total_size
= sysinfo
->total_size
;
189 sysinfo
= alloca (total_size
);
192 printf_filtered ("Memory error: %d (%s)\n", errno
,
193 safe_strerror (errno
));
195 error (_("alloca failed."));
199 if (devctl (fd
, DCMD_PROC_SYSINFO
, sysinfo
, total_size
, 0) != EOK
)
201 printf_filtered ("Error getting sysinfo: %d (%s)\n", errno
,
202 safe_strerror (errno
));
204 error (_("Devctl failed."));
209 nto_map_arch_to_cputype (TARGET_ARCHITECTURE
->arch_name
))
212 error (_("Invalid target CPU."));
218 printf_filtered ("Debugging using %s\n", nto_procfs_path
);
222 procfs_set_thread (ptid_t ptid
)
226 tid
= ptid_get_tid (ptid
);
227 devctl (ctl_fd
, DCMD_PROC_CURTHREAD
, &tid
, sizeof (tid
), 0);
230 /* Return nonzero if the thread TH is still alive. */
232 procfs_thread_alive (ptid_t ptid
)
236 tid
= ptid_get_tid (ptid
);
237 if (devctl (ctl_fd
, DCMD_PROC_CURTHREAD
, &tid
, sizeof (tid
), 0) == EOK
)
243 procfs_find_new_threads (void)
245 procfs_status status
;
252 pid
= ptid_get_pid (inferior_ptid
);
254 for (status
.tid
= 1;; ++status
.tid
)
256 if (devctl (ctl_fd
, DCMD_PROC_TIDSTATUS
, &status
, sizeof (status
), 0)
257 != EOK
&& status
.tid
!= 0)
259 ptid
= ptid_build (pid
, 0, status
.tid
);
260 if (!in_thread_list (ptid
))
267 procfs_pidlist (char *args
, int from_tty
)
270 struct dirent
*dirp
= NULL
;
273 procfs_info
*pidinfo
= NULL
;
274 procfs_debuginfo
*info
= NULL
;
275 procfs_status
*status
= NULL
;
276 pid_t num_threads
= 0;
280 dp
= opendir (nto_procfs_path
);
283 fprintf_unfiltered (gdb_stderr
, "failed to opendir \"%s\" - %d (%s)",
284 nto_procfs_path
, errno
, safe_strerror (errno
));
288 /* Start scan at first pid. */
293 /* Get the right pid and procfs path for the pid. */
302 snprintf (buf
, 511, "%s/%s/as", nto_procfs_path
, dirp
->d_name
);
303 pid
= atoi (dirp
->d_name
);
307 /* Open the procfs path. */
308 fd
= open (buf
, O_RDONLY
);
311 fprintf_unfiltered (gdb_stderr
, "failed to open %s - %d (%s)\n",
312 buf
, errno
, safe_strerror (errno
));
317 pidinfo
= (procfs_info
*) buf
;
318 if (devctl (fd
, DCMD_PROC_INFO
, pidinfo
, sizeof (buf
), 0) != EOK
)
320 fprintf_unfiltered (gdb_stderr
,
321 "devctl DCMD_PROC_INFO failed - %d (%s)\n",
322 errno
, safe_strerror (errno
));
325 num_threads
= pidinfo
->num_threads
;
327 info
= (procfs_debuginfo
*) buf
;
328 if (devctl (fd
, DCMD_PROC_MAPDEBUG_BASE
, info
, sizeof (buf
), 0) != EOK
)
329 strcpy (name
, "unavailable");
331 strcpy (name
, info
->path
);
333 /* Collect state info on all the threads. */
334 status
= (procfs_status
*) buf
;
335 for (status
->tid
= 1; status
->tid
<= num_threads
; status
->tid
++)
337 if (devctl (fd
, DCMD_PROC_TIDSTATUS
, status
, sizeof (buf
), 0) != EOK
340 if (status
->tid
!= 0)
341 printf_filtered ("%s - %d/%d\n", name
, pid
, status
->tid
);
345 while (dirp
!= NULL
);
353 procfs_meminfo (char *args
, int from_tty
)
355 procfs_mapinfo
*mapinfos
= NULL
;
356 static int num_mapinfos
= 0;
357 procfs_mapinfo
*mapinfo_p
, *mapinfo_p2
;
358 int flags
= ~0, err
, num
, i
, j
;
362 procfs_debuginfo info
;
363 char buff
[_POSIX_PATH_MAX
];
371 unsigned debug_vaddr
;
372 unsigned long long offset
;
377 unsigned long long ino
;
384 /* Get the number of map entrys. */
385 err
= devctl (ctl_fd
, DCMD_PROC_MAPINFO
, NULL
, 0, &num
);
388 printf ("failed devctl num mapinfos - %d (%s)\n", err
,
389 safe_strerror (err
));
393 mapinfos
= xmalloc (num
* sizeof (procfs_mapinfo
));
396 mapinfo_p
= mapinfos
;
398 /* Fill the map entrys. */
399 err
= devctl (ctl_fd
, DCMD_PROC_MAPINFO
, mapinfo_p
, num
400 * sizeof (procfs_mapinfo
), &num
);
403 printf ("failed devctl mapinfos - %d (%s)\n", err
, safe_strerror (err
));
408 num
= min (num
, num_mapinfos
);
410 /* Run through the list of mapinfos, and store the data and text info
411 so we can print it at the bottom of the loop. */
412 for (mapinfo_p
= mapinfos
, i
= 0; i
< num
; i
++, mapinfo_p
++)
414 if (!(mapinfo_p
->flags
& flags
))
417 if (mapinfo_p
->ino
== 0) /* Already visited. */
420 map
.info
.vaddr
= mapinfo_p
->vaddr
;
422 err
= devctl (ctl_fd
, DCMD_PROC_MAPDEBUG
, &map
, sizeof (map
), 0);
426 memset (&printme
, 0, sizeof printme
);
427 printme
.dev
= mapinfo_p
->dev
;
428 printme
.ino
= mapinfo_p
->ino
;
429 printme
.text
.addr
= mapinfo_p
->vaddr
;
430 printme
.text
.size
= mapinfo_p
->size
;
431 printme
.text
.flags
= mapinfo_p
->flags
;
432 printme
.text
.offset
= mapinfo_p
->offset
;
433 printme
.text
.debug_vaddr
= map
.info
.vaddr
;
434 strcpy (printme
.name
, map
.info
.path
);
436 /* Check for matching data. */
437 for (mapinfo_p2
= mapinfos
, j
= 0; j
< num
; j
++, mapinfo_p2
++)
439 if (mapinfo_p2
->vaddr
!= mapinfo_p
->vaddr
440 && mapinfo_p2
->ino
== mapinfo_p
->ino
441 && mapinfo_p2
->dev
== mapinfo_p
->dev
)
443 map
.info
.vaddr
= mapinfo_p2
->vaddr
;
445 devctl (ctl_fd
, DCMD_PROC_MAPDEBUG
, &map
, sizeof (map
), 0);
449 if (strcmp (map
.info
.path
, printme
.name
))
452 /* Lower debug_vaddr is always text, if nessessary, swap. */
453 if ((int) map
.info
.vaddr
< (int) printme
.text
.debug_vaddr
)
455 memcpy (&(printme
.data
), &(printme
.text
),
456 sizeof (printme
.data
));
457 printme
.text
.addr
= mapinfo_p2
->vaddr
;
458 printme
.text
.size
= mapinfo_p2
->size
;
459 printme
.text
.flags
= mapinfo_p2
->flags
;
460 printme
.text
.offset
= mapinfo_p2
->offset
;
461 printme
.text
.debug_vaddr
= map
.info
.vaddr
;
465 printme
.data
.addr
= mapinfo_p2
->vaddr
;
466 printme
.data
.size
= mapinfo_p2
->size
;
467 printme
.data
.flags
= mapinfo_p2
->flags
;
468 printme
.data
.offset
= mapinfo_p2
->offset
;
469 printme
.data
.debug_vaddr
= map
.info
.vaddr
;
476 printf_filtered ("%s\n", printme
.name
);
477 printf_filtered ("\ttext=%08x bytes @ 0x%08x\n", printme
.text
.size
,
479 printf_filtered ("\t\tflags=%08x\n", printme
.text
.flags
);
480 printf_filtered ("\t\tdebug=%08x\n", printme
.text
.debug_vaddr
);
481 printf_filtered ("\t\toffset=%016llx\n", printme
.text
.offset
);
482 if (printme
.data
.size
)
484 printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme
.data
.size
,
486 printf_filtered ("\t\tflags=%08x\n", printme
.data
.flags
);
487 printf_filtered ("\t\tdebug=%08x\n", printme
.data
.debug_vaddr
);
488 printf_filtered ("\t\toffset=%016llx\n", printme
.data
.offset
);
490 printf_filtered ("\tdev=0x%x\n", printme
.dev
);
491 printf_filtered ("\tino=0x%x\n", (unsigned int) printme
.ino
);
497 /* Print status information about what we're accessing. */
499 procfs_files_info (struct target_ops
*ignore
)
501 printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
502 attach_flag
? "attached" : "child",
503 target_pid_to_str (inferior_ptid
), nto_procfs_path
);
506 /* Mark our target-struct as eligible for stray "run" and "attach" commands. */
508 procfs_can_run (void)
513 /* Attach to process PID, then initialize for debugging it. */
515 procfs_attach (char *args
, int from_tty
)
521 error_no_arg (_("process-id to attach"));
525 if (pid
== getpid ())
526 error (_("Attaching GDB to itself is not a good idea..."));
530 exec_file
= (char *) get_exec_file (0);
533 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
534 target_pid_to_str (pid_to_ptid (pid
)));
536 printf_unfiltered ("Attaching to %s\n",
537 target_pid_to_str (pid_to_ptid (pid
)));
539 gdb_flush (gdb_stdout
);
541 inferior_ptid
= do_attach (pid_to_ptid (pid
));
542 push_target (&procfs_ops
);
546 procfs_post_attach (pid_t pid
)
548 #ifdef SOLIB_CREATE_INFERIOR_HOOK
550 SOLIB_CREATE_INFERIOR_HOOK (pid
);
555 do_attach (ptid_t ptid
)
557 procfs_status status
;
558 struct sigevent event
;
561 snprintf (path
, PATH_MAX
- 1, "%s/%d/as", nto_procfs_path
, PIDGET (ptid
));
562 ctl_fd
= open (path
, O_RDWR
);
564 error (_("Couldn't open proc file %s, error %d (%s)"), path
, errno
,
565 safe_strerror (errno
));
566 if (devctl (ctl_fd
, DCMD_PROC_STOP
, &status
, sizeof (status
), 0) != EOK
)
567 error (_("Couldn't stop process"));
569 /* Define a sigevent for process stopped notification. */
570 event
.sigev_notify
= SIGEV_SIGNAL_THREAD
;
571 event
.sigev_signo
= SIGUSR1
;
572 event
.sigev_code
= 0;
573 event
.sigev_value
.sival_ptr
= NULL
;
574 event
.sigev_priority
= -1;
575 devctl (ctl_fd
, DCMD_PROC_EVENT
, &event
, sizeof (event
), 0);
577 if (devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0) == EOK
578 && status
.flags
& _DEBUG_FLAG_STOPPED
)
579 SignalKill (nto_node (), PIDGET (ptid
), 0, SIGCONT
, 0, 0);
581 nto_init_solib_absolute_prefix ();
585 /* Ask the user what to do when an interrupt is received. */
587 interrupt_query (void)
589 target_terminal_ours ();
591 if (query ("Interrupted while waiting for the program.\n\
592 Give up (and stop debugging it)? "))
594 target_mourn_inferior ();
595 deprecated_throw_reason (RETURN_QUIT
);
598 target_terminal_inferior ();
601 /* The user typed ^C twice. */
603 nto_interrupt_twice (int signo
)
605 signal (signo
, ofunc
);
607 signal (signo
, nto_interrupt_twice
);
611 nto_interrupt (int signo
)
613 /* If this doesn't work, try more severe steps. */
614 signal (signo
, nto_interrupt_twice
);
620 procfs_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
624 procfs_status status
;
625 static int exit_signo
= 0; /* To track signals that cause termination. */
627 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
629 if (ptid_equal (inferior_ptid
, null_ptid
))
631 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
632 ourstatus
->value
.sig
= TARGET_SIGNAL_0
;
638 sigaddset (&set
, SIGUSR1
);
640 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
641 while (!(status
.flags
& _DEBUG_FLAG_ISTOP
))
643 ofunc
= (void (*)()) signal (SIGINT
, nto_interrupt
);
644 sigwaitinfo (&set
, &info
);
645 signal (SIGINT
, ofunc
);
646 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
649 if (status
.flags
& _DEBUG_FLAG_SSTEP
)
651 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
652 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
654 /* Was it a breakpoint? */
655 else if (status
.flags
& _DEBUG_FLAG_TRACE
)
657 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
658 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
660 else if (status
.flags
& _DEBUG_FLAG_ISTOP
)
664 case _DEBUG_WHY_SIGNALLED
:
665 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
666 ourstatus
->value
.sig
=
667 target_signal_from_host (status
.info
.si_signo
);
670 case _DEBUG_WHY_FAULTED
:
671 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
672 if (status
.info
.si_signo
== SIGTRAP
)
674 ourstatus
->value
.sig
= 0;
679 ourstatus
->value
.sig
=
680 target_signal_from_host (status
.info
.si_signo
);
681 exit_signo
= ourstatus
->value
.sig
;
685 case _DEBUG_WHY_TERMINATED
:
689 waitpid (PIDGET (inferior_ptid
), &waitval
, WNOHANG
);
692 /* Abnormal death. */
693 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
694 ourstatus
->value
.sig
= exit_signo
;
699 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
700 ourstatus
->value
.integer
= WEXITSTATUS (waitval
);
706 case _DEBUG_WHY_REQUESTED
:
707 /* We are assuming a requested stop is due to a SIGINT. */
708 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
709 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
715 return inferior_ptid
;
718 /* Read the current values of the inferior's registers, both the
719 general register set and floating point registers (if supported)
720 and update gdb's idea of their current values. */
722 procfs_fetch_registers (int regno
)
728 procfs_altreg altreg
;
733 procfs_set_thread (inferior_ptid
);
734 if (devctl (ctl_fd
, DCMD_PROC_GETGREG
, ®
, sizeof (reg
), ®size
) == EOK
)
735 nto_supply_gregset ((char *) ®
.greg
);
736 if (devctl (ctl_fd
, DCMD_PROC_GETFPREG
, ®
, sizeof (reg
), ®size
)
738 nto_supply_fpregset ((char *) ®
.fpreg
);
739 if (devctl (ctl_fd
, DCMD_PROC_GETALTREG
, ®
, sizeof (reg
), ®size
)
741 nto_supply_altregset ((char *) ®
.altreg
);
744 /* Copy LEN bytes to/from inferior's memory starting at MEMADDR
745 from/to debugger memory starting at MYADDR. Copy from inferior
746 if DOWRITE is zero or to inferior if DOWRITE is nonzero.
748 Returns the length copied, which is either the LEN argument or
749 zero. This xfer function does not do partial moves, since procfs_ops
750 doesn't allow memory operations to cross below us in the target stack
753 procfs_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int dowrite
,
754 struct mem_attrib
*attrib
, struct target_ops
*target
)
758 if (lseek (ctl_fd
, (off_t
) memaddr
, SEEK_SET
) == (off_t
) memaddr
)
761 nbytes
= write (ctl_fd
, myaddr
, len
);
763 nbytes
= read (ctl_fd
, myaddr
, len
);
770 /* Take a program previously attached to and detaches it.
771 The program resumes execution and will no longer stop
772 on signals, etc. We'd better not have left any breakpoints
773 in the program or it'll die when it hits one. */
775 procfs_detach (char *args
, int from_tty
)
781 char *exec_file
= get_exec_file (0);
784 printf_unfiltered ("Detaching from program: %s %s\n",
785 exec_file
, target_pid_to_str (inferior_ptid
));
786 gdb_flush (gdb_stdout
);
789 siggnal
= atoi (args
);
792 SignalKill (nto_node (), PIDGET (inferior_ptid
), 0, siggnal
, 0, 0);
797 inferior_ptid
= null_ptid
;
799 unpush_target (&procfs_ops
); /* Pop out of handling an inferior. */
803 procfs_breakpoint (CORE_ADDR addr
, int type
, int size
)
810 errno
= devctl (ctl_fd
, DCMD_PROC_BREAK
, &brk
, sizeof (brk
), 0);
817 procfs_insert_breakpoint (CORE_ADDR addr
, char *contents_cache
)
819 return procfs_breakpoint (addr
, _DEBUG_BREAK_EXEC
, 0);
823 procfs_remove_breakpoint (CORE_ADDR addr
, char *contents_cache
)
825 return procfs_breakpoint (addr
, _DEBUG_BREAK_EXEC
, -1);
829 procfs_insert_hw_breakpoint (CORE_ADDR addr
, char *contents_cache
)
831 return procfs_breakpoint (addr
, _DEBUG_BREAK_EXEC
| _DEBUG_BREAK_HW
, 0);
835 procfs_remove_hw_breakpoint (CORE_ADDR addr
, char *contents_cache
)
837 return procfs_breakpoint (addr
, _DEBUG_BREAK_EXEC
| _DEBUG_BREAK_HW
, -1);
841 procfs_resume (ptid_t ptid
, int step
, enum target_signal signo
)
844 procfs_status status
;
846 if (ptid_equal (inferior_ptid
, null_ptid
))
849 procfs_set_thread (ptid_equal (ptid
, minus_one_ptid
) ? inferior_ptid
:
852 run
.flags
= _DEBUG_RUN_FAULT
| _DEBUG_RUN_TRACE
;
854 run
.flags
|= _DEBUG_RUN_STEP
;
856 sigemptyset ((sigset_t
*) &run
.fault
);
857 sigaddset ((sigset_t
*) &run
.fault
, FLTBPT
);
858 sigaddset ((sigset_t
*) &run
.fault
, FLTTRACE
);
859 sigaddset ((sigset_t
*) &run
.fault
, FLTILL
);
860 sigaddset ((sigset_t
*) &run
.fault
, FLTPRIV
);
861 sigaddset ((sigset_t
*) &run
.fault
, FLTBOUNDS
);
862 sigaddset ((sigset_t
*) &run
.fault
, FLTIOVF
);
863 sigaddset ((sigset_t
*) &run
.fault
, FLTIZDIV
);
864 sigaddset ((sigset_t
*) &run
.fault
, FLTFPE
);
865 /* Peter V will be changing this at some point. */
866 sigaddset ((sigset_t
*) &run
.fault
, FLTPAGE
);
868 run
.flags
|= _DEBUG_RUN_ARM
;
870 sigemptyset (&run
.trace
);
872 signal_to_pass
= target_signal_to_host (signo
);
876 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
877 signal_to_pass
= target_signal_to_host (signo
);
878 if (status
.why
& (_DEBUG_WHY_SIGNALLED
| _DEBUG_WHY_FAULTED
))
880 if (signal_to_pass
!= status
.info
.si_signo
)
882 SignalKill (nto_node (), PIDGET (inferior_ptid
), 0,
883 signal_to_pass
, 0, 0);
884 run
.flags
|= _DEBUG_RUN_CLRFLT
| _DEBUG_RUN_CLRSIG
;
886 else /* Let it kill the program without telling us. */
887 sigdelset (&run
.trace
, signal_to_pass
);
891 run
.flags
|= _DEBUG_RUN_CLRSIG
| _DEBUG_RUN_CLRFLT
;
893 errno
= devctl (ctl_fd
, DCMD_PROC_RUN
, &run
, sizeof (run
), 0);
896 perror ("run error!\n");
902 procfs_mourn_inferior (void)
904 if (!ptid_equal (inferior_ptid
, null_ptid
))
906 SignalKill (nto_node (), PIDGET (inferior_ptid
), 0, SIGKILL
, 0, 0);
909 inferior_ptid
= null_ptid
;
911 unpush_target (&procfs_ops
);
912 generic_mourn_inferior ();
916 /* This function breaks up an argument string into an argument
917 vector suitable for passing to execvp().
918 E.g., on "run a b c d" this routine would get as input
919 the string "a b c d", and as output it would fill in argv with
920 the four arguments "a", "b", "c", "d". The only additional
921 functionality is simple quoting. The gdb command:
923 will fill in argv with the three args "a", "b c d", "e". */
925 breakup_args (char *scratch
, char **argv
)
927 char *pp
, *cp
= scratch
;
932 /* Scan past leading separators. */
934 while (*cp
== ' ' || *cp
== '\t' || *cp
== '\n')
937 /* Break if at end of string. */
945 quoting
= strchr (cp
, '"') ? 1 : 0;
950 /* Scan for next arg separator. */
953 cp
= strchr (pp
, '"');
954 if ((cp
== NULL
) || (!quoting
))
955 cp
= strchr (pp
, ' ');
957 cp
= strchr (pp
, '\t');
959 cp
= strchr (pp
, '\n');
961 /* No separators => end of string => break. */
968 /* Replace the separator with a terminator. */
972 /* Execv requires a null-terminated arg vector. */
977 procfs_create_inferior (char *exec_file
, char *allargs
, char **env
,
980 struct inheritance inherit
;
984 const char *in
= "", *out
= "", *err
= "";
987 const char *inferior_io_terminal
= get_inferior_io_terminal ();
989 argv
= xmalloc (((strlen (allargs
) + 1) / (unsigned) 2 + 2) *
991 argv
[0] = get_exec_file (1);
1000 args
= xstrdup (allargs
);
1001 breakup_args (args
, exec_file
? &argv
[1] : &argv
[0]);
1003 argv
= nto_parse_redirection (argv
, &in
, &out
, &err
);
1005 fds
[0] = STDIN_FILENO
;
1006 fds
[1] = STDOUT_FILENO
;
1007 fds
[2] = STDERR_FILENO
;
1009 /* If the user specified I/O via gdb's --tty= arg, use it, but only
1010 if the i/o is not also being specified via redirection. */
1011 if (inferior_io_terminal
)
1014 in
= inferior_io_terminal
;
1016 out
= inferior_io_terminal
;
1018 err
= inferior_io_terminal
;
1023 fd
= open (in
, O_RDONLY
);
1031 fd
= open (out
, O_WRONLY
);
1039 fd
= open (err
, O_WRONLY
);
1046 /* Clear any pending SIGUSR1's but keep the behavior the same. */
1047 signal (SIGUSR1
, signal (SIGUSR1
, SIG_IGN
));
1050 sigaddset (&set
, SIGUSR1
);
1051 sigprocmask (SIG_UNBLOCK
, &set
, NULL
);
1053 memset (&inherit
, 0, sizeof (inherit
));
1055 if (ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) != 0)
1057 inherit
.nd
= nto_node ();
1058 inherit
.flags
|= SPAWN_SETND
;
1059 inherit
.flags
&= ~SPAWN_EXEC
;
1061 inherit
.flags
|= SPAWN_SETGROUP
| SPAWN_HOLD
;
1062 inherit
.pgroup
= SPAWN_NEWPGROUP
;
1063 pid
= spawnp (argv
[0], 3, fds
, &inherit
, argv
,
1064 ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) == 0 ? env
: 0);
1067 sigprocmask (SIG_BLOCK
, &set
, NULL
);
1070 error (_("Error spawning %s: %d (%s)"), argv
[0], errno
,
1071 safe_strerror (errno
));
1073 if (fds
[0] != STDIN_FILENO
)
1075 if (fds
[1] != STDOUT_FILENO
)
1077 if (fds
[2] != STDERR_FILENO
)
1080 inferior_ptid
= do_attach (pid_to_ptid (pid
));
1083 flags
= _DEBUG_FLAG_KLC
; /* Kill-on-Last-Close flag. */
1084 errn
= devctl (ctl_fd
, DCMD_PROC_SET_FLAG
, &flags
, sizeof (flags
), 0);
1087 /* FIXME: expected warning? */
1088 /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
1089 errn, strerror(errn) ); */
1091 push_target (&procfs_ops
);
1092 target_terminal_init ();
1094 #ifdef SOLIB_CREATE_INFERIOR_HOOK
1095 if (exec_bfd
!= NULL
1096 || (symfile_objfile
!= NULL
&& symfile_objfile
->obfd
!= NULL
))
1097 SOLIB_CREATE_INFERIOR_HOOK (pid
);
1100 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
1106 devctl (ctl_fd
, DCMD_PROC_STOP
, NULL
, 0, 0);
1110 procfs_kill_inferior (void)
1112 target_mourn_inferior ();
1115 /* Store register REGNO, or all registers if REGNO == -1, from the contents
1118 procfs_prepare_to_store (void)
1122 /* Fill buf with regset and return devctl cmd to do the setting. Return
1123 -1 if we fail to get the regset. Store size of regset in regsize. */
1125 get_regset (int regset
, char *buf
, int bufsize
, int *regsize
)
1127 int dev_get
, dev_set
;
1130 case NTO_REG_GENERAL
:
1131 dev_get
= DCMD_PROC_GETGREG
;
1132 dev_set
= DCMD_PROC_SETGREG
;
1136 dev_get
= DCMD_PROC_GETFPREG
;
1137 dev_set
= DCMD_PROC_SETFPREG
;
1141 dev_get
= DCMD_PROC_GETALTREG
;
1142 dev_set
= DCMD_PROC_SETALTREG
;
1145 case NTO_REG_SYSTEM
:
1149 if (devctl (ctl_fd
, dev_get
, &buf
, bufsize
, regsize
) != EOK
)
1156 procfs_store_registers (int regno
)
1162 procfs_altreg altreg
;
1166 int len
, regset
, regsize
, dev_set
, err
;
1169 if (ptid_equal (inferior_ptid
, null_ptid
))
1171 procfs_set_thread (inferior_ptid
);
1175 for (regset
= NTO_REG_GENERAL
; regset
< NTO_REG_END
; regset
++)
1177 dev_set
= get_regset (regset
, (char *) ®
,
1178 sizeof (reg
), ®size
);
1182 if (nto_regset_fill (regset
, (char *) ®
) == -1)
1185 err
= devctl (ctl_fd
, dev_set
, ®
, regsize
, 0);
1187 fprintf_unfiltered (gdb_stderr
,
1188 "Warning unable to write regset %d: %s\n",
1189 regno
, safe_strerror (err
));
1194 regset
= nto_regset_id (regno
);
1198 dev_set
= get_regset (regset
, (char *) ®
, sizeof (reg
), ®size
);
1202 len
= nto_register_area (regno
, regset
, &off
);
1207 regcache_raw_collect (current_regcache
, regno
, (char *) ®
+ off
);
1209 err
= devctl (ctl_fd
, dev_set
, ®
, regsize
, 0);
1211 fprintf_unfiltered (gdb_stderr
,
1212 "Warning unable to write regset %d: %s\n", regno
,
1213 safe_strerror (err
));
1218 notice_signals (void)
1222 for (signo
= 1; signo
< NSIG
; signo
++)
1224 if (signal_stop_state (target_signal_from_host (signo
)) == 0
1225 && signal_print_state (target_signal_from_host (signo
)) == 0
1226 && signal_pass_state (target_signal_from_host (signo
)) == 1)
1227 sigdelset (&run
.trace
, signo
);
1229 sigaddset (&run
.trace
, signo
);
1233 /* When the user changes the state of gdb's signal handling via the
1234 "handle" command, this function gets called to see if any change
1235 in the /proc interface is required. It is also called internally
1236 by other /proc interface functions to initialize the state of
1237 the traced signal set. */
1239 procfs_notice_signals (ptid_t ptid
)
1241 sigemptyset (&run
.trace
);
1245 static struct tidinfo
*
1246 procfs_thread_info (pid_t pid
, short tid
)
1253 procfs_pid_to_str (ptid_t ptid
)
1255 static char buf
[1024];
1257 struct tidinfo
*tip
;
1259 pid
= ptid_get_pid (ptid
);
1260 tid
= ptid_get_tid (ptid
);
1262 n
= snprintf (buf
, 1023, "process %d", pid
);
1265 tip
= procfs_thread_info (pid
, tid
);
1267 snprintf (&buf
[n
], 1023, " (state = 0x%02x)", tip
->state
);
1274 init_procfs_ops (void)
1276 procfs_ops
.to_shortname
= "procfs";
1277 procfs_ops
.to_longname
= "QNX Neutrino procfs child process";
1279 "QNX Neutrino procfs child process (started by the \"run\" command).\n\
1280 target procfs <node>";
1281 procfs_ops
.to_open
= procfs_open
;
1282 procfs_ops
.to_attach
= procfs_attach
;
1283 procfs_ops
.to_post_attach
= procfs_post_attach
;
1284 procfs_ops
.to_detach
= procfs_detach
;
1285 procfs_ops
.to_resume
= procfs_resume
;
1286 procfs_ops
.to_wait
= procfs_wait
;
1287 procfs_ops
.to_fetch_registers
= procfs_fetch_registers
;
1288 procfs_ops
.to_store_registers
= procfs_store_registers
;
1289 procfs_ops
.to_prepare_to_store
= procfs_prepare_to_store
;
1290 procfs_ops
.deprecated_xfer_memory
= procfs_xfer_memory
;
1291 procfs_ops
.to_files_info
= procfs_files_info
;
1292 procfs_ops
.to_insert_breakpoint
= procfs_insert_breakpoint
;
1293 procfs_ops
.to_remove_breakpoint
= procfs_remove_breakpoint
;
1294 procfs_ops
.to_can_use_hw_breakpoint
= procfs_can_use_hw_breakpoint
;
1295 procfs_ops
.to_insert_hw_breakpoint
= procfs_insert_hw_breakpoint
;
1296 procfs_ops
.to_remove_hw_breakpoint
= procfs_remove_breakpoint
;
1297 procfs_ops
.to_insert_watchpoint
= procfs_insert_hw_watchpoint
;
1298 procfs_ops
.to_remove_watchpoint
= procfs_remove_hw_watchpoint
;
1299 procfs_ops
.to_stopped_by_watchpoint
= procfs_stopped_by_watchpoint
;
1300 procfs_ops
.to_terminal_init
= terminal_init_inferior
;
1301 procfs_ops
.to_terminal_inferior
= terminal_inferior
;
1302 procfs_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1303 procfs_ops
.to_terminal_ours
= terminal_ours
;
1304 procfs_ops
.to_terminal_info
= child_terminal_info
;
1305 procfs_ops
.to_kill
= procfs_kill_inferior
;
1306 procfs_ops
.to_create_inferior
= procfs_create_inferior
;
1307 procfs_ops
.to_mourn_inferior
= procfs_mourn_inferior
;
1308 procfs_ops
.to_can_run
= procfs_can_run
;
1309 procfs_ops
.to_notice_signals
= procfs_notice_signals
;
1310 procfs_ops
.to_thread_alive
= procfs_thread_alive
;
1311 procfs_ops
.to_find_new_threads
= procfs_find_new_threads
;
1312 procfs_ops
.to_pid_to_str
= procfs_pid_to_str
;
1313 procfs_ops
.to_stop
= procfs_stop
;
1314 procfs_ops
.to_stratum
= process_stratum
;
1315 procfs_ops
.to_has_all_memory
= 1;
1316 procfs_ops
.to_has_memory
= 1;
1317 procfs_ops
.to_has_stack
= 1;
1318 procfs_ops
.to_has_registers
= 1;
1319 procfs_ops
.to_has_execution
= 1;
1320 procfs_ops
.to_magic
= OPS_MAGIC
;
1321 procfs_ops
.to_have_continuable_watchpoint
= 1;
1324 #define OSTYPE_NTO 1
1327 _initialize_procfs (void)
1332 add_target (&procfs_ops
);
1334 /* We use SIGUSR1 to gain control after we block waiting for a process.
1335 We use sigwaitevent to wait. */
1337 sigaddset (&set
, SIGUSR1
);
1338 sigprocmask (SIG_BLOCK
, &set
, NULL
);
1340 /* Set up trace and fault sets, as gdb expects them. */
1341 sigemptyset (&run
.trace
);
1343 /* Stuff some information. */
1344 nto_cpuinfo_flags
= SYSPAGE_ENTRY (cpuinfo
)->flags
;
1345 nto_cpuinfo_valid
= 1;
1347 add_info ("pidlist", procfs_pidlist
, _("pidlist"));
1348 add_info ("meminfo", procfs_meminfo
, _("memory information"));
1350 nto_is_nto_target
= procfs_is_nto_target
;
1355 procfs_hw_watchpoint (int addr
, int len
, int type
)
1362 brk
.type
= _DEBUG_BREAK_RD
;
1364 case 2: /* Read/Write. */
1365 brk
.type
= _DEBUG_BREAK_RW
;
1367 default: /* Modify. */
1368 /* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason. */
1369 brk
.type
= _DEBUG_BREAK_RW
;
1371 brk
.type
|= _DEBUG_BREAK_HW
; /* Always ask for HW. */
1375 errno
= devctl (ctl_fd
, DCMD_PROC_BREAK
, &brk
, sizeof (brk
), 0);
1378 perror ("Failed to set hardware watchpoint");
1385 procfs_can_use_hw_breakpoint (int type
, int cnt
, int othertype
)
1391 procfs_remove_hw_watchpoint (CORE_ADDR addr
, int len
, int type
)
1393 return procfs_hw_watchpoint (addr
, -1, type
);
1397 procfs_insert_hw_watchpoint (CORE_ADDR addr
, int len
, int type
)
1399 return procfs_hw_watchpoint (addr
, len
, type
);
1403 procfs_stopped_by_watchpoint (void)