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