1 /* Copyright (C) 2009, 2010 Free Software Foundation, Inc.
3 This file is part of GDB.
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include <sys/ptrace.h>
24 #include <sys/piddef.h> /* Provides PIDGET, TIDGET, BUILDPID, etc. */
26 #include <sys/ioctl.h>
27 #include <sys/types.h>
31 int using_threads
= 1;
33 /* Print a debug trace on standard output if debug_threads is set. */
36 lynx_debug (char *string
, ...)
43 va_start (args
, string
);
44 fprintf (stderr
, "DEBUG(lynx): ");
45 vfprintf (stderr
, string
, args
);
46 fprintf (stderr
, "\n");
50 /* Build a ptid_t given a PID and a LynxOS TID. */
53 lynx_ptid_build (int pid
, long tid
)
55 /* brobecker/2010-06-21: It looks like the LWP field in ptids
56 should be distinct for each thread (see write_ptid where it
57 writes the thread ID from the LWP). So instead of storing
58 the LynxOS tid in the tid field of the ptid, we store it in
60 return ptid_build (pid
, tid
, 0);
63 /* Return the process ID of the given PTID.
65 This function has little reason to exist, it's just a wrapper around
66 ptid_get_pid. But since we have a getter function for the lynxos
67 ptid, it feels cleaner to have a getter for the pid as well. */
70 lynx_ptid_get_pid (ptid_t ptid
)
72 return ptid_get_pid (ptid
);
75 /* Return the LynxOS tid of the given PTID. */
78 lynx_ptid_get_tid (ptid_t ptid
)
80 /* See lynx_ptid_build: The LynxOS tid is stored inside the lwp field
82 return ptid_get_lwp (ptid
);
85 /* For a given PTID, return the associated PID as known by the LynxOS
89 lynx_ptrace_pid_from_ptid (ptid_t ptid
)
91 return BUILDPID (lynx_ptid_get_pid (ptid
), lynx_ptid_get_tid (ptid
));
94 /* Return a string image of the ptrace REQUEST number. */
97 ptrace_request_to_str (int request
)
102 return "PTRACE_TRACEME";
104 case PTRACE_PEEKTEXT
:
105 return "PTRACE_PEEKTEXT";
107 case PTRACE_PEEKDATA
:
108 return "PTRACE_PEEKDATA";
110 case PTRACE_PEEKUSER
:
111 return "PTRACE_PEEKUSER";
113 case PTRACE_POKETEXT
:
114 return "PTRACE_POKETEXT";
116 case PTRACE_POKEDATA
:
117 return "PTRACE_POKEDATA";
119 case PTRACE_POKEUSER
:
120 return "PTRACE_POKEUSER";
123 return "PTRACE_CONT";
126 return "PTRACE_KILL";
128 case PTRACE_SINGLESTEP
:
129 return "PTRACE_SINGLESTEP";
132 return "PTRACE_ATTACH";
135 return "PTRACE_DETACH";
138 return "PTRACE_GETREGS";
141 return "PTRACE_SETREGS";
143 case PTRACE_GETFPREGS
:
144 return "PTRACE_GETFPREGS";
146 case PTRACE_SETFPREGS
:
147 return "PTRACE_SETFPREGS";
149 case PTRACE_READDATA
:
150 return "PTRACE_READDATA";
152 case PTRACE_WRITEDATA
:
153 return "PTRACE_WRITEDATA";
155 case PTRACE_READTEXT
:
156 return "PTRACE_READTEXT";
158 case PTRACE_WRITETEXT
:
159 return "PTRACE_WRITETEXT";
161 case PTRACE_GETFPAREGS
:
162 return "PTRACE_GETFPAREGS";
164 case PTRACE_SETFPAREGS
:
165 return "PTRACE_SETFPAREGS";
167 case PTRACE_GETWINDOW
:
168 return "PTRACE_GETWINDOW";
170 case PTRACE_SETWINDOW
:
171 return "PTRACE_SETWINDOW";
174 return "PTRACE_SYSCALL";
176 case PTRACE_DUMPCORE
:
177 return "PTRACE_DUMPCORE";
179 case PTRACE_SETWRBKPT
:
180 return "PTRACE_SETWRBKPT";
182 case PTRACE_SETACBKPT
:
183 return "PTRACE_SETACBKPT";
186 return "PTRACE_CLRBKPT";
188 case PTRACE_GET_UCODE
:
189 return "PTRACE_GET_UCODE";
193 return "PT_READ_GPR";
198 return "PT_WRITE_GPR";
203 return "PT_READ_FPR";
208 return "PT_WRITE_FPR";
211 #ifdef PTRACE_GETVECREGS
212 case PTRACE_GETVECREGS
:
213 return "PTRACE_GETVECREGS";
216 #ifdef PTRACE_SETVECREGS
217 case PTRACE_SETVECREGS
:
218 return "PTRACE_SETVECREGS";
223 return "PT_READ_VPR";
228 return "PT_WRITE_VPR";
231 #ifdef PTRACE_PEEKUSP
233 return "PTRACE_PEEKUSP";
236 #ifdef PTRACE_POKEUSP
238 return "PTRACE_POKEUSP";
241 case PTRACE_PEEKTHREAD
:
242 return "PTRACE_PEEKTHREAD";
244 case PTRACE_THREADUSER
:
245 return "PTRACE_THREADUSER";
248 return "PTRACE_FPREAD";
251 return "PTRACE_FPWRITE";
254 return "PTRACE_SETSIG";
256 case PTRACE_CONT_ONE
:
257 return "PTRACE_CONT_ONE";
259 case PTRACE_KILL_ONE
:
260 return "PTRACE_KILL_ONE";
262 case PTRACE_SINGLESTEP_ONE
:
263 return "PTRACE_SINGLESTEP_ONE";
265 case PTRACE_GETLOADINFO
:
266 return "PTRACE_GETLOADINFO";
268 case PTRACE_GETTHREADLIST
:
269 return "PTRACE_GETTHREADLIST";
271 case PTRACE_POSTSYSCALL
:
272 return "PTRACE_POSTSYSCALL";
274 case PTRACE_USE_SIGEXECED
:
275 return "PTRACE_USE_SIGEXECED";
277 case PTRACE_GETTRACESIG
:
278 return "PTRACE_GETTRACESIG";
281 return "PTRACE_GETCWD";
283 case PTRACE_TRAPFORK
:
284 return "PTRACE_TRAPFORK";
286 case PTRACE_GETCHILDPID
:
287 return "PTRACE_GETCHILDPID";
289 case PTRACE_SYSCALL_ONE
:
290 return "PTRACE_SYSCALL_ONE";
293 return "PTRACE_SIGMASK";
296 return "PTRACE_GETIWD";
298 case PTRACE_GETEXECFILE
:
299 return "PTRACE_GETEXECFILE";
302 return "<unknown-request>";
305 /* A wrapper around ptrace that allows us to print debug traces of
306 ptrace calls if debug traces are activated. */
309 lynx_ptrace (int request
, ptid_t ptid
, int addr
, int data
, int addr2
)
312 const int pid
= lynx_ptrace_pid_from_ptid (ptid
);
316 fprintf (stderr
, "PTRACE (%s, pid=%d(pid=%d, tid=%d), addr=0x%x, "
317 "data=0x%x, addr2=0x%x)",
318 ptrace_request_to_str (request
), pid
, PIDGET (pid
), TIDGET (pid
),
320 result
= ptrace (request
, pid
, addr
, data
, addr2
);
323 fprintf (stderr
, " -> %d (=0x%x)\n", result
, result
);
329 /* Implement the create_inferior method of the target_ops vector. */
332 lynx_create_inferior (char *program
, char **allargs
)
334 struct process_info
*new_process
;
337 lynx_debug ("lynx_create_inferior ()");
341 perror_with_name ("fork");
347 /* Switch child to its own process group so that signals won't
348 directly affect gdbserver. */
351 ioctl (0, TIOCSPGRP
, &pgrp
);
352 lynx_ptrace (PTRACE_TRACEME
, null_ptid
, 0, 0, 0);
353 execv (program
, allargs
);
354 fprintf (stderr
, "Cannot exec %s: %s.\n", program
, strerror (errno
));
359 new_process
= add_process (pid
, 0);
360 /* Do not add the process thread just yet, as we do not know its tid.
361 We will add it later, during the wait for the STOP event corresponding
362 to the lynx_ptrace (PTRACE_TRACEME) call above. */
366 /* Implement the attach target_ops method. */
369 lynx_attach (unsigned long pid
)
371 struct process_info
*new_process
;
372 ptid_t ptid
= lynx_ptid_build (pid
, 0);
374 if (lynx_ptrace (PTRACE_ATTACH
, ptid
, 0, 0, 0) != 0)
375 error ("Cannot attach to process %lu: %s (%d)\n", pid
,
376 strerror (errno
), errno
);
378 new_process
= add_process (pid
, 1);
379 add_thread (ptid
, NULL
);
384 /* Implement the resume target_ops method. */
387 lynx_resume (struct thread_resume
*resume_info
, size_t n
)
389 ptid_t inferior_ptid
= thread_to_gdb_id (current_inferior
);
390 /* FIXME: Assume for now that n == 1. */
391 const int request
= (resume_info
[0].kind
== resume_step
392 ? PTRACE_SINGLESTEP
: PTRACE_CONT
);
393 const int signal
= resume_info
[0].sig
;
396 regcache_invalidate ();
397 ret
= lynx_ptrace (request
, inferior_ptid
, 1, signal
, 0);
400 /* Resume the execution of the given PTID. */
403 lynx_continue (ptid_t ptid
)
405 struct thread_resume resume_info
;
407 resume_info
.thread
= ptid
;
408 resume_info
.kind
= resume_continue
;
411 lynx_resume (&resume_info
, 1);
414 /* Remove all inferiors and associated threads. */
417 lynx_clear_inferiors (void)
419 /* We do not use private data, so nothing much to do except calling
424 /* A wrapper around waitpid that handles the various idiosyncrasies
425 of LynxOS' waitpid. */
428 lynx_waitpid (int pid
, int *stat_loc
)
434 ret
= waitpid (pid
, stat_loc
, WNOHANG
);
437 /* An ECHILD error is not indicative of a real problem.
438 It happens for instance while waiting for the inferior
439 to stop after attaching to it. */
441 perror_with_name ("waitpid (WNOHANG)");
445 /* No event with WNOHANG. See if there is one with WUNTRACED. */
446 ret
= waitpid (pid
, stat_loc
, WNOHANG
| WUNTRACED
);
449 /* An ECHILD error is not indicative of a real problem.
450 It happens for instance while waiting for the inferior
451 to stop after attaching to it. */
453 perror_with_name ("waitpid (WNOHANG|WUNTRACED)");
462 /* Implement the wait target_ops method. */
465 lynx_wait_1 (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
472 if (ptid_equal (ptid
, minus_one_ptid
))
473 pid
= lynx_ptid_get_pid (thread_to_gdb_id (current_inferior
));
475 pid
= BUILDPID (lynx_ptid_get_pid (ptid
), lynx_ptid_get_tid (ptid
));
479 ret
= lynx_waitpid (pid
, &wstat
);
480 new_ptid
= lynx_ptid_build (ret
, ((union wait
*) &wstat
)->w_tid
);
482 /* If this is a new thread, then add it now. The reason why we do
483 this here instead of when handling new-thread events is because
484 we need to add the thread associated to the "main" thread - even
485 for non-threaded applications where the new-thread events are not
487 if (!find_thread_ptid (new_ptid
))
488 add_thread (new_ptid
, NULL
);
490 if (WIFSTOPPED (wstat
))
492 status
->kind
= TARGET_WAITKIND_STOPPED
;
493 status
->value
.integer
= target_signal_from_host (WSTOPSIG (wstat
));
494 lynx_debug ("process stopped with signal: %d",
495 status
->value
.integer
);
497 else if (WIFEXITED (wstat
))
499 status
->kind
= TARGET_WAITKIND_EXITED
;
500 status
->value
.integer
= WEXITSTATUS (wstat
);
501 lynx_debug ("process exited with code: %d", status
->value
.integer
);
503 else if (WIFSIGNALED (wstat
))
505 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
506 status
->value
.integer
= target_signal_from_host (WTERMSIG (wstat
));
507 lynx_debug ("process terminated with code: %d",
508 status
->value
.integer
);
512 /* Not sure what happened if we get here, or whether we can
513 in fact get here. But if we do, handle the event the best
515 status
->kind
= TARGET_WAITKIND_STOPPED
;
516 status
->value
.integer
= target_signal_from_host (0);
517 lynx_debug ("unknown event ????");
520 /* SIGTRAP events are generated for situations other than single-step/
521 breakpoint events (Eg. new-thread events). Handle those other types
522 of events, and resume the execution if necessary. */
523 if (status
->kind
== TARGET_WAITKIND_STOPPED
524 && status
->value
.integer
== TARGET_SIGNAL_TRAP
)
526 const int realsig
= lynx_ptrace (PTRACE_GETTRACESIG
, new_ptid
, 0, 0, 0);
528 lynx_debug ("(realsig = %d)", realsig
);
532 /* We just added the new thread above. No need to do anything
533 further. Just resume the execution again. */
534 lynx_continue (ptid
);
538 remove_thread (find_thread_ptid (new_ptid
));
539 lynx_continue (ptid
);
547 /* A wrapper around lynx_wait_1 that also prints debug traces when
548 such debug traces have been activated. */
551 lynx_wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
555 lynx_debug ("lynx_wait (pid = %d, tid = %ld)",
556 lynx_ptid_get_pid (ptid
), lynx_ptid_get_tid (ptid
));
557 new_ptid
= lynx_wait_1 (ptid
, status
, options
);
558 lynx_debug (" -> (pid=%d, tid=%ld, status->kind = %d)",
559 lynx_ptid_get_pid (new_ptid
), lynx_ptid_get_tid (new_ptid
),
564 /* Implement the kill target_ops method. */
569 ptid_t ptid
= lynx_ptid_build (pid
, 0);
570 struct target_waitstatus status
;
571 struct process_info
*process
;
573 process
= find_process_pid (pid
);
577 lynx_ptrace (PTRACE_KILL
, ptid
, 0, 0, 0);
578 lynx_wait (ptid
, &status
, 0);
579 the_target
->mourn (process
);
583 /* Implement the detach target_ops method. */
586 lynx_detach (int pid
)
588 ptid_t ptid
= lynx_ptid_build (pid
, 0);
589 struct process_info
*process
;
591 process
= find_process_pid (pid
);
595 lynx_ptrace (PTRACE_DETACH
, ptid
, 0, 0, 0);
596 the_target
->mourn (process
);
600 /* Implement the mourn target_ops method. */
603 lynx_mourn (struct process_info
*proc
)
605 lynx_clear_inferiors ();
608 /* Implement the join target_ops method. */
613 /* The PTRACE_DETACH is sufficient to detach from the process.
614 So no need to do anything extra. */
617 /* Implement the thread_alive target_ops method. */
620 lynx_thread_alive (ptid_t ptid
)
622 /* The list of threads is updated at the end of each wait, so it
623 should be up to date. No need to re-fetch it. */
624 return (find_thread_ptid (ptid
) != NULL
);
627 /* Implement the fetch_registers target_ops method. */
630 lynx_fetch_registers (struct regcache
*regcache
, int regno
)
632 struct lynx_regset_info
*regset
= lynx_target_regsets
;
633 ptid_t inferior_ptid
= thread_to_gdb_id (current_inferior
);
635 lynx_debug ("lynx_fetch_registers (regno = %d)", regno
);
637 while (regset
->size
>= 0)
642 buf
= xmalloc (regset
->size
);
643 res
= lynx_ptrace (regset
->get_request
, inferior_ptid
, (int) buf
, 0, 0);
646 regset
->store_function (regcache
, buf
);
652 /* Implement the store_registers target_ops method. */
655 lynx_store_registers (struct regcache
*regcache
, int regno
)
657 struct lynx_regset_info
*regset
= lynx_target_regsets
;
658 ptid_t inferior_ptid
= thread_to_gdb_id (current_inferior
);
660 lynx_debug ("lynx_store_registers (regno = %d)", regno
);
662 while (regset
->size
>= 0)
667 buf
= xmalloc (regset
->size
);
668 res
= lynx_ptrace (regset
->get_request
, inferior_ptid
, (int) buf
, 0, 0);
671 /* Then overlay our cached registers on that. */
672 regset
->fill_function (regcache
, buf
);
673 /* Only now do we write the register set. */
674 res
= lynx_ptrace (regset
->set_request
, inferior_ptid
, (int) buf
,
684 /* Implement the read_memory target_ops method. */
687 lynx_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
689 /* On LynxOS, memory reads needs to be performed in chunks the size
690 of int types, and they should also be aligned accordingly. */
692 const int xfer_size
= sizeof (buf
);
693 CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) xfer_size
;
694 ptid_t inferior_ptid
= thread_to_gdb_id (current_inferior
);
696 while (addr
< memaddr
+ len
)
703 skip
= memaddr
- addr
;
704 if (addr
+ xfer_size
> memaddr
+ len
)
705 truncate
= addr
+ xfer_size
- memaddr
- len
;
706 buf
= lynx_ptrace (PTRACE_PEEKTEXT
, inferior_ptid
, addr
, 0, 0);
709 memcpy (myaddr
+ (addr
- memaddr
) + skip
, (gdb_byte
*) &buf
+ skip
,
710 xfer_size
- skip
- truncate
);
717 /* Implement the write_memory target_ops method. */
720 lynx_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
722 /* On LynxOS, memory writes needs to be performed in chunks the size
723 of int types, and they should also be aligned accordingly. */
725 const int xfer_size
= sizeof (buf
);
726 CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) xfer_size
;
727 ptid_t inferior_ptid
= thread_to_gdb_id (current_inferior
);
729 while (addr
< memaddr
+ len
)
735 skip
= memaddr
- addr
;
736 if (addr
+ xfer_size
> memaddr
+ len
)
737 truncate
= addr
+ xfer_size
- memaddr
- len
;
738 if (skip
> 0 || truncate
> 0)
739 /* We need to read the memory at this address in order to preserve
740 the data that we are not overwriting. */
741 lynx_read_memory (addr
, (unsigned char *) &buf
, xfer_size
);
744 memcpy ((gdb_byte
*) &buf
+ skip
, myaddr
+ (addr
- memaddr
) + skip
,
745 xfer_size
- skip
- truncate
);
747 lynx_ptrace (PTRACE_POKETEXT
, inferior_ptid
, addr
, buf
, 0);
756 /* Implement the kill_request target_ops method. */
759 lynx_request_interrupt (void)
761 ptid_t inferior_ptid
= thread_to_gdb_id (current_inferior
);
763 kill (lynx_ptid_get_pid (inferior_ptid
), SIGINT
);
766 /* The LynxOS target_ops vector. */
768 static struct target_ops lynx_target_ops
= {
769 lynx_create_inferior
,
778 lynx_fetch_registers
,
779 lynx_store_registers
,
780 NULL
, /* prepare_to_access_memory */
781 NULL
, /* done_accessing_memory */
784 NULL
, /* look_up_symbols */
785 lynx_request_interrupt
,
786 NULL
, /* read_auxv */
787 NULL
, /* insert_point */
788 NULL
, /* remove_point */
789 NULL
, /* stopped_by_watchpoint */
790 NULL
, /* stopped_data_address */
791 NULL
, /* read_offsets */
792 NULL
, /* get_tls_address */
793 NULL
, /* qxfer_spu */
794 NULL
, /* hostio_last_error */
795 NULL
, /* qxfer_osdata */
796 NULL
, /* qxfer_siginfo */
797 NULL
, /* supports_non_stop */
799 NULL
, /* start_non_stop */
800 NULL
, /* supports_multi_process */
801 NULL
, /* handle_monitor_command */
805 initialize_low (void)
807 set_target_ops (&lynx_target_ops
);
808 the_low_target
.arch_setup ();