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-2014 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>
32 #include <sys/netmgr.h>
34 #include "exceptions.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 int procfs_xfer_memory (CORE_ADDR
, gdb_byte
*, int, int,
63 struct mem_attrib
*attrib
,
66 static void init_procfs_ops (void);
68 static ptid_t
do_attach (ptid_t ptid
);
70 static int procfs_can_use_hw_breakpoint (struct target_ops
*self
,
73 static int procfs_insert_hw_watchpoint (CORE_ADDR addr
, int len
, int type
,
74 struct expression
*cond
);
76 static int procfs_remove_hw_watchpoint (struct target_ops
*self
,
77 CORE_ADDR addr
, int len
, int type
,
78 struct expression
*cond
);
80 static int procfs_stopped_by_watchpoint (struct target_ops
*ops
);
82 /* These two globals are only ever set in procfs_open(), but are
83 referenced elsewhere. 'nto_procfs_node' is a flag used to say
84 whether we are local, or we should get the current node descriptor
85 for the remote QNX node. */
86 static char nto_procfs_path
[PATH_MAX
] = { "/proc" };
87 static unsigned nto_procfs_node
= ND_LOCAL_NODE
;
89 /* Return the current QNX Node, or error out. This is a simple
90 wrapper for the netmgr_strtond() function. The reason this
91 is required is because QNX node descriptors are transient so
92 we have to re-acquire them every time. */
98 if (ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) == 0)
101 node
= netmgr_strtond (nto_procfs_path
, 0);
103 error (_("Lost the QNX node. Debug session probably over."));
108 static enum gdb_osabi
109 procfs_is_nto_target (bfd
*abfd
)
111 return GDB_OSABI_QNXNTO
;
114 /* This is called when we call 'target procfs <arg>' from the (gdb) prompt.
115 For QNX6 (nto), the only valid arg will be a QNX node string,
116 eg: "/net/some_node". If arg is not a valid QNX node, we will
119 procfs_open (char *arg
, int from_tty
)
125 procfs_sysinfo
*sysinfo
;
126 struct cleanup
*cleanups
;
128 nto_is_nto_target
= procfs_is_nto_target
;
130 /* Set the default node used for spawning to this one,
131 and only override it if there is a valid arg. */
133 nto_procfs_node
= ND_LOCAL_NODE
;
134 nodestr
= arg
? xstrdup (arg
) : arg
;
140 nto_procfs_node
= netmgr_strtond (nodestr
, &endstr
);
141 if (nto_procfs_node
== -1)
143 if (errno
== ENOTSUP
)
144 printf_filtered ("QNX Net Manager not found.\n");
145 printf_filtered ("Invalid QNX node %s: error %d (%s).\n", nodestr
,
146 errno
, safe_strerror (errno
));
149 nto_procfs_node
= ND_LOCAL_NODE
;
153 if (*(endstr
- 1) == '/')
159 snprintf (nto_procfs_path
, PATH_MAX
- 1, "%s%s", nodestr
? nodestr
: "",
164 fd
= open (nto_procfs_path
, O_RDONLY
);
167 printf_filtered ("Error opening %s : %d (%s)\n", nto_procfs_path
, errno
,
168 safe_strerror (errno
));
169 error (_("Invalid procfs arg"));
171 cleanups
= make_cleanup_close (fd
);
173 sysinfo
= (void *) buffer
;
174 if (devctl (fd
, DCMD_PROC_SYSINFO
, sysinfo
, sizeof buffer
, 0) != EOK
)
176 printf_filtered ("Error getting size: %d (%s)\n", errno
,
177 safe_strerror (errno
));
178 error (_("Devctl failed."));
182 total_size
= sysinfo
->total_size
;
183 sysinfo
= alloca (total_size
);
186 printf_filtered ("Memory error: %d (%s)\n", errno
,
187 safe_strerror (errno
));
188 error (_("alloca failed."));
192 if (devctl (fd
, DCMD_PROC_SYSINFO
, sysinfo
, total_size
, 0) != EOK
)
194 printf_filtered ("Error getting sysinfo: %d (%s)\n", errno
,
195 safe_strerror (errno
));
196 error (_("Devctl failed."));
201 nto_map_arch_to_cputype (gdbarch_bfd_arch_info
202 (target_gdbarch ())->arch_name
))
203 error (_("Invalid target CPU."));
207 do_cleanups (cleanups
);
208 printf_filtered ("Debugging using %s\n", nto_procfs_path
);
212 procfs_set_thread (ptid_t ptid
)
216 tid
= ptid_get_tid (ptid
);
217 devctl (ctl_fd
, DCMD_PROC_CURTHREAD
, &tid
, sizeof (tid
), 0);
220 /* Return nonzero if the thread TH is still alive. */
222 procfs_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
226 procfs_status status
;
229 tid
= ptid_get_tid (ptid
);
230 pid
= ptid_get_pid (ptid
);
232 if (kill (pid
, 0) == -1)
236 if ((err
= devctl (ctl_fd
, DCMD_PROC_TIDSTATUS
,
237 &status
, sizeof (status
), 0)) != EOK
)
240 /* Thread is alive or dead but not yet joined,
241 or dead and there is an alive (or dead unjoined) thread with
244 If the tid is not the same as requested, requested tid is dead. */
245 return (status
.tid
== tid
) && (status
.state
!= STATE_DEAD
);
249 update_thread_private_data_name (struct thread_info
*new_thread
,
253 struct private_thread_info
*pti
;
255 gdb_assert (newname
!= NULL
);
256 gdb_assert (new_thread
!= NULL
);
257 newnamelen
= strlen (newname
);
258 if (!new_thread
->private)
260 new_thread
->private = xmalloc (offsetof (struct private_thread_info
,
263 memcpy (new_thread
->private->name
, newname
, newnamelen
+ 1);
265 else if (strcmp (newname
, new_thread
->private->name
) != 0)
267 /* Reallocate if neccessary. */
268 int oldnamelen
= strlen (new_thread
->private->name
);
270 if (oldnamelen
< newnamelen
)
271 new_thread
->private = xrealloc (new_thread
->private,
272 offsetof (struct private_thread_info
,
275 memcpy (new_thread
->private->name
, newname
, newnamelen
+ 1);
280 update_thread_private_data (struct thread_info
*new_thread
,
281 pthread_t tid
, int state
, int flags
)
283 struct private_thread_info
*pti
;
285 struct _thread_name
*tn
;
286 procfs_threadctl tctl
;
288 #if _NTO_VERSION > 630
289 gdb_assert (new_thread
!= NULL
);
291 if (devctl (ctl_fd
, DCMD_PROC_INFO
, &pidinfo
,
292 sizeof(pidinfo
), 0) != EOK
)
295 memset (&tctl
, 0, sizeof (tctl
));
296 tctl
.cmd
= _NTO_TCTL_NAME
;
297 tn
= (struct _thread_name
*) (&tctl
.data
);
299 /* Fetch name for the given thread. */
301 tn
->name_buf_len
= sizeof (tctl
.data
) - sizeof (*tn
);
302 tn
->new_name_len
= -1; /* Getting, not setting. */
303 if (devctl (ctl_fd
, DCMD_PROC_THREADCTL
, &tctl
, sizeof (tctl
), NULL
) != EOK
)
304 tn
->name_buf
[0] = '\0';
306 tn
->name_buf
[_NTO_THREAD_NAME_MAX
] = '\0';
308 update_thread_private_data_name (new_thread
, tn
->name_buf
);
310 pti
= (struct private_thread_info
*) new_thread
->private;
314 #endif /* _NTO_VERSION */
318 procfs_find_new_threads (struct target_ops
*ops
)
320 procfs_status status
;
324 struct thread_info
*new_thread
;
329 pid
= ptid_get_pid (inferior_ptid
);
333 for (tid
= 1;; ++tid
)
335 if (status
.tid
== tid
336 && (devctl (ctl_fd
, DCMD_PROC_TIDSTATUS
, &status
, sizeof (status
), 0)
339 if (status
.tid
!= tid
)
340 /* The reason why this would not be equal is that devctl might have
341 returned different tid, meaning the requested tid no longer exists
342 (e.g. thread exited). */
344 ptid
= ptid_build (pid
, 0, tid
);
345 new_thread
= find_thread_ptid (ptid
);
347 new_thread
= add_thread (ptid
);
348 update_thread_private_data (new_thread
, tid
, status
.state
, 0);
355 do_closedir_cleanup (void *dir
)
361 procfs_pidlist (char *args
, int from_tty
)
364 struct dirent
*dirp
= NULL
;
366 procfs_info
*pidinfo
= NULL
;
367 procfs_debuginfo
*info
= NULL
;
368 procfs_status
*status
= NULL
;
369 pid_t num_threads
= 0;
372 struct cleanup
*cleanups
;
374 dp
= opendir (nto_procfs_path
);
377 fprintf_unfiltered (gdb_stderr
, "failed to opendir \"%s\" - %d (%s)",
378 nto_procfs_path
, errno
, safe_strerror (errno
));
382 cleanups
= make_cleanup (do_closedir_cleanup
, dp
);
384 /* Start scan at first pid. */
390 struct cleanup
*inner_cleanup
;
392 /* Get the right pid and procfs path for the pid. */
398 do_cleanups (cleanups
);
401 snprintf (buf
, 511, "%s/%s/as", nto_procfs_path
, dirp
->d_name
);
402 pid
= atoi (dirp
->d_name
);
406 /* Open the procfs path. */
407 fd
= open (buf
, O_RDONLY
);
410 fprintf_unfiltered (gdb_stderr
, "failed to open %s - %d (%s)\n",
411 buf
, errno
, safe_strerror (errno
));
412 do_cleanups (cleanups
);
415 inner_cleanup
= make_cleanup_close (fd
);
417 pidinfo
= (procfs_info
*) buf
;
418 if (devctl (fd
, DCMD_PROC_INFO
, pidinfo
, sizeof (buf
), 0) != EOK
)
420 fprintf_unfiltered (gdb_stderr
,
421 "devctl DCMD_PROC_INFO failed - %d (%s)\n",
422 errno
, safe_strerror (errno
));
425 num_threads
= pidinfo
->num_threads
;
427 info
= (procfs_debuginfo
*) buf
;
428 if (devctl (fd
, DCMD_PROC_MAPDEBUG_BASE
, info
, sizeof (buf
), 0) != EOK
)
429 strcpy (name
, "unavailable");
431 strcpy (name
, info
->path
);
433 /* Collect state info on all the threads. */
434 status
= (procfs_status
*) buf
;
435 for (status
->tid
= 1; status
->tid
<= num_threads
; status
->tid
++)
437 if (devctl (fd
, DCMD_PROC_TIDSTATUS
, status
, sizeof (buf
), 0) != EOK
440 if (status
->tid
!= 0)
441 printf_filtered ("%s - %d/%d\n", name
, pid
, status
->tid
);
444 do_cleanups (inner_cleanup
);
446 while (dirp
!= NULL
);
448 do_cleanups (cleanups
);
453 procfs_meminfo (char *args
, int from_tty
)
455 procfs_mapinfo
*mapinfos
= NULL
;
456 static int num_mapinfos
= 0;
457 procfs_mapinfo
*mapinfo_p
, *mapinfo_p2
;
458 int flags
= ~0, err
, num
, i
, j
;
462 procfs_debuginfo info
;
463 char buff
[_POSIX_PATH_MAX
];
471 unsigned debug_vaddr
;
472 unsigned long long offset
;
477 unsigned long long ino
;
484 /* Get the number of map entrys. */
485 err
= devctl (ctl_fd
, DCMD_PROC_MAPINFO
, NULL
, 0, &num
);
488 printf ("failed devctl num mapinfos - %d (%s)\n", err
,
489 safe_strerror (err
));
493 mapinfos
= xmalloc (num
* sizeof (procfs_mapinfo
));
496 mapinfo_p
= mapinfos
;
498 /* Fill the map entrys. */
499 err
= devctl (ctl_fd
, DCMD_PROC_MAPINFO
, mapinfo_p
, num
500 * sizeof (procfs_mapinfo
), &num
);
503 printf ("failed devctl mapinfos - %d (%s)\n", err
, safe_strerror (err
));
508 num
= min (num
, num_mapinfos
);
510 /* Run through the list of mapinfos, and store the data and text info
511 so we can print it at the bottom of the loop. */
512 for (mapinfo_p
= mapinfos
, i
= 0; i
< num
; i
++, mapinfo_p
++)
514 if (!(mapinfo_p
->flags
& flags
))
517 if (mapinfo_p
->ino
== 0) /* Already visited. */
520 map
.info
.vaddr
= mapinfo_p
->vaddr
;
522 err
= devctl (ctl_fd
, DCMD_PROC_MAPDEBUG
, &map
, sizeof (map
), 0);
526 memset (&printme
, 0, sizeof printme
);
527 printme
.dev
= mapinfo_p
->dev
;
528 printme
.ino
= mapinfo_p
->ino
;
529 printme
.text
.addr
= mapinfo_p
->vaddr
;
530 printme
.text
.size
= mapinfo_p
->size
;
531 printme
.text
.flags
= mapinfo_p
->flags
;
532 printme
.text
.offset
= mapinfo_p
->offset
;
533 printme
.text
.debug_vaddr
= map
.info
.vaddr
;
534 strcpy (printme
.name
, map
.info
.path
);
536 /* Check for matching data. */
537 for (mapinfo_p2
= mapinfos
, j
= 0; j
< num
; j
++, mapinfo_p2
++)
539 if (mapinfo_p2
->vaddr
!= mapinfo_p
->vaddr
540 && mapinfo_p2
->ino
== mapinfo_p
->ino
541 && mapinfo_p2
->dev
== mapinfo_p
->dev
)
543 map
.info
.vaddr
= mapinfo_p2
->vaddr
;
545 devctl (ctl_fd
, DCMD_PROC_MAPDEBUG
, &map
, sizeof (map
), 0);
549 if (strcmp (map
.info
.path
, printme
.name
))
552 /* Lower debug_vaddr is always text, if nessessary, swap. */
553 if ((int) map
.info
.vaddr
< (int) printme
.text
.debug_vaddr
)
555 memcpy (&(printme
.data
), &(printme
.text
),
556 sizeof (printme
.data
));
557 printme
.text
.addr
= mapinfo_p2
->vaddr
;
558 printme
.text
.size
= mapinfo_p2
->size
;
559 printme
.text
.flags
= mapinfo_p2
->flags
;
560 printme
.text
.offset
= mapinfo_p2
->offset
;
561 printme
.text
.debug_vaddr
= map
.info
.vaddr
;
565 printme
.data
.addr
= mapinfo_p2
->vaddr
;
566 printme
.data
.size
= mapinfo_p2
->size
;
567 printme
.data
.flags
= mapinfo_p2
->flags
;
568 printme
.data
.offset
= mapinfo_p2
->offset
;
569 printme
.data
.debug_vaddr
= map
.info
.vaddr
;
576 printf_filtered ("%s\n", printme
.name
);
577 printf_filtered ("\ttext=%08x bytes @ 0x%08x\n", printme
.text
.size
,
579 printf_filtered ("\t\tflags=%08x\n", printme
.text
.flags
);
580 printf_filtered ("\t\tdebug=%08x\n", printme
.text
.debug_vaddr
);
581 printf_filtered ("\t\toffset=%s\n", phex (printme
.text
.offset
, 8));
582 if (printme
.data
.size
)
584 printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme
.data
.size
,
586 printf_filtered ("\t\tflags=%08x\n", printme
.data
.flags
);
587 printf_filtered ("\t\tdebug=%08x\n", printme
.data
.debug_vaddr
);
588 printf_filtered ("\t\toffset=%s\n", phex (printme
.data
.offset
, 8));
590 printf_filtered ("\tdev=0x%x\n", printme
.dev
);
591 printf_filtered ("\tino=0x%x\n", (unsigned int) printme
.ino
);
597 /* Print status information about what we're accessing. */
599 procfs_files_info (struct target_ops
*ignore
)
601 struct inferior
*inf
= current_inferior ();
603 printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
604 inf
->attach_flag
? "attached" : "child",
605 target_pid_to_str (inferior_ptid
), nto_procfs_path
);
608 /* Mark our target-struct as eligible for stray "run" and "attach"
611 procfs_can_run (void)
616 /* Attach to process PID, then initialize for debugging it. */
618 procfs_attach (struct target_ops
*ops
, char *args
, int from_tty
)
622 struct inferior
*inf
;
624 pid
= parse_pid_to_attach (args
);
626 if (pid
== getpid ())
627 error (_("Attaching GDB to itself is not a good idea..."));
631 exec_file
= (char *) get_exec_file (0);
634 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
635 target_pid_to_str (pid_to_ptid (pid
)));
637 printf_unfiltered ("Attaching to %s\n",
638 target_pid_to_str (pid_to_ptid (pid
)));
640 gdb_flush (gdb_stdout
);
642 inferior_ptid
= do_attach (pid_to_ptid (pid
));
643 inf
= current_inferior ();
644 inferior_appeared (inf
, pid
);
645 inf
->attach_flag
= 1;
649 procfs_find_new_threads (ops
);
653 procfs_post_attach (struct target_ops
*self
, pid_t pid
)
656 solib_create_inferior_hook (0);
660 do_attach (ptid_t ptid
)
662 procfs_status status
;
663 struct sigevent event
;
666 snprintf (path
, PATH_MAX
- 1, "%s/%d/as", nto_procfs_path
,
667 ptid_get_pid (ptid
));
668 ctl_fd
= open (path
, O_RDWR
);
670 error (_("Couldn't open proc file %s, error %d (%s)"), path
, errno
,
671 safe_strerror (errno
));
672 if (devctl (ctl_fd
, DCMD_PROC_STOP
, &status
, sizeof (status
), 0) != EOK
)
673 error (_("Couldn't stop process"));
675 /* Define a sigevent for process stopped notification. */
676 event
.sigev_notify
= SIGEV_SIGNAL_THREAD
;
677 event
.sigev_signo
= SIGUSR1
;
678 event
.sigev_code
= 0;
679 event
.sigev_value
.sival_ptr
= NULL
;
680 event
.sigev_priority
= -1;
681 devctl (ctl_fd
, DCMD_PROC_EVENT
, &event
, sizeof (event
), 0);
683 if (devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0) == EOK
684 && status
.flags
& _DEBUG_FLAG_STOPPED
)
685 SignalKill (nto_node (), ptid_get_pid (ptid
), 0, SIGCONT
, 0, 0);
686 nto_init_solib_absolute_prefix ();
687 return ptid_build (ptid_get_pid (ptid
), 0, status
.tid
);
690 /* Ask the user what to do when an interrupt is received. */
692 interrupt_query (void)
694 target_terminal_ours ();
696 if (query (_("Interrupted while waiting for the program.\n\
697 Give up (and stop debugging it)? ")))
699 target_mourn_inferior ();
703 target_terminal_inferior ();
706 /* The user typed ^C twice. */
708 nto_interrupt_twice (int signo
)
710 signal (signo
, ofunc
);
712 signal (signo
, nto_interrupt_twice
);
716 nto_interrupt (int signo
)
718 /* If this doesn't work, try more severe steps. */
719 signal (signo
, nto_interrupt_twice
);
721 target_stop (inferior_ptid
);
725 procfs_wait (struct target_ops
*ops
,
726 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
730 procfs_status status
;
731 static int exit_signo
= 0; /* To track signals that cause termination. */
733 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
735 if (ptid_equal (inferior_ptid
, null_ptid
))
737 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
738 ourstatus
->value
.sig
= GDB_SIGNAL_0
;
744 sigaddset (&set
, SIGUSR1
);
746 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
747 while (!(status
.flags
& _DEBUG_FLAG_ISTOP
))
749 ofunc
= (void (*)()) signal (SIGINT
, nto_interrupt
);
750 sigwaitinfo (&set
, &info
);
751 signal (SIGINT
, ofunc
);
752 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
755 if (status
.flags
& _DEBUG_FLAG_SSTEP
)
757 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
758 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
760 /* Was it a breakpoint? */
761 else if (status
.flags
& _DEBUG_FLAG_TRACE
)
763 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
764 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
766 else if (status
.flags
& _DEBUG_FLAG_ISTOP
)
770 case _DEBUG_WHY_SIGNALLED
:
771 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
772 ourstatus
->value
.sig
=
773 gdb_signal_from_host (status
.info
.si_signo
);
776 case _DEBUG_WHY_FAULTED
:
777 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
778 if (status
.info
.si_signo
== SIGTRAP
)
780 ourstatus
->value
.sig
= 0;
785 ourstatus
->value
.sig
=
786 gdb_signal_from_host (status
.info
.si_signo
);
787 exit_signo
= ourstatus
->value
.sig
;
791 case _DEBUG_WHY_TERMINATED
:
795 waitpid (ptid_get_pid (inferior_ptid
), &waitval
, WNOHANG
);
798 /* Abnormal death. */
799 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
800 ourstatus
->value
.sig
= exit_signo
;
805 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
806 ourstatus
->value
.integer
= WEXITSTATUS (waitval
);
812 case _DEBUG_WHY_REQUESTED
:
813 /* We are assuming a requested stop is due to a SIGINT. */
814 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
815 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
821 return ptid_build (status
.pid
, 0, status
.tid
);
824 /* Read the current values of the inferior's registers, both the
825 general register set and floating point registers (if supported)
826 and update gdb's idea of their current values. */
828 procfs_fetch_registers (struct target_ops
*ops
,
829 struct regcache
*regcache
, int regno
)
835 procfs_altreg altreg
;
840 procfs_set_thread (inferior_ptid
);
841 if (devctl (ctl_fd
, DCMD_PROC_GETGREG
, ®
, sizeof (reg
), ®size
) == EOK
)
842 nto_supply_gregset (regcache
, (char *) ®
.greg
);
843 if (devctl (ctl_fd
, DCMD_PROC_GETFPREG
, ®
, sizeof (reg
), ®size
)
845 nto_supply_fpregset (regcache
, (char *) ®
.fpreg
);
846 if (devctl (ctl_fd
, DCMD_PROC_GETALTREG
, ®
, sizeof (reg
), ®size
)
848 nto_supply_altregset (regcache
, (char *) ®
.altreg
);
851 /* Copy LEN bytes to/from inferior's memory starting at MEMADDR
852 from/to debugger memory starting at MYADDR. Copy from inferior
853 if DOWRITE is zero or to inferior if DOWRITE is nonzero.
855 Returns the length copied, which is either the LEN argument or
856 zero. This xfer function does not do partial moves, since procfs_ops
857 doesn't allow memory operations to cross below us in the target stack
860 procfs_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int dowrite
,
861 struct mem_attrib
*attrib
, struct target_ops
*target
)
865 if (lseek (ctl_fd
, (off_t
) memaddr
, SEEK_SET
) == (off_t
) memaddr
)
868 nbytes
= write (ctl_fd
, myaddr
, len
);
870 nbytes
= read (ctl_fd
, myaddr
, len
);
877 /* Take a program previously attached to and detaches it.
878 The program resumes execution and will no longer stop
879 on signals, etc. We'd better not have left any breakpoints
880 in the program or it'll die when it hits one. */
882 procfs_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
889 char *exec_file
= get_exec_file (0);
892 printf_unfiltered ("Detaching from program: %s %s\n",
893 exec_file
, target_pid_to_str (inferior_ptid
));
894 gdb_flush (gdb_stdout
);
897 siggnal
= atoi (args
);
900 SignalKill (nto_node (), ptid_get_pid (inferior_ptid
), 0, siggnal
, 0, 0);
905 pid
= ptid_get_pid (inferior_ptid
);
906 inferior_ptid
= null_ptid
;
907 detach_inferior (pid
);
909 unpush_target (&procfs_ops
); /* Pop out of handling an inferior. */
913 procfs_breakpoint (CORE_ADDR addr
, int type
, int size
)
920 errno
= devctl (ctl_fd
, DCMD_PROC_BREAK
, &brk
, sizeof (brk
), 0);
927 procfs_insert_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
928 struct bp_target_info
*bp_tgt
)
930 return procfs_breakpoint (bp_tgt
->placed_address
, _DEBUG_BREAK_EXEC
, 0);
934 procfs_remove_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
935 struct bp_target_info
*bp_tgt
)
937 return procfs_breakpoint (bp_tgt
->placed_address
, _DEBUG_BREAK_EXEC
, -1);
941 procfs_insert_hw_breakpoint (struct target_ops
*self
, struct gdbarch
*gdbarch
,
942 struct bp_target_info
*bp_tgt
)
944 return procfs_breakpoint (bp_tgt
->placed_address
,
945 _DEBUG_BREAK_EXEC
| _DEBUG_BREAK_HW
, 0);
949 procfs_remove_hw_breakpoint (struct gdbarch
*gdbarch
,
950 struct bp_target_info
*bp_tgt
)
952 return procfs_breakpoint (bp_tgt
->placed_address
,
953 _DEBUG_BREAK_EXEC
| _DEBUG_BREAK_HW
, -1);
957 procfs_resume (struct target_ops
*ops
,
958 ptid_t ptid
, int step
, enum gdb_signal signo
)
961 procfs_status status
;
962 sigset_t
*run_fault
= (sigset_t
*) (void *) &run
.fault
;
964 if (ptid_equal (inferior_ptid
, null_ptid
))
967 procfs_set_thread (ptid_equal (ptid
, minus_one_ptid
) ? inferior_ptid
:
970 run
.flags
= _DEBUG_RUN_FAULT
| _DEBUG_RUN_TRACE
;
972 run
.flags
|= _DEBUG_RUN_STEP
;
974 sigemptyset (run_fault
);
975 sigaddset (run_fault
, FLTBPT
);
976 sigaddset (run_fault
, FLTTRACE
);
977 sigaddset (run_fault
, FLTILL
);
978 sigaddset (run_fault
, FLTPRIV
);
979 sigaddset (run_fault
, FLTBOUNDS
);
980 sigaddset (run_fault
, FLTIOVF
);
981 sigaddset (run_fault
, FLTIZDIV
);
982 sigaddset (run_fault
, FLTFPE
);
983 /* Peter V will be changing this at some point. */
984 sigaddset (run_fault
, FLTPAGE
);
986 run
.flags
|= _DEBUG_RUN_ARM
;
988 signal_to_pass
= gdb_signal_to_host (signo
);
992 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
993 signal_to_pass
= gdb_signal_to_host (signo
);
994 if (status
.why
& (_DEBUG_WHY_SIGNALLED
| _DEBUG_WHY_FAULTED
))
996 if (signal_to_pass
!= status
.info
.si_signo
)
998 SignalKill (nto_node (), ptid_get_pid (inferior_ptid
), 0,
999 signal_to_pass
, 0, 0);
1000 run
.flags
|= _DEBUG_RUN_CLRFLT
| _DEBUG_RUN_CLRSIG
;
1002 else /* Let it kill the program without telling us. */
1003 sigdelset (&run
.trace
, signal_to_pass
);
1007 run
.flags
|= _DEBUG_RUN_CLRSIG
| _DEBUG_RUN_CLRFLT
;
1009 errno
= devctl (ctl_fd
, DCMD_PROC_RUN
, &run
, sizeof (run
), 0);
1012 perror (_("run error!\n"));
1018 procfs_mourn_inferior (struct target_ops
*ops
)
1020 if (!ptid_equal (inferior_ptid
, null_ptid
))
1022 SignalKill (nto_node (), ptid_get_pid (inferior_ptid
), 0, SIGKILL
, 0, 0);
1025 inferior_ptid
= null_ptid
;
1026 init_thread_list ();
1027 unpush_target (&procfs_ops
);
1028 generic_mourn_inferior ();
1031 /* This function breaks up an argument string into an argument
1032 vector suitable for passing to execvp().
1033 E.g., on "run a b c d" this routine would get as input
1034 the string "a b c d", and as output it would fill in argv with
1035 the four arguments "a", "b", "c", "d". The only additional
1036 functionality is simple quoting. The gdb command:
1038 will fill in argv with the three args "a", "b c d", "e". */
1040 breakup_args (char *scratch
, char **argv
)
1042 char *pp
, *cp
= scratch
;
1047 /* Scan past leading separators. */
1049 while (*cp
== ' ' || *cp
== '\t' || *cp
== '\n')
1052 /* Break if at end of string. */
1060 quoting
= strchr (cp
, '"') ? 1 : 0;
1065 /* Scan for next arg separator. */
1068 cp
= strchr (pp
, '"');
1069 if ((cp
== NULL
) || (!quoting
))
1070 cp
= strchr (pp
, ' ');
1072 cp
= strchr (pp
, '\t');
1074 cp
= strchr (pp
, '\n');
1076 /* No separators => end of string => break. */
1083 /* Replace the separator with a terminator. */
1087 /* Execv requires a null-terminated arg vector. */
1092 procfs_create_inferior (struct target_ops
*ops
, char *exec_file
,
1093 char *allargs
, char **env
, int from_tty
)
1095 struct inheritance inherit
;
1099 const char *in
= "", *out
= "", *err
= "";
1102 const char *inferior_io_terminal
= get_inferior_io_terminal ();
1103 struct inferior
*inf
;
1105 argv
= xmalloc (((strlen (allargs
) + 1) / (unsigned) 2 + 2) *
1107 argv
[0] = get_exec_file (1);
1111 argv
[0] = exec_file
;
1116 args
= xstrdup (allargs
);
1117 breakup_args (args
, exec_file
? &argv
[1] : &argv
[0]);
1119 argv
= nto_parse_redirection (argv
, &in
, &out
, &err
);
1121 fds
[0] = STDIN_FILENO
;
1122 fds
[1] = STDOUT_FILENO
;
1123 fds
[2] = STDERR_FILENO
;
1125 /* If the user specified I/O via gdb's --tty= arg, use it, but only
1126 if the i/o is not also being specified via redirection. */
1127 if (inferior_io_terminal
)
1130 in
= inferior_io_terminal
;
1132 out
= inferior_io_terminal
;
1134 err
= inferior_io_terminal
;
1139 fd
= open (in
, O_RDONLY
);
1147 fd
= open (out
, O_WRONLY
);
1155 fd
= open (err
, O_WRONLY
);
1162 /* Clear any pending SIGUSR1's but keep the behavior the same. */
1163 signal (SIGUSR1
, signal (SIGUSR1
, SIG_IGN
));
1166 sigaddset (&set
, SIGUSR1
);
1167 sigprocmask (SIG_UNBLOCK
, &set
, NULL
);
1169 memset (&inherit
, 0, sizeof (inherit
));
1171 if (ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) != 0)
1173 inherit
.nd
= nto_node ();
1174 inherit
.flags
|= SPAWN_SETND
;
1175 inherit
.flags
&= ~SPAWN_EXEC
;
1177 inherit
.flags
|= SPAWN_SETGROUP
| SPAWN_HOLD
;
1178 inherit
.pgroup
= SPAWN_NEWPGROUP
;
1179 pid
= spawnp (argv
[0], 3, fds
, &inherit
, argv
,
1180 ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) == 0 ? env
: 0);
1183 sigprocmask (SIG_BLOCK
, &set
, NULL
);
1186 error (_("Error spawning %s: %d (%s)"), argv
[0], errno
,
1187 safe_strerror (errno
));
1189 if (fds
[0] != STDIN_FILENO
)
1191 if (fds
[1] != STDOUT_FILENO
)
1193 if (fds
[2] != STDERR_FILENO
)
1196 inferior_ptid
= do_attach (pid_to_ptid (pid
));
1197 procfs_find_new_threads (ops
);
1199 inf
= current_inferior ();
1200 inferior_appeared (inf
, pid
);
1201 inf
->attach_flag
= 0;
1203 flags
= _DEBUG_FLAG_KLC
; /* Kill-on-Last-Close flag. */
1204 errn
= devctl (ctl_fd
, DCMD_PROC_SET_FLAG
, &flags
, sizeof (flags
), 0);
1207 /* FIXME: expected warning? */
1208 /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
1209 errn, strerror(errn) ); */
1212 target_terminal_init ();
1214 if (exec_bfd
!= NULL
1215 || (symfile_objfile
!= NULL
&& symfile_objfile
->obfd
!= NULL
))
1216 solib_create_inferior_hook (0);
1220 procfs_stop (ptid_t ptid
)
1222 devctl (ctl_fd
, DCMD_PROC_STOP
, NULL
, 0, 0);
1226 procfs_kill_inferior (struct target_ops
*ops
)
1228 target_mourn_inferior ();
1231 /* Store register REGNO, or all registers if REGNO == -1, from the contents
1234 procfs_prepare_to_store (struct target_ops
*self
, struct regcache
*regcache
)
1238 /* Fill buf with regset and return devctl cmd to do the setting. Return
1239 -1 if we fail to get the regset. Store size of regset in regsize. */
1241 get_regset (int regset
, char *buf
, int bufsize
, int *regsize
)
1243 int dev_get
, dev_set
;
1246 case NTO_REG_GENERAL
:
1247 dev_get
= DCMD_PROC_GETGREG
;
1248 dev_set
= DCMD_PROC_SETGREG
;
1252 dev_get
= DCMD_PROC_GETFPREG
;
1253 dev_set
= DCMD_PROC_SETFPREG
;
1257 dev_get
= DCMD_PROC_GETALTREG
;
1258 dev_set
= DCMD_PROC_SETALTREG
;
1261 case NTO_REG_SYSTEM
:
1265 if (devctl (ctl_fd
, dev_get
, buf
, bufsize
, regsize
) != EOK
)
1272 procfs_store_registers (struct target_ops
*ops
,
1273 struct regcache
*regcache
, int regno
)
1279 procfs_altreg altreg
;
1283 int len
, regset
, regsize
, dev_set
, err
;
1286 if (ptid_equal (inferior_ptid
, null_ptid
))
1288 procfs_set_thread (inferior_ptid
);
1292 for (regset
= NTO_REG_GENERAL
; regset
< NTO_REG_END
; regset
++)
1294 dev_set
= get_regset (regset
, (char *) ®
,
1295 sizeof (reg
), ®size
);
1299 if (nto_regset_fill (regcache
, regset
, (char *) ®
) == -1)
1302 err
= devctl (ctl_fd
, dev_set
, ®
, regsize
, 0);
1304 fprintf_unfiltered (gdb_stderr
,
1305 "Warning unable to write regset %d: %s\n",
1306 regno
, safe_strerror (err
));
1311 regset
= nto_regset_id (regno
);
1315 dev_set
= get_regset (regset
, (char *) ®
, sizeof (reg
), ®size
);
1319 len
= nto_register_area (get_regcache_arch (regcache
),
1320 regno
, regset
, &off
);
1325 regcache_raw_collect (regcache
, regno
, (char *) ®
+ off
);
1327 err
= devctl (ctl_fd
, dev_set
, ®
, regsize
, 0);
1329 fprintf_unfiltered (gdb_stderr
,
1330 "Warning unable to write regset %d: %s\n", regno
,
1331 safe_strerror (err
));
1335 /* Set list of signals to be handled in the target. */
1338 procfs_pass_signals (int numsigs
, unsigned char *pass_signals
)
1342 sigfillset (&run
.trace
);
1344 for (signo
= 1; signo
< NSIG
; signo
++)
1346 int target_signo
= gdb_signal_from_host (signo
);
1347 if (target_signo
< numsigs
&& pass_signals
[target_signo
])
1348 sigdelset (&run
.trace
, signo
);
1352 static struct tidinfo
*
1353 procfs_thread_info (pid_t pid
, short tid
)
1360 procfs_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1362 static char buf
[1024];
1364 struct tidinfo
*tip
;
1366 pid
= ptid_get_pid (ptid
);
1367 tid
= ptid_get_tid (ptid
);
1369 n
= snprintf (buf
, 1023, "process %d", pid
);
1372 tip
= procfs_thread_info (pid
, tid
);
1374 snprintf (&buf
[n
], 1023, " (state = 0x%02x)", tip
->state
);
1381 init_procfs_ops (void)
1383 procfs_ops
.to_shortname
= "procfs";
1384 procfs_ops
.to_longname
= "QNX Neutrino procfs child process";
1386 "QNX Neutrino procfs child process (started by the \"run\" command).\n\
1387 target procfs <node>";
1388 procfs_ops
.to_open
= procfs_open
;
1389 procfs_ops
.to_attach
= procfs_attach
;
1390 procfs_ops
.to_post_attach
= procfs_post_attach
;
1391 procfs_ops
.to_detach
= procfs_detach
;
1392 procfs_ops
.to_resume
= procfs_resume
;
1393 procfs_ops
.to_wait
= procfs_wait
;
1394 procfs_ops
.to_fetch_registers
= procfs_fetch_registers
;
1395 procfs_ops
.to_store_registers
= procfs_store_registers
;
1396 procfs_ops
.to_prepare_to_store
= procfs_prepare_to_store
;
1397 procfs_ops
.deprecated_xfer_memory
= procfs_xfer_memory
;
1398 procfs_ops
.to_files_info
= procfs_files_info
;
1399 procfs_ops
.to_insert_breakpoint
= procfs_insert_breakpoint
;
1400 procfs_ops
.to_remove_breakpoint
= procfs_remove_breakpoint
;
1401 procfs_ops
.to_can_use_hw_breakpoint
= procfs_can_use_hw_breakpoint
;
1402 procfs_ops
.to_insert_hw_breakpoint
= procfs_insert_hw_breakpoint
;
1403 procfs_ops
.to_remove_hw_breakpoint
= procfs_remove_breakpoint
;
1404 procfs_ops
.to_insert_watchpoint
= procfs_insert_hw_watchpoint
;
1405 procfs_ops
.to_remove_watchpoint
= procfs_remove_hw_watchpoint
;
1406 procfs_ops
.to_stopped_by_watchpoint
= procfs_stopped_by_watchpoint
;
1407 procfs_ops
.to_terminal_init
= terminal_init_inferior
;
1408 procfs_ops
.to_terminal_inferior
= terminal_inferior
;
1409 procfs_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1410 procfs_ops
.to_terminal_ours
= terminal_ours
;
1411 procfs_ops
.to_terminal_info
= child_terminal_info
;
1412 procfs_ops
.to_kill
= procfs_kill_inferior
;
1413 procfs_ops
.to_create_inferior
= procfs_create_inferior
;
1414 procfs_ops
.to_mourn_inferior
= procfs_mourn_inferior
;
1415 procfs_ops
.to_can_run
= procfs_can_run
;
1416 procfs_ops
.to_pass_signals
= procfs_pass_signals
;
1417 procfs_ops
.to_thread_alive
= procfs_thread_alive
;
1418 procfs_ops
.to_find_new_threads
= procfs_find_new_threads
;
1419 procfs_ops
.to_pid_to_str
= procfs_pid_to_str
;
1420 procfs_ops
.to_stop
= procfs_stop
;
1421 procfs_ops
.to_stratum
= process_stratum
;
1422 procfs_ops
.to_has_all_memory
= default_child_has_all_memory
;
1423 procfs_ops
.to_has_memory
= default_child_has_memory
;
1424 procfs_ops
.to_has_stack
= default_child_has_stack
;
1425 procfs_ops
.to_has_registers
= default_child_has_registers
;
1426 procfs_ops
.to_has_execution
= default_child_has_execution
;
1427 procfs_ops
.to_magic
= OPS_MAGIC
;
1428 procfs_ops
.to_have_continuable_watchpoint
= 1;
1429 procfs_ops
.to_extra_thread_info
= nto_extra_thread_info
;
1432 #define OSTYPE_NTO 1
1435 _initialize_procfs (void)
1440 add_target (&procfs_ops
);
1442 /* We use SIGUSR1 to gain control after we block waiting for a process.
1443 We use sigwaitevent to wait. */
1445 sigaddset (&set
, SIGUSR1
);
1446 sigprocmask (SIG_BLOCK
, &set
, NULL
);
1448 /* Initially, make sure all signals are reported. */
1449 sigfillset (&run
.trace
);
1451 /* Stuff some information. */
1452 nto_cpuinfo_flags
= SYSPAGE_ENTRY (cpuinfo
)->flags
;
1453 nto_cpuinfo_valid
= 1;
1455 add_info ("pidlist", procfs_pidlist
, _("pidlist"));
1456 add_info ("meminfo", procfs_meminfo
, _("memory information"));
1458 nto_is_nto_target
= procfs_is_nto_target
;
1463 procfs_hw_watchpoint (int addr
, int len
, int type
)
1470 brk
.type
= _DEBUG_BREAK_RD
;
1472 case 2: /* Read/Write. */
1473 brk
.type
= _DEBUG_BREAK_RW
;
1475 default: /* Modify. */
1476 /* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason. */
1477 brk
.type
= _DEBUG_BREAK_RW
;
1479 brk
.type
|= _DEBUG_BREAK_HW
; /* Always ask for HW. */
1483 errno
= devctl (ctl_fd
, DCMD_PROC_BREAK
, &brk
, sizeof (brk
), 0);
1486 perror (_("Failed to set hardware watchpoint"));
1493 procfs_can_use_hw_breakpoint (struct target_ops
*self
,
1494 int type
, int cnt
, int othertype
)
1500 procfs_remove_hw_watchpoint (struct target_ops
*self
,
1501 CORE_ADDR addr
, int len
, int type
,
1502 struct expression
*cond
)
1504 return procfs_hw_watchpoint (addr
, -1, type
);
1508 procfs_insert_hw_watchpoint (CORE_ADDR addr
, int len
, int type
,
1509 struct expression
*cond
)
1511 return procfs_hw_watchpoint (addr
, len
, type
);
1515 procfs_stopped_by_watchpoint (struct target_ops
*ops
)