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-2018 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>
39 #include "gdbthread.h"
44 #include "inf-child.h"
45 #include "common/filestuff.h"
46 #include "common/scoped_fd.h"
49 #define _DEBUG_FLAG_TRACE (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\
50 _DEBUG_FLAG_TRACE_WR|_DEBUG_FLAG_TRACE_MODIFY)
54 static sighandler_t ofunc
;
56 static procfs_run run
;
58 /* Create the "native" and "procfs" targets. */
60 struct nto_procfs_target
: public inf_child_target
62 void open (const char *arg
, int from_tty
) override
;
64 void attach (const char *, int) override
= 0;
66 void post_attach (int);
68 void detach (inferior
*, int) override
;
70 void resume (ptid_t
, int, enum gdb_signal
) override
;
72 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
74 void fetch_registers (struct regcache
*, int) override
;
75 void store_registers (struct regcache
*, int) override
;
77 enum target_xfer_status
xfer_partial (enum target_object object
,
80 const gdb_byte
*writebuf
,
81 ULONGEST offset
, ULONGEST len
,
82 ULONGEST
*xfered_len
) override
;
84 void files_info () override
;
86 int insert_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
88 int remove_breakpoint (struct gdbarch
*, struct bp_target_info
*,
89 enum remove_bp_reason
) override
;
91 int can_use_hw_breakpoint (enum bptype
, int, int) override
;
93 int insert_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
95 int remove_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
97 int insert_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
98 struct expression
*) override
;
100 int remove_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
101 struct expression
*) override
;
103 int stopped_by_watchpoint () override
;
105 void kill () override
;
107 void create_inferior (const char *, const std::string
&,
108 char **, int) override
;
110 void mourn_inferior () override
;
112 void pass_signals (int, unsigned char *) override
;
114 int thread_alive (ptid_t ptid
) override
;
116 void update_thread_list () override
;
118 const char *pid_to_str (ptid_t
) override
;
120 void interrupt () override
;
122 bool have_continuable_watchpoint ()
125 const char *extra_thread_info (struct thread_info
*) override
;
127 char *pid_to_exec_file (int pid
) override
;
130 /* For "target native". */
131 struct nto_procfs_target_native final
: public nto_procfs_target
133 /* Leave shortname as "native". */
135 const char *longname () override
136 { return _("QNX Neutrino local process"); }
138 const char *doc () override
139 { return _("QNX Neutrino local process (started by the \"run\" command)."); }
142 /* For "target procfs <node>". */
143 struct nto_procfs_target_procfs final
: public nto_procfs_target
145 const char *shortname () override
148 const char *longname () override
149 { return _("QNX Neutrino local or remote process"); }
151 const char *doc () override
152 { return _("QNX Neutrino process. target procfs <node>"); }
155 static ptid_t
do_attach (ptid_t ptid
);
157 /* These two globals are only ever set in procfs_open_1, but are
158 referenced elsewhere. 'nto_procfs_node' is a flag used to say
159 whether we are local, or we should get the current node descriptor
160 for the remote QNX node. */
161 static char *nodestr
;
162 static unsigned nto_procfs_node
= ND_LOCAL_NODE
;
164 /* Return the current QNX Node, or error out. This is a simple
165 wrapper for the netmgr_strtond() function. The reason this
166 is required is because QNX node descriptors are transient so
167 we have to re-acquire them every time. */
173 if (ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) == 0
175 return ND_LOCAL_NODE
;
177 node
= netmgr_strtond (nodestr
, 0);
179 error (_("Lost the QNX node. Debug session probably over."));
184 static enum gdb_osabi
185 procfs_is_nto_target (bfd
*abfd
)
187 return GDB_OSABI_QNXNTO
;
190 /* This is called when we call 'target native' or 'target procfs
191 <arg>' from the (gdb) prompt. For QNX6 (nto), the only valid arg
192 will be a QNX node string, eg: "/net/some_node". If arg is not a
193 valid QNX node, we will default to local. */
195 nto_procfs_target::open (const char *arg
, int from_tty
)
200 procfs_sysinfo
*sysinfo
;
201 char nto_procfs_path
[PATH_MAX
];
203 /* Offer to kill previous inferiors before opening this target. */
204 target_preopen (from_tty
);
206 nto_is_nto_target
= procfs_is_nto_target
;
208 /* Set the default node used for spawning to this one,
209 and only override it if there is a valid arg. */
214 nto_procfs_node
= ND_LOCAL_NODE
;
215 nodestr
= (arg
!= NULL
) ? xstrdup (arg
) : NULL
;
221 nto_procfs_node
= netmgr_strtond (nodestr
, &endstr
);
222 if (nto_procfs_node
== -1)
224 if (errno
== ENOTSUP
)
225 printf_filtered ("QNX Net Manager not found.\n");
226 printf_filtered ("Invalid QNX node %s: error %d (%s).\n", nodestr
,
227 errno
, safe_strerror (errno
));
230 nto_procfs_node
= ND_LOCAL_NODE
;
234 if (*(endstr
- 1) == '/')
240 snprintf (nto_procfs_path
, PATH_MAX
- 1, "%s%s",
241 (nodestr
!= NULL
) ? nodestr
: "", "/proc");
243 scoped_fd
fd (open (nto_procfs_path
, O_RDONLY
));
246 printf_filtered ("Error opening %s : %d (%s)\n", nto_procfs_path
, errno
,
247 safe_strerror (errno
));
248 error (_("Invalid procfs arg"));
251 sysinfo
= (void *) buffer
;
252 if (devctl (fd
.get (), DCMD_PROC_SYSINFO
, sysinfo
, sizeof buffer
, 0) != EOK
)
254 printf_filtered ("Error getting size: %d (%s)\n", errno
,
255 safe_strerror (errno
));
256 error (_("Devctl failed."));
260 total_size
= sysinfo
->total_size
;
261 sysinfo
= alloca (total_size
);
264 printf_filtered ("Memory error: %d (%s)\n", errno
,
265 safe_strerror (errno
));
266 error (_("alloca failed."));
270 if (devctl (fd
.get (), DCMD_PROC_SYSINFO
, sysinfo
, total_size
, 0)
273 printf_filtered ("Error getting sysinfo: %d (%s)\n", errno
,
274 safe_strerror (errno
));
275 error (_("Devctl failed."));
280 nto_map_arch_to_cputype (gdbarch_bfd_arch_info
281 (target_gdbarch ())->arch_name
))
282 error (_("Invalid target CPU."));
287 inf_child_target::open (arg
, from_tty
);
288 printf_filtered ("Debugging using %s\n", nto_procfs_path
);
292 procfs_set_thread (ptid_t ptid
)
296 tid
= ptid_get_tid (ptid
);
297 devctl (ctl_fd
, DCMD_PROC_CURTHREAD
, &tid
, sizeof (tid
), 0);
300 /* Return nonzero if the thread TH is still alive. */
302 nto_procfs_target::thread_alive (ptid_t ptid
)
306 procfs_status status
;
309 tid
= ptid_get_tid (ptid
);
310 pid
= ptid_get_pid (ptid
);
312 if (kill (pid
, 0) == -1)
316 if ((err
= devctl (ctl_fd
, DCMD_PROC_TIDSTATUS
,
317 &status
, sizeof (status
), 0)) != EOK
)
320 /* Thread is alive or dead but not yet joined,
321 or dead and there is an alive (or dead unjoined) thread with
324 If the tid is not the same as requested, requested tid is dead. */
325 return (status
.tid
== tid
) && (status
.state
!= STATE_DEAD
);
329 update_thread_private_data_name (struct thread_info
*new_thread
,
332 nto_thread_info
*pti
= get_nto_thread_info (new_thread
);
334 gdb_assert (newname
!= NULL
);
335 gdb_assert (new_thread
!= NULL
);
339 pti
= new nto_thread_info
;
340 new_thread
->priv
.reset (pti
);
347 update_thread_private_data (struct thread_info
*new_thread
,
348 pthread_t tid
, int state
, int flags
)
351 struct _thread_name
*tn
;
352 procfs_threadctl tctl
;
354 #if _NTO_VERSION > 630
355 gdb_assert (new_thread
!= NULL
);
357 if (devctl (ctl_fd
, DCMD_PROC_INFO
, &pidinfo
,
358 sizeof(pidinfo
), 0) != EOK
)
361 memset (&tctl
, 0, sizeof (tctl
));
362 tctl
.cmd
= _NTO_TCTL_NAME
;
363 tn
= (struct _thread_name
*) (&tctl
.data
);
365 /* Fetch name for the given thread. */
367 tn
->name_buf_len
= sizeof (tctl
.data
) - sizeof (*tn
);
368 tn
->new_name_len
= -1; /* Getting, not setting. */
369 if (devctl (ctl_fd
, DCMD_PROC_THREADCTL
, &tctl
, sizeof (tctl
), NULL
) != EOK
)
370 tn
->name_buf
[0] = '\0';
372 tn
->name_buf
[_NTO_THREAD_NAME_MAX
] = '\0';
374 update_thread_private_data_name (new_thread
, tn
->name_buf
);
376 nto_thread_info
*pti
= get_nto_thread_info (new_thread
);
380 #endif /* _NTO_VERSION */
384 nto_procfs_target::update_thread_list ()
386 procfs_status status
;
390 struct thread_info
*new_thread
;
397 pid
= ptid_get_pid (inferior_ptid
);
401 for (tid
= 1;; ++tid
)
403 if (status
.tid
== tid
404 && (devctl (ctl_fd
, DCMD_PROC_TIDSTATUS
, &status
, sizeof (status
), 0)
407 if (status
.tid
!= tid
)
408 /* The reason why this would not be equal is that devctl might have
409 returned different tid, meaning the requested tid no longer exists
410 (e.g. thread exited). */
412 ptid
= ptid_build (pid
, 0, tid
);
413 new_thread
= find_thread_ptid (ptid
);
415 new_thread
= add_thread (ptid
);
416 update_thread_private_data (new_thread
, tid
, status
.state
, 0);
423 do_closedir_cleanup (void *dir
)
429 procfs_pidlist (const char *args
, int from_tty
)
432 struct dirent
*dirp
= NULL
;
434 procfs_info
*pidinfo
= NULL
;
435 procfs_debuginfo
*info
= NULL
;
436 procfs_status
*status
= NULL
;
437 pid_t num_threads
= 0;
440 struct cleanup
*cleanups
;
441 char procfs_dir
[PATH_MAX
];
443 snprintf (procfs_dir
, sizeof (procfs_dir
), "%s%s",
444 (nodestr
!= NULL
) ? nodestr
: "", "/proc");
446 dp
= opendir (procfs_dir
);
449 fprintf_unfiltered (gdb_stderr
, "failed to opendir \"%s\" - %d (%s)",
450 procfs_dir
, errno
, safe_strerror (errno
));
454 cleanups
= make_cleanup (do_closedir_cleanup
, dp
);
456 /* Start scan at first pid. */
461 /* Get the right pid and procfs path for the pid. */
467 do_cleanups (cleanups
);
470 snprintf (buf
, sizeof (buf
), "%s%s/%s/as",
471 (nodestr
!= NULL
) ? nodestr
: "",
472 "/proc", dirp
->d_name
);
473 pid
= atoi (dirp
->d_name
);
477 /* Open the procfs path. */
478 scoped_fd
fd (open (buf
, O_RDONLY
));
481 fprintf_unfiltered (gdb_stderr
, "failed to open %s - %d (%s)\n",
482 buf
, errno
, safe_strerror (errno
));
486 pidinfo
= (procfs_info
*) buf
;
487 if (devctl (fd
.get (), DCMD_PROC_INFO
, pidinfo
, sizeof (buf
), 0) != EOK
)
489 fprintf_unfiltered (gdb_stderr
,
490 "devctl DCMD_PROC_INFO failed - %d (%s)\n",
491 errno
, safe_strerror (errno
));
494 num_threads
= pidinfo
->num_threads
;
496 info
= (procfs_debuginfo
*) buf
;
497 if (devctl (fd
.get (), DCMD_PROC_MAPDEBUG_BASE
, info
, sizeof (buf
), 0)
499 strcpy (name
, "unavailable");
501 strcpy (name
, info
->path
);
503 /* Collect state info on all the threads. */
504 status
= (procfs_status
*) buf
;
505 for (status
->tid
= 1; status
->tid
<= num_threads
; status
->tid
++)
508 = devctl (fd
.get (), DCMD_PROC_TIDSTATUS
, status
, sizeof (buf
), 0);
509 printf_filtered ("%s - %d", name
, pid
);
510 if (err
== EOK
&& status
->tid
!= 0)
511 printf_filtered ("/%d\n", status
->tid
);
514 printf_filtered ("\n");
519 while (dirp
!= NULL
);
521 do_cleanups (cleanups
);
526 procfs_meminfo (const char *args
, int from_tty
)
528 procfs_mapinfo
*mapinfos
= NULL
;
529 static int num_mapinfos
= 0;
530 procfs_mapinfo
*mapinfo_p
, *mapinfo_p2
;
531 int flags
= ~0, err
, num
, i
, j
;
535 procfs_debuginfo info
;
536 char buff
[_POSIX_PATH_MAX
];
544 unsigned debug_vaddr
;
545 unsigned long long offset
;
550 unsigned long long ino
;
557 /* Get the number of map entrys. */
558 err
= devctl (ctl_fd
, DCMD_PROC_MAPINFO
, NULL
, 0, &num
);
561 printf ("failed devctl num mapinfos - %d (%s)\n", err
,
562 safe_strerror (err
));
566 mapinfos
= XNEWVEC (procfs_mapinfo
, num
);
569 mapinfo_p
= mapinfos
;
571 /* Fill the map entrys. */
572 err
= devctl (ctl_fd
, DCMD_PROC_MAPINFO
, mapinfo_p
, num
573 * sizeof (procfs_mapinfo
), &num
);
576 printf ("failed devctl mapinfos - %d (%s)\n", err
, safe_strerror (err
));
581 num
= std::min (num
, num_mapinfos
);
583 /* Run through the list of mapinfos, and store the data and text info
584 so we can print it at the bottom of the loop. */
585 for (mapinfo_p
= mapinfos
, i
= 0; i
< num
; i
++, mapinfo_p
++)
587 if (!(mapinfo_p
->flags
& flags
))
590 if (mapinfo_p
->ino
== 0) /* Already visited. */
593 map
.info
.vaddr
= mapinfo_p
->vaddr
;
595 err
= devctl (ctl_fd
, DCMD_PROC_MAPDEBUG
, &map
, sizeof (map
), 0);
599 memset (&printme
, 0, sizeof printme
);
600 printme
.dev
= mapinfo_p
->dev
;
601 printme
.ino
= mapinfo_p
->ino
;
602 printme
.text
.addr
= mapinfo_p
->vaddr
;
603 printme
.text
.size
= mapinfo_p
->size
;
604 printme
.text
.flags
= mapinfo_p
->flags
;
605 printme
.text
.offset
= mapinfo_p
->offset
;
606 printme
.text
.debug_vaddr
= map
.info
.vaddr
;
607 strcpy (printme
.name
, map
.info
.path
);
609 /* Check for matching data. */
610 for (mapinfo_p2
= mapinfos
, j
= 0; j
< num
; j
++, mapinfo_p2
++)
612 if (mapinfo_p2
->vaddr
!= mapinfo_p
->vaddr
613 && mapinfo_p2
->ino
== mapinfo_p
->ino
614 && mapinfo_p2
->dev
== mapinfo_p
->dev
)
616 map
.info
.vaddr
= mapinfo_p2
->vaddr
;
618 devctl (ctl_fd
, DCMD_PROC_MAPDEBUG
, &map
, sizeof (map
), 0);
622 if (strcmp (map
.info
.path
, printme
.name
))
625 /* Lower debug_vaddr is always text, if nessessary, swap. */
626 if ((int) map
.info
.vaddr
< (int) printme
.text
.debug_vaddr
)
628 memcpy (&(printme
.data
), &(printme
.text
),
629 sizeof (printme
.data
));
630 printme
.text
.addr
= mapinfo_p2
->vaddr
;
631 printme
.text
.size
= mapinfo_p2
->size
;
632 printme
.text
.flags
= mapinfo_p2
->flags
;
633 printme
.text
.offset
= mapinfo_p2
->offset
;
634 printme
.text
.debug_vaddr
= map
.info
.vaddr
;
638 printme
.data
.addr
= mapinfo_p2
->vaddr
;
639 printme
.data
.size
= mapinfo_p2
->size
;
640 printme
.data
.flags
= mapinfo_p2
->flags
;
641 printme
.data
.offset
= mapinfo_p2
->offset
;
642 printme
.data
.debug_vaddr
= map
.info
.vaddr
;
649 printf_filtered ("%s\n", printme
.name
);
650 printf_filtered ("\ttext=%08x bytes @ 0x%08x\n", printme
.text
.size
,
652 printf_filtered ("\t\tflags=%08x\n", printme
.text
.flags
);
653 printf_filtered ("\t\tdebug=%08x\n", printme
.text
.debug_vaddr
);
654 printf_filtered ("\t\toffset=%s\n", phex (printme
.text
.offset
, 8));
655 if (printme
.data
.size
)
657 printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme
.data
.size
,
659 printf_filtered ("\t\tflags=%08x\n", printme
.data
.flags
);
660 printf_filtered ("\t\tdebug=%08x\n", printme
.data
.debug_vaddr
);
661 printf_filtered ("\t\toffset=%s\n", phex (printme
.data
.offset
, 8));
663 printf_filtered ("\tdev=0x%x\n", printme
.dev
);
664 printf_filtered ("\tino=0x%x\n", (unsigned int) printme
.ino
);
670 /* Print status information about what we're accessing. */
672 nto_procfs_target::files_info ()
674 struct inferior
*inf
= current_inferior ();
676 printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
677 inf
->attach_flag
? "attached" : "child",
678 target_pid_to_str (inferior_ptid
),
679 (nodestr
!= NULL
) ? nodestr
: "local node");
682 /* Target to_pid_to_exec_file implementation. */
685 nto_procfs_target::pid_to_exec_file (const int pid
)
688 static char proc_path
[PATH_MAX
];
691 /* Read exe file name. */
692 snprintf (proc_path
, sizeof (proc_path
), "%s/proc/%d/exefile",
693 (nodestr
!= NULL
) ? nodestr
: "", pid
);
694 proc_fd
= open (proc_path
, O_RDONLY
);
698 rd
= read (proc_fd
, proc_path
, sizeof (proc_path
) - 1);
705 proc_path
[rd
] = '\0';
709 /* Attach to process PID, then initialize for debugging it. */
711 nto_procfs_target::attach (const char *args
, int from_tty
)
715 struct inferior
*inf
;
717 pid
= parse_pid_to_attach (args
);
719 if (pid
== getpid ())
720 error (_("Attaching GDB to itself is not a good idea..."));
724 exec_file
= (char *) get_exec_file (0);
727 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
728 target_pid_to_str (pid_to_ptid (pid
)));
730 printf_unfiltered ("Attaching to %s\n",
731 target_pid_to_str (pid_to_ptid (pid
)));
733 gdb_flush (gdb_stdout
);
735 inferior_ptid
= do_attach (pid_to_ptid (pid
));
736 inf
= current_inferior ();
737 inferior_appeared (inf
, pid
);
738 inf
->attach_flag
= 1;
740 if (!target_is_pushed (ops
))
743 procfs_update_thread_list (ops
);
747 nto_procfs_target::post_attach (pid_t pid
)
750 solib_create_inferior_hook (0);
754 do_attach (ptid_t ptid
)
756 procfs_status status
;
757 struct sigevent event
;
760 snprintf (path
, PATH_MAX
- 1, "%s%s/%d/as",
761 (nodestr
!= NULL
) ? nodestr
: "", "/proc", ptid_get_pid (ptid
));
762 ctl_fd
= open (path
, O_RDWR
);
764 error (_("Couldn't open proc file %s, error %d (%s)"), path
, errno
,
765 safe_strerror (errno
));
766 if (devctl (ctl_fd
, DCMD_PROC_STOP
, &status
, sizeof (status
), 0) != EOK
)
767 error (_("Couldn't stop process"));
769 /* Define a sigevent for process stopped notification. */
770 event
.sigev_notify
= SIGEV_SIGNAL_THREAD
;
771 event
.sigev_signo
= SIGUSR1
;
772 event
.sigev_code
= 0;
773 event
.sigev_value
.sival_ptr
= NULL
;
774 event
.sigev_priority
= -1;
775 devctl (ctl_fd
, DCMD_PROC_EVENT
, &event
, sizeof (event
), 0);
777 if (devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0) == EOK
778 && status
.flags
& _DEBUG_FLAG_STOPPED
)
779 SignalKill (nto_node (), ptid_get_pid (ptid
), 0, SIGCONT
, 0, 0);
780 nto_init_solib_absolute_prefix ();
781 return ptid_build (ptid_get_pid (ptid
), 0, status
.tid
);
784 /* Ask the user what to do when an interrupt is received. */
786 interrupt_query (void)
788 if (query (_("Interrupted while waiting for the program.\n\
789 Give up (and stop debugging it)? ")))
791 target_mourn_inferior (inferior_ptid
);
796 /* The user typed ^C twice. */
798 nto_handle_sigint_twice (int signo
)
800 signal (signo
, ofunc
);
802 signal (signo
, nto_handle_sigint_twice
);
806 nto_handle_sigint (int signo
)
808 /* If this doesn't work, try more severe steps. */
809 signal (signo
, nto_handle_sigint_twice
);
815 nto_procfs_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
820 procfs_status status
;
821 static int exit_signo
= 0; /* To track signals that cause termination. */
823 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
825 if (ptid_equal (inferior_ptid
, null_ptid
))
827 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
828 ourstatus
->value
.sig
= GDB_SIGNAL_0
;
834 sigaddset (&set
, SIGUSR1
);
836 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
837 while (!(status
.flags
& _DEBUG_FLAG_ISTOP
))
839 ofunc
= signal (SIGINT
, nto_handle_sigint
);
840 sigwaitinfo (&set
, &info
);
841 signal (SIGINT
, ofunc
);
842 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
845 nto_inferior_data (NULL
)->stopped_flags
= status
.flags
;
846 nto_inferior_data (NULL
)->stopped_pc
= status
.ip
;
848 if (status
.flags
& _DEBUG_FLAG_SSTEP
)
850 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
851 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
853 /* Was it a breakpoint? */
854 else if (status
.flags
& _DEBUG_FLAG_TRACE
)
856 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
857 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
859 else if (status
.flags
& _DEBUG_FLAG_ISTOP
)
863 case _DEBUG_WHY_SIGNALLED
:
864 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
865 ourstatus
->value
.sig
=
866 gdb_signal_from_host (status
.info
.si_signo
);
869 case _DEBUG_WHY_FAULTED
:
870 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
871 if (status
.info
.si_signo
== SIGTRAP
)
873 ourstatus
->value
.sig
= 0;
878 ourstatus
->value
.sig
=
879 gdb_signal_from_host (status
.info
.si_signo
);
880 exit_signo
= ourstatus
->value
.sig
;
884 case _DEBUG_WHY_TERMINATED
:
888 waitpid (ptid_get_pid (inferior_ptid
), &waitval
, WNOHANG
);
891 /* Abnormal death. */
892 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
893 ourstatus
->value
.sig
= exit_signo
;
898 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
899 ourstatus
->value
.integer
= WEXITSTATUS (waitval
);
905 case _DEBUG_WHY_REQUESTED
:
906 /* We are assuming a requested stop is due to a SIGINT. */
907 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
908 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
914 return ptid_build (status
.pid
, 0, status
.tid
);
917 /* Read the current values of the inferior's registers, both the
918 general register set and floating point registers (if supported)
919 and update gdb's idea of their current values. */
921 nto_procfs_target::fetch_registers (struct regcache
*regcache
, int regno
)
927 procfs_altreg altreg
;
932 procfs_set_thread (regcache_get_ptid (regcache
));
933 if (devctl (ctl_fd
, DCMD_PROC_GETGREG
, ®
, sizeof (reg
), ®size
) == EOK
)
934 nto_supply_gregset (regcache
, (char *) ®
.greg
);
935 if (devctl (ctl_fd
, DCMD_PROC_GETFPREG
, ®
, sizeof (reg
), ®size
)
937 nto_supply_fpregset (regcache
, (char *) ®
.fpreg
);
938 if (devctl (ctl_fd
, DCMD_PROC_GETALTREG
, ®
, sizeof (reg
), ®size
)
940 nto_supply_altregset (regcache
, (char *) ®
.altreg
);
943 /* Helper for procfs_xfer_partial that handles memory transfers.
944 Arguments are like target_xfer_partial. */
946 static enum target_xfer_status
947 procfs_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
948 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
952 if (lseek (ctl_fd
, (off_t
) memaddr
, SEEK_SET
) != (off_t
) memaddr
)
953 return TARGET_XFER_E_IO
;
955 if (writebuf
!= NULL
)
956 nbytes
= write (ctl_fd
, writebuf
, len
);
958 nbytes
= read (ctl_fd
, readbuf
, len
);
960 return TARGET_XFER_E_IO
;
961 *xfered_len
= nbytes
;
962 return TARGET_XFER_OK
;
965 /* Target to_xfer_partial implementation. */
967 enum target_xfer_status
968 nto_procfs_target::xfer_partial (enum target_object object
,
969 const char *annex
, gdb_byte
*readbuf
,
970 const gdb_byte
*writebuf
, ULONGEST offset
,
971 ULONGEST len
, ULONGEST
*xfered_len
)
975 case TARGET_OBJECT_MEMORY
:
976 return procfs_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
977 case TARGET_OBJECT_AUXV
:
981 CORE_ADDR initial_stack
;
982 debug_process_t procinfo
;
983 /* For 32-bit architecture, size of auxv_t is 8 bytes. */
984 const unsigned int sizeof_auxv_t
= sizeof (auxv_t
);
985 const unsigned int sizeof_tempbuf
= 20 * sizeof_auxv_t
;
987 gdb_byte
*const tempbuf
= alloca (sizeof_tempbuf
);
990 return TARGET_XFER_E_IO
;
992 err
= devctl (ctl_fd
, DCMD_PROC_INFO
, &procinfo
,
995 return TARGET_XFER_E_IO
;
997 initial_stack
= procinfo
.initial_stack
;
999 /* procfs is always 'self-hosted', no byte-order manipulation. */
1000 tempread
= nto_read_auxv_from_initial_stack (initial_stack
, tempbuf
,
1003 tempread
= std::min (tempread
, len
) - offset
;
1004 memcpy (readbuf
, tempbuf
+ offset
, tempread
);
1005 *xfered_len
= tempread
;
1006 return tempread
? TARGET_XFER_OK
: TARGET_XFER_EOF
;
1010 return this->beneath
->xfer_partial (object
, annex
,
1011 readbuf
, writebuf
, offset
, len
,
1016 /* Take a program previously attached to and detaches it.
1017 The program resumes execution and will no longer stop
1018 on signals, etc. We'd better not have left any breakpoints
1019 in the program or it'll die when it hits one. */
1021 nto_procfs_target::detach (inferior
*inf
, int from_tty
)
1025 target_announce_detach ();
1028 SignalKill (nto_node (), ptid_get_pid (inferior_ptid
), 0, 0, 0, 0);
1033 pid
= ptid_get_pid (inferior_ptid
);
1034 inferior_ptid
= null_ptid
;
1035 detach_inferior (pid
);
1036 init_thread_list ();
1037 inf_child_maybe_unpush_target (ops
);
1041 procfs_breakpoint (CORE_ADDR addr
, int type
, int size
)
1048 errno
= devctl (ctl_fd
, DCMD_PROC_BREAK
, &brk
, sizeof (brk
), 0);
1055 nto_procfs_target::insert_breakpoint (struct gdbarch
*gdbarch
,
1056 struct bp_target_info
*bp_tgt
)
1058 bp_tgt
->placed_address
= bp_tgt
->reqstd_address
;
1059 return procfs_breakpoint (bp_tgt
->placed_address
, _DEBUG_BREAK_EXEC
, 0);
1063 nto_procfs_target::remove_breakpoint (struct gdbarch
*gdbarch
,
1064 struct bp_target_info
*bp_tgt
,
1065 enum remove_bp_reason reason
)
1067 return procfs_breakpoint (bp_tgt
->placed_address
, _DEBUG_BREAK_EXEC
, -1);
1071 nto_procfs_target::insert_hw_breakpoint (struct gdbarch
*gdbarch
,
1072 struct bp_target_info
*bp_tgt
)
1074 bp_tgt
->placed_address
= bp_tgt
->reqstd_address
;
1075 return procfs_breakpoint (bp_tgt
->placed_address
,
1076 _DEBUG_BREAK_EXEC
| _DEBUG_BREAK_HW
, 0);
1080 nto_procfs_target::remove_hw_breakpoint (struct gdbarch
*gdbarch
,
1081 struct bp_target_info
*bp_tgt
)
1083 return procfs_breakpoint (bp_tgt
->placed_address
,
1084 _DEBUG_BREAK_EXEC
| _DEBUG_BREAK_HW
, -1);
1088 nto_procfs_target::resume (ptid_t ptid
, int step
, enum gdb_signal signo
)
1091 procfs_status status
;
1092 sigset_t
*run_fault
= (sigset_t
*) (void *) &run
.fault
;
1094 if (ptid_equal (inferior_ptid
, null_ptid
))
1097 procfs_set_thread (ptid_equal (ptid
, minus_one_ptid
) ? inferior_ptid
:
1100 run
.flags
= _DEBUG_RUN_FAULT
| _DEBUG_RUN_TRACE
;
1102 run
.flags
|= _DEBUG_RUN_STEP
;
1104 sigemptyset (run_fault
);
1105 sigaddset (run_fault
, FLTBPT
);
1106 sigaddset (run_fault
, FLTTRACE
);
1107 sigaddset (run_fault
, FLTILL
);
1108 sigaddset (run_fault
, FLTPRIV
);
1109 sigaddset (run_fault
, FLTBOUNDS
);
1110 sigaddset (run_fault
, FLTIOVF
);
1111 sigaddset (run_fault
, FLTIZDIV
);
1112 sigaddset (run_fault
, FLTFPE
);
1113 /* Peter V will be changing this at some point. */
1114 sigaddset (run_fault
, FLTPAGE
);
1116 run
.flags
|= _DEBUG_RUN_ARM
;
1118 signal_to_pass
= gdb_signal_to_host (signo
);
1122 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
1123 signal_to_pass
= gdb_signal_to_host (signo
);
1124 if (status
.why
& (_DEBUG_WHY_SIGNALLED
| _DEBUG_WHY_FAULTED
))
1126 if (signal_to_pass
!= status
.info
.si_signo
)
1128 SignalKill (nto_node (), ptid_get_pid (inferior_ptid
), 0,
1129 signal_to_pass
, 0, 0);
1130 run
.flags
|= _DEBUG_RUN_CLRFLT
| _DEBUG_RUN_CLRSIG
;
1132 else /* Let it kill the program without telling us. */
1133 sigdelset (&run
.trace
, signal_to_pass
);
1137 run
.flags
|= _DEBUG_RUN_CLRSIG
| _DEBUG_RUN_CLRFLT
;
1139 errno
= devctl (ctl_fd
, DCMD_PROC_RUN
, &run
, sizeof (run
), 0);
1142 perror (_("run error!\n"));
1148 nto_procfs_target::mourn_inferior ()
1150 if (!ptid_equal (inferior_ptid
, null_ptid
))
1152 SignalKill (nto_node (), ptid_get_pid (inferior_ptid
), 0, SIGKILL
, 0, 0);
1155 inferior_ptid
= null_ptid
;
1156 init_thread_list ();
1157 inf_child_mourn_inferior (ops
);
1160 /* This function breaks up an argument string into an argument
1161 vector suitable for passing to execvp().
1162 E.g., on "run a b c d" this routine would get as input
1163 the string "a b c d", and as output it would fill in argv with
1164 the four arguments "a", "b", "c", "d". The only additional
1165 functionality is simple quoting. The gdb command:
1167 will fill in argv with the three args "a", "b c d", "e". */
1169 breakup_args (char *scratch
, char **argv
)
1171 char *pp
, *cp
= scratch
;
1176 /* Scan past leading separators. */
1178 while (*cp
== ' ' || *cp
== '\t' || *cp
== '\n')
1181 /* Break if at end of string. */
1189 quoting
= strchr (cp
, '"') ? 1 : 0;
1194 /* Scan for next arg separator. */
1197 cp
= strchr (pp
, '"');
1198 if ((cp
== NULL
) || (!quoting
))
1199 cp
= strchr (pp
, ' ');
1201 cp
= strchr (pp
, '\t');
1203 cp
= strchr (pp
, '\n');
1205 /* No separators => end of string => break. */
1212 /* Replace the separator with a terminator. */
1216 /* Execv requires a null-terminated arg vector. */
1221 nto_procfs_target::create_inferior (const char *exec_file
,
1222 const std::string
&allargs
,
1223 char **env
, int from_tty
)
1225 struct inheritance inherit
;
1229 const char *in
= "", *out
= "", *err
= "";
1232 const char *inferior_io_terminal
= get_inferior_io_terminal ();
1233 struct inferior
*inf
;
1235 argv
= xmalloc ((allargs
.size () / (unsigned) 2 + 2) *
1237 argv
[0] = get_exec_file (1);
1241 argv
[0] = exec_file
;
1246 args
= xstrdup (allargs
.c_str ());
1247 breakup_args (args
, (exec_file
!= NULL
) ? &argv
[1] : &argv
[0]);
1249 argv
= nto_parse_redirection (argv
, &in
, &out
, &err
);
1251 fds
[0] = STDIN_FILENO
;
1252 fds
[1] = STDOUT_FILENO
;
1253 fds
[2] = STDERR_FILENO
;
1255 /* If the user specified I/O via gdb's --tty= arg, use it, but only
1256 if the i/o is not also being specified via redirection. */
1257 if (inferior_io_terminal
)
1260 in
= inferior_io_terminal
;
1262 out
= inferior_io_terminal
;
1264 err
= inferior_io_terminal
;
1269 fd
= open (in
, O_RDONLY
);
1277 fd
= open (out
, O_WRONLY
);
1285 fd
= open (err
, O_WRONLY
);
1292 /* Clear any pending SIGUSR1's but keep the behavior the same. */
1293 signal (SIGUSR1
, signal (SIGUSR1
, SIG_IGN
));
1296 sigaddset (&set
, SIGUSR1
);
1297 sigprocmask (SIG_UNBLOCK
, &set
, NULL
);
1299 memset (&inherit
, 0, sizeof (inherit
));
1301 if (ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) != 0)
1303 inherit
.nd
= nto_node ();
1304 inherit
.flags
|= SPAWN_SETND
;
1305 inherit
.flags
&= ~SPAWN_EXEC
;
1307 inherit
.flags
|= SPAWN_SETGROUP
| SPAWN_HOLD
;
1308 inherit
.pgroup
= SPAWN_NEWPGROUP
;
1309 pid
= spawnp (argv
[0], 3, fds
, &inherit
, argv
,
1310 ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) == 0 ? env
: 0);
1313 sigprocmask (SIG_BLOCK
, &set
, NULL
);
1316 error (_("Error spawning %s: %d (%s)"), argv
[0], errno
,
1317 safe_strerror (errno
));
1319 if (fds
[0] != STDIN_FILENO
)
1321 if (fds
[1] != STDOUT_FILENO
)
1323 if (fds
[2] != STDERR_FILENO
)
1326 inferior_ptid
= do_attach (pid_to_ptid (pid
));
1327 procfs_update_thread_list (ops
);
1329 inf
= current_inferior ();
1330 inferior_appeared (inf
, pid
);
1331 inf
->attach_flag
= 0;
1333 flags
= _DEBUG_FLAG_KLC
; /* Kill-on-Last-Close flag. */
1334 errn
= devctl (ctl_fd
, DCMD_PROC_SET_FLAG
, &flags
, sizeof (flags
), 0);
1337 /* FIXME: expected warning? */
1338 /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
1339 errn, strerror(errn) ); */
1341 if (!target_is_pushed (ops
))
1343 target_terminal::init ();
1345 if (exec_bfd
!= NULL
1346 || (symfile_objfile
!= NULL
&& symfile_objfile
->obfd
!= NULL
))
1347 solib_create_inferior_hook (0);
1351 nto_procfs_target::interrupt ()
1353 devctl (ctl_fd
, DCMD_PROC_STOP
, NULL
, 0, 0);
1357 nto_procfs_target::kill ()
1359 target_mourn_inferior (inferior_ptid
);
1362 /* Fill buf with regset and return devctl cmd to do the setting. Return
1363 -1 if we fail to get the regset. Store size of regset in regsize. */
1365 get_regset (int regset
, char *buf
, int bufsize
, int *regsize
)
1367 int dev_get
, dev_set
;
1370 case NTO_REG_GENERAL
:
1371 dev_get
= DCMD_PROC_GETGREG
;
1372 dev_set
= DCMD_PROC_SETGREG
;
1376 dev_get
= DCMD_PROC_GETFPREG
;
1377 dev_set
= DCMD_PROC_SETFPREG
;
1381 dev_get
= DCMD_PROC_GETALTREG
;
1382 dev_set
= DCMD_PROC_SETALTREG
;
1385 case NTO_REG_SYSTEM
:
1389 if (devctl (ctl_fd
, dev_get
, buf
, bufsize
, regsize
) != EOK
)
1396 nto_procfs_target::store_registers (struct regcache
*regcache
, int regno
)
1402 procfs_altreg altreg
;
1406 int len
, regset
, regsize
, dev_set
, err
;
1408 ptid_t ptid
= regcache_get_ptid (regcache
);
1410 if (ptid_equal (ptid
, null_ptid
))
1412 procfs_set_thread (ptid
);
1416 for (regset
= NTO_REG_GENERAL
; regset
< NTO_REG_END
; regset
++)
1418 dev_set
= get_regset (regset
, (char *) ®
,
1419 sizeof (reg
), ®size
);
1423 if (nto_regset_fill (regcache
, regset
, (char *) ®
) == -1)
1426 err
= devctl (ctl_fd
, dev_set
, ®
, regsize
, 0);
1428 fprintf_unfiltered (gdb_stderr
,
1429 "Warning unable to write regset %d: %s\n",
1430 regno
, safe_strerror (err
));
1435 regset
= nto_regset_id (regno
);
1439 dev_set
= get_regset (regset
, (char *) ®
, sizeof (reg
), ®size
);
1443 len
= nto_register_area (regcache
->arch (),
1444 regno
, regset
, &off
);
1449 regcache_raw_collect (regcache
, regno
, (char *) ®
+ off
);
1451 err
= devctl (ctl_fd
, dev_set
, ®
, regsize
, 0);
1453 fprintf_unfiltered (gdb_stderr
,
1454 "Warning unable to write regset %d: %s\n", regno
,
1455 safe_strerror (err
));
1459 /* Set list of signals to be handled in the target. */
1462 nto_procfs_target::pass_signals (int numsigs
, unsigned char *pass_signals
)
1466 sigfillset (&run
.trace
);
1468 for (signo
= 1; signo
< NSIG
; signo
++)
1470 int target_signo
= gdb_signal_from_host (signo
);
1471 if (target_signo
< numsigs
&& pass_signals
[target_signo
])
1472 sigdelset (&run
.trace
, signo
);
1477 nto_procfs_target::pid_to_str (ptid_t ptid
)
1479 static char buf
[1024];
1481 struct tidinfo
*tip
;
1483 pid
= ptid_get_pid (ptid
);
1484 tid
= ptid_get_tid (ptid
);
1486 n
= snprintf (buf
, 1023, "process %d", pid
);
1489 tip
= procfs_thread_info (pid
, tid
);
1491 snprintf (&buf
[n
], 1023, " (state = 0x%02x)", tip
->state
);
1497 /* to_can_run implementation for "target procfs". Note this really
1498 means "can this target be the default run target", which there can
1499 be only one, and we make it be "target native" like other ports.
1500 "target procfs <node>" wouldn't make sense as default run target, as
1504 nto_procfs_target::can_run ()
1509 /* "target procfs". */
1510 static nto_procfs_target_procfs nto_procfs_ops
;
1512 /* "target native". */
1513 static nto_procfs_target_native nto_native_ops
;
1515 /* Create the "native" and "procfs" targets. */
1518 init_procfs_targets (void)
1520 /* Register "target native". This is the default run target. */
1521 add_target (&nto_native_ops
);
1523 /* Register "target procfs <node>". */
1524 add_target (&nto_procfs_ops
);
1527 #define OSTYPE_NTO 1
1530 _initialize_procfs (void)
1534 init_procfs_targets ();
1536 /* We use SIGUSR1 to gain control after we block waiting for a process.
1537 We use sigwaitevent to wait. */
1539 sigaddset (&set
, SIGUSR1
);
1540 sigprocmask (SIG_BLOCK
, &set
, NULL
);
1542 /* Initially, make sure all signals are reported. */
1543 sigfillset (&run
.trace
);
1545 /* Stuff some information. */
1546 nto_cpuinfo_flags
= SYSPAGE_ENTRY (cpuinfo
)->flags
;
1547 nto_cpuinfo_valid
= 1;
1549 add_info ("pidlist", procfs_pidlist
, _("pidlist"));
1550 add_info ("meminfo", procfs_meminfo
, _("memory information"));
1552 nto_is_nto_target
= procfs_is_nto_target
;
1557 procfs_hw_watchpoint (int addr
, int len
, enum target_hw_bp_type type
)
1564 brk
.type
= _DEBUG_BREAK_RD
;
1567 brk
.type
= _DEBUG_BREAK_RW
;
1569 default: /* Modify. */
1570 /* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason. */
1571 brk
.type
= _DEBUG_BREAK_RW
;
1573 brk
.type
|= _DEBUG_BREAK_HW
; /* Always ask for HW. */
1577 errno
= devctl (ctl_fd
, DCMD_PROC_BREAK
, &brk
, sizeof (brk
), 0);
1580 perror (_("Failed to set hardware watchpoint"));
1587 nto_procfs_target::can_use_hw_breakpoint (enum bptype type
,
1588 int cnt
, int othertype
)
1594 nto_procfs_target::remove_hw_watchpoint (CORE_ADDR addr
, int len
,
1595 enum target_hw_bp_type type
,
1596 struct expression
*cond
)
1598 return procfs_hw_watchpoint (addr
, -1, type
);
1602 nto_procfs_target::insert_hw_watchpoint (CORE_ADDR addr
, int len
,
1603 enum target_hw_bp_type type
,
1604 struct expression
*cond
)
1606 return procfs_hw_watchpoint (addr
, len
, type
);
1610 nto_procfs_target::stopped_by_watchpoint ()
1612 /* NOTE: nto_stopped_by_watchpoint will be called ONLY while we are
1613 stopped due to a SIGTRAP. This assumes gdb works in 'all-stop' mode;
1614 future gdb versions will likely run in 'non-stop' mode in which case
1615 we will have to store/examine statuses per thread in question.
1616 Until then, this will work fine. */
1618 struct inferior
*inf
= current_inferior ();
1619 struct nto_inferior_data
*inf_data
;
1621 gdb_assert (inf
!= NULL
);
1623 inf_data
= nto_inferior_data (inf
);
1625 return inf_data
->stopped_flags
1626 & (_DEBUG_FLAG_TRACE_RD
1627 | _DEBUG_FLAG_TRACE_WR
1628 | _DEBUG_FLAG_TRACE_MODIFY
);