1/* <proc_service.h> implementation. 2 3 Copyright (C) 1999, 2000, 2002, 2007 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20#include "defs.h" 21 22#include "gdbcore.h" 23#include "inferior.h" 24#include "symtab.h" 25#include "target.h" 26#include "regcache.h" 27 28#include "gdb_proc_service.h" 29#include "gdb_stdint.h" 30 31#include <sys/procfs.h> 32 33/* Prototypes for supply_gregset etc. */ 34#include "gregset.h" 35 36 37/* Fix-up some broken systems. */ 38 39/* The prototypes in <proc_service.h> are slightly different on older 40 systems. Compensate for the discrepancies. */ 41 42#ifdef PROC_SERVICE_IS_OLD 43typedef const struct ps_prochandle *gdb_ps_prochandle_t; 44typedef char *gdb_ps_read_buf_t; 45typedef char *gdb_ps_write_buf_t; 46typedef int gdb_ps_size_t; 47#else 48typedef struct ps_prochandle *gdb_ps_prochandle_t; 49typedef void *gdb_ps_read_buf_t; 50typedef const void *gdb_ps_write_buf_t; 51typedef size_t gdb_ps_size_t; 52#endif 53 54 55/* Building process ids. */ 56 57#define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0) 58 59 60/* Helper functions. */ 61 62/* Convert a psaddr_t to a CORE_ADDR. */ 63 64static CORE_ADDR 65ps_addr_to_core_addr (psaddr_t addr) 66{ 67 if (exec_bfd && bfd_get_sign_extend_vma (exec_bfd)) 68 return (intptr_t) addr; 69 else 70 return (uintptr_t) addr; 71} 72 73/* Convert a CORE_ADDR to a psaddr_t. */ 74 75static psaddr_t 76core_addr_to_ps_addr (CORE_ADDR addr) 77{ 78 if (exec_bfd && bfd_get_sign_extend_vma (exec_bfd)) 79 return (psaddr_t) (intptr_t) addr; 80 else 81 return (psaddr_t) (uintptr_t) addr; 82} 83 84/* Transfer LEN bytes of memory between BUF and address ADDR in the 85 process specified by PH. If WRITE, transfer them to the process, 86 else transfer them from the process. Returns PS_OK for success, 87 PS_ERR on failure. 88 89 This is a helper function for ps_pdread, ps_pdwrite, ps_ptread and 90 ps_ptwrite. */ 91 92static ps_err_e 93ps_xfer_memory (const struct ps_prochandle *ph, psaddr_t addr, 94 gdb_byte *buf, size_t len, int write) 95{ 96 struct cleanup *old_chain = save_inferior_ptid (); 97 int ret; 98 CORE_ADDR core_addr = ps_addr_to_core_addr (addr); 99 100 inferior_ptid = pid_to_ptid (ph->pid); 101 102 if (write) 103 ret = target_write_memory (core_addr, buf, len); 104 else 105 ret = target_read_memory (core_addr, buf, len); 106 107 do_cleanups (old_chain); 108 109 return (ret == 0 ? PS_OK : PS_ERR); 110} 111 112 113/* Stop the target process PH. */ 114 115ps_err_e 116ps_pstop (gdb_ps_prochandle_t ph) 117{ 118 /* The process is always stopped when under control of GDB. */ 119 return PS_OK; 120} 121 122/* Resume the target process PH. */ 123 124ps_err_e 125ps_pcontinue (gdb_ps_prochandle_t ph) 126{ 127 /* Pretend we did successfully continue the process. GDB will take 128 care of it later on. */ 129 return PS_OK; 130} 131 132/* Stop the lightweight process LWPID within the target process PH. */ 133 134ps_err_e 135ps_lstop (gdb_ps_prochandle_t ph, lwpid_t lwpid) 136{ 137 /* All lightweight processes are stopped when under control of GDB. */ 138 return PS_OK; 139} 140 141/* Resume the lightweight process (LWP) LWPID within the target 142 process PH. */ 143 144ps_err_e 145ps_lcontinue (gdb_ps_prochandle_t ph, lwpid_t lwpid) 146{ 147 /* Pretend we did successfully continue LWPID. GDB will take care 148 of it later on. */ 149 return PS_OK; 150} 151 152/* Get the size of the architecture-dependent extra state registers 153 for LWP LWPID within the target process PH and return it in 154 *XREGSIZE. */ 155 156ps_err_e 157ps_lgetxregsize (gdb_ps_prochandle_t ph, lwpid_t lwpid, int *xregsize) 158{ 159 /* FIXME: Not supported yet. */ 160 return PS_OK; 161} 162 163/* Get the extra state registers of LWP LWPID within the target 164 process PH and store them in XREGSET. */ 165 166ps_err_e 167ps_lgetxregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, caddr_t xregset) 168{ 169 /* FIXME: Not supported yet. */ 170 return PS_OK; 171} 172 173/* Set the extra state registers of LWP LWPID within the target 174 process PH from XREGSET. */ 175 176ps_err_e 177ps_lsetxregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, caddr_t xregset) 178{ 179 /* FIXME: Not supported yet. */ 180 return PS_OK; 181} 182 183/* Log (additional) diognostic information. */ 184 185void 186ps_plog (const char *fmt, ...) 187{ 188 va_list args; 189 190 va_start (args, fmt); 191 vfprintf_filtered (gdb_stderr, fmt, args); 192} 193 194/* Search for the symbol named NAME within the object named OBJ within 195 the target process PH. If the symbol is found the address of the 196 symbol is stored in SYM_ADDR. */ 197 198ps_err_e 199ps_pglobal_lookup (gdb_ps_prochandle_t ph, const char *obj, 200 const char *name, psaddr_t *sym_addr) 201{ 202 struct minimal_symbol *ms; 203 204 /* FIXME: kettenis/2000-09-03: What should we do with OBJ? */ 205 ms = lookup_minimal_symbol (name, NULL, NULL); 206 if (ms == NULL) 207 return PS_NOSYM; 208 209 *sym_addr = core_addr_to_ps_addr (SYMBOL_VALUE_ADDRESS (ms)); 210 return PS_OK; 211} 212 213/* Read SIZE bytes from the target process PH at address ADDR and copy 214 them into BUF. */ 215 216ps_err_e 217ps_pdread (gdb_ps_prochandle_t ph, psaddr_t addr, 218 gdb_ps_read_buf_t buf, gdb_ps_size_t size) 219{ 220 return ps_xfer_memory (ph, addr, buf, size, 0); 221} 222 223/* Write SIZE bytes from BUF into the target process PH at address ADDR. */ 224 225ps_err_e 226ps_pdwrite (gdb_ps_prochandle_t ph, psaddr_t addr, 227 gdb_ps_write_buf_t buf, gdb_ps_size_t size) 228{ 229 return ps_xfer_memory (ph, addr, (gdb_byte *) buf, size, 1); 230} 231 232/* Read SIZE bytes from the target process PH at address ADDR and copy 233 them into BUF. */ 234 235ps_err_e 236ps_ptread (gdb_ps_prochandle_t ph, psaddr_t addr, 237 gdb_ps_read_buf_t buf, gdb_ps_size_t size) 238{ 239 return ps_xfer_memory (ph, addr, (gdb_byte *) buf, size, 0); 240} 241 242/* Write SIZE bytes from BUF into the target process PH at address ADDR. */ 243 244ps_err_e 245ps_ptwrite (gdb_ps_prochandle_t ph, psaddr_t addr, 246 gdb_ps_write_buf_t buf, gdb_ps_size_t size) 247{ 248 return ps_xfer_memory (ph, addr, (gdb_byte *) buf, size, 1); 249} 250 251/* Get the general registers of LWP LWPID within the target process PH 252 and store them in GREGSET. */ 253 254ps_err_e 255ps_lgetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, prgregset_t gregset) 256{ 257 struct cleanup *old_chain = save_inferior_ptid (); 258 struct regcache *regcache; 259 260 inferior_ptid = BUILD_LWP (lwpid, ph->pid); 261 regcache = get_thread_regcache (inferior_ptid); 262 263 target_fetch_registers (regcache, -1); 264 fill_gregset (regcache, (gdb_gregset_t *) gregset, -1); 265 266 do_cleanups (old_chain); 267 return PS_OK; 268} 269 270/* Set the general registers of LWP LWPID within the target process PH 271 from GREGSET. */ 272 273ps_err_e 274ps_lsetregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, const prgregset_t gregset) 275{ 276 struct cleanup *old_chain = save_inferior_ptid (); 277 struct regcache *regcache; 278 279 inferior_ptid = BUILD_LWP (lwpid, ph->pid); 280 regcache = get_thread_regcache (inferior_ptid); 281 282 supply_gregset (regcache, (const gdb_gregset_t *) gregset); 283 target_store_registers (regcache, -1); 284 285 do_cleanups (old_chain); 286 return PS_OK; 287} 288 289/* Get the floating-point registers of LWP LWPID within the target 290 process PH and store them in FPREGSET. */ 291 292ps_err_e 293ps_lgetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, 294 gdb_prfpregset_t *fpregset) 295{ 296 struct cleanup *old_chain = save_inferior_ptid (); 297 struct regcache *regcache; 298 299 inferior_ptid = BUILD_LWP (lwpid, ph->pid); 300 regcache = get_thread_regcache (inferior_ptid); 301 302 target_fetch_registers (regcache, -1); 303 fill_fpregset (regcache, (gdb_fpregset_t *) fpregset, -1); 304 305 do_cleanups (old_chain); 306 return PS_OK; 307} 308 309/* Set the floating-point registers of LWP LWPID within the target 310 process PH from FPREGSET. */ 311 312ps_err_e 313ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, 314 const gdb_prfpregset_t *fpregset) 315{ 316 struct cleanup *old_chain = save_inferior_ptid (); 317 struct regcache *regcache; 318 319 inferior_ptid = BUILD_LWP (lwpid, ph->pid); 320 regcache = get_thread_regcache (inferior_ptid); 321 322 supply_fpregset (regcache, (const gdb_fpregset_t *) fpregset); 323 target_store_registers (regcache, -1); 324 325 do_cleanups (old_chain); 326 return PS_OK; 327} 328 329/* Return overall process id of the target PH. Special for GNU/Linux 330 -- not used on Solaris. */ 331 332pid_t 333ps_getpid (gdb_ps_prochandle_t ph) 334{ 335 return ph->pid; 336} 337 338void 339_initialize_proc_service (void) 340{ 341 /* This function solely exists to make sure this module is linked 342 into the final binary. */ 343} 344