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 "gdb_string.h"
41 #include "gdbthread.h"
47 #define _DEBUG_FLAG_TRACE (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\
48 _DEBUG_FLAG_TRACE_WR|_DEBUG_FLAG_TRACE_MODIFY)
50 static struct target_ops procfs_ops
;
54 static void (*ofunc
) ();
56 static procfs_run run
;
58 static void procfs_open (char *, int);
60 static int procfs_can_run (void);
62 static ptid_t
procfs_wait (ptid_t
, struct target_waitstatus
*);
64 static int procfs_xfer_memory (CORE_ADDR
, char *, int, int,
65 struct mem_attrib
*attrib
,
68 static void procfs_fetch_registers (int);
70 static void notice_signals (void);
72 static void init_procfs_ops (void);
74 static ptid_t
do_attach (ptid_t ptid
);
76 static int procfs_can_use_hw_breakpoint (int, int, int);
78 static int procfs_insert_hw_breakpoint (CORE_ADDR
, char *);
80 static int procfs_remove_hw_breakpoint (CORE_ADDR addr
, char *);
82 static int procfs_insert_hw_watchpoint (CORE_ADDR addr
, int len
, int type
);
84 static int procfs_remove_hw_watchpoint (CORE_ADDR addr
, int len
, int type
);
86 static int procfs_stopped_by_watchpoint (void);
88 /* These two globals are only ever set in procfs_open(), but are
89 referenced elsewhere. 'nto_procfs_node' is a flag used to say
90 whether we are local, or we should get the current node descriptor
91 for the remote QNX node. */
92 static char nto_procfs_path
[PATH_MAX
] = { "/proc" };
93 static unsigned nto_procfs_node
= ND_LOCAL_NODE
;
95 /* Return the current QNX Node, or error out. This is a simple
96 wrapper for the netmgr_strtond() function. The reason this
97 is required is because QNX node descriptors are transient so
98 we have to re-acquire them every time. */
104 if (ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) == 0)
105 return ND_LOCAL_NODE
;
107 node
= netmgr_strtond (nto_procfs_path
, 0);
109 error ("Lost the QNX node. Debug session probably over.");
114 static enum gdb_osabi
115 procfs_is_nto_target (bfd
*abfd
)
117 return GDB_OSABI_QNXNTO
;
120 /* This is called when we call 'target procfs <arg>' from the (gdb) prompt.
121 For QNX6 (nto), the only valid arg will be a QNX node string,
122 eg: "/net/some_node". If arg is not a valid QNX node, we will
125 procfs_open (char *arg
, int from_tty
)
131 procfs_sysinfo
*sysinfo
;
133 nto_is_nto_target
= procfs_is_nto_target
;
135 /* Set the default node used for spawning to this one,
136 and only override it if there is a valid arg. */
138 nto_procfs_node
= ND_LOCAL_NODE
;
139 nodestr
= arg
? xstrdup (arg
) : arg
;
145 nto_procfs_node
= netmgr_strtond (nodestr
, &endstr
);
146 if (nto_procfs_node
== -1)
148 if (errno
== ENOTSUP
)
149 printf_filtered ("QNX Net Manager not found.\n");
150 printf_filtered ("Invalid QNX node %s: error %d (%s).\n", nodestr
,
151 errno
, safe_strerror (errno
));
154 nto_procfs_node
= ND_LOCAL_NODE
;
158 if (*(endstr
- 1) == '/')
164 snprintf (nto_procfs_path
, PATH_MAX
- 1, "%s%s", nodestr
? nodestr
: "",
169 fd
= open (nto_procfs_path
, O_RDONLY
);
172 printf_filtered ("Error opening %s : %d (%s)\n", nto_procfs_path
, errno
,
173 safe_strerror (errno
));
174 error ("Invalid procfs arg");
177 sysinfo
= (void *) buffer
;
178 if (devctl (fd
, DCMD_PROC_SYSINFO
, sysinfo
, sizeof buffer
, 0) != EOK
)
180 printf_filtered ("Error getting size: %d (%s)\n", errno
,
181 safe_strerror (errno
));
183 error ("Devctl failed.");
187 total_size
= sysinfo
->total_size
;
188 sysinfo
= alloca (total_size
);
191 printf_filtered ("Memory error: %d (%s)\n", errno
,
192 safe_strerror (errno
));
194 error ("alloca failed.");
198 if (devctl (fd
, DCMD_PROC_SYSINFO
, sysinfo
, total_size
, 0) != EOK
)
200 printf_filtered ("Error getting sysinfo: %d (%s)\n", errno
,
201 safe_strerror (errno
));
203 error ("Devctl failed.");
208 nto_map_arch_to_cputype (TARGET_ARCHITECTURE
->arch_name
))
211 error ("Invalid target CPU.");
217 printf_filtered ("Debugging using %s\n", nto_procfs_path
);
221 procfs_set_thread (ptid_t ptid
)
225 tid
= ptid_get_tid (ptid
);
226 devctl (ctl_fd
, DCMD_PROC_CURTHREAD
, &tid
, sizeof (tid
), 0);
229 /* Return nonzero if the thread TH is still alive. */
231 procfs_thread_alive (ptid_t ptid
)
235 tid
= ptid_get_tid (ptid
);
236 if (devctl (ctl_fd
, DCMD_PROC_CURTHREAD
, &tid
, sizeof (tid
), 0) == EOK
)
242 procfs_find_new_threads (void)
244 procfs_status status
;
251 pid
= ptid_get_pid (inferior_ptid
);
253 for (status
.tid
= 1;; ++status
.tid
)
255 if (devctl (ctl_fd
, DCMD_PROC_TIDSTATUS
, &status
, sizeof (status
), 0)
256 != EOK
&& status
.tid
!= 0)
258 ptid
= ptid_build (pid
, 0, status
.tid
);
259 if (!in_thread_list (ptid
))
266 procfs_pidlist (char *args
, int from_tty
)
269 struct dirent
*dirp
= NULL
;
272 procfs_info
*pidinfo
= NULL
;
273 procfs_debuginfo
*info
= NULL
;
274 procfs_status
*status
= NULL
;
275 pid_t num_threads
= 0;
279 dp
= opendir (nto_procfs_path
);
282 fprintf_unfiltered (gdb_stderr
, "failed to opendir \"%s\" - %d (%s)",
283 nto_procfs_path
, errno
, safe_strerror (errno
));
287 /* Start scan at first pid. */
292 /* Get the right pid and procfs path for the pid. */
301 snprintf (buf
, 511, "%s/%s/as", nto_procfs_path
, dirp
->d_name
);
302 pid
= atoi (dirp
->d_name
);
306 /* Open the procfs path. */
307 fd
= open (buf
, O_RDONLY
);
310 fprintf_unfiltered (gdb_stderr
, "failed to open %s - %d (%s)\n",
311 buf
, errno
, safe_strerror (errno
));
316 pidinfo
= (procfs_info
*) buf
;
317 if (devctl (fd
, DCMD_PROC_INFO
, pidinfo
, sizeof (buf
), 0) != EOK
)
319 fprintf_unfiltered (gdb_stderr
,
320 "devctl DCMD_PROC_INFO failed - %d (%s)\n",
321 errno
, safe_strerror (errno
));
324 num_threads
= pidinfo
->num_threads
;
326 info
= (procfs_debuginfo
*) buf
;
327 if (devctl (fd
, DCMD_PROC_MAPDEBUG_BASE
, info
, sizeof (buf
), 0) != EOK
)
328 strcpy (name
, "unavailable");
330 strcpy (name
, info
->path
);
332 /* Collect state info on all the threads. */
333 status
= (procfs_status
*) buf
;
334 for (status
->tid
= 1; status
->tid
<= num_threads
; status
->tid
++)
336 if (devctl (fd
, DCMD_PROC_TIDSTATUS
, status
, sizeof (buf
), 0) != EOK
339 if (status
->tid
!= 0)
340 printf_filtered ("%s - %d/%d\n", name
, pid
, status
->tid
);
344 while (dirp
!= NULL
);
352 procfs_meminfo (char *args
, int from_tty
)
354 procfs_mapinfo
*mapinfos
= NULL
;
355 static int num_mapinfos
= 0;
356 procfs_mapinfo
*mapinfo_p
, *mapinfo_p2
;
357 int flags
= ~0, err
, num
, i
, j
;
361 procfs_debuginfo info
;
362 char buff
[_POSIX_PATH_MAX
];
370 unsigned debug_vaddr
;
371 unsigned long long offset
;
376 unsigned long long ino
;
383 /* Get the number of map entrys. */
384 err
= devctl (ctl_fd
, DCMD_PROC_MAPINFO
, NULL
, 0, &num
);
387 printf ("failed devctl num mapinfos - %d (%s)\n", err
,
388 safe_strerror (err
));
392 mapinfos
= xmalloc (num
* sizeof (procfs_mapinfo
));
395 mapinfo_p
= mapinfos
;
397 /* Fill the map entrys. */
398 err
= devctl (ctl_fd
, DCMD_PROC_MAPINFO
, mapinfo_p
, num
399 * sizeof (procfs_mapinfo
), &num
);
402 printf ("failed devctl mapinfos - %d (%s)\n", err
, safe_strerror (err
));
407 num
= min (num
, num_mapinfos
);
409 /* Run through the list of mapinfos, and store the data and text info
410 so we can print it at the bottom of the loop. */
411 for (mapinfo_p
= mapinfos
, i
= 0; i
< num
; i
++, mapinfo_p
++)
413 if (!(mapinfo_p
->flags
& flags
))
416 if (mapinfo_p
->ino
== 0) /* Already visited. */
419 map
.info
.vaddr
= mapinfo_p
->vaddr
;
421 err
= devctl (ctl_fd
, DCMD_PROC_MAPDEBUG
, &map
, sizeof (map
), 0);
425 memset (&printme
, 0, sizeof printme
);
426 printme
.dev
= mapinfo_p
->dev
;
427 printme
.ino
= mapinfo_p
->ino
;
428 printme
.text
.addr
= mapinfo_p
->vaddr
;
429 printme
.text
.size
= mapinfo_p
->size
;
430 printme
.text
.flags
= mapinfo_p
->flags
;
431 printme
.text
.offset
= mapinfo_p
->offset
;
432 printme
.text
.debug_vaddr
= map
.info
.vaddr
;
433 strcpy (printme
.name
, map
.info
.path
);
435 /* Check for matching data. */
436 for (mapinfo_p2
= mapinfos
, j
= 0; j
< num
; j
++, mapinfo_p2
++)
438 if (mapinfo_p2
->vaddr
!= mapinfo_p
->vaddr
439 && mapinfo_p2
->ino
== mapinfo_p
->ino
440 && mapinfo_p2
->dev
== mapinfo_p
->dev
)
442 map
.info
.vaddr
= mapinfo_p2
->vaddr
;
444 devctl (ctl_fd
, DCMD_PROC_MAPDEBUG
, &map
, sizeof (map
), 0);
448 if (strcmp (map
.info
.path
, printme
.name
))
451 /* Lower debug_vaddr is always text, if nessessary, swap. */
452 if ((int) map
.info
.vaddr
< (int) printme
.text
.debug_vaddr
)
454 memcpy (&(printme
.data
), &(printme
.text
),
455 sizeof (printme
.data
));
456 printme
.text
.addr
= mapinfo_p2
->vaddr
;
457 printme
.text
.size
= mapinfo_p2
->size
;
458 printme
.text
.flags
= mapinfo_p2
->flags
;
459 printme
.text
.offset
= mapinfo_p2
->offset
;
460 printme
.text
.debug_vaddr
= map
.info
.vaddr
;
464 printme
.data
.addr
= mapinfo_p2
->vaddr
;
465 printme
.data
.size
= mapinfo_p2
->size
;
466 printme
.data
.flags
= mapinfo_p2
->flags
;
467 printme
.data
.offset
= mapinfo_p2
->offset
;
468 printme
.data
.debug_vaddr
= map
.info
.vaddr
;
475 printf_filtered ("%s\n", printme
.name
);
476 printf_filtered ("\ttext=%08x bytes @ 0x%08x\n", printme
.text
.size
,
478 printf_filtered ("\t\tflags=%08x\n", printme
.text
.flags
);
479 printf_filtered ("\t\tdebug=%08x\n", printme
.text
.debug_vaddr
);
480 printf_filtered ("\t\toffset=%016llx\n", printme
.text
.offset
);
481 if (printme
.data
.size
)
483 printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme
.data
.size
,
485 printf_filtered ("\t\tflags=%08x\n", printme
.data
.flags
);
486 printf_filtered ("\t\tdebug=%08x\n", printme
.data
.debug_vaddr
);
487 printf_filtered ("\t\toffset=%016llx\n", printme
.data
.offset
);
489 printf_filtered ("\tdev=0x%x\n", printme
.dev
);
490 printf_filtered ("\tino=0x%x\n", (unsigned int) printme
.ino
);
496 /* Print status information about what we're accessing. */
498 procfs_files_info (struct target_ops
*ignore
)
500 printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
501 attach_flag
? "attached" : "child",
502 target_pid_to_str (inferior_ptid
), nto_procfs_path
);
505 /* Mark our target-struct as eligible for stray "run" and "attach" commands. */
507 procfs_can_run (void)
512 /* Attach to process PID, then initialize for debugging it. */
514 procfs_attach (char *args
, int from_tty
)
520 error_no_arg ("process-id to attach");
524 if (pid
== getpid ())
525 error ("Attaching GDB to itself is not a good idea...");
529 exec_file
= (char *) get_exec_file (0);
532 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
533 target_pid_to_str (pid_to_ptid (pid
)));
535 printf_unfiltered ("Attaching to %s\n",
536 target_pid_to_str (pid_to_ptid (pid
)));
538 gdb_flush (gdb_stdout
);
540 inferior_ptid
= do_attach (pid_to_ptid (pid
));
541 push_target (&procfs_ops
);
545 procfs_post_attach (pid_t pid
)
547 #ifdef SOLIB_CREATE_INFERIOR_HOOK
549 SOLIB_CREATE_INFERIOR_HOOK (pid
);
554 do_attach (ptid_t ptid
)
556 procfs_status status
;
557 struct sigevent event
;
560 snprintf (path
, PATH_MAX
- 1, "%s/%d/as", nto_procfs_path
, PIDGET (ptid
));
561 ctl_fd
= open (path
, O_RDWR
);
563 error ("Couldn't open proc file %s, error %d (%s)", path
, errno
,
564 safe_strerror (errno
));
565 if (devctl (ctl_fd
, DCMD_PROC_STOP
, &status
, sizeof (status
), 0) != EOK
)
566 error ("Couldn't stop process");
568 /* Define a sigevent for process stopped notification. */
569 event
.sigev_notify
= SIGEV_SIGNAL_THREAD
;
570 event
.sigev_signo
= SIGUSR1
;
571 event
.sigev_code
= 0;
572 event
.sigev_value
.sival_ptr
= NULL
;
573 event
.sigev_priority
= -1;
574 devctl (ctl_fd
, DCMD_PROC_EVENT
, &event
, sizeof (event
), 0);
576 if (devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0) == EOK
577 && status
.flags
& _DEBUG_FLAG_STOPPED
)
578 SignalKill (nto_node (), PIDGET (ptid
), 0, SIGCONT
, 0, 0);
580 nto_init_solib_absolute_prefix ();
584 /* Ask the user what to do when an interrupt is received. */
586 interrupt_query (void)
588 target_terminal_ours ();
590 if (query ("Interrupted while waiting for the program.\n\
591 Give up (and stop debugging it)? "))
593 target_mourn_inferior ();
594 throw_exception (RETURN_QUIT
);
597 target_terminal_inferior ();
600 /* The user typed ^C twice. */
602 nto_interrupt_twice (int signo
)
604 signal (signo
, ofunc
);
606 signal (signo
, nto_interrupt_twice
);
610 nto_interrupt (int signo
)
612 /* If this doesn't work, try more severe steps. */
613 signal (signo
, nto_interrupt_twice
);
619 procfs_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
623 procfs_status status
;
624 static int exit_signo
= 0; /* To track signals that cause termination. */
626 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
628 if (ptid_equal (inferior_ptid
, null_ptid
))
630 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
631 ourstatus
->value
.sig
= TARGET_SIGNAL_0
;
637 sigaddset (&set
, SIGUSR1
);
639 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
640 while (!(status
.flags
& _DEBUG_FLAG_ISTOP
))
642 ofunc
= (void (*)()) signal (SIGINT
, nto_interrupt
);
643 sigwaitinfo (&set
, &info
);
644 signal (SIGINT
, ofunc
);
645 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
648 if (status
.flags
& _DEBUG_FLAG_SSTEP
)
650 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
651 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
653 /* Was it a breakpoint? */
654 else if (status
.flags
& _DEBUG_FLAG_TRACE
)
656 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
657 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
659 else if (status
.flags
& _DEBUG_FLAG_ISTOP
)
663 case _DEBUG_WHY_SIGNALLED
:
664 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
665 ourstatus
->value
.sig
=
666 target_signal_from_host (status
.info
.si_signo
);
669 case _DEBUG_WHY_FAULTED
:
670 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
671 if (status
.info
.si_signo
== SIGTRAP
)
673 ourstatus
->value
.sig
= 0;
678 ourstatus
->value
.sig
=
679 target_signal_from_host (status
.info
.si_signo
);
680 exit_signo
= ourstatus
->value
.sig
;
684 case _DEBUG_WHY_TERMINATED
:
688 waitpid (PIDGET (inferior_ptid
), &waitval
, WNOHANG
);
691 /* Abnormal death. */
692 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
693 ourstatus
->value
.sig
= exit_signo
;
698 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
699 ourstatus
->value
.integer
= WEXITSTATUS (waitval
);
705 case _DEBUG_WHY_REQUESTED
:
706 /* We are assuming a requested stop is due to a SIGINT. */
707 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
708 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
714 return inferior_ptid
;
717 /* Read the current values of the inferior's registers, both the
718 general register set and floating point registers (if supported)
719 and update gdb's idea of their current values. */
721 procfs_fetch_registers (int regno
)
727 procfs_altreg altreg
;
732 procfs_set_thread (inferior_ptid
);
733 if (devctl (ctl_fd
, DCMD_PROC_GETGREG
, ®
, sizeof (reg
), ®size
) == EOK
)
734 nto_supply_gregset ((char *) ®
.greg
);
735 if (devctl (ctl_fd
, DCMD_PROC_GETFPREG
, ®
, sizeof (reg
), ®size
)
737 nto_supply_fpregset ((char *) ®
.fpreg
);
738 if (devctl (ctl_fd
, DCMD_PROC_GETALTREG
, ®
, sizeof (reg
), ®size
)
740 nto_supply_altregset ((char *) ®
.altreg
);
743 /* Copy LEN bytes to/from inferior's memory starting at MEMADDR
744 from/to debugger memory starting at MYADDR. Copy from inferior
745 if DOWRITE is zero or to inferior if DOWRITE is nonzero.
747 Returns the length copied, which is either the LEN argument or
748 zero. This xfer function does not do partial moves, since procfs_ops
749 doesn't allow memory operations to cross below us in the target stack
752 procfs_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int dowrite
,
753 struct mem_attrib
*attrib
, struct target_ops
*target
)
757 if (lseek (ctl_fd
, (off_t
) memaddr
, SEEK_SET
) == (off_t
) memaddr
)
760 nbytes
= write (ctl_fd
, myaddr
, len
);
762 nbytes
= read (ctl_fd
, myaddr
, len
);
769 /* Take a program previously attached to and detaches it.
770 The program resumes execution and will no longer stop
771 on signals, etc. We'd better not have left any breakpoints
772 in the program or it'll die when it hits one. */
774 procfs_detach (char *args
, int from_tty
)
780 char *exec_file
= get_exec_file (0);
783 printf_unfiltered ("Detaching from program: %s %s\n",
784 exec_file
, target_pid_to_str (inferior_ptid
));
785 gdb_flush (gdb_stdout
);
788 siggnal
= atoi (args
);
791 SignalKill (nto_node (), PIDGET (inferior_ptid
), 0, siggnal
, 0, 0);
796 inferior_ptid
= null_ptid
;
798 unpush_target (&procfs_ops
); /* Pop out of handling an inferior. */
802 procfs_breakpoint (CORE_ADDR addr
, int type
, int size
)
809 errno
= devctl (ctl_fd
, DCMD_PROC_BREAK
, &brk
, sizeof (brk
), 0);
816 procfs_insert_breakpoint (CORE_ADDR addr
, char *contents_cache
)
818 return procfs_breakpoint (addr
, _DEBUG_BREAK_EXEC
, 0);
822 procfs_remove_breakpoint (CORE_ADDR addr
, char *contents_cache
)
824 return procfs_breakpoint (addr
, _DEBUG_BREAK_EXEC
, -1);
828 procfs_insert_hw_breakpoint (CORE_ADDR addr
, char *contents_cache
)
830 return procfs_breakpoint (addr
, _DEBUG_BREAK_EXEC
| _DEBUG_BREAK_HW
, 0);
834 procfs_remove_hw_breakpoint (CORE_ADDR addr
, char *contents_cache
)
836 return procfs_breakpoint (addr
, _DEBUG_BREAK_EXEC
| _DEBUG_BREAK_HW
, -1);
840 procfs_resume (ptid_t ptid
, int step
, enum target_signal signo
)
843 procfs_status status
;
845 if (ptid_equal (inferior_ptid
, null_ptid
))
848 procfs_set_thread (ptid_equal (ptid
, minus_one_ptid
) ? inferior_ptid
:
851 run
.flags
= _DEBUG_RUN_FAULT
| _DEBUG_RUN_TRACE
;
853 run
.flags
|= _DEBUG_RUN_STEP
;
855 sigemptyset ((sigset_t
*) &run
.fault
);
856 sigaddset ((sigset_t
*) &run
.fault
, FLTBPT
);
857 sigaddset ((sigset_t
*) &run
.fault
, FLTTRACE
);
858 sigaddset ((sigset_t
*) &run
.fault
, FLTILL
);
859 sigaddset ((sigset_t
*) &run
.fault
, FLTPRIV
);
860 sigaddset ((sigset_t
*) &run
.fault
, FLTBOUNDS
);
861 sigaddset ((sigset_t
*) &run
.fault
, FLTIOVF
);
862 sigaddset ((sigset_t
*) &run
.fault
, FLTIZDIV
);
863 sigaddset ((sigset_t
*) &run
.fault
, FLTFPE
);
864 /* Peter V will be changing this at some point. */
865 sigaddset ((sigset_t
*) &run
.fault
, FLTPAGE
);
867 run
.flags
|= _DEBUG_RUN_ARM
;
869 sigemptyset (&run
.trace
);
871 signal_to_pass
= target_signal_to_host (signo
);
875 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
876 signal_to_pass
= target_signal_to_host (signo
);
877 if (status
.why
& (_DEBUG_WHY_SIGNALLED
| _DEBUG_WHY_FAULTED
))
879 if (signal_to_pass
!= status
.info
.si_signo
)
881 SignalKill (nto_node (), PIDGET (inferior_ptid
), 0,
882 signal_to_pass
, 0, 0);
883 run
.flags
|= _DEBUG_RUN_CLRFLT
| _DEBUG_RUN_CLRSIG
;
885 else /* Let it kill the program without telling us. */
886 sigdelset (&run
.trace
, signal_to_pass
);
890 run
.flags
|= _DEBUG_RUN_CLRSIG
| _DEBUG_RUN_CLRFLT
;
892 errno
= devctl (ctl_fd
, DCMD_PROC_RUN
, &run
, sizeof (run
), 0);
895 perror ("run error!\n");
901 procfs_mourn_inferior (void)
903 if (!ptid_equal (inferior_ptid
, null_ptid
))
905 SignalKill (nto_node (), PIDGET (inferior_ptid
), 0, SIGKILL
, 0, 0);
908 inferior_ptid
= null_ptid
;
910 unpush_target (&procfs_ops
);
911 generic_mourn_inferior ();
915 /* This function breaks up an argument string into an argument
916 vector suitable for passing to execvp().
917 E.g., on "run a b c d" this routine would get as input
918 the string "a b c d", and as output it would fill in argv with
919 the four arguments "a", "b", "c", "d". The only additional
920 functionality is simple quoting. The gdb command:
922 will fill in argv with the three args "a", "b c d", "e". */
924 breakup_args (char *scratch
, char **argv
)
926 char *pp
, *cp
= scratch
;
931 /* Scan past leading separators. */
933 while (*cp
== ' ' || *cp
== '\t' || *cp
== '\n')
936 /* Break if at end of string. */
944 quoting
= strchr (cp
, '"') ? 1 : 0;
949 /* Scan for next arg separator. */
952 cp
= strchr (pp
, '"');
953 if ((cp
== NULL
) || (!quoting
))
954 cp
= strchr (pp
, ' ');
956 cp
= strchr (pp
, '\t');
958 cp
= strchr (pp
, '\n');
960 /* No separators => end of string => break. */
967 /* Replace the separator with a terminator. */
971 /* Execv requires a null-terminated arg vector. */
976 procfs_create_inferior (char *exec_file
, char *allargs
, char **env
,
979 struct inheritance inherit
;
983 char *in
= "", *out
= "", *err
= "";
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 #ifdef SOLIB_CREATE_INFERIOR_HOOK
1093 if (exec_bfd
!= NULL
1094 || (symfile_objfile
!= NULL
&& symfile_objfile
->obfd
!= NULL
))
1095 SOLIB_CREATE_INFERIOR_HOOK (pid
);
1098 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
1104 devctl (ctl_fd
, DCMD_PROC_STOP
, NULL
, 0, 0);
1108 procfs_kill_inferior (void)
1110 target_mourn_inferior ();
1113 /* Store register REGNO, or all registers if REGNO == -1, from the contents
1116 procfs_prepare_to_store (void)
1120 /* Fill buf with regset and return devctl cmd to do the setting. Return
1121 -1 if we fail to get the regset. Store size of regset in regsize. */
1123 get_regset (int regset
, char *buf
, int bufsize
, int *regsize
)
1125 int dev_get
, dev_set
;
1128 case NTO_REG_GENERAL
:
1129 dev_get
= DCMD_PROC_GETGREG
;
1130 dev_set
= DCMD_PROC_SETGREG
;
1134 dev_get
= DCMD_PROC_GETFPREG
;
1135 dev_set
= DCMD_PROC_SETFPREG
;
1139 dev_get
= DCMD_PROC_GETALTREG
;
1140 dev_set
= DCMD_PROC_SETALTREG
;
1143 case NTO_REG_SYSTEM
:
1147 if (devctl (ctl_fd
, dev_get
, &buf
, bufsize
, regsize
) != EOK
)
1154 procfs_store_registers (int regno
)
1160 procfs_altreg altreg
;
1164 int len
, regset
, regsize
, dev_set
, err
;
1167 if (ptid_equal (inferior_ptid
, null_ptid
))
1169 procfs_set_thread (inferior_ptid
);
1173 for (regset
= NTO_REG_GENERAL
; regset
< NTO_REG_END
; regset
++)
1175 dev_set
= get_regset (regset
, (char *) ®
,
1176 sizeof (reg
), ®size
);
1180 if (nto_regset_fill (regset
, (char *) ®
) == -1)
1183 err
= devctl (ctl_fd
, dev_set
, ®
, regsize
, 0);
1185 fprintf_unfiltered (gdb_stderr
,
1186 "Warning unable to write regset %d: %s\n",
1187 regno
, safe_strerror (err
));
1192 regset
= nto_regset_id (regno
);
1196 dev_set
= get_regset (regset
, (char *) ®
, sizeof (reg
), ®size
);
1200 len
= nto_register_area (regno
, regset
, &off
);
1205 regcache_raw_collect (current_regcache
, regno
, (char *) ®
+ off
);
1207 err
= devctl (ctl_fd
, dev_set
, ®
, regsize
, 0);
1209 fprintf_unfiltered (gdb_stderr
,
1210 "Warning unable to write regset %d: %s\n", regno
,
1211 safe_strerror (err
));
1216 notice_signals (void)
1220 for (signo
= 1; signo
< NSIG
; signo
++)
1222 if (signal_stop_state (target_signal_from_host (signo
)) == 0
1223 && signal_print_state (target_signal_from_host (signo
)) == 0
1224 && signal_pass_state (target_signal_from_host (signo
)) == 1)
1225 sigdelset (&run
.trace
, signo
);
1227 sigaddset (&run
.trace
, signo
);
1231 /* When the user changes the state of gdb's signal handling via the
1232 "handle" command, this function gets called to see if any change
1233 in the /proc interface is required. It is also called internally
1234 by other /proc interface functions to initialize the state of
1235 the traced signal set. */
1237 procfs_notice_signals (ptid_t ptid
)
1239 sigemptyset (&run
.trace
);
1243 static struct tidinfo
*
1244 procfs_thread_info (pid_t pid
, short tid
)
1251 procfs_pid_to_str (ptid_t ptid
)
1253 static char buf
[1024];
1255 struct tidinfo
*tip
;
1257 pid
= ptid_get_pid (ptid
);
1258 tid
= ptid_get_tid (ptid
);
1260 n
= snprintf (buf
, 1023, "process %d", pid
);
1263 tip
= procfs_thread_info (pid
, tid
);
1265 snprintf (&buf
[n
], 1023, " (state = 0x%02x)", tip
->state
);
1272 init_procfs_ops (void)
1274 procfs_ops
.to_shortname
= "procfs";
1275 procfs_ops
.to_longname
= "QNX Neutrino procfs child process";
1277 "QNX Neutrino procfs child process (started by the \"run\" command).\n\
1278 target procfs <node>";
1279 procfs_ops
.to_open
= procfs_open
;
1280 procfs_ops
.to_attach
= procfs_attach
;
1281 procfs_ops
.to_post_attach
= procfs_post_attach
;
1282 procfs_ops
.to_detach
= procfs_detach
;
1283 procfs_ops
.to_resume
= procfs_resume
;
1284 procfs_ops
.to_wait
= procfs_wait
;
1285 procfs_ops
.to_fetch_registers
= procfs_fetch_registers
;
1286 procfs_ops
.to_store_registers
= procfs_store_registers
;
1287 procfs_ops
.to_prepare_to_store
= procfs_prepare_to_store
;
1288 procfs_ops
.deprecated_xfer_memory
= procfs_xfer_memory
;
1289 procfs_ops
.to_files_info
= procfs_files_info
;
1290 procfs_ops
.to_insert_breakpoint
= procfs_insert_breakpoint
;
1291 procfs_ops
.to_remove_breakpoint
= procfs_remove_breakpoint
;
1292 procfs_ops
.to_can_use_hw_breakpoint
= procfs_can_use_hw_breakpoint
;
1293 procfs_ops
.to_insert_hw_breakpoint
= procfs_insert_hw_breakpoint
;
1294 procfs_ops
.to_remove_hw_breakpoint
= procfs_remove_breakpoint
;
1295 procfs_ops
.to_insert_watchpoint
= procfs_insert_hw_watchpoint
;
1296 procfs_ops
.to_remove_watchpoint
= procfs_remove_hw_watchpoint
;
1297 procfs_ops
.to_stopped_by_watchpoint
= procfs_stopped_by_watchpoint
;
1298 procfs_ops
.to_terminal_init
= terminal_init_inferior
;
1299 procfs_ops
.to_terminal_inferior
= terminal_inferior
;
1300 procfs_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1301 procfs_ops
.to_terminal_ours
= terminal_ours
;
1302 procfs_ops
.to_terminal_info
= child_terminal_info
;
1303 procfs_ops
.to_kill
= procfs_kill_inferior
;
1304 procfs_ops
.to_create_inferior
= procfs_create_inferior
;
1305 procfs_ops
.to_mourn_inferior
= procfs_mourn_inferior
;
1306 procfs_ops
.to_can_run
= procfs_can_run
;
1307 procfs_ops
.to_notice_signals
= procfs_notice_signals
;
1308 procfs_ops
.to_thread_alive
= procfs_thread_alive
;
1309 procfs_ops
.to_find_new_threads
= procfs_find_new_threads
;
1310 procfs_ops
.to_pid_to_str
= procfs_pid_to_str
;
1311 procfs_ops
.to_stop
= procfs_stop
;
1312 procfs_ops
.to_stratum
= process_stratum
;
1313 procfs_ops
.to_has_all_memory
= 1;
1314 procfs_ops
.to_has_memory
= 1;
1315 procfs_ops
.to_has_stack
= 1;
1316 procfs_ops
.to_has_registers
= 1;
1317 procfs_ops
.to_has_execution
= 1;
1318 procfs_ops
.to_magic
= OPS_MAGIC
;
1319 procfs_ops
.to_have_continuable_watchpoint
= 1;
1322 #define OSTYPE_NTO 1
1325 _initialize_procfs (void)
1330 add_target (&procfs_ops
);
1332 /* We use SIGUSR1 to gain control after we block waiting for a process.
1333 We use sigwaitevent to wait. */
1335 sigaddset (&set
, SIGUSR1
);
1336 sigprocmask (SIG_BLOCK
, &set
, NULL
);
1338 /* Set up trace and fault sets, as gdb expects them. */
1339 sigemptyset (&run
.trace
);
1341 /* Stuff some information. */
1342 nto_cpuinfo_flags
= SYSPAGE_ENTRY (cpuinfo
)->flags
;
1343 nto_cpuinfo_valid
= 1;
1345 add_info ("pidlist", procfs_pidlist
, "pidlist");
1346 add_info ("meminfo", procfs_meminfo
, "memory information");
1348 nto_is_nto_target
= procfs_is_nto_target
;
1353 procfs_hw_watchpoint (int addr
, int len
, int type
)
1360 brk
.type
= _DEBUG_BREAK_RD
;
1362 case 2: /* Read/Write. */
1363 brk
.type
= _DEBUG_BREAK_RW
;
1365 default: /* Modify. */
1366 /* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason. */
1367 brk
.type
= _DEBUG_BREAK_RW
;
1369 brk
.type
|= _DEBUG_BREAK_HW
; /* Always ask for HW. */
1373 errno
= devctl (ctl_fd
, DCMD_PROC_BREAK
, &brk
, sizeof (brk
), 0);
1376 perror ("Failed to set hardware watchpoint");
1383 procfs_can_use_hw_breakpoint (int type
, int cnt
, int othertype
)
1389 procfs_remove_hw_watchpoint (CORE_ADDR addr
, int len
, int type
)
1391 return procfs_hw_watchpoint (addr
, -1, type
);
1395 procfs_insert_hw_watchpoint (CORE_ADDR addr
, int len
, int type
)
1397 return procfs_hw_watchpoint (addr
, len
, type
);
1401 procfs_stopped_by_watchpoint (void)