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 /*
27 * Copyright (c) 2013, Joyent, Inc. All rights reserved.
28 * Copyright (c) 2013 by Delphix. All rights reserved.
29 */
30
31 #include <sys/types.h>
32 #include <sys/uio.h>
33 #include <string.h>
34 #include <errno.h>
35 #include <limits.h>
36
37 #include "Pcontrol.h"
38 #include "P32ton.h"
39
40 /*
41 * This file implements the routines to read and write per-lwp register
42 * information from either a live process or core file opened with libproc.
43 * We build up a few common routines for reading and writing register
44 * information, and then the public functions are all trivial calls to these.
45 */
46
47 /*
48 * Utility function to return a pointer to the structure of cached information
49 * about an lwp in the core file, given its lwpid.
50 */
51 static lwp_info_t *
52 getlwpcore(struct ps_prochandle *P, lwpid_t lwpid)
53 {
54 core_info_t *core = P->data;
55 lwp_info_t *lwp = list_next(&core->core_lwp_head);
56 uint_t i;
57
58 for (i = 0; i < core->core_nlwp; i++, lwp = list_next(lwp)) {
59 if (lwp->lwp_id == lwpid)
60 return (lwp);
61 }
62
63 errno = EINVAL;
64 return (NULL);
65 }
66
67 /*
68 * Utility function to open and read the contents of a per-lwp /proc file.
69 * This function is used to slurp in lwpstatus, xregs, and asrs.
70 */
71 static int
72 getlwpfile(struct ps_prochandle *P, lwpid_t lwpid,
73 const char *fbase, void *rp, size_t n)
74 {
75 char fname[PATH_MAX];
76 int fd;
77
78 (void) snprintf(fname, sizeof (fname), "%s/%d/lwp/%d/%s",
79 procfs_path, (int)P->status.pr_pid, (int)lwpid, fbase);
80
81 if ((fd = open(fname, O_RDONLY)) >= 0) {
82 if (read(fd, rp, n) > 0) {
83 (void) close(fd);
84 return (0);
85 }
86 (void) close(fd);
87 }
88 return (-1);
89 }
90
91 /*
92 * Get the lwpstatus_t for an lwp from either the live process or our
93 * cached information from the core file. This is used to get the
94 * general-purpose registers or floating point registers.
95 */
96 int
97 getlwpstatus(struct ps_prochandle *P, lwpid_t lwpid, lwpstatus_t *lps)
98 {
99 lwp_info_t *lwp;
100
101 /*
102 * For both live processes and cores, our job is easy if the lwpid
103 * matches that of the representative lwp:
104 */
105 if (P->status.pr_lwp.pr_lwpid == lwpid) {
106 (void) memcpy(lps, &P->status.pr_lwp, sizeof (lwpstatus_t));
107 return (0);
108 }
109
110 /*
111 * If this is a live process, then just read the information out
112 * of the per-lwp status file:
113 */
114 if (P->state != PS_DEAD) {
115 return (getlwpfile(P, lwpid, "lwpstatus",
116 lps, sizeof (lwpstatus_t)));
117 }
118
119 /*
120 * If this is a core file, we need to iterate through our list of
121 * cached lwp information and then copy out the status.
122 */
123 if (P->data != NULL && (lwp = getlwpcore(P, lwpid)) != NULL) {
124 (void) memcpy(lps, &lwp->lwp_status, sizeof (lwpstatus_t));
125 return (0);
126 }
127
128 return (-1);
129 }
130
131 /*
132 * Utility function to modify lwp registers. This is done using either the
133 * process control file or per-lwp control file as necessary.
134 */
135 static int
136 setlwpregs(struct ps_prochandle *P, lwpid_t lwpid, long cmd,
137 const void *rp, size_t n)
138 {
139 iovec_t iov[2];
140 char fname[PATH_MAX];
141 int fd;
142
143 if (P->state != PS_STOP) {
144 errno = EBUSY;
145 return (-1);
146 }
147
148 iov[0].iov_base = (caddr_t)&cmd;
149 iov[0].iov_len = sizeof (long);
150 iov[1].iov_base = (caddr_t)rp;
151 iov[1].iov_len = n;
152
153 /*
154 * Writing the process control file writes the representative lwp.
155 * Psync before we write to make sure we are consistent with the
156 * primary interfaces. Similarly, make sure to update P->status
157 * afterward if we are modifying one of its register sets.
158 */
159 if (P->status.pr_lwp.pr_lwpid == lwpid) {
160 Psync(P);
161
162 if (writev(P->ctlfd, iov, 2) == -1)
163 return (-1);
164
165 if (cmd == PCSREG)
166 (void) memcpy(P->status.pr_lwp.pr_reg, rp, n);
167 else if (cmd == PCSFPREG)
168 (void) memcpy(&P->status.pr_lwp.pr_fpreg, rp, n);
169
170 return (0);
171 }
172
173 /*
174 * If the lwp we want is not the representative lwp, we need to
175 * open the ctl file for that specific lwp.
176 */
177 (void) snprintf(fname, sizeof (fname), "%s/%d/lwp/%d/lwpctl",
178 procfs_path, (int)P->status.pr_pid, (int)lwpid);
179
180 if ((fd = open(fname, O_WRONLY)) >= 0) {
181 if (writev(fd, iov, 2) > 0) {
182 (void) close(fd);
183 return (0);
184 }
185 (void) close(fd);
186 }
187 return (-1);
188 }
189
190 int
191 Plwp_getregs(struct ps_prochandle *P, lwpid_t lwpid, prgregset_t gregs)
192 {
193 lwpstatus_t lps;
194
195 if (getlwpstatus(P, lwpid, &lps) == -1)
196 return (-1);
197
198 (void) memcpy(gregs, lps.pr_reg, sizeof (prgregset_t));
199 return (0);
200 }
201
202 int
203 Plwp_setregs(struct ps_prochandle *P, lwpid_t lwpid, const prgregset_t gregs)
204 {
205 return (setlwpregs(P, lwpid, PCSREG, gregs, sizeof (prgregset_t)));
206 }
207
208 int
209 Plwp_getfpregs(struct ps_prochandle *P, lwpid_t lwpid, prfpregset_t *fpregs)
210 {
211 lwpstatus_t lps;
212
213 if (getlwpstatus(P, lwpid, &lps) == -1)
214 return (-1);
215
216 (void) memcpy(fpregs, &lps.pr_fpreg, sizeof (prfpregset_t));
217 return (0);
218 }
219
220 int Plwp_setfpregs(struct ps_prochandle *P, lwpid_t lwpid,
221 const prfpregset_t *fpregs)
222 {
223 return (setlwpregs(P, lwpid, PCSFPREG, fpregs, sizeof (prfpregset_t)));
224 }
225
226 #if defined(sparc) || defined(__sparc)
227 int
228 Plwp_getxregs(struct ps_prochandle *P, lwpid_t lwpid, prxregset_t *xregs)
229 {
230 lwp_info_t *lwp;
231
232 if (P->state == PS_IDLE) {
233 errno = ENODATA;
234 return (-1);
235 }
236
237 if (P->state != PS_DEAD) {
238 if (P->state != PS_STOP) {
239 errno = EBUSY;
240 return (-1);
241 }
242
243 return (getlwpfile(P, lwpid, "xregs",
244 xregs, sizeof (prxregset_t)));
245 }
246
247 if ((lwp = getlwpcore(P, lwpid)) != NULL && lwp->lwp_xregs != NULL) {
248 (void) memcpy(xregs, lwp->lwp_xregs, sizeof (prxregset_t));
249 return (0);
250 }
251
252 if (lwp != NULL)
253 errno = ENODATA;
254 return (-1);
255 }
256
257 int
258 Plwp_setxregs(struct ps_prochandle *P, lwpid_t lwpid, const prxregset_t *xregs)
259 {
260 return (setlwpregs(P, lwpid, PCSXREG, xregs, sizeof (prxregset_t)));
261 }
262
263 int
264 Plwp_getgwindows(struct ps_prochandle *P, lwpid_t lwpid, gwindows_t *gwins)
265 {
266 lwp_info_t *lwp;
267
268 if (P->state == PS_IDLE) {
269 errno = ENODATA;
270 return (-1);
271 }
272
273 if (P->state != PS_DEAD) {
274 if (P->state != PS_STOP) {
275 errno = EBUSY;
276 return (-1);
277 }
278
279 return (getlwpfile(P, lwpid, "gwindows",
280 gwins, sizeof (gwindows_t)));
281 }
282
283 if ((lwp = getlwpcore(P, lwpid)) != NULL && lwp->lwp_gwins != NULL) {
284 *gwins = *lwp->lwp_gwins;
285 return (0);
286 }
287
288 if (lwp != NULL)
289 errno = ENODATA;
290 return (-1);
291 }
292
293 #if defined(__sparcv9)
294 int
295 Plwp_getasrs(struct ps_prochandle *P, lwpid_t lwpid, asrset_t asrs)
296 {
297 lwp_info_t *lwp;
298
299 if (P->state == PS_IDLE) {
300 errno = ENODATA;
301 return (-1);
302 }
303
304 if (P->state != PS_DEAD) {
305 if (P->state != PS_STOP) {
306 errno = EBUSY;
307 return (-1);
308 }
309
310 return (getlwpfile(P, lwpid, "asrs", asrs, sizeof (asrset_t)));
311 }
312
313 if ((lwp = getlwpcore(P, lwpid)) != NULL && lwp->lwp_asrs != NULL) {
314 (void) memcpy(asrs, lwp->lwp_asrs, sizeof (asrset_t));
315 return (0);
316 }
317
318 if (lwp != NULL)
319 errno = ENODATA;
320 return (-1);
321
322 }
323
324 int
325 Plwp_setasrs(struct ps_prochandle *P, lwpid_t lwpid, const asrset_t asrs)
326 {
327 return (setlwpregs(P, lwpid, PCSASRS, asrs, sizeof (asrset_t)));
328 }
329 #endif /* __sparcv9 */
330 #endif /* __sparc */
331
332 int
333 Plwp_getpsinfo(struct ps_prochandle *P, lwpid_t lwpid, lwpsinfo_t *lps)
334 {
335 lwp_info_t *lwp;
336
337 if (P->state == PS_IDLE) {
338 errno = ENODATA;
339 return (-1);
340 }
341
342 if (P->state != PS_DEAD) {
343 return (getlwpfile(P, lwpid, "lwpsinfo",
344 lps, sizeof (lwpsinfo_t)));
345 }
346
347 if ((lwp = getlwpcore(P, lwpid)) != NULL) {
348 (void) memcpy(lps, &lwp->lwp_psinfo, sizeof (lwpsinfo_t));
349 return (0);
350 }
351
352 return (-1);
353 }
354
355 int
356 Plwp_getspymaster(struct ps_prochandle *P, lwpid_t lwpid, psinfo_t *ps)
357 {
358 lwpstatus_t lps;
359
360 if (P->state == PS_IDLE) {
361 errno = ENODATA;
362 return (-1);
363 }
364
365 if (getlwpstatus(P, lwpid, &lps) != 0)
366 return (-1);
367
368 if (!(lps.pr_flags & PR_AGENT)) {
369 errno = EINVAL;
370 return (-1);
371 }
372
373 if (P->state != PS_DEAD) {
374 return (getlwpfile(P, lwpid, "spymaster",
375 ps, sizeof (psinfo_t)));
376 }
377
378 if (P->spymaster.pr_nlwp != 0) {
379 (void) memcpy(ps, &P->spymaster, sizeof (psinfo_t));
380 return (0);
381 }
382
383 errno = ENODATA;
384
385 return (-1);
386 }
387
388 int
389 Plwp_stack(struct ps_prochandle *P, lwpid_t lwpid, stack_t *stkp)
390 {
391 uintptr_t addr;
392
393 if (P->state == PS_IDLE) {
394 errno = ENODATA;
395 return (-1);
396 }
397
398 if (P->state != PS_DEAD) {
399 lwpstatus_t ls;
400 if (getlwpfile(P, lwpid, "lwpstatus", &ls, sizeof (ls)) != 0)
401 return (-1);
402 addr = ls.pr_ustack;
403 } else {
404 lwp_info_t *lwp;
405 if ((lwp = getlwpcore(P, lwpid)) == NULL)
406 return (-1);
407 addr = lwp->lwp_status.pr_ustack;
408 }
409
410
411 if (P->status.pr_dmodel == PR_MODEL_NATIVE) {
412 if (Pread(P, stkp, sizeof (*stkp), addr) != sizeof (*stkp))
413 return (-1);
414 #ifdef _LP64
415 } else {
416 stack32_t stk32;
417
418 if (Pread(P, &stk32, sizeof (stk32), addr) != sizeof (stk32))
419 return (-1);
420
421 stack_32_to_n(&stk32, stkp);
422 #endif
423 }
424
425 return (0);
426 }
427
428 int
429 Plwp_main_stack(struct ps_prochandle *P, lwpid_t lwpid, stack_t *stkp)
430 {
431 uintptr_t addr;
432 lwpstatus_t ls;
433
434 if (P->state == PS_IDLE) {
435 errno = ENODATA;
436 return (-1);
437 }
438
439 if (P->state != PS_DEAD) {
440 if (getlwpfile(P, lwpid, "lwpstatus", &ls, sizeof (ls)) != 0)
441 return (-1);
442 } else {
443 lwp_info_t *lwp;
444 if ((lwp = getlwpcore(P, lwpid)) == NULL)
445 return (-1);
446 ls = lwp->lwp_status;
447 }
448
449 addr = ls.pr_ustack;
450
451 /*
452 * Read out the current stack; if the SS_ONSTACK flag is set then
453 * this LWP is operating on the alternate signal stack. We can
454 * recover the original stack from pr_oldcontext.
455 */
456 if (P->status.pr_dmodel == PR_MODEL_NATIVE) {
457 if (Pread(P, stkp, sizeof (*stkp), addr) != sizeof (*stkp))
458 return (-1);
459
460 if (stkp->ss_flags & SS_ONSTACK)
461 goto on_altstack;
462 #ifdef _LP64
463 } else {
464 stack32_t stk32;
465
466 if (Pread(P, &stk32, sizeof (stk32), addr) != sizeof (stk32))
467 return (-1);
468
469 if (stk32.ss_flags & SS_ONSTACK)
470 goto on_altstack;
471
472 stack_32_to_n(&stk32, stkp);
473 #endif
474 }
475
476 return (0);
477
478 on_altstack:
479
480 if (P->status.pr_dmodel == PR_MODEL_NATIVE) {
481 ucontext_t *ctxp = (void *)ls.pr_oldcontext;
482
483 if (Pread(P, stkp, sizeof (*stkp),
484 (uintptr_t)&ctxp->uc_stack) != sizeof (*stkp))
485 return (-1);
486 #ifdef _LP64
487 } else {
488 ucontext32_t *ctxp = (void *)ls.pr_oldcontext;
489 stack32_t stk32;
490
491 if (Pread(P, &stk32, sizeof (stk32),
492 (uintptr_t)&ctxp->uc_stack) != sizeof (stk32))
493 return (-1);
494
495 stack_32_to_n(&stk32, stkp);
496 #endif
497 }
498
499 return (0);
500 }
501
502 int
503 Plwp_alt_stack(struct ps_prochandle *P, lwpid_t lwpid, stack_t *stkp)
504 {
505 if (P->state == PS_IDLE) {
506 errno = ENODATA;
507 return (-1);
508 }
509
510 if (P->state != PS_DEAD) {
511 lwpstatus_t ls;
512
513 if (getlwpfile(P, lwpid, "lwpstatus", &ls, sizeof (ls)) != 0)
514 return (-1);
515
516 if (ls.pr_altstack.ss_flags & SS_DISABLE) {
517 errno = ENODATA;
518 return (-1);
519 }
520
521 *stkp = ls.pr_altstack;
522 } else {
523 lwp_info_t *lwp;
524
525 if ((lwp = getlwpcore(P, lwpid)) == NULL)
526 return (-1);
527
528 if (lwp->lwp_status.pr_altstack.ss_flags & SS_DISABLE) {
529 errno = ENODATA;
530 return (-1);
531 }
532
533 *stkp = lwp->lwp_status.pr_altstack;
534 }
535
536 return (0);
537 }