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