1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #pragma ident "%Z%%M% %I% %E% SMI"
27
28 #include <stdarg.h>
29 #include <string.h>
30 #include "Pcontrol.h"
31
32 /*
33 * This file implements the process services declared in <proc_service.h>.
34 * This enables libproc to be used in conjunction with libc_db and
35 * librtld_db. As most of these facilities are already provided by
36 * (more elegant) interfaces in <libproc.h>, we can just call those.
37 *
38 * NOTE: We explicitly do *not* implement the functions ps_kill() and
39 * ps_lrolltoaddr() in this library. The very existence of these functions
40 * causes libc_db to create an "agent thread" in the target process.
41 * The only way to turn off this behavior is to omit these functions.
42 */
43
44 #pragma weak ps_pdread = ps_pread
45 #pragma weak ps_ptread = ps_pread
46 #pragma weak ps_pdwrite = ps_pwrite
47 #pragma weak ps_ptwrite = ps_pwrite
48
49 ps_err_e
50 ps_pdmodel(struct ps_prochandle *P, int *modelp)
51 {
52 *modelp = P->status.pr_dmodel;
53 return (PS_OK);
54 }
55
56 ps_err_e
57 ps_pread(struct ps_prochandle *P, psaddr_t addr, void *buf, size_t size)
58 {
59 if (P->ops->p_pread(P, buf, size, addr) != size)
60 return (PS_BADADDR);
61 return (PS_OK);
62 }
63
64 ps_err_e
65 ps_pwrite(struct ps_prochandle *P, psaddr_t addr, const void *buf, size_t size)
66 {
67 if (P->ops->p_pwrite(P, buf, size, addr) != size)
68 return (PS_BADADDR);
69 return (PS_OK);
70 }
71
72 /*
73 * libc_db calls matched pairs of ps_pstop()/ps_pcontinue()
74 * in the belief that the client may have left the process
75 * running while calling in to the libc_db interfaces.
76 *
77 * We interpret the meaning of these functions to be an inquiry
78 * as to whether the process is stopped, not an action to be
79 * performed to make it stopped. For similar reasons, we also
80 * return PS_OK for core files in order to allow libc_db to
81 * operate on these as well.
82 */
83 ps_err_e
84 ps_pstop(struct ps_prochandle *P)
85 {
86 if (P->state != PS_STOP && P->state != PS_DEAD)
87 return (PS_ERR);
88 return (PS_OK);
89 }
90
91 ps_err_e
92 ps_pcontinue(struct ps_prochandle *P)
93 {
94 if (P->state != PS_STOP && P->state != PS_DEAD)
95 return (PS_ERR);
96 return (PS_OK);
97 }
98
99 /*
100 * ps_lstop() and ps_lcontinue() are not called by any code in libc_db
101 * or librtld_db. We make them behave like ps_pstop() and ps_pcontinue().
102 */
103 /* ARGSUSED1 */
104 ps_err_e
105 ps_lstop(struct ps_prochandle *P, lwpid_t lwpid)
106 {
107 if (P->state != PS_STOP && P->state != PS_DEAD)
108 return (PS_ERR);
109 return (PS_OK);
110 }
111
112 /* ARGSUSED1 */
113 ps_err_e
114 ps_lcontinue(struct ps_prochandle *P, lwpid_t lwpid)
115 {
116 if (P->state != PS_STOP && P->state != PS_DEAD)
117 return (PS_ERR);
118 return (PS_OK);
119 }
120
121 ps_err_e
122 ps_lgetregs(struct ps_prochandle *P, lwpid_t lwpid, prgregset_t regs)
123 {
124 if (P->state != PS_STOP && P->state != PS_DEAD)
125 return (PS_ERR);
126
127 if (Plwp_getregs(P, lwpid, regs) == 0)
128 return (PS_OK);
129
130 return (PS_BADLID);
131 }
132
133 ps_err_e
134 ps_lsetregs(struct ps_prochandle *P, lwpid_t lwpid, const prgregset_t regs)
135 {
136 if (P->state != PS_STOP)
137 return (PS_ERR);
138
139 if (Plwp_setregs(P, lwpid, regs) == 0)
140 return (PS_OK);
141
142 return (PS_BADLID);
143 }
144
145 ps_err_e
146 ps_lgetfpregs(struct ps_prochandle *P, lwpid_t lwpid, prfpregset_t *regs)
147 {
148 if (P->state != PS_STOP && P->state != PS_DEAD)
149 return (PS_ERR);
150
151 if (Plwp_getfpregs(P, lwpid, regs) == 0)
152 return (PS_OK);
153
154 return (PS_BADLID);
155 }
156
157 ps_err_e
158 ps_lsetfpregs(struct ps_prochandle *P, lwpid_t lwpid, const prfpregset_t *regs)
159 {
160 if (P->state != PS_STOP)
161 return (PS_ERR);
162
163 if (Plwp_setfpregs(P, lwpid, regs) == 0)
164 return (PS_OK);
165
166 return (PS_BADLID);
167 }
168
169 #if defined(sparc) || defined(__sparc)
170
171 ps_err_e
172 ps_lgetxregsize(struct ps_prochandle *P, lwpid_t lwpid, int *xrsize)
173 {
174 char fname[PATH_MAX];
175 struct stat statb;
176
177 if (P->state == PS_DEAD) {
178 lwp_info_t *lwp = list_next(&P->core->core_lwp_head);
179 uint_t i;
180
181 for (i = 0; i < P->core->core_nlwp; i++, lwp = list_next(lwp)) {
182 if (lwp->lwp_id == lwpid) {
183 if (lwp->lwp_xregs != NULL)
184 *xrsize = sizeof (prxregset_t);
185 else
186 *xrsize = 0;
187 return (PS_OK);
188 }
189 }
190
191 return (PS_BADLID);
192 }
193
194 (void) snprintf(fname, sizeof (fname), "%s/%d/lwp/%d/xregs",
195 procfs_path, (int)P->status.pr_pid, (int)lwpid);
196
197 if (stat(fname, &statb) != 0)
198 return (PS_BADLID);
199
200 *xrsize = (int)statb.st_size;
201 return (PS_OK);
202 }
203
204 ps_err_e
205 ps_lgetxregs(struct ps_prochandle *P, lwpid_t lwpid, caddr_t xregs)
206 {
207 if (P->state != PS_STOP && P->state != PS_DEAD)
208 return (PS_ERR);
209
210 /* LINTED - alignment */
211 if (Plwp_getxregs(P, lwpid, (prxregset_t *)xregs) == 0)
212 return (PS_OK);
213
214 return (PS_BADLID);
215 }
216
217 ps_err_e
218 ps_lsetxregs(struct ps_prochandle *P, lwpid_t lwpid, caddr_t xregs)
219 {
220 if (P->state != PS_STOP)
221 return (PS_ERR);
222
223 /* LINTED - alignment */
224 if (Plwp_setxregs(P, lwpid, (prxregset_t *)xregs) == 0)
225 return (PS_OK);
226
227 return (PS_BADLID);
228 }
229
230 #endif /* sparc */
231
232 #if defined(__i386) || defined(__amd64)
233
234 ps_err_e
235 ps_lgetLDT(struct ps_prochandle *P, lwpid_t lwpid, struct ssd *ldt)
236 {
237 #if defined(__amd64) && defined(_LP64)
238 if (P->status.pr_dmodel != PR_MODEL_NATIVE) {
239 #endif
240 prgregset_t regs;
241 struct ssd *ldtarray;
242 ps_err_e error;
243 uint_t gs;
244 int nldt;
245 int i;
246
247 if (P->state != PS_STOP && P->state != PS_DEAD)
248 return (PS_ERR);
249
250 /*
251 * We need to get the ldt entry that matches the
252 * value in the lwp's GS register.
253 */
254 if ((error = ps_lgetregs(P, lwpid, regs)) != PS_OK)
255 return (error);
256
257 gs = regs[GS];
258
259 if ((nldt = Pldt(P, NULL, 0)) <= 0 ||
260 (ldtarray = malloc(nldt * sizeof (struct ssd))) == NULL)
261 return (PS_ERR);
262 if ((nldt = Pldt(P, ldtarray, nldt)) <= 0) {
263 free(ldtarray);
264 return (PS_ERR);
265 }
266
267 for (i = 0; i < nldt; i++) {
268 if (gs == ldtarray[i].sel) {
269 *ldt = ldtarray[i];
270 break;
271 }
272 }
273 free(ldtarray);
274
275 if (i < nldt)
276 return (PS_OK);
277 #if defined(__amd64) && defined(_LP64)
278 }
279 #endif
280
281 return (PS_ERR);
282 }
283
284 #endif /* __i386 || __amd64 */
285
286 /*
287 * Libthread_db doesn't use this function currently, but librtld_db uses
288 * it for its debugging output. We turn this on via rd_log if our debugging
289 * switch is on, and then echo the messages sent to ps_plog to stderr.
290 */
291 void
292 ps_plog(const char *fmt, ...)
293 {
294 va_list ap;
295
296 if (_libproc_debug && fmt != NULL && *fmt != '\0') {
297 va_start(ap, fmt);
298 (void) vfprintf(stderr, fmt, ap);
299 va_end(ap);
300 if (fmt[strlen(fmt) - 1] != '\n')
301 (void) fputc('\n', stderr);
302 }
303 }
304
305 /*
306 * Store a pointer to our internal copy of the aux vector at the address
307 * specified by the caller. It should not hold on to this data for too long.
308 */
309 ps_err_e
310 ps_pauxv(struct ps_prochandle *P, const auxv_t **aux)
311 {
312 if (P->auxv == NULL)
313 Preadauxvec(P);
314
315 if (P->auxv == NULL)
316 return (PS_ERR);
317
318 *aux = (const auxv_t *)P->auxv;
319 return (PS_OK);
320 }
321
322 ps_err_e
323 ps_pbrandname(struct ps_prochandle *P, char *buf, size_t len)
324 {
325 return (Pbrandname(P, buf, len) ? PS_OK : PS_ERR);
326 }
327
328 /*
329 * Search for a symbol by name and return the corresponding address.
330 */
331 ps_err_e
332 ps_pglobal_lookup(struct ps_prochandle *P, const char *object_name,
333 const char *sym_name, psaddr_t *sym_addr)
334 {
335 GElf_Sym sym;
336
337 if (Plookup_by_name(P, object_name, sym_name, &sym) == 0) {
338 dprintf("pglobal_lookup <%s> -> %p\n",
339 sym_name, (void *)(uintptr_t)sym.st_value);
340 *sym_addr = (psaddr_t)sym.st_value;
341 return (PS_OK);
342 }
343
344 return (PS_NOSYM);
345 }
346
347 /*
348 * Search for a symbol by name and return the corresponding symbol
349 * information. If we're compiled _LP64, we just call Plookup_by_name
350 * and return because ps_sym_t is defined to be an Elf64_Sym, which
351 * is the same as a GElf_Sym. In the _ILP32 case, we have to convert
352 * Plookup_by_name's result back to a ps_sym_t (which is an Elf32_Sym).
353 */
354 ps_err_e
355 ps_pglobal_sym(struct ps_prochandle *P, const char *object_name,
356 const char *sym_name, ps_sym_t *symp)
357 {
358 #if defined(_ILP32)
359 GElf_Sym sym;
360
361 if (Plookup_by_name(P, object_name, sym_name, &sym) == 0) {
362 symp->st_name = (Elf32_Word)sym.st_name;
363 symp->st_value = (Elf32_Addr)sym.st_value;
364 symp->st_size = (Elf32_Word)sym.st_size;
365 symp->st_info = ELF32_ST_INFO(
366 GELF_ST_BIND(sym.st_info), GELF_ST_TYPE(sym.st_info));
367 symp->st_other = sym.st_other;
368 symp->st_shndx = sym.st_shndx;
369 return (PS_OK);
370 }
371
372 #elif defined(_LP64)
373 if (Plookup_by_name(P, object_name, sym_name, symp) == 0)
374 return (PS_OK);
375 #endif
376 return (PS_NOSYM);
377 }