/* Copyright (C) 2009-2015 Free Software Foundation, Inc. This file is part of GDB. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include "server.h" #include "target.h" #include "lynx-low.h" #include #include #include /* Provides PIDGET, TIDGET, BUILDPID, etc. */ #include #include #include #include "gdb_wait.h" #include #include "filestuff.h" int using_threads = 1; const struct target_desc *lynx_tdesc; /* Per-process private data. */ struct process_info_private { /* The PTID obtained from the last wait performed on this process. Initialized to null_ptid until the first wait is performed. */ ptid_t last_wait_event_ptid; }; /* Print a debug trace on standard output if debug_threads is set. */ static void lynx_debug (char *string, ...) { va_list args; if (!debug_threads) return; va_start (args, string); fprintf (stderr, "DEBUG(lynx): "); vfprintf (stderr, string, args); fprintf (stderr, "\n"); va_end (args); } /* Build a ptid_t given a PID and a LynxOS TID. */ static ptid_t lynx_ptid_build (int pid, long tid) { /* brobecker/2010-06-21: It looks like the LWP field in ptids should be distinct for each thread (see write_ptid where it writes the thread ID from the LWP). So instead of storing the LynxOS tid in the tid field of the ptid, we store it in the lwp field. */ return ptid_build (pid, tid, 0); } /* Return the process ID of the given PTID. This function has little reason to exist, it's just a wrapper around ptid_get_pid. But since we have a getter function for the lynxos ptid, it feels cleaner to have a getter for the pid as well. */ static int lynx_ptid_get_pid (ptid_t ptid) { return ptid_get_pid (ptid); } /* Return the LynxOS tid of the given PTID. */ static long lynx_ptid_get_tid (ptid_t ptid) { /* See lynx_ptid_build: The LynxOS tid is stored inside the lwp field of the ptid. */ return ptid_get_lwp (ptid); } /* For a given PTID, return the associated PID as known by the LynxOS ptrace layer. */ static int lynx_ptrace_pid_from_ptid (ptid_t ptid) { return BUILDPID (lynx_ptid_get_pid (ptid), lynx_ptid_get_tid (ptid)); } /* Return a string image of the ptrace REQUEST number. */ static char * ptrace_request_to_str (int request) { #define CASE(X) case X: return #X switch (request) { CASE(PTRACE_TRACEME); CASE(PTRACE_PEEKTEXT); CASE(PTRACE_PEEKDATA); CASE(PTRACE_PEEKUSER); CASE(PTRACE_POKETEXT); CASE(PTRACE_POKEDATA); CASE(PTRACE_POKEUSER); CASE(PTRACE_CONT); CASE(PTRACE_KILL); CASE(PTRACE_SINGLESTEP); CASE(PTRACE_ATTACH); CASE(PTRACE_DETACH); CASE(PTRACE_GETREGS); CASE(PTRACE_SETREGS); CASE(PTRACE_GETFPREGS); CASE(PTRACE_SETFPREGS); CASE(PTRACE_READDATA); CASE(PTRACE_WRITEDATA); CASE(PTRACE_READTEXT); CASE(PTRACE_WRITETEXT); CASE(PTRACE_GETFPAREGS); CASE(PTRACE_SETFPAREGS); CASE(PTRACE_GETWINDOW); CASE(PTRACE_SETWINDOW); CASE(PTRACE_SYSCALL); CASE(PTRACE_DUMPCORE); CASE(PTRACE_SETWRBKPT); CASE(PTRACE_SETACBKPT); CASE(PTRACE_CLRBKPT); CASE(PTRACE_GET_UCODE); #ifdef PT_READ_GPR CASE(PT_READ_GPR); #endif #ifdef PT_WRITE_GPR CASE(PT_WRITE_GPR); #endif #ifdef PT_READ_FPR CASE(PT_READ_FPR); #endif #ifdef PT_WRITE_FPR CASE(PT_WRITE_FPR); #endif #ifdef PT_READ_VPR CASE(PT_READ_VPR); #endif #ifdef PT_WRITE_VPR CASE(PT_WRITE_VPR); #endif #ifdef PTRACE_PEEKUSP CASE(PTRACE_PEEKUSP); #endif #ifdef PTRACE_POKEUSP CASE(PTRACE_POKEUSP); #endif CASE(PTRACE_PEEKTHREAD); CASE(PTRACE_THREADUSER); CASE(PTRACE_FPREAD); CASE(PTRACE_FPWRITE); CASE(PTRACE_SETSIG); CASE(PTRACE_CONT_ONE); CASE(PTRACE_KILL_ONE); CASE(PTRACE_SINGLESTEP_ONE); CASE(PTRACE_GETLOADINFO); CASE(PTRACE_GETTRACESIG); #ifdef PTRACE_GETTHREADLIST CASE(PTRACE_GETTHREADLIST); #endif } #undef CASE return ""; } /* A wrapper around ptrace that allows us to print debug traces of ptrace calls if debug traces are activated. */ static int lynx_ptrace (int request, ptid_t ptid, int addr, int data, int addr2) { int result; const int pid = lynx_ptrace_pid_from_ptid (ptid); int saved_errno; if (debug_threads) fprintf (stderr, "PTRACE (%s, pid=%d(pid=%d, tid=%d), addr=0x%x, " "data=0x%x, addr2=0x%x)", ptrace_request_to_str (request), pid, PIDGET (pid), TIDGET (pid), addr, data, addr2); result = ptrace (request, pid, addr, data, addr2); saved_errno = errno; if (debug_threads) fprintf (stderr, " -> %d (=0x%x)\n", result, result); errno = saved_errno; return result; } /* Call add_process with the given parameters, and initializes the process' private data. */ static struct process_info * lynx_add_process (int pid, int attached) { struct process_info *proc; proc = add_process (pid, attached); proc->tdesc = lynx_tdesc; proc->priv = xcalloc (1, sizeof (*proc->priv)); proc->priv->last_wait_event_ptid = null_ptid; return proc; } /* Implement the create_inferior method of the target_ops vector. */ static int lynx_create_inferior (char *program, char **allargs) { int pid; lynx_debug ("lynx_create_inferior ()"); pid = fork (); if (pid < 0) perror_with_name ("fork"); if (pid == 0) { int pgrp; close_most_fds (); /* Switch child to its own process group so that signals won't directly affect gdbserver. */ pgrp = getpid(); setpgid (0, pgrp); ioctl (0, TIOCSPGRP, &pgrp); lynx_ptrace (PTRACE_TRACEME, null_ptid, 0, 0, 0); execv (program, allargs); fprintf (stderr, "Cannot exec %s: %s.\n", program, strerror (errno)); fflush (stderr); _exit (0177); } lynx_add_process (pid, 0); /* Do not add the process thread just yet, as we do not know its tid. We will add it later, during the wait for the STOP event corresponding to the lynx_ptrace (PTRACE_TRACEME) call above. */ return pid; } /* Assuming we've just attached to a running inferior whose pid is PID, add all threads running in that process. */ static void lynx_add_threads_after_attach (int pid) { /* Ugh! There appears to be no way to get the list of threads in the program we just attached to. So get the list by calling the "ps" command. This is only needed now, as we will then keep the thread list up to date thanks to thread creation and exit notifications. */ FILE *f; char buf[256]; int thread_pid, thread_tid; f = popen ("ps atx", "r"); if (f == NULL) perror_with_name ("Cannot get thread list"); while (fgets (buf, sizeof (buf), f) != NULL) if ((sscanf (buf, "%d %d", &thread_pid, &thread_tid) == 2 && thread_pid == pid)) { ptid_t thread_ptid = lynx_ptid_build (pid, thread_tid); if (!find_thread_ptid (thread_ptid)) { lynx_debug ("New thread: (pid = %d, tid = %d)", pid, thread_tid); add_thread (thread_ptid, NULL); } } pclose (f); } /* Implement the attach target_ops method. */ static int lynx_attach (unsigned long pid) { ptid_t ptid = lynx_ptid_build (pid, 0); if (lynx_ptrace (PTRACE_ATTACH, ptid, 0, 0, 0) != 0) error ("Cannot attach to process %lu: %s (%d)\n", pid, strerror (errno), errno); lynx_add_process (pid, 1); lynx_add_threads_after_attach (pid); return 0; } /* Implement the resume target_ops method. */ static void lynx_resume (struct thread_resume *resume_info, size_t n) { ptid_t ptid = resume_info[0].thread; const int request = (resume_info[0].kind == resume_step ? (n == 1 ? PTRACE_SINGLESTEP_ONE : PTRACE_SINGLESTEP) : PTRACE_CONT); const int signal = resume_info[0].sig; /* If given a minus_one_ptid, then try using the current_process' private->last_wait_event_ptid. On most LynxOS versions, using any of the process' thread works well enough, but LynxOS 178 is a little more sensitive, and triggers some unexpected signals (Eg SIG61) when we resume the inferior using a different thread. */ if (ptid_equal (ptid, minus_one_ptid)) ptid = current_process()->priv->last_wait_event_ptid; /* The ptid might still be minus_one_ptid; this can happen between the moment we create the inferior or attach to a process, and the moment we resume its execution for the first time. It is fine to use the current_thread's ptid in those cases. */ if (ptid_equal (ptid, minus_one_ptid)) ptid = thread_to_gdb_id (current_thread); regcache_invalidate (); errno = 0; lynx_ptrace (request, ptid, 1, signal, 0); if (errno) perror_with_name ("ptrace"); } /* Resume the execution of the given PTID. */ static void lynx_continue (ptid_t ptid) { struct thread_resume resume_info; resume_info.thread = ptid; resume_info.kind = resume_continue; resume_info.sig = 0; lynx_resume (&resume_info, 1); } /* A wrapper around waitpid that handles the various idiosyncrasies of LynxOS' waitpid. */ static int lynx_waitpid (int pid, int *stat_loc) { int ret = 0; while (1) { ret = waitpid (pid, stat_loc, WNOHANG); if (ret < 0) { /* An ECHILD error is not indicative of a real problem. It happens for instance while waiting for the inferior to stop after attaching to it. */ if (errno != ECHILD) perror_with_name ("waitpid (WNOHANG)"); } if (ret > 0) break; /* No event with WNOHANG. See if there is one with WUNTRACED. */ ret = waitpid (pid, stat_loc, WNOHANG | WUNTRACED); if (ret < 0) { /* An ECHILD error is not indicative of a real problem. It happens for instance while waiting for the inferior to stop after attaching to it. */ if (errno != ECHILD) perror_with_name ("waitpid (WNOHANG|WUNTRACED)"); } if (ret > 0) break; usleep (1000); } return ret; } /* Implement the wait target_ops method. */ static ptid_t lynx_wait_1 (ptid_t ptid, struct target_waitstatus *status, int options) { int pid; int ret; int wstat; ptid_t new_ptid; if (ptid_equal (ptid, minus_one_ptid)) pid = lynx_ptid_get_pid (thread_to_gdb_id (current_thread)); else pid = BUILDPID (lynx_ptid_get_pid (ptid), lynx_ptid_get_tid (ptid)); retry: ret = lynx_waitpid (pid, &wstat); new_ptid = lynx_ptid_build (ret, ((union wait *) &wstat)->w_tid); find_process_pid (ret)->priv->last_wait_event_ptid = new_ptid; /* If this is a new thread, then add it now. The reason why we do this here instead of when handling new-thread events is because we need to add the thread associated to the "main" thread - even for non-threaded applications where the new-thread events are not generated. */ if (!find_thread_ptid (new_ptid)) { lynx_debug ("New thread: (pid = %d, tid = %d)", lynx_ptid_get_pid (new_ptid), lynx_ptid_get_tid (new_ptid)); add_thread (new_ptid, NULL); } if (WIFSTOPPED (wstat)) { status->kind = TARGET_WAITKIND_STOPPED; status->value.integer = gdb_signal_from_host (WSTOPSIG (wstat)); lynx_debug ("process stopped with signal: %d", status->value.integer); } else if (WIFEXITED (wstat)) { status->kind = TARGET_WAITKIND_EXITED; status->value.integer = WEXITSTATUS (wstat); lynx_debug ("process exited with code: %d", status->value.integer); } else if (WIFSIGNALED (wstat)) { status->kind = TARGET_WAITKIND_SIGNALLED; status->value.integer = gdb_signal_from_host (WTERMSIG (wstat)); lynx_debug ("process terminated with code: %d", status->value.integer); } else { /* Not sure what happened if we get here, or whether we can in fact get here. But if we do, handle the event the best we can. */ status->kind = TARGET_WAITKIND_STOPPED; status->value.integer = gdb_signal_from_host (0); lynx_debug ("unknown event ????"); } /* SIGTRAP events are generated for situations other than single-step/ breakpoint events (Eg. new-thread events). Handle those other types of events, and resume the execution if necessary. */ if (status->kind == TARGET_WAITKIND_STOPPED && status->value.integer == GDB_SIGNAL_TRAP) { const int realsig = lynx_ptrace (PTRACE_GETTRACESIG, new_ptid, 0, 0, 0); lynx_debug ("(realsig = %d)", realsig); switch (realsig) { case SIGNEWTHREAD: /* We just added the new thread above. No need to do anything further. Just resume the execution again. */ lynx_continue (new_ptid); goto retry; case SIGTHREADEXIT: remove_thread (find_thread_ptid (new_ptid)); lynx_continue (new_ptid); goto retry; } } return new_ptid; } /* A wrapper around lynx_wait_1 that also prints debug traces when such debug traces have been activated. */ static ptid_t lynx_wait (ptid_t ptid, struct target_waitstatus *status, int options) { ptid_t new_ptid; lynx_debug ("lynx_wait (pid = %d, tid = %ld)", lynx_ptid_get_pid (ptid), lynx_ptid_get_tid (ptid)); new_ptid = lynx_wait_1 (ptid, status, options); lynx_debug (" -> (pid=%d, tid=%ld, status->kind = %d)", lynx_ptid_get_pid (new_ptid), lynx_ptid_get_tid (new_ptid), status->kind); return new_ptid; } /* Implement the kill target_ops method. */ static int lynx_kill (int pid) { ptid_t ptid = lynx_ptid_build (pid, 0); struct target_waitstatus status; struct process_info *process; process = find_process_pid (pid); if (process == NULL) return -1; lynx_ptrace (PTRACE_KILL, ptid, 0, 0, 0); lynx_wait (ptid, &status, 0); the_target->mourn (process); return 0; } /* Implement the detach target_ops method. */ static int lynx_detach (int pid) { ptid_t ptid = lynx_ptid_build (pid, 0); struct process_info *process; process = find_process_pid (pid); if (process == NULL) return -1; lynx_ptrace (PTRACE_DETACH, ptid, 0, 0, 0); the_target->mourn (process); return 0; } /* Implement the mourn target_ops method. */ static void lynx_mourn (struct process_info *proc) { /* Free our private data. */ free (proc->priv); proc->priv = NULL; clear_inferiors (); } /* Implement the join target_ops method. */ static void lynx_join (int pid) { /* The PTRACE_DETACH is sufficient to detach from the process. So no need to do anything extra. */ } /* Implement the thread_alive target_ops method. */ static int lynx_thread_alive (ptid_t ptid) { /* The list of threads is updated at the end of each wait, so it should be up to date. No need to re-fetch it. */ return (find_thread_ptid (ptid) != NULL); } /* Implement the fetch_registers target_ops method. */ static void lynx_fetch_registers (struct regcache *regcache, int regno) { struct lynx_regset_info *regset = lynx_target_regsets; ptid_t inferior_ptid = thread_to_gdb_id (current_thread); lynx_debug ("lynx_fetch_registers (regno = %d)", regno); while (regset->size >= 0) { char *buf; int res; buf = xmalloc (regset->size); res = lynx_ptrace (regset->get_request, inferior_ptid, (int) buf, 0, 0); if (res < 0) perror ("ptrace"); regset->store_function (regcache, buf); free (buf); regset++; } } /* Implement the store_registers target_ops method. */ static void lynx_store_registers (struct regcache *regcache, int regno) { struct lynx_regset_info *regset = lynx_target_regsets; ptid_t inferior_ptid = thread_to_gdb_id (current_thread); lynx_debug ("lynx_store_registers (regno = %d)", regno); while (regset->size >= 0) { char *buf; int res; buf = xmalloc (regset->size); res = lynx_ptrace (regset->get_request, inferior_ptid, (int) buf, 0, 0); if (res == 0) { /* Then overlay our cached registers on that. */ regset->fill_function (regcache, buf); /* Only now do we write the register set. */ res = lynx_ptrace (regset->set_request, inferior_ptid, (int) buf, 0, 0); } if (res < 0) perror ("ptrace"); free (buf); regset++; } } /* Implement the read_memory target_ops method. */ static int lynx_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len) { /* On LynxOS, memory reads needs to be performed in chunks the size of int types, and they should also be aligned accordingly. */ int buf; const int xfer_size = sizeof (buf); CORE_ADDR addr = memaddr & -(CORE_ADDR) xfer_size; ptid_t inferior_ptid = thread_to_gdb_id (current_thread); while (addr < memaddr + len) { int skip = 0; int truncate = 0; errno = 0; if (addr < memaddr) skip = memaddr - addr; if (addr + xfer_size > memaddr + len) truncate = addr + xfer_size - memaddr - len; buf = lynx_ptrace (PTRACE_PEEKTEXT, inferior_ptid, addr, 0, 0); if (errno) return errno; memcpy (myaddr + (addr - memaddr) + skip, (gdb_byte *) &buf + skip, xfer_size - skip - truncate); addr += xfer_size; } return 0; } /* Implement the write_memory target_ops method. */ static int lynx_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len) { /* On LynxOS, memory writes needs to be performed in chunks the size of int types, and they should also be aligned accordingly. */ int buf; const int xfer_size = sizeof (buf); CORE_ADDR addr = memaddr & -(CORE_ADDR) xfer_size; ptid_t inferior_ptid = thread_to_gdb_id (current_thread); while (addr < memaddr + len) { int skip = 0; int truncate = 0; if (addr < memaddr) skip = memaddr - addr; if (addr + xfer_size > memaddr + len) truncate = addr + xfer_size - memaddr - len; if (skip > 0 || truncate > 0) { /* We need to read the memory at this address in order to preserve the data that we are not overwriting. */ lynx_read_memory (addr, (unsigned char *) &buf, xfer_size); if (errno) return errno; } memcpy ((gdb_byte *) &buf + skip, myaddr + (addr - memaddr) + skip, xfer_size - skip - truncate); errno = 0; lynx_ptrace (PTRACE_POKETEXT, inferior_ptid, addr, buf, 0); if (errno) return errno; addr += xfer_size; } return 0; } /* Implement the kill_request target_ops method. */ static void lynx_request_interrupt (void) { ptid_t inferior_ptid = thread_to_gdb_id (current_thread); kill (lynx_ptid_get_pid (inferior_ptid), SIGINT); } /* The LynxOS target_ops vector. */ static struct target_ops lynx_target_ops = { lynx_create_inferior, NULL, /* arch_setup */ lynx_attach, lynx_kill, lynx_detach, lynx_mourn, lynx_join, lynx_thread_alive, lynx_resume, lynx_wait, lynx_fetch_registers, lynx_store_registers, NULL, /* prepare_to_access_memory */ NULL, /* done_accessing_memory */ lynx_read_memory, lynx_write_memory, NULL, /* look_up_symbols */ lynx_request_interrupt, NULL, /* read_auxv */ NULL, /* supports_z_point_type */ NULL, /* insert_point */ NULL, /* remove_point */ NULL, /* stopped_by_sw_breakpoint */ NULL, /* supports_stopped_by_sw_breakpoint */ NULL, /* stopped_by_hw_breakpoint */ NULL, /* supports_stopped_by_hw_breakpoint */ /* Although lynx has hardware single step, still disable this feature for lynx, because it is implemented in linux-low.c instead of in generic code. */ NULL, /* supports_conditional_breakpoints */ NULL, /* stopped_by_watchpoint */ NULL, /* stopped_data_address */ NULL, /* read_offsets */ NULL, /* get_tls_address */ NULL, /* qxfer_spu */ NULL, /* hostio_last_error */ NULL, /* qxfer_osdata */ NULL, /* qxfer_siginfo */ NULL, /* supports_non_stop */ NULL, /* async */ NULL, /* start_non_stop */ NULL, /* supports_multi_process */ NULL, /* supports_fork_events */ NULL, /* supports_vfork_events */ NULL, /* handle_new_gdb_connection */ NULL, /* handle_monitor_command */ }; void initialize_low (void) { set_target_ops (&lynx_target_ops); the_low_target.arch_setup (); }