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 } 538