1 /* Machine independent support for QNX Neutrino /proc (process file system)
2 for GDB. Written by Colin Burgess at QNX Software Systems Limited.
4 Copyright (C) 2003, 2006, 2007, 2008 Free Software Foundation, Inc.
6 Contributed by QNX Software Systems Ltd.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include <sys/debug.h>
28 #include <sys/procfs.h>
29 #include <sys/neutrino.h>
30 #include <sys/syspage.h>
31 #include "gdb_dirent.h"
32 #include <sys/netmgr.h>
34 #include "exceptions.h"
35 #include "gdb_string.h"
40 #include "gdbthread.h"
47 #define _DEBUG_FLAG_TRACE (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\
48 _DEBUG_FLAG_TRACE_WR|_DEBUG_FLAG_TRACE_MODIFY)
50 static struct target_ops procfs_ops
;
54 static void (*ofunc
) ();
56 static procfs_run run
;
58 static void procfs_open (char *, int);
60 static int procfs_can_run (void);
62 static ptid_t
procfs_wait (ptid_t
, struct target_waitstatus
*);
64 static int procfs_xfer_memory (CORE_ADDR
, gdb_byte
*, int, int,
65 struct mem_attrib
*attrib
,
68 static void procfs_fetch_registers (struct regcache
*, int);
70 static void notice_signals (void);
72 static void init_procfs_ops (void);
74 static ptid_t
do_attach (ptid_t ptid
);
76 static int procfs_can_use_hw_breakpoint (int, int, int);
78 static int procfs_insert_hw_watchpoint (CORE_ADDR addr
, int len
, int type
);
80 static int procfs_remove_hw_watchpoint (CORE_ADDR addr
, int len
, int type
);
82 static int procfs_stopped_by_watchpoint (void);
84 /* These two globals are only ever set in procfs_open(), but are
85 referenced elsewhere. 'nto_procfs_node' is a flag used to say
86 whether we are local, or we should get the current node descriptor
87 for the remote QNX node. */
88 static char nto_procfs_path
[PATH_MAX
] = { "/proc" };
89 static unsigned nto_procfs_node
= ND_LOCAL_NODE
;
91 /* Return the current QNX Node, or error out. This is a simple
92 wrapper for the netmgr_strtond() function. The reason this
93 is required is because QNX node descriptors are transient so
94 we have to re-acquire them every time. */
100 if (ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) == 0)
101 return ND_LOCAL_NODE
;
103 node
= netmgr_strtond (nto_procfs_path
, 0);
105 error (_("Lost the QNX node. Debug session probably over."));
110 static enum gdb_osabi
111 procfs_is_nto_target (bfd
*abfd
)
113 return GDB_OSABI_QNXNTO
;
116 /* This is called when we call 'target procfs <arg>' from the (gdb) prompt.
117 For QNX6 (nto), the only valid arg will be a QNX node string,
118 eg: "/net/some_node". If arg is not a valid QNX node, we will
121 procfs_open (char *arg
, int from_tty
)
127 procfs_sysinfo
*sysinfo
;
128 struct cleanup
*cleanups
;
130 nto_is_nto_target
= procfs_is_nto_target
;
132 /* Set the default node used for spawning to this one,
133 and only override it if there is a valid arg. */
135 nto_procfs_node
= ND_LOCAL_NODE
;
136 nodestr
= arg
? xstrdup (arg
) : arg
;
142 nto_procfs_node
= netmgr_strtond (nodestr
, &endstr
);
143 if (nto_procfs_node
== -1)
145 if (errno
== ENOTSUP
)
146 printf_filtered ("QNX Net Manager not found.\n");
147 printf_filtered ("Invalid QNX node %s: error %d (%s).\n", nodestr
,
148 errno
, safe_strerror (errno
));
151 nto_procfs_node
= ND_LOCAL_NODE
;
155 if (*(endstr
- 1) == '/')
161 snprintf (nto_procfs_path
, PATH_MAX
- 1, "%s%s", nodestr
? nodestr
: "",
166 fd
= open (nto_procfs_path
, O_RDONLY
);
169 printf_filtered ("Error opening %s : %d (%s)\n", nto_procfs_path
, errno
,
170 safe_strerror (errno
));
171 error (_("Invalid procfs arg"));
173 cleanups
= make_cleanup_close (fd
);
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
));
180 error (_("Devctl failed."));
184 total_size
= sysinfo
->total_size
;
185 sysinfo
= alloca (total_size
);
188 printf_filtered ("Memory error: %d (%s)\n", errno
,
189 safe_strerror (errno
));
190 error (_("alloca failed."));
194 if (devctl (fd
, DCMD_PROC_SYSINFO
, sysinfo
, total_size
, 0) != EOK
)
196 printf_filtered ("Error getting sysinfo: %d (%s)\n", errno
,
197 safe_strerror (errno
));
198 error (_("Devctl failed."));
203 nto_map_arch_to_cputype (gdbarch_bfd_arch_info
204 (current_gdbarch
)->arch_name
))
205 error (_("Invalid target CPU."));
209 do_cleanups (cleanups
);
210 printf_filtered ("Debugging using %s\n", nto_procfs_path
);
214 procfs_set_thread (ptid_t ptid
)
218 tid
= ptid_get_tid (ptid
);
219 devctl (ctl_fd
, DCMD_PROC_CURTHREAD
, &tid
, sizeof (tid
), 0);
222 /* Return nonzero if the thread TH is still alive. */
224 procfs_thread_alive (ptid_t ptid
)
228 tid
= ptid_get_tid (ptid
);
229 if (devctl (ctl_fd
, DCMD_PROC_CURTHREAD
, &tid
, sizeof (tid
), 0) == EOK
)
235 procfs_find_new_threads (void)
237 procfs_status status
;
244 pid
= ptid_get_pid (inferior_ptid
);
246 for (status
.tid
= 1;; ++status
.tid
)
248 if (devctl (ctl_fd
, DCMD_PROC_TIDSTATUS
, &status
, sizeof (status
), 0)
249 != EOK
&& status
.tid
!= 0)
251 ptid
= ptid_build (pid
, 0, status
.tid
);
252 if (!in_thread_list (ptid
))
259 do_closedir_cleanup (void *dir
)
265 procfs_pidlist (char *args
, int from_tty
)
268 struct dirent
*dirp
= NULL
;
270 procfs_info
*pidinfo
= NULL
;
271 procfs_debuginfo
*info
= NULL
;
272 procfs_status
*status
= NULL
;
273 pid_t num_threads
= 0;
276 struct cleanup
*cleanups
;
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 cleanups
= make_cleanup (do_closedir_cleanup
, dp
);
288 /* Start scan at first pid. */
294 struct cleanup
*inner_cleanup
;
296 /* Get the right pid and procfs path for the pid. */
302 do_cleanups (cleanups
);
305 snprintf (buf
, 511, "%s/%s/as", nto_procfs_path
, dirp
->d_name
);
306 pid
= atoi (dirp
->d_name
);
310 /* Open the procfs path. */
311 fd
= open (buf
, O_RDONLY
);
314 fprintf_unfiltered (gdb_stderr
, "failed to open %s - %d (%s)\n",
315 buf
, errno
, safe_strerror (errno
));
316 do_cleanups (cleanups
);
319 inner_cleanup
= make_cleanup_close (fd
);
321 pidinfo
= (procfs_info
*) buf
;
322 if (devctl (fd
, DCMD_PROC_INFO
, pidinfo
, sizeof (buf
), 0) != EOK
)
324 fprintf_unfiltered (gdb_stderr
,
325 "devctl DCMD_PROC_INFO failed - %d (%s)\n",
326 errno
, safe_strerror (errno
));
329 num_threads
= pidinfo
->num_threads
;
331 info
= (procfs_debuginfo
*) buf
;
332 if (devctl (fd
, DCMD_PROC_MAPDEBUG_BASE
, info
, sizeof (buf
), 0) != EOK
)
333 strcpy (name
, "unavailable");
335 strcpy (name
, info
->path
);
337 /* Collect state info on all the threads. */
338 status
= (procfs_status
*) buf
;
339 for (status
->tid
= 1; status
->tid
<= num_threads
; status
->tid
++)
341 if (devctl (fd
, DCMD_PROC_TIDSTATUS
, status
, sizeof (buf
), 0) != EOK
344 if (status
->tid
!= 0)
345 printf_filtered ("%s - %d/%d\n", name
, pid
, status
->tid
);
348 do_cleanups (inner_cleanup
);
350 while (dirp
!= NULL
);
352 do_cleanups (cleanups
);
357 procfs_meminfo (char *args
, int from_tty
)
359 procfs_mapinfo
*mapinfos
= NULL
;
360 static int num_mapinfos
= 0;
361 procfs_mapinfo
*mapinfo_p
, *mapinfo_p2
;
362 int flags
= ~0, err
, num
, i
, j
;
366 procfs_debuginfo info
;
367 char buff
[_POSIX_PATH_MAX
];
375 unsigned debug_vaddr
;
376 unsigned long long offset
;
381 unsigned long long ino
;
388 /* Get the number of map entrys. */
389 err
= devctl (ctl_fd
, DCMD_PROC_MAPINFO
, NULL
, 0, &num
);
392 printf ("failed devctl num mapinfos - %d (%s)\n", err
,
393 safe_strerror (err
));
397 mapinfos
= xmalloc (num
* sizeof (procfs_mapinfo
));
400 mapinfo_p
= mapinfos
;
402 /* Fill the map entrys. */
403 err
= devctl (ctl_fd
, DCMD_PROC_MAPINFO
, mapinfo_p
, num
404 * sizeof (procfs_mapinfo
), &num
);
407 printf ("failed devctl mapinfos - %d (%s)\n", err
, safe_strerror (err
));
412 num
= min (num
, num_mapinfos
);
414 /* Run through the list of mapinfos, and store the data and text info
415 so we can print it at the bottom of the loop. */
416 for (mapinfo_p
= mapinfos
, i
= 0; i
< num
; i
++, mapinfo_p
++)
418 if (!(mapinfo_p
->flags
& flags
))
421 if (mapinfo_p
->ino
== 0) /* Already visited. */
424 map
.info
.vaddr
= mapinfo_p
->vaddr
;
426 err
= devctl (ctl_fd
, DCMD_PROC_MAPDEBUG
, &map
, sizeof (map
), 0);
430 memset (&printme
, 0, sizeof printme
);
431 printme
.dev
= mapinfo_p
->dev
;
432 printme
.ino
= mapinfo_p
->ino
;
433 printme
.text
.addr
= mapinfo_p
->vaddr
;
434 printme
.text
.size
= mapinfo_p
->size
;
435 printme
.text
.flags
= mapinfo_p
->flags
;
436 printme
.text
.offset
= mapinfo_p
->offset
;
437 printme
.text
.debug_vaddr
= map
.info
.vaddr
;
438 strcpy (printme
.name
, map
.info
.path
);
440 /* Check for matching data. */
441 for (mapinfo_p2
= mapinfos
, j
= 0; j
< num
; j
++, mapinfo_p2
++)
443 if (mapinfo_p2
->vaddr
!= mapinfo_p
->vaddr
444 && mapinfo_p2
->ino
== mapinfo_p
->ino
445 && mapinfo_p2
->dev
== mapinfo_p
->dev
)
447 map
.info
.vaddr
= mapinfo_p2
->vaddr
;
449 devctl (ctl_fd
, DCMD_PROC_MAPDEBUG
, &map
, sizeof (map
), 0);
453 if (strcmp (map
.info
.path
, printme
.name
))
456 /* Lower debug_vaddr is always text, if nessessary, swap. */
457 if ((int) map
.info
.vaddr
< (int) printme
.text
.debug_vaddr
)
459 memcpy (&(printme
.data
), &(printme
.text
),
460 sizeof (printme
.data
));
461 printme
.text
.addr
= mapinfo_p2
->vaddr
;
462 printme
.text
.size
= mapinfo_p2
->size
;
463 printme
.text
.flags
= mapinfo_p2
->flags
;
464 printme
.text
.offset
= mapinfo_p2
->offset
;
465 printme
.text
.debug_vaddr
= map
.info
.vaddr
;
469 printme
.data
.addr
= mapinfo_p2
->vaddr
;
470 printme
.data
.size
= mapinfo_p2
->size
;
471 printme
.data
.flags
= mapinfo_p2
->flags
;
472 printme
.data
.offset
= mapinfo_p2
->offset
;
473 printme
.data
.debug_vaddr
= map
.info
.vaddr
;
480 printf_filtered ("%s\n", printme
.name
);
481 printf_filtered ("\ttext=%08x bytes @ 0x%08x\n", printme
.text
.size
,
483 printf_filtered ("\t\tflags=%08x\n", printme
.text
.flags
);
484 printf_filtered ("\t\tdebug=%08x\n", printme
.text
.debug_vaddr
);
485 printf_filtered ("\t\toffset=%016llx\n", printme
.text
.offset
);
486 if (printme
.data
.size
)
488 printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme
.data
.size
,
490 printf_filtered ("\t\tflags=%08x\n", printme
.data
.flags
);
491 printf_filtered ("\t\tdebug=%08x\n", printme
.data
.debug_vaddr
);
492 printf_filtered ("\t\toffset=%016llx\n", printme
.data
.offset
);
494 printf_filtered ("\tdev=0x%x\n", printme
.dev
);
495 printf_filtered ("\tino=0x%x\n", (unsigned int) printme
.ino
);
501 /* Print status information about what we're accessing. */
503 procfs_files_info (struct target_ops
*ignore
)
505 struct inferior
*inf
= current_inferior ();
507 printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
508 inf
->attach_flag
? "attached" : "child",
509 target_pid_to_str (inferior_ptid
), nto_procfs_path
);
512 /* Mark our target-struct as eligible for stray "run" and "attach" commands. */
514 procfs_can_run (void)
519 /* Attach to process PID, then initialize for debugging it. */
521 procfs_attach (struct target_ops
*ops
, char *args
, int from_tty
)
525 struct inferior
*inf
;
528 error_no_arg (_("process-id to attach"));
532 if (pid
== getpid ())
533 error (_("Attaching GDB to itself is not a good idea..."));
537 exec_file
= (char *) get_exec_file (0);
540 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
541 target_pid_to_str (pid_to_ptid (pid
)));
543 printf_unfiltered ("Attaching to %s\n",
544 target_pid_to_str (pid_to_ptid (pid
)));
546 gdb_flush (gdb_stdout
);
548 inferior_ptid
= do_attach (pid_to_ptid (pid
));
549 inf
= add_inferior (pid
);
550 inf
->attach_flag
= 1;
552 push_target (&procfs_ops
);
554 procfs_find_new_threads ();
558 procfs_post_attach (pid_t pid
)
561 solib_create_inferior_hook ();
565 do_attach (ptid_t ptid
)
567 procfs_status status
;
568 struct sigevent event
;
571 snprintf (path
, PATH_MAX
- 1, "%s/%d/as", nto_procfs_path
, PIDGET (ptid
));
572 ctl_fd
= open (path
, O_RDWR
);
574 error (_("Couldn't open proc file %s, error %d (%s)"), path
, errno
,
575 safe_strerror (errno
));
576 if (devctl (ctl_fd
, DCMD_PROC_STOP
, &status
, sizeof (status
), 0) != EOK
)
577 error (_("Couldn't stop process"));
579 /* Define a sigevent for process stopped notification. */
580 event
.sigev_notify
= SIGEV_SIGNAL_THREAD
;
581 event
.sigev_signo
= SIGUSR1
;
582 event
.sigev_code
= 0;
583 event
.sigev_value
.sival_ptr
= NULL
;
584 event
.sigev_priority
= -1;
585 devctl (ctl_fd
, DCMD_PROC_EVENT
, &event
, sizeof (event
), 0);
587 if (devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0) == EOK
588 && status
.flags
& _DEBUG_FLAG_STOPPED
)
589 SignalKill (nto_node (), PIDGET (ptid
), 0, SIGCONT
, 0, 0);
590 nto_init_solib_absolute_prefix ();
591 return ptid_build (PIDGET (ptid
), 0, status
.tid
);
594 /* Ask the user what to do when an interrupt is received. */
596 interrupt_query (void)
598 target_terminal_ours ();
600 if (query ("Interrupted while waiting for the program.\n\
601 Give up (and stop debugging it)? "))
603 target_mourn_inferior ();
604 deprecated_throw_reason (RETURN_QUIT
);
607 target_terminal_inferior ();
610 /* The user typed ^C twice. */
612 nto_interrupt_twice (int signo
)
614 signal (signo
, ofunc
);
616 signal (signo
, nto_interrupt_twice
);
620 nto_interrupt (int signo
)
622 /* If this doesn't work, try more severe steps. */
623 signal (signo
, nto_interrupt_twice
);
625 target_stop (inferior_ptid
);
629 procfs_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
633 procfs_status status
;
634 static int exit_signo
= 0; /* To track signals that cause termination. */
636 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
638 if (ptid_equal (inferior_ptid
, null_ptid
))
640 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
641 ourstatus
->value
.sig
= TARGET_SIGNAL_0
;
647 sigaddset (&set
, SIGUSR1
);
649 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
650 while (!(status
.flags
& _DEBUG_FLAG_ISTOP
))
652 ofunc
= (void (*)()) signal (SIGINT
, nto_interrupt
);
653 sigwaitinfo (&set
, &info
);
654 signal (SIGINT
, ofunc
);
655 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
658 if (status
.flags
& _DEBUG_FLAG_SSTEP
)
660 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
661 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
663 /* Was it a breakpoint? */
664 else if (status
.flags
& _DEBUG_FLAG_TRACE
)
666 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
667 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
669 else if (status
.flags
& _DEBUG_FLAG_ISTOP
)
673 case _DEBUG_WHY_SIGNALLED
:
674 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
675 ourstatus
->value
.sig
=
676 target_signal_from_host (status
.info
.si_signo
);
679 case _DEBUG_WHY_FAULTED
:
680 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
681 if (status
.info
.si_signo
== SIGTRAP
)
683 ourstatus
->value
.sig
= 0;
688 ourstatus
->value
.sig
=
689 target_signal_from_host (status
.info
.si_signo
);
690 exit_signo
= ourstatus
->value
.sig
;
694 case _DEBUG_WHY_TERMINATED
:
698 waitpid (PIDGET (inferior_ptid
), &waitval
, WNOHANG
);
701 /* Abnormal death. */
702 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
703 ourstatus
->value
.sig
= exit_signo
;
708 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
709 ourstatus
->value
.integer
= WEXITSTATUS (waitval
);
715 case _DEBUG_WHY_REQUESTED
:
716 /* We are assuming a requested stop is due to a SIGINT. */
717 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
718 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
724 return ptid_build (status
.pid
, 0, status
.tid
);
727 /* Read the current values of the inferior's registers, both the
728 general register set and floating point registers (if supported)
729 and update gdb's idea of their current values. */
731 procfs_fetch_registers (struct regcache
*regcache
, int regno
)
737 procfs_altreg altreg
;
742 procfs_set_thread (inferior_ptid
);
743 if (devctl (ctl_fd
, DCMD_PROC_GETGREG
, ®
, sizeof (reg
), ®size
) == EOK
)
744 nto_supply_gregset (regcache
, (char *) ®
.greg
);
745 if (devctl (ctl_fd
, DCMD_PROC_GETFPREG
, ®
, sizeof (reg
), ®size
)
747 nto_supply_fpregset (regcache
, (char *) ®
.fpreg
);
748 if (devctl (ctl_fd
, DCMD_PROC_GETALTREG
, ®
, sizeof (reg
), ®size
)
750 nto_supply_altregset (regcache
, (char *) ®
.altreg
);
753 /* Copy LEN bytes to/from inferior's memory starting at MEMADDR
754 from/to debugger memory starting at MYADDR. Copy from inferior
755 if DOWRITE is zero or to inferior if DOWRITE is nonzero.
757 Returns the length copied, which is either the LEN argument or
758 zero. This xfer function does not do partial moves, since procfs_ops
759 doesn't allow memory operations to cross below us in the target stack
762 procfs_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int dowrite
,
763 struct mem_attrib
*attrib
, struct target_ops
*target
)
767 if (lseek (ctl_fd
, (off_t
) memaddr
, SEEK_SET
) == (off_t
) memaddr
)
770 nbytes
= write (ctl_fd
, myaddr
, len
);
772 nbytes
= read (ctl_fd
, myaddr
, len
);
779 /* Take a program previously attached to and detaches it.
780 The program resumes execution and will no longer stop
781 on signals, etc. We'd better not have left any breakpoints
782 in the program or it'll die when it hits one. */
784 procfs_detach (struct target_ops
*ops
, char *args
, int from_tty
)
791 char *exec_file
= get_exec_file (0);
794 printf_unfiltered ("Detaching from program: %s %s\n",
795 exec_file
, target_pid_to_str (inferior_ptid
));
796 gdb_flush (gdb_stdout
);
799 siggnal
= atoi (args
);
802 SignalKill (nto_node (), PIDGET (inferior_ptid
), 0, siggnal
, 0, 0);
807 pid
= ptid_get_pid (inferior_ptid
);
808 inferior_ptid
= null_ptid
;
809 detach_inferior (pid
);
811 unpush_target (&procfs_ops
); /* Pop out of handling an inferior. */
815 procfs_breakpoint (CORE_ADDR addr
, int type
, int size
)
822 errno
= devctl (ctl_fd
, DCMD_PROC_BREAK
, &brk
, sizeof (brk
), 0);
829 procfs_insert_breakpoint (struct bp_target_info
*bp_tgt
)
831 return procfs_breakpoint (bp_tgt
->placed_address
, _DEBUG_BREAK_EXEC
, 0);
835 procfs_remove_breakpoint (struct bp_target_info
*bp_tgt
)
837 return procfs_breakpoint (bp_tgt
->placed_address
, _DEBUG_BREAK_EXEC
, -1);
841 procfs_insert_hw_breakpoint (struct bp_target_info
*bp_tgt
)
843 return procfs_breakpoint (bp_tgt
->placed_address
,
844 _DEBUG_BREAK_EXEC
| _DEBUG_BREAK_HW
, 0);
848 procfs_remove_hw_breakpoint (struct bp_target_info
*bp_tgt
)
850 return procfs_breakpoint (bp_tgt
->placed_address
,
851 _DEBUG_BREAK_EXEC
| _DEBUG_BREAK_HW
, -1);
855 procfs_resume (ptid_t ptid
, int step
, enum target_signal signo
)
858 procfs_status status
;
859 sigset_t
*run_fault
= (sigset_t
*) (void *) &run
.fault
;
861 if (ptid_equal (inferior_ptid
, null_ptid
))
864 procfs_set_thread (ptid_equal (ptid
, minus_one_ptid
) ? inferior_ptid
:
867 run
.flags
= _DEBUG_RUN_FAULT
| _DEBUG_RUN_TRACE
;
869 run
.flags
|= _DEBUG_RUN_STEP
;
871 sigemptyset (run_fault
);
872 sigaddset (run_fault
, FLTBPT
);
873 sigaddset (run_fault
, FLTTRACE
);
874 sigaddset (run_fault
, FLTILL
);
875 sigaddset (run_fault
, FLTPRIV
);
876 sigaddset (run_fault
, FLTBOUNDS
);
877 sigaddset (run_fault
, FLTIOVF
);
878 sigaddset (run_fault
, FLTIZDIV
);
879 sigaddset (run_fault
, FLTFPE
);
880 /* Peter V will be changing this at some point. */
881 sigaddset (run_fault
, FLTPAGE
);
883 run
.flags
|= _DEBUG_RUN_ARM
;
885 sigemptyset (&run
.trace
);
887 signal_to_pass
= target_signal_to_host (signo
);
891 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
892 signal_to_pass
= target_signal_to_host (signo
);
893 if (status
.why
& (_DEBUG_WHY_SIGNALLED
| _DEBUG_WHY_FAULTED
))
895 if (signal_to_pass
!= status
.info
.si_signo
)
897 SignalKill (nto_node (), PIDGET (inferior_ptid
), 0,
898 signal_to_pass
, 0, 0);
899 run
.flags
|= _DEBUG_RUN_CLRFLT
| _DEBUG_RUN_CLRSIG
;
901 else /* Let it kill the program without telling us. */
902 sigdelset (&run
.trace
, signal_to_pass
);
906 run
.flags
|= _DEBUG_RUN_CLRSIG
| _DEBUG_RUN_CLRFLT
;
908 errno
= devctl (ctl_fd
, DCMD_PROC_RUN
, &run
, sizeof (run
), 0);
911 perror ("run error!\n");
917 procfs_mourn_inferior (struct target_ops
*ops
)
919 if (!ptid_equal (inferior_ptid
, null_ptid
))
921 SignalKill (nto_node (), PIDGET (inferior_ptid
), 0, SIGKILL
, 0, 0);
924 inferior_ptid
= null_ptid
;
926 unpush_target (&procfs_ops
);
927 generic_mourn_inferior ();
930 /* This function breaks up an argument string into an argument
931 vector suitable for passing to execvp().
932 E.g., on "run a b c d" this routine would get as input
933 the string "a b c d", and as output it would fill in argv with
934 the four arguments "a", "b", "c", "d". The only additional
935 functionality is simple quoting. The gdb command:
937 will fill in argv with the three args "a", "b c d", "e". */
939 breakup_args (char *scratch
, char **argv
)
941 char *pp
, *cp
= scratch
;
946 /* Scan past leading separators. */
948 while (*cp
== ' ' || *cp
== '\t' || *cp
== '\n')
951 /* Break if at end of string. */
959 quoting
= strchr (cp
, '"') ? 1 : 0;
964 /* Scan for next arg separator. */
967 cp
= strchr (pp
, '"');
968 if ((cp
== NULL
) || (!quoting
))
969 cp
= strchr (pp
, ' ');
971 cp
= strchr (pp
, '\t');
973 cp
= strchr (pp
, '\n');
975 /* No separators => end of string => break. */
982 /* Replace the separator with a terminator. */
986 /* Execv requires a null-terminated arg vector. */
991 procfs_create_inferior (struct target_ops
*ops
, char *exec_file
,
992 char *allargs
, char **env
, int from_tty
)
994 struct inheritance inherit
;
998 const char *in
= "", *out
= "", *err
= "";
1001 const char *inferior_io_terminal
= get_inferior_io_terminal ();
1002 struct inferior
*inf
;
1004 argv
= xmalloc (((strlen (allargs
) + 1) / (unsigned) 2 + 2) *
1006 argv
[0] = get_exec_file (1);
1010 argv
[0] = exec_file
;
1015 args
= xstrdup (allargs
);
1016 breakup_args (args
, exec_file
? &argv
[1] : &argv
[0]);
1018 argv
= nto_parse_redirection (argv
, &in
, &out
, &err
);
1020 fds
[0] = STDIN_FILENO
;
1021 fds
[1] = STDOUT_FILENO
;
1022 fds
[2] = STDERR_FILENO
;
1024 /* If the user specified I/O via gdb's --tty= arg, use it, but only
1025 if the i/o is not also being specified via redirection. */
1026 if (inferior_io_terminal
)
1029 in
= inferior_io_terminal
;
1031 out
= inferior_io_terminal
;
1033 err
= inferior_io_terminal
;
1038 fd
= open (in
, O_RDONLY
);
1046 fd
= open (out
, O_WRONLY
);
1054 fd
= open (err
, O_WRONLY
);
1061 /* Clear any pending SIGUSR1's but keep the behavior the same. */
1062 signal (SIGUSR1
, signal (SIGUSR1
, SIG_IGN
));
1065 sigaddset (&set
, SIGUSR1
);
1066 sigprocmask (SIG_UNBLOCK
, &set
, NULL
);
1068 memset (&inherit
, 0, sizeof (inherit
));
1070 if (ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) != 0)
1072 inherit
.nd
= nto_node ();
1073 inherit
.flags
|= SPAWN_SETND
;
1074 inherit
.flags
&= ~SPAWN_EXEC
;
1076 inherit
.flags
|= SPAWN_SETGROUP
| SPAWN_HOLD
;
1077 inherit
.pgroup
= SPAWN_NEWPGROUP
;
1078 pid
= spawnp (argv
[0], 3, fds
, &inherit
, argv
,
1079 ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) == 0 ? env
: 0);
1082 sigprocmask (SIG_BLOCK
, &set
, NULL
);
1085 error (_("Error spawning %s: %d (%s)"), argv
[0], errno
,
1086 safe_strerror (errno
));
1088 if (fds
[0] != STDIN_FILENO
)
1090 if (fds
[1] != STDOUT_FILENO
)
1092 if (fds
[2] != STDERR_FILENO
)
1095 inferior_ptid
= do_attach (pid_to_ptid (pid
));
1096 procfs_find_new_threads ();
1098 inf
= add_inferior (pid
);
1099 inf
->attach_flag
= 0;
1101 flags
= _DEBUG_FLAG_KLC
; /* Kill-on-Last-Close flag. */
1102 errn
= devctl (ctl_fd
, DCMD_PROC_SET_FLAG
, &flags
, sizeof (flags
), 0);
1105 /* FIXME: expected warning? */
1106 /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
1107 errn, strerror(errn) ); */
1109 push_target (&procfs_ops
);
1110 target_terminal_init ();
1112 if (exec_bfd
!= NULL
1113 || (symfile_objfile
!= NULL
&& symfile_objfile
->obfd
!= NULL
))
1114 solib_create_inferior_hook ();
1118 procfs_stop (ptid_t ptid
)
1120 devctl (ctl_fd
, DCMD_PROC_STOP
, NULL
, 0, 0);
1124 procfs_kill_inferior (void)
1126 target_mourn_inferior ();
1129 /* Store register REGNO, or all registers if REGNO == -1, from the contents
1132 procfs_prepare_to_store (struct regcache
*regcache
)
1136 /* Fill buf with regset and return devctl cmd to do the setting. Return
1137 -1 if we fail to get the regset. Store size of regset in regsize. */
1139 get_regset (int regset
, char *buf
, int bufsize
, int *regsize
)
1141 int dev_get
, dev_set
;
1144 case NTO_REG_GENERAL
:
1145 dev_get
= DCMD_PROC_GETGREG
;
1146 dev_set
= DCMD_PROC_SETGREG
;
1150 dev_get
= DCMD_PROC_GETFPREG
;
1151 dev_set
= DCMD_PROC_SETFPREG
;
1155 dev_get
= DCMD_PROC_GETALTREG
;
1156 dev_set
= DCMD_PROC_SETALTREG
;
1159 case NTO_REG_SYSTEM
:
1163 if (devctl (ctl_fd
, dev_get
, &buf
, bufsize
, regsize
) != EOK
)
1170 procfs_store_registers (struct regcache
*regcache
, int regno
)
1176 procfs_altreg altreg
;
1180 int len
, regset
, regsize
, dev_set
, err
;
1183 if (ptid_equal (inferior_ptid
, null_ptid
))
1185 procfs_set_thread (inferior_ptid
);
1189 for (regset
= NTO_REG_GENERAL
; regset
< NTO_REG_END
; regset
++)
1191 dev_set
= get_regset (regset
, (char *) ®
,
1192 sizeof (reg
), ®size
);
1196 if (nto_regset_fill (regcache
, regset
, (char *) ®
) == -1)
1199 err
= devctl (ctl_fd
, dev_set
, ®
, regsize
, 0);
1201 fprintf_unfiltered (gdb_stderr
,
1202 "Warning unable to write regset %d: %s\n",
1203 regno
, safe_strerror (err
));
1208 regset
= nto_regset_id (regno
);
1212 dev_set
= get_regset (regset
, (char *) ®
, sizeof (reg
), ®size
);
1216 len
= nto_register_area (get_regcache_arch (regcache
),
1217 regno
, regset
, &off
);
1222 regcache_raw_collect (regcache
, regno
, (char *) ®
+ off
);
1224 err
= devctl (ctl_fd
, dev_set
, ®
, regsize
, 0);
1226 fprintf_unfiltered (gdb_stderr
,
1227 "Warning unable to write regset %d: %s\n", regno
,
1228 safe_strerror (err
));
1233 notice_signals (void)
1237 for (signo
= 1; signo
< NSIG
; signo
++)
1239 if (signal_stop_state (target_signal_from_host (signo
)) == 0
1240 && signal_print_state (target_signal_from_host (signo
)) == 0
1241 && signal_pass_state (target_signal_from_host (signo
)) == 1)
1242 sigdelset (&run
.trace
, signo
);
1244 sigaddset (&run
.trace
, signo
);
1248 /* When the user changes the state of gdb's signal handling via the
1249 "handle" command, this function gets called to see if any change
1250 in the /proc interface is required. It is also called internally
1251 by other /proc interface functions to initialize the state of
1252 the traced signal set. */
1254 procfs_notice_signals (ptid_t ptid
)
1256 sigemptyset (&run
.trace
);
1260 static struct tidinfo
*
1261 procfs_thread_info (pid_t pid
, short tid
)
1268 procfs_pid_to_str (ptid_t ptid
)
1270 static char buf
[1024];
1272 struct tidinfo
*tip
;
1274 pid
= ptid_get_pid (ptid
);
1275 tid
= ptid_get_tid (ptid
);
1277 n
= snprintf (buf
, 1023, "process %d", pid
);
1280 tip
= procfs_thread_info (pid
, tid
);
1282 snprintf (&buf
[n
], 1023, " (state = 0x%02x)", tip
->state
);
1289 init_procfs_ops (void)
1291 procfs_ops
.to_shortname
= "procfs";
1292 procfs_ops
.to_longname
= "QNX Neutrino procfs child process";
1294 "QNX Neutrino procfs child process (started by the \"run\" command).\n\
1295 target procfs <node>";
1296 procfs_ops
.to_open
= procfs_open
;
1297 procfs_ops
.to_attach
= procfs_attach
;
1298 procfs_ops
.to_post_attach
= procfs_post_attach
;
1299 procfs_ops
.to_detach
= procfs_detach
;
1300 procfs_ops
.to_resume
= procfs_resume
;
1301 procfs_ops
.to_wait
= procfs_wait
;
1302 procfs_ops
.to_fetch_registers
= procfs_fetch_registers
;
1303 procfs_ops
.to_store_registers
= procfs_store_registers
;
1304 procfs_ops
.to_prepare_to_store
= procfs_prepare_to_store
;
1305 procfs_ops
.deprecated_xfer_memory
= procfs_xfer_memory
;
1306 procfs_ops
.to_files_info
= procfs_files_info
;
1307 procfs_ops
.to_insert_breakpoint
= procfs_insert_breakpoint
;
1308 procfs_ops
.to_remove_breakpoint
= procfs_remove_breakpoint
;
1309 procfs_ops
.to_can_use_hw_breakpoint
= procfs_can_use_hw_breakpoint
;
1310 procfs_ops
.to_insert_hw_breakpoint
= procfs_insert_hw_breakpoint
;
1311 procfs_ops
.to_remove_hw_breakpoint
= procfs_remove_breakpoint
;
1312 procfs_ops
.to_insert_watchpoint
= procfs_insert_hw_watchpoint
;
1313 procfs_ops
.to_remove_watchpoint
= procfs_remove_hw_watchpoint
;
1314 procfs_ops
.to_stopped_by_watchpoint
= procfs_stopped_by_watchpoint
;
1315 procfs_ops
.to_terminal_init
= terminal_init_inferior
;
1316 procfs_ops
.to_terminal_inferior
= terminal_inferior
;
1317 procfs_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1318 procfs_ops
.to_terminal_ours
= terminal_ours
;
1319 procfs_ops
.to_terminal_info
= child_terminal_info
;
1320 procfs_ops
.to_kill
= procfs_kill_inferior
;
1321 procfs_ops
.to_create_inferior
= procfs_create_inferior
;
1322 procfs_ops
.to_mourn_inferior
= procfs_mourn_inferior
;
1323 procfs_ops
.to_can_run
= procfs_can_run
;
1324 procfs_ops
.to_notice_signals
= procfs_notice_signals
;
1325 procfs_ops
.to_thread_alive
= procfs_thread_alive
;
1326 procfs_ops
.to_find_new_threads
= procfs_find_new_threads
;
1327 procfs_ops
.to_pid_to_str
= procfs_pid_to_str
;
1328 procfs_ops
.to_stop
= procfs_stop
;
1329 procfs_ops
.to_stratum
= process_stratum
;
1330 procfs_ops
.to_has_all_memory
= 1;
1331 procfs_ops
.to_has_memory
= 1;
1332 procfs_ops
.to_has_stack
= 1;
1333 procfs_ops
.to_has_registers
= 1;
1334 procfs_ops
.to_has_execution
= 1;
1335 procfs_ops
.to_magic
= OPS_MAGIC
;
1336 procfs_ops
.to_have_continuable_watchpoint
= 1;
1339 #define OSTYPE_NTO 1
1342 _initialize_procfs (void)
1347 add_target (&procfs_ops
);
1349 /* We use SIGUSR1 to gain control after we block waiting for a process.
1350 We use sigwaitevent to wait. */
1352 sigaddset (&set
, SIGUSR1
);
1353 sigprocmask (SIG_BLOCK
, &set
, NULL
);
1355 /* Set up trace and fault sets, as gdb expects them. */
1356 sigemptyset (&run
.trace
);
1358 /* Stuff some information. */
1359 nto_cpuinfo_flags
= SYSPAGE_ENTRY (cpuinfo
)->flags
;
1360 nto_cpuinfo_valid
= 1;
1362 add_info ("pidlist", procfs_pidlist
, _("pidlist"));
1363 add_info ("meminfo", procfs_meminfo
, _("memory information"));
1365 nto_is_nto_target
= procfs_is_nto_target
;
1370 procfs_hw_watchpoint (int addr
, int len
, int type
)
1377 brk
.type
= _DEBUG_BREAK_RD
;
1379 case 2: /* Read/Write. */
1380 brk
.type
= _DEBUG_BREAK_RW
;
1382 default: /* Modify. */
1383 /* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason. */
1384 brk
.type
= _DEBUG_BREAK_RW
;
1386 brk
.type
|= _DEBUG_BREAK_HW
; /* Always ask for HW. */
1390 errno
= devctl (ctl_fd
, DCMD_PROC_BREAK
, &brk
, sizeof (brk
), 0);
1393 perror ("Failed to set hardware watchpoint");
1400 procfs_can_use_hw_breakpoint (int type
, int cnt
, int othertype
)
1406 procfs_remove_hw_watchpoint (CORE_ADDR addr
, int len
, int type
)
1408 return procfs_hw_watchpoint (addr
, -1, type
);
1412 procfs_insert_hw_watchpoint (CORE_ADDR addr
, int len
, int type
)
1414 return procfs_hw_watchpoint (addr
, len
, type
);
1418 procfs_stopped_by_watchpoint (void)