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, 2009 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 int procfs_xfer_memory (CORE_ADDR
, gdb_byte
*, int, int,
63 struct mem_attrib
*attrib
,
66 static void notice_signals (void);
68 static void init_procfs_ops (void);
70 static ptid_t
do_attach (ptid_t ptid
);
72 static int procfs_can_use_hw_breakpoint (int, int, int);
74 static int procfs_insert_hw_watchpoint (CORE_ADDR addr
, int len
, int type
);
76 static int procfs_remove_hw_watchpoint (CORE_ADDR addr
, int len
, int type
);
78 static int procfs_stopped_by_watchpoint (void);
80 /* These two globals are only ever set in procfs_open(), but are
81 referenced elsewhere. 'nto_procfs_node' is a flag used to say
82 whether we are local, or we should get the current node descriptor
83 for the remote QNX node. */
84 static char nto_procfs_path
[PATH_MAX
] = { "/proc" };
85 static unsigned nto_procfs_node
= ND_LOCAL_NODE
;
87 /* Return the current QNX Node, or error out. This is a simple
88 wrapper for the netmgr_strtond() function. The reason this
89 is required is because QNX node descriptors are transient so
90 we have to re-acquire them every time. */
96 if (ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) == 0)
99 node
= netmgr_strtond (nto_procfs_path
, 0);
101 error (_("Lost the QNX node. Debug session probably over."));
106 static enum gdb_osabi
107 procfs_is_nto_target (bfd
*abfd
)
109 return GDB_OSABI_QNXNTO
;
112 /* This is called when we call 'target procfs <arg>' from the (gdb) prompt.
113 For QNX6 (nto), the only valid arg will be a QNX node string,
114 eg: "/net/some_node". If arg is not a valid QNX node, we will
117 procfs_open (char *arg
, int from_tty
)
123 procfs_sysinfo
*sysinfo
;
124 struct cleanup
*cleanups
;
126 nto_is_nto_target
= procfs_is_nto_target
;
128 /* Set the default node used for spawning to this one,
129 and only override it if there is a valid arg. */
131 nto_procfs_node
= ND_LOCAL_NODE
;
132 nodestr
= arg
? xstrdup (arg
) : arg
;
138 nto_procfs_node
= netmgr_strtond (nodestr
, &endstr
);
139 if (nto_procfs_node
== -1)
141 if (errno
== ENOTSUP
)
142 printf_filtered ("QNX Net Manager not found.\n");
143 printf_filtered ("Invalid QNX node %s: error %d (%s).\n", nodestr
,
144 errno
, safe_strerror (errno
));
147 nto_procfs_node
= ND_LOCAL_NODE
;
151 if (*(endstr
- 1) == '/')
157 snprintf (nto_procfs_path
, PATH_MAX
- 1, "%s%s", nodestr
? nodestr
: "",
162 fd
= open (nto_procfs_path
, O_RDONLY
);
165 printf_filtered ("Error opening %s : %d (%s)\n", nto_procfs_path
, errno
,
166 safe_strerror (errno
));
167 error (_("Invalid procfs arg"));
169 cleanups
= make_cleanup_close (fd
);
171 sysinfo
= (void *) buffer
;
172 if (devctl (fd
, DCMD_PROC_SYSINFO
, sysinfo
, sizeof buffer
, 0) != EOK
)
174 printf_filtered ("Error getting size: %d (%s)\n", errno
,
175 safe_strerror (errno
));
176 error (_("Devctl failed."));
180 total_size
= sysinfo
->total_size
;
181 sysinfo
= alloca (total_size
);
184 printf_filtered ("Memory error: %d (%s)\n", errno
,
185 safe_strerror (errno
));
186 error (_("alloca failed."));
190 if (devctl (fd
, DCMD_PROC_SYSINFO
, sysinfo
, total_size
, 0) != EOK
)
192 printf_filtered ("Error getting sysinfo: %d (%s)\n", errno
,
193 safe_strerror (errno
));
194 error (_("Devctl failed."));
199 nto_map_arch_to_cputype (gdbarch_bfd_arch_info
200 (target_gdbarch
)->arch_name
))
201 error (_("Invalid target CPU."));
205 do_cleanups (cleanups
);
206 printf_filtered ("Debugging using %s\n", nto_procfs_path
);
210 procfs_set_thread (ptid_t ptid
)
214 tid
= ptid_get_tid (ptid
);
215 devctl (ctl_fd
, DCMD_PROC_CURTHREAD
, &tid
, sizeof (tid
), 0);
218 /* Return nonzero if the thread TH is still alive. */
220 procfs_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
224 procfs_status status
;
227 tid
= ptid_get_tid (ptid
);
228 pid
= ptid_get_pid (ptid
);
230 if (kill (pid
, 0) == -1)
234 if ((err
= devctl (ctl_fd
, DCMD_PROC_TIDSTATUS
,
235 &status
, sizeof (status
), 0)) != EOK
)
238 /* Thread is alive or dead but not yet joined,
239 or dead and there is an alive (or dead unjoined) thread with
242 If the tid is not the same as requested, requested tid is dead. */
243 return (status
.tid
== tid
) && (status
.state
!= STATE_DEAD
);
247 update_thread_private_data_name (struct thread_info
*new_thread
,
251 struct private_thread_info
*pti
;
253 gdb_assert (newname
!= NULL
);
254 gdb_assert (new_thread
!= NULL
);
255 newnamelen
= strlen (newname
);
256 if (!new_thread
->private)
258 new_thread
->private = xmalloc (offsetof (struct private_thread_info
,
261 memcpy (new_thread
->private->name
, newname
, newnamelen
+ 1);
263 else if (strcmp (newname
, new_thread
->private->name
) != 0)
265 /* Reallocate if neccessary. */
266 int oldnamelen
= strlen (new_thread
->private->name
);
268 if (oldnamelen
< newnamelen
)
269 new_thread
->private = xrealloc (new_thread
->private,
270 offsetof (struct private_thread_info
,
273 memcpy (new_thread
->private->name
, newname
, newnamelen
+ 1);
278 update_thread_private_data (struct thread_info
*new_thread
,
279 pthread_t tid
, int state
, int flags
)
281 struct private_thread_info
*pti
;
283 struct _thread_name
*tn
;
284 procfs_threadctl tctl
;
286 #if _NTO_VERSION > 630
287 gdb_assert (new_thread
!= NULL
);
289 if (devctl (ctl_fd
, DCMD_PROC_INFO
, &pidinfo
,
290 sizeof(pidinfo
), 0) != EOK
)
293 memset (&tctl
, 0, sizeof (tctl
));
294 tctl
.cmd
= _NTO_TCTL_NAME
;
295 tn
= (struct _thread_name
*) (&tctl
.data
);
297 /* Fetch name for the given thread. */
299 tn
->name_buf_len
= sizeof (tctl
.data
) - sizeof (*tn
);
300 tn
->new_name_len
= -1; /* Getting, not setting. */
301 if (devctl (ctl_fd
, DCMD_PROC_THREADCTL
, &tctl
, sizeof (tctl
), NULL
) != EOK
)
302 tn
->name_buf
[0] = '\0';
304 tn
->name_buf
[_NTO_THREAD_NAME_MAX
] = '\0';
306 update_thread_private_data_name (new_thread
, tn
->name_buf
);
308 pti
= (struct private_thread_info
*) new_thread
->private;
312 #endif /* _NTO_VERSION */
316 procfs_find_new_threads (struct target_ops
*ops
)
318 procfs_status status
;
322 struct thread_info
*new_thread
;
327 pid
= ptid_get_pid (inferior_ptid
);
331 for (tid
= 1;; ++tid
)
333 if (status
.tid
== tid
334 && (devctl (ctl_fd
, DCMD_PROC_TIDSTATUS
, &status
, sizeof (status
), 0)
337 if (status
.tid
!= tid
)
338 /* The reason why this would not be equal is that devctl might have
339 returned different tid, meaning the requested tid no longer exists
340 (e.g. thread exited). */
342 ptid
= ptid_build (pid
, 0, tid
);
343 new_thread
= find_thread_ptid (ptid
);
345 new_thread
= add_thread (ptid
);
346 update_thread_private_data (new_thread
, tid
, status
.state
, 0);
353 do_closedir_cleanup (void *dir
)
359 procfs_pidlist (char *args
, int from_tty
)
362 struct dirent
*dirp
= NULL
;
364 procfs_info
*pidinfo
= NULL
;
365 procfs_debuginfo
*info
= NULL
;
366 procfs_status
*status
= NULL
;
367 pid_t num_threads
= 0;
370 struct cleanup
*cleanups
;
372 dp
= opendir (nto_procfs_path
);
375 fprintf_unfiltered (gdb_stderr
, "failed to opendir \"%s\" - %d (%s)",
376 nto_procfs_path
, errno
, safe_strerror (errno
));
380 cleanups
= make_cleanup (do_closedir_cleanup
, dp
);
382 /* Start scan at first pid. */
388 struct cleanup
*inner_cleanup
;
390 /* Get the right pid and procfs path for the pid. */
396 do_cleanups (cleanups
);
399 snprintf (buf
, 511, "%s/%s/as", nto_procfs_path
, dirp
->d_name
);
400 pid
= atoi (dirp
->d_name
);
404 /* Open the procfs path. */
405 fd
= open (buf
, O_RDONLY
);
408 fprintf_unfiltered (gdb_stderr
, "failed to open %s - %d (%s)\n",
409 buf
, errno
, safe_strerror (errno
));
410 do_cleanups (cleanups
);
413 inner_cleanup
= make_cleanup_close (fd
);
415 pidinfo
= (procfs_info
*) buf
;
416 if (devctl (fd
, DCMD_PROC_INFO
, pidinfo
, sizeof (buf
), 0) != EOK
)
418 fprintf_unfiltered (gdb_stderr
,
419 "devctl DCMD_PROC_INFO failed - %d (%s)\n",
420 errno
, safe_strerror (errno
));
423 num_threads
= pidinfo
->num_threads
;
425 info
= (procfs_debuginfo
*) buf
;
426 if (devctl (fd
, DCMD_PROC_MAPDEBUG_BASE
, info
, sizeof (buf
), 0) != EOK
)
427 strcpy (name
, "unavailable");
429 strcpy (name
, info
->path
);
431 /* Collect state info on all the threads. */
432 status
= (procfs_status
*) buf
;
433 for (status
->tid
= 1; status
->tid
<= num_threads
; status
->tid
++)
435 if (devctl (fd
, DCMD_PROC_TIDSTATUS
, status
, sizeof (buf
), 0) != EOK
438 if (status
->tid
!= 0)
439 printf_filtered ("%s - %d/%d\n", name
, pid
, status
->tid
);
442 do_cleanups (inner_cleanup
);
444 while (dirp
!= NULL
);
446 do_cleanups (cleanups
);
451 procfs_meminfo (char *args
, int from_tty
)
453 procfs_mapinfo
*mapinfos
= NULL
;
454 static int num_mapinfos
= 0;
455 procfs_mapinfo
*mapinfo_p
, *mapinfo_p2
;
456 int flags
= ~0, err
, num
, i
, j
;
460 procfs_debuginfo info
;
461 char buff
[_POSIX_PATH_MAX
];
469 unsigned debug_vaddr
;
470 unsigned long long offset
;
475 unsigned long long ino
;
482 /* Get the number of map entrys. */
483 err
= devctl (ctl_fd
, DCMD_PROC_MAPINFO
, NULL
, 0, &num
);
486 printf ("failed devctl num mapinfos - %d (%s)\n", err
,
487 safe_strerror (err
));
491 mapinfos
= xmalloc (num
* sizeof (procfs_mapinfo
));
494 mapinfo_p
= mapinfos
;
496 /* Fill the map entrys. */
497 err
= devctl (ctl_fd
, DCMD_PROC_MAPINFO
, mapinfo_p
, num
498 * sizeof (procfs_mapinfo
), &num
);
501 printf ("failed devctl mapinfos - %d (%s)\n", err
, safe_strerror (err
));
506 num
= min (num
, num_mapinfos
);
508 /* Run through the list of mapinfos, and store the data and text info
509 so we can print it at the bottom of the loop. */
510 for (mapinfo_p
= mapinfos
, i
= 0; i
< num
; i
++, mapinfo_p
++)
512 if (!(mapinfo_p
->flags
& flags
))
515 if (mapinfo_p
->ino
== 0) /* Already visited. */
518 map
.info
.vaddr
= mapinfo_p
->vaddr
;
520 err
= devctl (ctl_fd
, DCMD_PROC_MAPDEBUG
, &map
, sizeof (map
), 0);
524 memset (&printme
, 0, sizeof printme
);
525 printme
.dev
= mapinfo_p
->dev
;
526 printme
.ino
= mapinfo_p
->ino
;
527 printme
.text
.addr
= mapinfo_p
->vaddr
;
528 printme
.text
.size
= mapinfo_p
->size
;
529 printme
.text
.flags
= mapinfo_p
->flags
;
530 printme
.text
.offset
= mapinfo_p
->offset
;
531 printme
.text
.debug_vaddr
= map
.info
.vaddr
;
532 strcpy (printme
.name
, map
.info
.path
);
534 /* Check for matching data. */
535 for (mapinfo_p2
= mapinfos
, j
= 0; j
< num
; j
++, mapinfo_p2
++)
537 if (mapinfo_p2
->vaddr
!= mapinfo_p
->vaddr
538 && mapinfo_p2
->ino
== mapinfo_p
->ino
539 && mapinfo_p2
->dev
== mapinfo_p
->dev
)
541 map
.info
.vaddr
= mapinfo_p2
->vaddr
;
543 devctl (ctl_fd
, DCMD_PROC_MAPDEBUG
, &map
, sizeof (map
), 0);
547 if (strcmp (map
.info
.path
, printme
.name
))
550 /* Lower debug_vaddr is always text, if nessessary, swap. */
551 if ((int) map
.info
.vaddr
< (int) printme
.text
.debug_vaddr
)
553 memcpy (&(printme
.data
), &(printme
.text
),
554 sizeof (printme
.data
));
555 printme
.text
.addr
= mapinfo_p2
->vaddr
;
556 printme
.text
.size
= mapinfo_p2
->size
;
557 printme
.text
.flags
= mapinfo_p2
->flags
;
558 printme
.text
.offset
= mapinfo_p2
->offset
;
559 printme
.text
.debug_vaddr
= map
.info
.vaddr
;
563 printme
.data
.addr
= mapinfo_p2
->vaddr
;
564 printme
.data
.size
= mapinfo_p2
->size
;
565 printme
.data
.flags
= mapinfo_p2
->flags
;
566 printme
.data
.offset
= mapinfo_p2
->offset
;
567 printme
.data
.debug_vaddr
= map
.info
.vaddr
;
574 printf_filtered ("%s\n", printme
.name
);
575 printf_filtered ("\ttext=%08x bytes @ 0x%08x\n", printme
.text
.size
,
577 printf_filtered ("\t\tflags=%08x\n", printme
.text
.flags
);
578 printf_filtered ("\t\tdebug=%08x\n", printme
.text
.debug_vaddr
);
579 printf_filtered ("\t\toffset=%016llx\n", printme
.text
.offset
);
580 if (printme
.data
.size
)
582 printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme
.data
.size
,
584 printf_filtered ("\t\tflags=%08x\n", printme
.data
.flags
);
585 printf_filtered ("\t\tdebug=%08x\n", printme
.data
.debug_vaddr
);
586 printf_filtered ("\t\toffset=%016llx\n", printme
.data
.offset
);
588 printf_filtered ("\tdev=0x%x\n", printme
.dev
);
589 printf_filtered ("\tino=0x%x\n", (unsigned int) printme
.ino
);
595 /* Print status information about what we're accessing. */
597 procfs_files_info (struct target_ops
*ignore
)
599 struct inferior
*inf
= current_inferior ();
601 printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
602 inf
->attach_flag
? "attached" : "child",
603 target_pid_to_str (inferior_ptid
), nto_procfs_path
);
606 /* Mark our target-struct as eligible for stray "run" and "attach" commands. */
608 procfs_can_run (void)
613 /* Attach to process PID, then initialize for debugging it. */
615 procfs_attach (struct target_ops
*ops
, char *args
, int from_tty
)
619 struct inferior
*inf
;
622 error_no_arg (_("process-id to attach"));
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
= add_inferior (pid
);
644 inf
->attach_flag
= 1;
648 procfs_find_new_threads (ops
);
652 procfs_post_attach (pid_t pid
)
655 solib_create_inferior_hook ();
659 do_attach (ptid_t ptid
)
661 procfs_status status
;
662 struct sigevent event
;
665 snprintf (path
, PATH_MAX
- 1, "%s/%d/as", nto_procfs_path
, PIDGET (ptid
));
666 ctl_fd
= open (path
, O_RDWR
);
668 error (_("Couldn't open proc file %s, error %d (%s)"), path
, errno
,
669 safe_strerror (errno
));
670 if (devctl (ctl_fd
, DCMD_PROC_STOP
, &status
, sizeof (status
), 0) != EOK
)
671 error (_("Couldn't stop process"));
673 /* Define a sigevent for process stopped notification. */
674 event
.sigev_notify
= SIGEV_SIGNAL_THREAD
;
675 event
.sigev_signo
= SIGUSR1
;
676 event
.sigev_code
= 0;
677 event
.sigev_value
.sival_ptr
= NULL
;
678 event
.sigev_priority
= -1;
679 devctl (ctl_fd
, DCMD_PROC_EVENT
, &event
, sizeof (event
), 0);
681 if (devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0) == EOK
682 && status
.flags
& _DEBUG_FLAG_STOPPED
)
683 SignalKill (nto_node (), PIDGET (ptid
), 0, SIGCONT
, 0, 0);
684 nto_init_solib_absolute_prefix ();
685 return ptid_build (PIDGET (ptid
), 0, status
.tid
);
688 /* Ask the user what to do when an interrupt is received. */
690 interrupt_query (void)
692 target_terminal_ours ();
694 if (query (_("Interrupted while waiting for the program.\n\
695 Give up (and stop debugging it)? ")))
697 target_mourn_inferior ();
698 deprecated_throw_reason (RETURN_QUIT
);
701 target_terminal_inferior ();
704 /* The user typed ^C twice. */
706 nto_interrupt_twice (int signo
)
708 signal (signo
, ofunc
);
710 signal (signo
, nto_interrupt_twice
);
714 nto_interrupt (int signo
)
716 /* If this doesn't work, try more severe steps. */
717 signal (signo
, nto_interrupt_twice
);
719 target_stop (inferior_ptid
);
723 procfs_wait (struct target_ops
*ops
,
724 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
728 procfs_status status
;
729 static int exit_signo
= 0; /* To track signals that cause termination. */
731 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
733 if (ptid_equal (inferior_ptid
, null_ptid
))
735 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
736 ourstatus
->value
.sig
= TARGET_SIGNAL_0
;
742 sigaddset (&set
, SIGUSR1
);
744 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
745 while (!(status
.flags
& _DEBUG_FLAG_ISTOP
))
747 ofunc
= (void (*)()) signal (SIGINT
, nto_interrupt
);
748 sigwaitinfo (&set
, &info
);
749 signal (SIGINT
, ofunc
);
750 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
753 if (status
.flags
& _DEBUG_FLAG_SSTEP
)
755 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
756 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
758 /* Was it a breakpoint? */
759 else if (status
.flags
& _DEBUG_FLAG_TRACE
)
761 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
762 ourstatus
->value
.sig
= TARGET_SIGNAL_TRAP
;
764 else if (status
.flags
& _DEBUG_FLAG_ISTOP
)
768 case _DEBUG_WHY_SIGNALLED
:
769 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
770 ourstatus
->value
.sig
=
771 target_signal_from_host (status
.info
.si_signo
);
774 case _DEBUG_WHY_FAULTED
:
775 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
776 if (status
.info
.si_signo
== SIGTRAP
)
778 ourstatus
->value
.sig
= 0;
783 ourstatus
->value
.sig
=
784 target_signal_from_host (status
.info
.si_signo
);
785 exit_signo
= ourstatus
->value
.sig
;
789 case _DEBUG_WHY_TERMINATED
:
793 waitpid (PIDGET (inferior_ptid
), &waitval
, WNOHANG
);
796 /* Abnormal death. */
797 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
798 ourstatus
->value
.sig
= exit_signo
;
803 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
804 ourstatus
->value
.integer
= WEXITSTATUS (waitval
);
810 case _DEBUG_WHY_REQUESTED
:
811 /* We are assuming a requested stop is due to a SIGINT. */
812 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
813 ourstatus
->value
.sig
= TARGET_SIGNAL_INT
;
819 return ptid_build (status
.pid
, 0, status
.tid
);
822 /* Read the current values of the inferior's registers, both the
823 general register set and floating point registers (if supported)
824 and update gdb's idea of their current values. */
826 procfs_fetch_registers (struct target_ops
*ops
,
827 struct regcache
*regcache
, int regno
)
833 procfs_altreg altreg
;
838 procfs_set_thread (inferior_ptid
);
839 if (devctl (ctl_fd
, DCMD_PROC_GETGREG
, ®
, sizeof (reg
), ®size
) == EOK
)
840 nto_supply_gregset (regcache
, (char *) ®
.greg
);
841 if (devctl (ctl_fd
, DCMD_PROC_GETFPREG
, ®
, sizeof (reg
), ®size
)
843 nto_supply_fpregset (regcache
, (char *) ®
.fpreg
);
844 if (devctl (ctl_fd
, DCMD_PROC_GETALTREG
, ®
, sizeof (reg
), ®size
)
846 nto_supply_altregset (regcache
, (char *) ®
.altreg
);
849 /* Copy LEN bytes to/from inferior's memory starting at MEMADDR
850 from/to debugger memory starting at MYADDR. Copy from inferior
851 if DOWRITE is zero or to inferior if DOWRITE is nonzero.
853 Returns the length copied, which is either the LEN argument or
854 zero. This xfer function does not do partial moves, since procfs_ops
855 doesn't allow memory operations to cross below us in the target stack
858 procfs_xfer_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, int len
, int dowrite
,
859 struct mem_attrib
*attrib
, struct target_ops
*target
)
863 if (lseek (ctl_fd
, (off_t
) memaddr
, SEEK_SET
) == (off_t
) memaddr
)
866 nbytes
= write (ctl_fd
, myaddr
, len
);
868 nbytes
= read (ctl_fd
, myaddr
, len
);
875 /* Take a program previously attached to and detaches it.
876 The program resumes execution and will no longer stop
877 on signals, etc. We'd better not have left any breakpoints
878 in the program or it'll die when it hits one. */
880 procfs_detach (struct target_ops
*ops
, char *args
, int from_tty
)
887 char *exec_file
= get_exec_file (0);
890 printf_unfiltered ("Detaching from program: %s %s\n",
891 exec_file
, target_pid_to_str (inferior_ptid
));
892 gdb_flush (gdb_stdout
);
895 siggnal
= atoi (args
);
898 SignalKill (nto_node (), PIDGET (inferior_ptid
), 0, siggnal
, 0, 0);
903 pid
= ptid_get_pid (inferior_ptid
);
904 inferior_ptid
= null_ptid
;
905 detach_inferior (pid
);
907 unpush_target (&procfs_ops
); /* Pop out of handling an inferior. */
911 procfs_breakpoint (CORE_ADDR addr
, int type
, int size
)
918 errno
= devctl (ctl_fd
, DCMD_PROC_BREAK
, &brk
, sizeof (brk
), 0);
925 procfs_insert_breakpoint (struct gdbarch
*gdbarch
,
926 struct bp_target_info
*bp_tgt
)
928 return procfs_breakpoint (bp_tgt
->placed_address
, _DEBUG_BREAK_EXEC
, 0);
932 procfs_remove_breakpoint (struct gdbarch
*gdbarch
,
933 struct bp_target_info
*bp_tgt
)
935 return procfs_breakpoint (bp_tgt
->placed_address
, _DEBUG_BREAK_EXEC
, -1);
939 procfs_insert_hw_breakpoint (struct gdbarch
*gdbarch
,
940 struct bp_target_info
*bp_tgt
)
942 return procfs_breakpoint (bp_tgt
->placed_address
,
943 _DEBUG_BREAK_EXEC
| _DEBUG_BREAK_HW
, 0);
947 procfs_remove_hw_breakpoint (struct gdbarch
*gdbarch
,
948 struct bp_target_info
*bp_tgt
)
950 return procfs_breakpoint (bp_tgt
->placed_address
,
951 _DEBUG_BREAK_EXEC
| _DEBUG_BREAK_HW
, -1);
955 procfs_resume (struct target_ops
*ops
,
956 ptid_t ptid
, int step
, enum target_signal signo
)
959 procfs_status status
;
960 sigset_t
*run_fault
= (sigset_t
*) (void *) &run
.fault
;
962 if (ptid_equal (inferior_ptid
, null_ptid
))
965 procfs_set_thread (ptid_equal (ptid
, minus_one_ptid
) ? inferior_ptid
:
968 run
.flags
= _DEBUG_RUN_FAULT
| _DEBUG_RUN_TRACE
;
970 run
.flags
|= _DEBUG_RUN_STEP
;
972 sigemptyset (run_fault
);
973 sigaddset (run_fault
, FLTBPT
);
974 sigaddset (run_fault
, FLTTRACE
);
975 sigaddset (run_fault
, FLTILL
);
976 sigaddset (run_fault
, FLTPRIV
);
977 sigaddset (run_fault
, FLTBOUNDS
);
978 sigaddset (run_fault
, FLTIOVF
);
979 sigaddset (run_fault
, FLTIZDIV
);
980 sigaddset (run_fault
, FLTFPE
);
981 /* Peter V will be changing this at some point. */
982 sigaddset (run_fault
, FLTPAGE
);
984 run
.flags
|= _DEBUG_RUN_ARM
;
986 sigemptyset (&run
.trace
);
988 signal_to_pass
= target_signal_to_host (signo
);
992 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
993 signal_to_pass
= target_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 (), PIDGET (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 (), PIDGET (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
= add_inferior (pid
);
1200 inf
->attach_flag
= 0;
1202 flags
= _DEBUG_FLAG_KLC
; /* Kill-on-Last-Close flag. */
1203 errn
= devctl (ctl_fd
, DCMD_PROC_SET_FLAG
, &flags
, sizeof (flags
), 0);
1206 /* FIXME: expected warning? */
1207 /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
1208 errn, strerror(errn) ); */
1211 target_terminal_init ();
1213 if (exec_bfd
!= NULL
1214 || (symfile_objfile
!= NULL
&& symfile_objfile
->obfd
!= NULL
))
1215 solib_create_inferior_hook ();
1219 procfs_stop (ptid_t ptid
)
1221 devctl (ctl_fd
, DCMD_PROC_STOP
, NULL
, 0, 0);
1225 procfs_kill_inferior (struct target_ops
*ops
)
1227 target_mourn_inferior ();
1230 /* Store register REGNO, or all registers if REGNO == -1, from the contents
1233 procfs_prepare_to_store (struct regcache
*regcache
)
1237 /* Fill buf with regset and return devctl cmd to do the setting. Return
1238 -1 if we fail to get the regset. Store size of regset in regsize. */
1240 get_regset (int regset
, char *buf
, int bufsize
, int *regsize
)
1242 int dev_get
, dev_set
;
1245 case NTO_REG_GENERAL
:
1246 dev_get
= DCMD_PROC_GETGREG
;
1247 dev_set
= DCMD_PROC_SETGREG
;
1251 dev_get
= DCMD_PROC_GETFPREG
;
1252 dev_set
= DCMD_PROC_SETFPREG
;
1256 dev_get
= DCMD_PROC_GETALTREG
;
1257 dev_set
= DCMD_PROC_SETALTREG
;
1260 case NTO_REG_SYSTEM
:
1264 if (devctl (ctl_fd
, dev_get
, buf
, bufsize
, regsize
) != EOK
)
1271 procfs_store_registers (struct target_ops
*ops
,
1272 struct regcache
*regcache
, int regno
)
1278 procfs_altreg altreg
;
1282 int len
, regset
, regsize
, dev_set
, err
;
1285 if (ptid_equal (inferior_ptid
, null_ptid
))
1287 procfs_set_thread (inferior_ptid
);
1291 for (regset
= NTO_REG_GENERAL
; regset
< NTO_REG_END
; regset
++)
1293 dev_set
= get_regset (regset
, (char *) ®
,
1294 sizeof (reg
), ®size
);
1298 if (nto_regset_fill (regcache
, regset
, (char *) ®
) == -1)
1301 err
= devctl (ctl_fd
, dev_set
, ®
, regsize
, 0);
1303 fprintf_unfiltered (gdb_stderr
,
1304 "Warning unable to write regset %d: %s\n",
1305 regno
, safe_strerror (err
));
1310 regset
= nto_regset_id (regno
);
1314 dev_set
= get_regset (regset
, (char *) ®
, sizeof (reg
), ®size
);
1318 len
= nto_register_area (get_regcache_arch (regcache
),
1319 regno
, regset
, &off
);
1324 regcache_raw_collect (regcache
, regno
, (char *) ®
+ off
);
1326 err
= devctl (ctl_fd
, dev_set
, ®
, regsize
, 0);
1328 fprintf_unfiltered (gdb_stderr
,
1329 "Warning unable to write regset %d: %s\n", regno
,
1330 safe_strerror (err
));
1335 notice_signals (void)
1339 for (signo
= 1; signo
< NSIG
; signo
++)
1341 if (signal_stop_state (target_signal_from_host (signo
)) == 0
1342 && signal_print_state (target_signal_from_host (signo
)) == 0
1343 && signal_pass_state (target_signal_from_host (signo
)) == 1)
1344 sigdelset (&run
.trace
, signo
);
1346 sigaddset (&run
.trace
, signo
);
1350 /* When the user changes the state of gdb's signal handling via the
1351 "handle" command, this function gets called to see if any change
1352 in the /proc interface is required. It is also called internally
1353 by other /proc interface functions to initialize the state of
1354 the traced signal set. */
1356 procfs_notice_signals (ptid_t ptid
)
1358 sigemptyset (&run
.trace
);
1362 static struct tidinfo
*
1363 procfs_thread_info (pid_t pid
, short tid
)
1370 procfs_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1372 static char buf
[1024];
1374 struct tidinfo
*tip
;
1376 pid
= ptid_get_pid (ptid
);
1377 tid
= ptid_get_tid (ptid
);
1379 n
= snprintf (buf
, 1023, "process %d", pid
);
1382 tip
= procfs_thread_info (pid
, tid
);
1384 snprintf (&buf
[n
], 1023, " (state = 0x%02x)", tip
->state
);
1391 init_procfs_ops (void)
1393 procfs_ops
.to_shortname
= "procfs";
1394 procfs_ops
.to_longname
= "QNX Neutrino procfs child process";
1396 "QNX Neutrino procfs child process (started by the \"run\" command).\n\
1397 target procfs <node>";
1398 procfs_ops
.to_open
= procfs_open
;
1399 procfs_ops
.to_attach
= procfs_attach
;
1400 procfs_ops
.to_post_attach
= procfs_post_attach
;
1401 procfs_ops
.to_detach
= procfs_detach
;
1402 procfs_ops
.to_resume
= procfs_resume
;
1403 procfs_ops
.to_wait
= procfs_wait
;
1404 procfs_ops
.to_fetch_registers
= procfs_fetch_registers
;
1405 procfs_ops
.to_store_registers
= procfs_store_registers
;
1406 procfs_ops
.to_prepare_to_store
= procfs_prepare_to_store
;
1407 procfs_ops
.deprecated_xfer_memory
= procfs_xfer_memory
;
1408 procfs_ops
.to_files_info
= procfs_files_info
;
1409 procfs_ops
.to_insert_breakpoint
= procfs_insert_breakpoint
;
1410 procfs_ops
.to_remove_breakpoint
= procfs_remove_breakpoint
;
1411 procfs_ops
.to_can_use_hw_breakpoint
= procfs_can_use_hw_breakpoint
;
1412 procfs_ops
.to_insert_hw_breakpoint
= procfs_insert_hw_breakpoint
;
1413 procfs_ops
.to_remove_hw_breakpoint
= procfs_remove_breakpoint
;
1414 procfs_ops
.to_insert_watchpoint
= procfs_insert_hw_watchpoint
;
1415 procfs_ops
.to_remove_watchpoint
= procfs_remove_hw_watchpoint
;
1416 procfs_ops
.to_stopped_by_watchpoint
= procfs_stopped_by_watchpoint
;
1417 procfs_ops
.to_terminal_init
= terminal_init_inferior
;
1418 procfs_ops
.to_terminal_inferior
= terminal_inferior
;
1419 procfs_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
1420 procfs_ops
.to_terminal_ours
= terminal_ours
;
1421 procfs_ops
.to_terminal_info
= child_terminal_info
;
1422 procfs_ops
.to_kill
= procfs_kill_inferior
;
1423 procfs_ops
.to_create_inferior
= procfs_create_inferior
;
1424 procfs_ops
.to_mourn_inferior
= procfs_mourn_inferior
;
1425 procfs_ops
.to_can_run
= procfs_can_run
;
1426 procfs_ops
.to_notice_signals
= procfs_notice_signals
;
1427 procfs_ops
.to_thread_alive
= procfs_thread_alive
;
1428 procfs_ops
.to_find_new_threads
= procfs_find_new_threads
;
1429 procfs_ops
.to_pid_to_str
= procfs_pid_to_str
;
1430 procfs_ops
.to_stop
= procfs_stop
;
1431 procfs_ops
.to_stratum
= process_stratum
;
1432 procfs_ops
.to_has_all_memory
= default_child_has_all_memory
;
1433 procfs_ops
.to_has_memory
= default_child_has_memory
;
1434 procfs_ops
.to_has_stack
= default_child_has_stack
;
1435 procfs_ops
.to_has_registers
= default_child_has_registers
;
1436 procfs_ops
.to_has_execution
= default_child_has_execution
;
1437 procfs_ops
.to_magic
= OPS_MAGIC
;
1438 procfs_ops
.to_have_continuable_watchpoint
= 1;
1439 procfs_ops
.to_extra_thread_info
= nto_extra_thread_info
;
1442 #define OSTYPE_NTO 1
1445 _initialize_procfs (void)
1450 add_target (&procfs_ops
);
1452 /* We use SIGUSR1 to gain control after we block waiting for a process.
1453 We use sigwaitevent to wait. */
1455 sigaddset (&set
, SIGUSR1
);
1456 sigprocmask (SIG_BLOCK
, &set
, NULL
);
1458 /* Set up trace and fault sets, as gdb expects them. */
1459 sigemptyset (&run
.trace
);
1461 /* Stuff some information. */
1462 nto_cpuinfo_flags
= SYSPAGE_ENTRY (cpuinfo
)->flags
;
1463 nto_cpuinfo_valid
= 1;
1465 add_info ("pidlist", procfs_pidlist
, _("pidlist"));
1466 add_info ("meminfo", procfs_meminfo
, _("memory information"));
1468 nto_is_nto_target
= procfs_is_nto_target
;
1473 procfs_hw_watchpoint (int addr
, int len
, int type
)
1480 brk
.type
= _DEBUG_BREAK_RD
;
1482 case 2: /* Read/Write. */
1483 brk
.type
= _DEBUG_BREAK_RW
;
1485 default: /* Modify. */
1486 /* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason. */
1487 brk
.type
= _DEBUG_BREAK_RW
;
1489 brk
.type
|= _DEBUG_BREAK_HW
; /* Always ask for HW. */
1493 errno
= devctl (ctl_fd
, DCMD_PROC_BREAK
, &brk
, sizeof (brk
), 0);
1496 perror ("Failed to set hardware watchpoint");
1503 procfs_can_use_hw_breakpoint (int type
, int cnt
, int othertype
)
1509 procfs_remove_hw_watchpoint (CORE_ADDR addr
, int len
, int type
)
1511 return procfs_hw_watchpoint (addr
, -1, type
);
1515 procfs_insert_hw_watchpoint (CORE_ADDR addr
, int len
, int type
)
1517 return procfs_hw_watchpoint (addr
, len
, type
);
1521 procfs_stopped_by_watchpoint (void)