17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 57c478bd9Sstevel@tonic-gate * Common Development and Distribution License, Version 1.0 only 67c478bd9Sstevel@tonic-gate * (the "License"). You may not use this file except in compliance 77c478bd9Sstevel@tonic-gate * with the License. 87c478bd9Sstevel@tonic-gate * 97c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 107c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 117c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 127c478bd9Sstevel@tonic-gate * and limitations under the License. 137c478bd9Sstevel@tonic-gate * 147c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 157c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 167c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 177c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 187c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 197c478bd9Sstevel@tonic-gate * 207c478bd9Sstevel@tonic-gate * CDDL HEADER END 217c478bd9Sstevel@tonic-gate */ 22*e4586ebfSmws 237c478bd9Sstevel@tonic-gate /* 24*e4586ebfSmws * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 257c478bd9Sstevel@tonic-gate * Use is subject to license terms. 267c478bd9Sstevel@tonic-gate */ 277c478bd9Sstevel@tonic-gate 287c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 297c478bd9Sstevel@tonic-gate 307c478bd9Sstevel@tonic-gate #include <stdio.h> 317c478bd9Sstevel@tonic-gate #include <stdlib.h> 327c478bd9Sstevel@tonic-gate #include <unistd.h> 337c478bd9Sstevel@tonic-gate #include <ctype.h> 347c478bd9Sstevel@tonic-gate #include <fcntl.h> 357c478bd9Sstevel@tonic-gate #include <string.h> 367c478bd9Sstevel@tonic-gate #include <memory.h> 377c478bd9Sstevel@tonic-gate #include <errno.h> 387c478bd9Sstevel@tonic-gate #include <dirent.h> 397c478bd9Sstevel@tonic-gate #include <limits.h> 407c478bd9Sstevel@tonic-gate #include <signal.h> 417c478bd9Sstevel@tonic-gate #include <sys/types.h> 427c478bd9Sstevel@tonic-gate #include <sys/uio.h> 437c478bd9Sstevel@tonic-gate #include <sys/stat.h> 447c478bd9Sstevel@tonic-gate #include <sys/resource.h> 457c478bd9Sstevel@tonic-gate #include <sys/param.h> 467c478bd9Sstevel@tonic-gate #include <sys/stack.h> 477c478bd9Sstevel@tonic-gate #include <sys/fault.h> 487c478bd9Sstevel@tonic-gate #include <sys/syscall.h> 497c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 507c478bd9Sstevel@tonic-gate 517c478bd9Sstevel@tonic-gate #include "libproc.h" 527c478bd9Sstevel@tonic-gate #include "Pcontrol.h" 537c478bd9Sstevel@tonic-gate #include "Putil.h" 547c478bd9Sstevel@tonic-gate #include "P32ton.h" 557c478bd9Sstevel@tonic-gate 567c478bd9Sstevel@tonic-gate int _libproc_debug; /* set non-zero to enable debugging printfs */ 577c478bd9Sstevel@tonic-gate sigset_t blockable_sigs; /* signals to block when we need to be safe */ 587c478bd9Sstevel@tonic-gate static int minfd; /* minimum file descriptor returned by dupfd(fd, 0) */ 597c478bd9Sstevel@tonic-gate 607c478bd9Sstevel@tonic-gate /* 617c478bd9Sstevel@tonic-gate * Function prototypes for static routines in this module. 627c478bd9Sstevel@tonic-gate */ 637c478bd9Sstevel@tonic-gate static void deadcheck(struct ps_prochandle *); 647c478bd9Sstevel@tonic-gate static void restore_tracing_flags(struct ps_prochandle *); 657c478bd9Sstevel@tonic-gate static void Lfree_internal(struct ps_prochandle *, struct ps_lwphandle *); 667c478bd9Sstevel@tonic-gate 677c478bd9Sstevel@tonic-gate /* 687c478bd9Sstevel@tonic-gate * Read/write interface for live processes: just pread/pwrite the 697c478bd9Sstevel@tonic-gate * /proc/<pid>/as file: 707c478bd9Sstevel@tonic-gate */ 717c478bd9Sstevel@tonic-gate 727c478bd9Sstevel@tonic-gate static ssize_t 737c478bd9Sstevel@tonic-gate Pread_live(struct ps_prochandle *P, void *buf, size_t n, uintptr_t addr) 747c478bd9Sstevel@tonic-gate { 757c478bd9Sstevel@tonic-gate return (pread(P->asfd, buf, n, (off_t)addr)); 767c478bd9Sstevel@tonic-gate } 777c478bd9Sstevel@tonic-gate 787c478bd9Sstevel@tonic-gate static ssize_t 797c478bd9Sstevel@tonic-gate Pwrite_live(struct ps_prochandle *P, const void *buf, size_t n, uintptr_t addr) 807c478bd9Sstevel@tonic-gate { 817c478bd9Sstevel@tonic-gate return (pwrite(P->asfd, buf, n, (off_t)addr)); 827c478bd9Sstevel@tonic-gate } 837c478bd9Sstevel@tonic-gate 847c478bd9Sstevel@tonic-gate static const ps_rwops_t P_live_ops = { Pread_live, Pwrite_live }; 857c478bd9Sstevel@tonic-gate 867c478bd9Sstevel@tonic-gate /* 877c478bd9Sstevel@tonic-gate * This is the library's .init handler. 887c478bd9Sstevel@tonic-gate */ 897c478bd9Sstevel@tonic-gate #pragma init(_libproc_init) 907c478bd9Sstevel@tonic-gate void 917c478bd9Sstevel@tonic-gate _libproc_init(void) 927c478bd9Sstevel@tonic-gate { 937c478bd9Sstevel@tonic-gate _libproc_debug = getenv("LIBPROC_DEBUG") != NULL; 947c478bd9Sstevel@tonic-gate 957c478bd9Sstevel@tonic-gate (void) sigfillset(&blockable_sigs); 967c478bd9Sstevel@tonic-gate (void) sigdelset(&blockable_sigs, SIGKILL); 977c478bd9Sstevel@tonic-gate (void) sigdelset(&blockable_sigs, SIGSTOP); 987c478bd9Sstevel@tonic-gate } 997c478bd9Sstevel@tonic-gate 1007c478bd9Sstevel@tonic-gate /* 1017c478bd9Sstevel@tonic-gate * Call set_minfd() once before calling dupfd() several times. 1027c478bd9Sstevel@tonic-gate * We assume that the application will not reduce its current file 1037c478bd9Sstevel@tonic-gate * descriptor limit lower than 512 once it has set at least that value. 1047c478bd9Sstevel@tonic-gate */ 1057c478bd9Sstevel@tonic-gate int 1067c478bd9Sstevel@tonic-gate set_minfd(void) 1077c478bd9Sstevel@tonic-gate { 1087c478bd9Sstevel@tonic-gate static mutex_t minfd_lock = DEFAULTMUTEX; 1097c478bd9Sstevel@tonic-gate struct rlimit rlim; 1107c478bd9Sstevel@tonic-gate int fd; 1117c478bd9Sstevel@tonic-gate 1127c478bd9Sstevel@tonic-gate if ((fd = minfd) < 256) { 1137c478bd9Sstevel@tonic-gate (void) mutex_lock(&minfd_lock); 1147c478bd9Sstevel@tonic-gate if ((fd = minfd) < 256) { 1157c478bd9Sstevel@tonic-gate if (getrlimit(RLIMIT_NOFILE, &rlim) != 0) 1167c478bd9Sstevel@tonic-gate rlim.rlim_cur = rlim.rlim_max = 0; 1177c478bd9Sstevel@tonic-gate if (rlim.rlim_cur >= 512) 1187c478bd9Sstevel@tonic-gate fd = 256; 1197c478bd9Sstevel@tonic-gate else if ((fd = rlim.rlim_cur / 2) < 3) 1207c478bd9Sstevel@tonic-gate fd = 3; 1217c478bd9Sstevel@tonic-gate minfd = fd; 1227c478bd9Sstevel@tonic-gate } 1237c478bd9Sstevel@tonic-gate (void) mutex_unlock(&minfd_lock); 1247c478bd9Sstevel@tonic-gate } 1257c478bd9Sstevel@tonic-gate return (fd); 1267c478bd9Sstevel@tonic-gate } 1277c478bd9Sstevel@tonic-gate 1287c478bd9Sstevel@tonic-gate int 1297c478bd9Sstevel@tonic-gate dupfd(int fd, int dfd) 1307c478bd9Sstevel@tonic-gate { 1317c478bd9Sstevel@tonic-gate int mfd; 1327c478bd9Sstevel@tonic-gate 1337c478bd9Sstevel@tonic-gate /* 1347c478bd9Sstevel@tonic-gate * Make fd be greater than 255 (the 32-bit stdio limit), 1357c478bd9Sstevel@tonic-gate * or at least make it greater than 2 so that the 1367c478bd9Sstevel@tonic-gate * program will work when spawned by init(1m). 1377c478bd9Sstevel@tonic-gate * Also, if dfd is non-zero, dup the fd to be dfd. 1387c478bd9Sstevel@tonic-gate */ 1397c478bd9Sstevel@tonic-gate if ((mfd = minfd) == 0) 1407c478bd9Sstevel@tonic-gate mfd = set_minfd(); 1417c478bd9Sstevel@tonic-gate if (dfd > 0 || (0 <= fd && fd < mfd)) { 1427c478bd9Sstevel@tonic-gate if (dfd <= 0) 1437c478bd9Sstevel@tonic-gate dfd = mfd; 1447c478bd9Sstevel@tonic-gate dfd = fcntl(fd, F_DUPFD, dfd); 1457c478bd9Sstevel@tonic-gate (void) close(fd); 1467c478bd9Sstevel@tonic-gate fd = dfd; 1477c478bd9Sstevel@tonic-gate } 1487c478bd9Sstevel@tonic-gate /* 1497c478bd9Sstevel@tonic-gate * Mark it close-on-exec so any created process doesn't inherit it. 1507c478bd9Sstevel@tonic-gate */ 1517c478bd9Sstevel@tonic-gate if (fd >= 0) 1527c478bd9Sstevel@tonic-gate (void) fcntl(fd, F_SETFD, FD_CLOEXEC); 1537c478bd9Sstevel@tonic-gate return (fd); 1547c478bd9Sstevel@tonic-gate } 1557c478bd9Sstevel@tonic-gate 1567c478bd9Sstevel@tonic-gate /* 1577c478bd9Sstevel@tonic-gate * Create a new controlled process. 1587c478bd9Sstevel@tonic-gate * Leave it stopped on successful exit from exec() or execve(). 1597c478bd9Sstevel@tonic-gate * Return an opaque pointer to its process control structure. 1607c478bd9Sstevel@tonic-gate * Return NULL if process cannot be created (fork()/exec() not successful). 1617c478bd9Sstevel@tonic-gate */ 1627c478bd9Sstevel@tonic-gate struct ps_prochandle * 1637c478bd9Sstevel@tonic-gate Pxcreate(const char *file, /* executable file name */ 1647c478bd9Sstevel@tonic-gate char *const *argv, /* argument vector */ 1657c478bd9Sstevel@tonic-gate char *const *envp, /* environment */ 1667c478bd9Sstevel@tonic-gate int *perr, /* pointer to error return code */ 1677c478bd9Sstevel@tonic-gate char *path, /* if non-null, holds exec path name on return */ 1687c478bd9Sstevel@tonic-gate size_t len) /* size of the path buffer */ 1697c478bd9Sstevel@tonic-gate { 1707c478bd9Sstevel@tonic-gate char execpath[PATH_MAX]; 1717c478bd9Sstevel@tonic-gate char procname[100]; 1727c478bd9Sstevel@tonic-gate struct ps_prochandle *P; 1737c478bd9Sstevel@tonic-gate pid_t pid; 1747c478bd9Sstevel@tonic-gate int fd; 1757c478bd9Sstevel@tonic-gate char *fname; 1767c478bd9Sstevel@tonic-gate int rc; 1777c478bd9Sstevel@tonic-gate int lasterrno = 0; 1787c478bd9Sstevel@tonic-gate 1797c478bd9Sstevel@tonic-gate if (len == 0) /* zero length, no path */ 1807c478bd9Sstevel@tonic-gate path = NULL; 1817c478bd9Sstevel@tonic-gate if (path != NULL) 1827c478bd9Sstevel@tonic-gate *path = '\0'; 1837c478bd9Sstevel@tonic-gate 1847c478bd9Sstevel@tonic-gate if ((P = malloc(sizeof (struct ps_prochandle))) == NULL) { 1857c478bd9Sstevel@tonic-gate *perr = C_STRANGE; 1867c478bd9Sstevel@tonic-gate return (NULL); 1877c478bd9Sstevel@tonic-gate } 1887c478bd9Sstevel@tonic-gate 1897c478bd9Sstevel@tonic-gate if ((pid = fork1()) == -1) { 1907c478bd9Sstevel@tonic-gate free(P); 1917c478bd9Sstevel@tonic-gate *perr = C_FORK; 1927c478bd9Sstevel@tonic-gate return (NULL); 1937c478bd9Sstevel@tonic-gate } 1947c478bd9Sstevel@tonic-gate 1957c478bd9Sstevel@tonic-gate if (pid == 0) { /* child process */ 1967c478bd9Sstevel@tonic-gate id_t id; 1977c478bd9Sstevel@tonic-gate extern char **environ; 1987c478bd9Sstevel@tonic-gate 1997c478bd9Sstevel@tonic-gate /* 2007c478bd9Sstevel@tonic-gate * If running setuid or setgid, reset credentials to normal. 2017c478bd9Sstevel@tonic-gate */ 2027c478bd9Sstevel@tonic-gate if ((id = getgid()) != getegid()) 2037c478bd9Sstevel@tonic-gate (void) setgid(id); 2047c478bd9Sstevel@tonic-gate if ((id = getuid()) != geteuid()) 2057c478bd9Sstevel@tonic-gate (void) setuid(id); 2067c478bd9Sstevel@tonic-gate 2077c478bd9Sstevel@tonic-gate Pcreate_callback(P); /* execute callback (see below) */ 2087c478bd9Sstevel@tonic-gate (void) pause(); /* wait for PRSABORT from parent */ 2097c478bd9Sstevel@tonic-gate 2107c478bd9Sstevel@tonic-gate /* 2117c478bd9Sstevel@tonic-gate * This is ugly. There is no execvep() function that takes a 2127c478bd9Sstevel@tonic-gate * path and an environment. We cheat here by replacing the 2137c478bd9Sstevel@tonic-gate * global 'environ' variable right before we call this. 2147c478bd9Sstevel@tonic-gate */ 2157c478bd9Sstevel@tonic-gate if (envp) 2167c478bd9Sstevel@tonic-gate environ = (char **)envp; 2177c478bd9Sstevel@tonic-gate 2187c478bd9Sstevel@tonic-gate (void) execvp(file, argv); /* execute the program */ 2197c478bd9Sstevel@tonic-gate _exit(127); 2207c478bd9Sstevel@tonic-gate } 2217c478bd9Sstevel@tonic-gate 2227c478bd9Sstevel@tonic-gate /* 2237c478bd9Sstevel@tonic-gate * Initialize the process structure. 2247c478bd9Sstevel@tonic-gate */ 2257c478bd9Sstevel@tonic-gate (void) memset(P, 0, sizeof (*P)); 2267c478bd9Sstevel@tonic-gate (void) mutex_init(&P->proc_lock, USYNC_THREAD, NULL); 2277c478bd9Sstevel@tonic-gate P->flags |= CREATED; 2287c478bd9Sstevel@tonic-gate P->state = PS_RUN; 2297c478bd9Sstevel@tonic-gate P->pid = pid; 2307c478bd9Sstevel@tonic-gate P->asfd = -1; 2317c478bd9Sstevel@tonic-gate P->ctlfd = -1; 2327c478bd9Sstevel@tonic-gate P->statfd = -1; 2337c478bd9Sstevel@tonic-gate P->agentctlfd = -1; 2347c478bd9Sstevel@tonic-gate P->agentstatfd = -1; 2357c478bd9Sstevel@tonic-gate P->ops = &P_live_ops; 2367c478bd9Sstevel@tonic-gate Pinitsym(P); 2377c478bd9Sstevel@tonic-gate 2387c478bd9Sstevel@tonic-gate /* 2397c478bd9Sstevel@tonic-gate * Open the /proc/pid files. 2407c478bd9Sstevel@tonic-gate */ 2417c478bd9Sstevel@tonic-gate (void) sprintf(procname, "/proc/%d/", (int)pid); 2427c478bd9Sstevel@tonic-gate fname = procname + strlen(procname); 2437c478bd9Sstevel@tonic-gate (void) set_minfd(); 2447c478bd9Sstevel@tonic-gate 2457c478bd9Sstevel@tonic-gate /* 2467c478bd9Sstevel@tonic-gate * Exclusive write open advises others not to interfere. 2477c478bd9Sstevel@tonic-gate * There is no reason for any of these open()s to fail. 2487c478bd9Sstevel@tonic-gate */ 2497c478bd9Sstevel@tonic-gate (void) strcpy(fname, "as"); 2507c478bd9Sstevel@tonic-gate if ((fd = open(procname, (O_RDWR|O_EXCL))) < 0 || 2517c478bd9Sstevel@tonic-gate (fd = dupfd(fd, 0)) < 0) { 2527c478bd9Sstevel@tonic-gate dprintf("Pcreate: failed to open %s: %s\n", 2537c478bd9Sstevel@tonic-gate procname, strerror(errno)); 2547c478bd9Sstevel@tonic-gate rc = C_STRANGE; 2557c478bd9Sstevel@tonic-gate goto bad; 2567c478bd9Sstevel@tonic-gate } 2577c478bd9Sstevel@tonic-gate P->asfd = fd; 2587c478bd9Sstevel@tonic-gate 2597c478bd9Sstevel@tonic-gate (void) strcpy(fname, "status"); 2607c478bd9Sstevel@tonic-gate if ((fd = open(procname, O_RDONLY)) < 0 || 2617c478bd9Sstevel@tonic-gate (fd = dupfd(fd, 0)) < 0) { 2627c478bd9Sstevel@tonic-gate dprintf("Pcreate: failed to open %s: %s\n", 2637c478bd9Sstevel@tonic-gate procname, strerror(errno)); 2647c478bd9Sstevel@tonic-gate rc = C_STRANGE; 2657c478bd9Sstevel@tonic-gate goto bad; 2667c478bd9Sstevel@tonic-gate } 2677c478bd9Sstevel@tonic-gate P->statfd = fd; 2687c478bd9Sstevel@tonic-gate 2697c478bd9Sstevel@tonic-gate (void) strcpy(fname, "ctl"); 2707c478bd9Sstevel@tonic-gate if ((fd = open(procname, O_WRONLY)) < 0 || 2717c478bd9Sstevel@tonic-gate (fd = dupfd(fd, 0)) < 0) { 2727c478bd9Sstevel@tonic-gate dprintf("Pcreate: failed to open %s: %s\n", 2737c478bd9Sstevel@tonic-gate procname, strerror(errno)); 2747c478bd9Sstevel@tonic-gate rc = C_STRANGE; 2757c478bd9Sstevel@tonic-gate goto bad; 2767c478bd9Sstevel@tonic-gate } 2777c478bd9Sstevel@tonic-gate P->ctlfd = fd; 2787c478bd9Sstevel@tonic-gate 2797c478bd9Sstevel@tonic-gate (void) Pstop(P, 0); /* stop the controlled process */ 2807c478bd9Sstevel@tonic-gate 2817c478bd9Sstevel@tonic-gate /* 2827c478bd9Sstevel@tonic-gate * Wait for process to sleep in pause(). 2837c478bd9Sstevel@tonic-gate * If the process has already called pause(), then it should be 2847c478bd9Sstevel@tonic-gate * stopped (PR_REQUESTED) while asleep in pause and we are done. 2857c478bd9Sstevel@tonic-gate * Else we set up to catch entry/exit to pause() and set the process 2867c478bd9Sstevel@tonic-gate * running again, expecting it to stop when it reaches pause(). 2877c478bd9Sstevel@tonic-gate * There is no reason for this to fail other than an interrupt. 2887c478bd9Sstevel@tonic-gate */ 2897c478bd9Sstevel@tonic-gate (void) Psysentry(P, SYS_pause, 1); 2907c478bd9Sstevel@tonic-gate (void) Psysexit(P, SYS_pause, 1); 2917c478bd9Sstevel@tonic-gate for (;;) { 2927c478bd9Sstevel@tonic-gate if (P->state == PS_STOP && 2937c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_syscall == SYS_pause && 2947c478bd9Sstevel@tonic-gate (P->status.pr_lwp.pr_why == PR_REQUESTED || 2957c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_why == PR_SYSENTRY || 2967c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_why == PR_SYSEXIT)) 2977c478bd9Sstevel@tonic-gate break; 2987c478bd9Sstevel@tonic-gate 2997c478bd9Sstevel@tonic-gate if (P->state != PS_STOP || /* interrupt or process died */ 3007c478bd9Sstevel@tonic-gate Psetrun(P, 0, 0) != 0) { /* can't restart */ 3017c478bd9Sstevel@tonic-gate if (errno == EINTR || errno == ERESTART) 3027c478bd9Sstevel@tonic-gate rc = C_INTR; 3037c478bd9Sstevel@tonic-gate else { 3047c478bd9Sstevel@tonic-gate dprintf("Pcreate: Psetrun failed: %s\n", 3057c478bd9Sstevel@tonic-gate strerror(errno)); 3067c478bd9Sstevel@tonic-gate rc = C_STRANGE; 3077c478bd9Sstevel@tonic-gate } 3087c478bd9Sstevel@tonic-gate goto bad; 3097c478bd9Sstevel@tonic-gate } 3107c478bd9Sstevel@tonic-gate 3117c478bd9Sstevel@tonic-gate (void) Pwait(P, 0); 3127c478bd9Sstevel@tonic-gate } 3137c478bd9Sstevel@tonic-gate (void) Psysentry(P, SYS_pause, 0); 3147c478bd9Sstevel@tonic-gate (void) Psysexit(P, SYS_pause, 0); 3157c478bd9Sstevel@tonic-gate 3167c478bd9Sstevel@tonic-gate /* 3177c478bd9Sstevel@tonic-gate * Kick the process off the pause() and catch 3187c478bd9Sstevel@tonic-gate * it again on entry to exec() or exit(). 3197c478bd9Sstevel@tonic-gate */ 3207c478bd9Sstevel@tonic-gate (void) Psysentry(P, SYS_exit, 1); 3217c478bd9Sstevel@tonic-gate (void) Psysentry(P, SYS_exec, 1); 3227c478bd9Sstevel@tonic-gate (void) Psysentry(P, SYS_execve, 1); 3237c478bd9Sstevel@tonic-gate if (Psetrun(P, 0, PRSABORT) == -1) { 3247c478bd9Sstevel@tonic-gate dprintf("Pcreate: Psetrun failed: %s\n", strerror(errno)); 3257c478bd9Sstevel@tonic-gate rc = C_STRANGE; 3267c478bd9Sstevel@tonic-gate goto bad; 3277c478bd9Sstevel@tonic-gate } 3287c478bd9Sstevel@tonic-gate (void) Pwait(P, 0); 3297c478bd9Sstevel@tonic-gate if (P->state != PS_STOP) { 3307c478bd9Sstevel@tonic-gate dprintf("Pcreate: Pwait failed: %s\n", strerror(errno)); 3317c478bd9Sstevel@tonic-gate rc = C_STRANGE; 3327c478bd9Sstevel@tonic-gate goto bad; 3337c478bd9Sstevel@tonic-gate } 3347c478bd9Sstevel@tonic-gate 3357c478bd9Sstevel@tonic-gate /* 3367c478bd9Sstevel@tonic-gate * Move the process through instances of failed exec()s 3377c478bd9Sstevel@tonic-gate * to reach the point of stopped on successful exec(). 3387c478bd9Sstevel@tonic-gate */ 3397c478bd9Sstevel@tonic-gate (void) Psysexit(P, SYS_exec, TRUE); 3407c478bd9Sstevel@tonic-gate (void) Psysexit(P, SYS_execve, TRUE); 3417c478bd9Sstevel@tonic-gate 3427c478bd9Sstevel@tonic-gate while (P->state == PS_STOP && 3437c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_why == PR_SYSENTRY && 3447c478bd9Sstevel@tonic-gate (P->status.pr_lwp.pr_what == SYS_execve || 3457c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_what == SYS_exec)) { 3467c478bd9Sstevel@tonic-gate /* 3477c478bd9Sstevel@tonic-gate * Fetch the exec path name now, before we complete 3487c478bd9Sstevel@tonic-gate * the exec(). We may lose the process and be unable 3497c478bd9Sstevel@tonic-gate * to get the information later. 3507c478bd9Sstevel@tonic-gate */ 3517c478bd9Sstevel@tonic-gate (void) Pread_string(P, execpath, sizeof (execpath), 3527c478bd9Sstevel@tonic-gate (off_t)P->status.pr_lwp.pr_sysarg[0]); 3537c478bd9Sstevel@tonic-gate if (path != NULL) 3547c478bd9Sstevel@tonic-gate (void) strncpy(path, execpath, len); 3557c478bd9Sstevel@tonic-gate /* 3567c478bd9Sstevel@tonic-gate * Set the process running and wait for 3577c478bd9Sstevel@tonic-gate * it to stop on exit from the exec(). 3587c478bd9Sstevel@tonic-gate */ 3597c478bd9Sstevel@tonic-gate (void) Psetrun(P, 0, 0); 3607c478bd9Sstevel@tonic-gate (void) Pwait(P, 0); 3617c478bd9Sstevel@tonic-gate 3627c478bd9Sstevel@tonic-gate if (P->state == PS_LOST && /* we lost control */ 3637c478bd9Sstevel@tonic-gate Preopen(P) != 0) { /* and we can't get it back */ 3647c478bd9Sstevel@tonic-gate rc = C_PERM; 3657c478bd9Sstevel@tonic-gate goto bad; 3667c478bd9Sstevel@tonic-gate } 3677c478bd9Sstevel@tonic-gate 3687c478bd9Sstevel@tonic-gate /* 3697c478bd9Sstevel@tonic-gate * If the exec() failed, continue the loop, expecting 3707c478bd9Sstevel@tonic-gate * there to be more attempts to exec(), based on PATH. 3717c478bd9Sstevel@tonic-gate */ 3727c478bd9Sstevel@tonic-gate if (P->state == PS_STOP && 3737c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_why == PR_SYSEXIT && 3747c478bd9Sstevel@tonic-gate (P->status.pr_lwp.pr_what == SYS_execve || 3757c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_what == SYS_exec) && 3767c478bd9Sstevel@tonic-gate (lasterrno = P->status.pr_lwp.pr_errno) != 0) { 3777c478bd9Sstevel@tonic-gate /* 3787c478bd9Sstevel@tonic-gate * The exec() failed. Set the process running and 3797c478bd9Sstevel@tonic-gate * wait for it to stop on entry to the next exec(). 3807c478bd9Sstevel@tonic-gate */ 3817c478bd9Sstevel@tonic-gate (void) Psetrun(P, 0, 0); 3827c478bd9Sstevel@tonic-gate (void) Pwait(P, 0); 3837c478bd9Sstevel@tonic-gate 3847c478bd9Sstevel@tonic-gate continue; 3857c478bd9Sstevel@tonic-gate } 3867c478bd9Sstevel@tonic-gate break; 3877c478bd9Sstevel@tonic-gate } 3887c478bd9Sstevel@tonic-gate 3897c478bd9Sstevel@tonic-gate if (P->state == PS_STOP && 3907c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_why == PR_SYSEXIT && 3917c478bd9Sstevel@tonic-gate (P->status.pr_lwp.pr_what == SYS_execve || 3927c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_what == SYS_exec) && 3937c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_errno == 0) { 3947c478bd9Sstevel@tonic-gate /* 3957c478bd9Sstevel@tonic-gate * The process is stopped on successful exec() or execve(). 3967c478bd9Sstevel@tonic-gate * Turn off all tracing flags and return success. 3977c478bd9Sstevel@tonic-gate */ 3987c478bd9Sstevel@tonic-gate restore_tracing_flags(P); 3997c478bd9Sstevel@tonic-gate #ifndef _LP64 4007c478bd9Sstevel@tonic-gate /* We must be a 64-bit process to deal with a 64-bit process */ 4017c478bd9Sstevel@tonic-gate if (P->status.pr_dmodel == PR_MODEL_LP64) { 4027c478bd9Sstevel@tonic-gate rc = C_LP64; 4037c478bd9Sstevel@tonic-gate goto bad; 4047c478bd9Sstevel@tonic-gate } 4057c478bd9Sstevel@tonic-gate #endif 4067c478bd9Sstevel@tonic-gate /* 4077c478bd9Sstevel@tonic-gate * Set run-on-last-close so the controlled process 4087c478bd9Sstevel@tonic-gate * runs even if we die on a signal. 4097c478bd9Sstevel@tonic-gate */ 4107c478bd9Sstevel@tonic-gate (void) Psetflags(P, PR_RLC); 4117c478bd9Sstevel@tonic-gate *perr = 0; 4127c478bd9Sstevel@tonic-gate return (P); 4137c478bd9Sstevel@tonic-gate } 4147c478bd9Sstevel@tonic-gate 4157c478bd9Sstevel@tonic-gate rc = lasterrno == ENOENT ? C_NOENT : C_NOEXEC; 4167c478bd9Sstevel@tonic-gate 4177c478bd9Sstevel@tonic-gate bad: 4187c478bd9Sstevel@tonic-gate (void) kill(pid, SIGKILL); 4197c478bd9Sstevel@tonic-gate if (path != NULL && rc != C_PERM && rc != C_LP64) 4207c478bd9Sstevel@tonic-gate *path = '\0'; 4217c478bd9Sstevel@tonic-gate Pfree(P); 4227c478bd9Sstevel@tonic-gate *perr = rc; 4237c478bd9Sstevel@tonic-gate return (NULL); 4247c478bd9Sstevel@tonic-gate } 4257c478bd9Sstevel@tonic-gate 4267c478bd9Sstevel@tonic-gate struct ps_prochandle * 4277c478bd9Sstevel@tonic-gate Pcreate( 4287c478bd9Sstevel@tonic-gate const char *file, /* executable file name */ 4297c478bd9Sstevel@tonic-gate char *const *argv, /* argument vector */ 4307c478bd9Sstevel@tonic-gate int *perr, /* pointer to error return code */ 4317c478bd9Sstevel@tonic-gate char *path, /* if non-null, holds exec path name on return */ 4327c478bd9Sstevel@tonic-gate size_t len) /* size of the path buffer */ 4337c478bd9Sstevel@tonic-gate { 4347c478bd9Sstevel@tonic-gate return (Pxcreate(file, argv, NULL, perr, path, len)); 4357c478bd9Sstevel@tonic-gate } 4367c478bd9Sstevel@tonic-gate 4377c478bd9Sstevel@tonic-gate /* 4387c478bd9Sstevel@tonic-gate * Return a printable string corresponding to a Pcreate() error return. 4397c478bd9Sstevel@tonic-gate */ 4407c478bd9Sstevel@tonic-gate const char * 4417c478bd9Sstevel@tonic-gate Pcreate_error(int error) 4427c478bd9Sstevel@tonic-gate { 4437c478bd9Sstevel@tonic-gate const char *str; 4447c478bd9Sstevel@tonic-gate 4457c478bd9Sstevel@tonic-gate switch (error) { 4467c478bd9Sstevel@tonic-gate case C_FORK: 4477c478bd9Sstevel@tonic-gate str = "cannot fork"; 4487c478bd9Sstevel@tonic-gate break; 4497c478bd9Sstevel@tonic-gate case C_PERM: 4507c478bd9Sstevel@tonic-gate str = "file is set-id or unreadable"; 4517c478bd9Sstevel@tonic-gate break; 4527c478bd9Sstevel@tonic-gate case C_NOEXEC: 4537c478bd9Sstevel@tonic-gate str = "cannot execute file"; 4547c478bd9Sstevel@tonic-gate break; 4557c478bd9Sstevel@tonic-gate case C_INTR: 4567c478bd9Sstevel@tonic-gate str = "operation interrupted"; 4577c478bd9Sstevel@tonic-gate break; 4587c478bd9Sstevel@tonic-gate case C_LP64: 4597c478bd9Sstevel@tonic-gate str = "program is _LP64, self is not"; 4607c478bd9Sstevel@tonic-gate break; 4617c478bd9Sstevel@tonic-gate case C_STRANGE: 4627c478bd9Sstevel@tonic-gate str = "unanticipated system error"; 4637c478bd9Sstevel@tonic-gate break; 4647c478bd9Sstevel@tonic-gate case C_NOENT: 4657c478bd9Sstevel@tonic-gate str = "cannot find executable file"; 4667c478bd9Sstevel@tonic-gate break; 4677c478bd9Sstevel@tonic-gate default: 4687c478bd9Sstevel@tonic-gate str = "unknown error"; 4697c478bd9Sstevel@tonic-gate break; 4707c478bd9Sstevel@tonic-gate } 4717c478bd9Sstevel@tonic-gate 4727c478bd9Sstevel@tonic-gate return (str); 4737c478bd9Sstevel@tonic-gate } 4747c478bd9Sstevel@tonic-gate 4757c478bd9Sstevel@tonic-gate /* 4767c478bd9Sstevel@tonic-gate * Callback to execute in each child process created with Pcreate() after fork 4777c478bd9Sstevel@tonic-gate * but before it execs the new process image. By default, we do nothing, but 4787c478bd9Sstevel@tonic-gate * by calling this function we allow the client program to define its own 4797c478bd9Sstevel@tonic-gate * version of the function which will interpose on our empty default. This 4807c478bd9Sstevel@tonic-gate * may be useful for clients that need to modify signal dispositions, terminal 4817c478bd9Sstevel@tonic-gate * attributes, or process group and session properties for each new victim. 4827c478bd9Sstevel@tonic-gate */ 4837c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 4847c478bd9Sstevel@tonic-gate void 4857c478bd9Sstevel@tonic-gate Pcreate_callback(struct ps_prochandle *P) 4867c478bd9Sstevel@tonic-gate { 4877c478bd9Sstevel@tonic-gate /* nothing to do here */ 4887c478bd9Sstevel@tonic-gate } 4897c478bd9Sstevel@tonic-gate 4907c478bd9Sstevel@tonic-gate /* 4917c478bd9Sstevel@tonic-gate * Grab an existing process. 4927c478bd9Sstevel@tonic-gate * Return an opaque pointer to its process control structure. 4937c478bd9Sstevel@tonic-gate * 4947c478bd9Sstevel@tonic-gate * pid: UNIX process ID. 4957c478bd9Sstevel@tonic-gate * flags: 4967c478bd9Sstevel@tonic-gate * PGRAB_RETAIN Retain tracing flags (default clears all tracing flags). 4977c478bd9Sstevel@tonic-gate * PGRAB_FORCE Grab regardless of whether process is already traced. 4987c478bd9Sstevel@tonic-gate * PGRAB_RDONLY Open the address space file O_RDONLY instead of O_RDWR, 4997c478bd9Sstevel@tonic-gate * and do not open the process control file. 5007c478bd9Sstevel@tonic-gate * PGRAB_NOSTOP Open the process but do not force it to stop. 5017c478bd9Sstevel@tonic-gate * perr: pointer to error return code. 5027c478bd9Sstevel@tonic-gate */ 5037c478bd9Sstevel@tonic-gate struct ps_prochandle * 5047c478bd9Sstevel@tonic-gate Pgrab(pid_t pid, int flags, int *perr) 5057c478bd9Sstevel@tonic-gate { 5067c478bd9Sstevel@tonic-gate struct ps_prochandle *P; 5077c478bd9Sstevel@tonic-gate int fd, omode; 5087c478bd9Sstevel@tonic-gate char procname[100]; 5097c478bd9Sstevel@tonic-gate char *fname; 5107c478bd9Sstevel@tonic-gate int rc = 0; 5117c478bd9Sstevel@tonic-gate 5127c478bd9Sstevel@tonic-gate /* 5137c478bd9Sstevel@tonic-gate * PGRAB_RDONLY means that we do not open the /proc/<pid>/control file, 5147c478bd9Sstevel@tonic-gate * and so it implies RETAIN and NOSTOP since both require control. 5157c478bd9Sstevel@tonic-gate */ 5167c478bd9Sstevel@tonic-gate if (flags & PGRAB_RDONLY) 5177c478bd9Sstevel@tonic-gate flags |= PGRAB_RETAIN | PGRAB_NOSTOP; 5187c478bd9Sstevel@tonic-gate 5197c478bd9Sstevel@tonic-gate if ((P = malloc(sizeof (struct ps_prochandle))) == NULL) { 5207c478bd9Sstevel@tonic-gate *perr = G_STRANGE; 5217c478bd9Sstevel@tonic-gate return (NULL); 5227c478bd9Sstevel@tonic-gate } 5237c478bd9Sstevel@tonic-gate 5247c478bd9Sstevel@tonic-gate P->asfd = -1; 5257c478bd9Sstevel@tonic-gate P->ctlfd = -1; 5267c478bd9Sstevel@tonic-gate P->statfd = -1; 5277c478bd9Sstevel@tonic-gate 5287c478bd9Sstevel@tonic-gate again: /* Come back here if we lose it in the Window of Vulnerability */ 5297c478bd9Sstevel@tonic-gate if (P->ctlfd >= 0) 5307c478bd9Sstevel@tonic-gate (void) close(P->ctlfd); 5317c478bd9Sstevel@tonic-gate if (P->asfd >= 0) 5327c478bd9Sstevel@tonic-gate (void) close(P->asfd); 5337c478bd9Sstevel@tonic-gate if (P->statfd >= 0) 5347c478bd9Sstevel@tonic-gate (void) close(P->statfd); 5357c478bd9Sstevel@tonic-gate (void) memset(P, 0, sizeof (*P)); 5367c478bd9Sstevel@tonic-gate (void) mutex_init(&P->proc_lock, USYNC_THREAD, NULL); 5377c478bd9Sstevel@tonic-gate P->ctlfd = -1; 5387c478bd9Sstevel@tonic-gate P->asfd = -1; 5397c478bd9Sstevel@tonic-gate P->statfd = -1; 5407c478bd9Sstevel@tonic-gate P->agentctlfd = -1; 5417c478bd9Sstevel@tonic-gate P->agentstatfd = -1; 5427c478bd9Sstevel@tonic-gate P->ops = &P_live_ops; 5437c478bd9Sstevel@tonic-gate Pinitsym(P); 5447c478bd9Sstevel@tonic-gate 5457c478bd9Sstevel@tonic-gate /* 5467c478bd9Sstevel@tonic-gate * Open the /proc/pid files 5477c478bd9Sstevel@tonic-gate */ 5487c478bd9Sstevel@tonic-gate (void) sprintf(procname, "/proc/%d/", (int)pid); 5497c478bd9Sstevel@tonic-gate fname = procname + strlen(procname); 5507c478bd9Sstevel@tonic-gate (void) set_minfd(); 5517c478bd9Sstevel@tonic-gate 5527c478bd9Sstevel@tonic-gate /* 5537c478bd9Sstevel@tonic-gate * Request exclusive open to avoid grabbing someone else's 5547c478bd9Sstevel@tonic-gate * process and to prevent others from interfering afterwards. 5557c478bd9Sstevel@tonic-gate * If this fails and the 'PGRAB_FORCE' flag is set, attempt to 5567c478bd9Sstevel@tonic-gate * open non-exclusively. 5577c478bd9Sstevel@tonic-gate */ 5587c478bd9Sstevel@tonic-gate (void) strcpy(fname, "as"); 5597c478bd9Sstevel@tonic-gate omode = (flags & PGRAB_RDONLY) ? O_RDONLY : O_RDWR; 5607c478bd9Sstevel@tonic-gate 5617c478bd9Sstevel@tonic-gate if (((fd = open(procname, omode | O_EXCL)) < 0 && 5627c478bd9Sstevel@tonic-gate (fd = ((flags & PGRAB_FORCE)? open(procname, omode) : -1)) < 0) || 5637c478bd9Sstevel@tonic-gate (fd = dupfd(fd, 0)) < 0) { 5647c478bd9Sstevel@tonic-gate switch (errno) { 5657c478bd9Sstevel@tonic-gate case ENOENT: 5667c478bd9Sstevel@tonic-gate rc = G_NOPROC; 5677c478bd9Sstevel@tonic-gate break; 5687c478bd9Sstevel@tonic-gate case EACCES: 5697c478bd9Sstevel@tonic-gate case EPERM: 5707c478bd9Sstevel@tonic-gate rc = G_PERM; 5717c478bd9Sstevel@tonic-gate break; 5727c478bd9Sstevel@tonic-gate case EBUSY: 5737c478bd9Sstevel@tonic-gate if (!(flags & PGRAB_FORCE) || geteuid() != 0) { 5747c478bd9Sstevel@tonic-gate rc = G_BUSY; 5757c478bd9Sstevel@tonic-gate break; 5767c478bd9Sstevel@tonic-gate } 5777c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 5787c478bd9Sstevel@tonic-gate default: 5797c478bd9Sstevel@tonic-gate dprintf("Pgrab: failed to open %s: %s\n", 5807c478bd9Sstevel@tonic-gate procname, strerror(errno)); 5817c478bd9Sstevel@tonic-gate rc = G_STRANGE; 5827c478bd9Sstevel@tonic-gate break; 5837c478bd9Sstevel@tonic-gate } 5847c478bd9Sstevel@tonic-gate goto err; 5857c478bd9Sstevel@tonic-gate } 5867c478bd9Sstevel@tonic-gate P->asfd = fd; 5877c478bd9Sstevel@tonic-gate 5887c478bd9Sstevel@tonic-gate (void) strcpy(fname, "status"); 5897c478bd9Sstevel@tonic-gate if ((fd = open(procname, O_RDONLY)) < 0 || 5907c478bd9Sstevel@tonic-gate (fd = dupfd(fd, 0)) < 0) { 5917c478bd9Sstevel@tonic-gate switch (errno) { 5927c478bd9Sstevel@tonic-gate case ENOENT: 5937c478bd9Sstevel@tonic-gate rc = G_NOPROC; 5947c478bd9Sstevel@tonic-gate break; 5957c478bd9Sstevel@tonic-gate default: 5967c478bd9Sstevel@tonic-gate dprintf("Pgrab: failed to open %s: %s\n", 5977c478bd9Sstevel@tonic-gate procname, strerror(errno)); 5987c478bd9Sstevel@tonic-gate rc = G_STRANGE; 5997c478bd9Sstevel@tonic-gate break; 6007c478bd9Sstevel@tonic-gate } 6017c478bd9Sstevel@tonic-gate goto err; 6027c478bd9Sstevel@tonic-gate } 6037c478bd9Sstevel@tonic-gate P->statfd = fd; 6047c478bd9Sstevel@tonic-gate 6057c478bd9Sstevel@tonic-gate if (!(flags & PGRAB_RDONLY)) { 6067c478bd9Sstevel@tonic-gate (void) strcpy(fname, "ctl"); 6077c478bd9Sstevel@tonic-gate if ((fd = open(procname, O_WRONLY)) < 0 || 6087c478bd9Sstevel@tonic-gate (fd = dupfd(fd, 0)) < 0) { 6097c478bd9Sstevel@tonic-gate switch (errno) { 6107c478bd9Sstevel@tonic-gate case ENOENT: 6117c478bd9Sstevel@tonic-gate rc = G_NOPROC; 6127c478bd9Sstevel@tonic-gate break; 6137c478bd9Sstevel@tonic-gate default: 6147c478bd9Sstevel@tonic-gate dprintf("Pgrab: failed to open %s: %s\n", 6157c478bd9Sstevel@tonic-gate procname, strerror(errno)); 6167c478bd9Sstevel@tonic-gate rc = G_STRANGE; 6177c478bd9Sstevel@tonic-gate break; 6187c478bd9Sstevel@tonic-gate } 6197c478bd9Sstevel@tonic-gate goto err; 6207c478bd9Sstevel@tonic-gate } 6217c478bd9Sstevel@tonic-gate P->ctlfd = fd; 6227c478bd9Sstevel@tonic-gate } 6237c478bd9Sstevel@tonic-gate 6247c478bd9Sstevel@tonic-gate P->state = PS_RUN; 6257c478bd9Sstevel@tonic-gate P->pid = pid; 6267c478bd9Sstevel@tonic-gate 6277c478bd9Sstevel@tonic-gate /* 6287c478bd9Sstevel@tonic-gate * We are now in the Window of Vulnerability (WoV). The process may 6297c478bd9Sstevel@tonic-gate * exec() a setuid/setgid or unreadable object file between the open() 6307c478bd9Sstevel@tonic-gate * and the PCSTOP. We will get EAGAIN in this case and must start over. 6317c478bd9Sstevel@tonic-gate * As Pstopstatus will trigger the first read() from a /proc file, 6327c478bd9Sstevel@tonic-gate * we also need to handle EOVERFLOW here when 32-bit as an indicator 6337c478bd9Sstevel@tonic-gate * that this process is 64-bit. Finally, if the process has become 6347c478bd9Sstevel@tonic-gate * a zombie (PS_UNDEAD) while we were trying to grab it, just remain 6357c478bd9Sstevel@tonic-gate * silent about this and pretend there was no process. 6367c478bd9Sstevel@tonic-gate */ 6377c478bd9Sstevel@tonic-gate if (Pstopstatus(P, PCNULL, 0) != 0) { 6387c478bd9Sstevel@tonic-gate #ifndef _LP64 6397c478bd9Sstevel@tonic-gate if (errno == EOVERFLOW) { 6407c478bd9Sstevel@tonic-gate rc = G_LP64; 6417c478bd9Sstevel@tonic-gate goto err; 6427c478bd9Sstevel@tonic-gate } 6437c478bd9Sstevel@tonic-gate #endif 6447c478bd9Sstevel@tonic-gate if (P->state == PS_LOST) { /* WoV */ 6457c478bd9Sstevel@tonic-gate (void) mutex_destroy(&P->proc_lock); 6467c478bd9Sstevel@tonic-gate goto again; 6477c478bd9Sstevel@tonic-gate } 6487c478bd9Sstevel@tonic-gate 6497c478bd9Sstevel@tonic-gate if (P->state == PS_UNDEAD) 6507c478bd9Sstevel@tonic-gate rc = G_NOPROC; 6517c478bd9Sstevel@tonic-gate else 6527c478bd9Sstevel@tonic-gate rc = G_STRANGE; 6537c478bd9Sstevel@tonic-gate 6547c478bd9Sstevel@tonic-gate goto err; 6557c478bd9Sstevel@tonic-gate } 6567c478bd9Sstevel@tonic-gate 6577c478bd9Sstevel@tonic-gate /* 6587c478bd9Sstevel@tonic-gate * If the process is a system process, we can't control it even as root 6597c478bd9Sstevel@tonic-gate */ 6607c478bd9Sstevel@tonic-gate if (P->status.pr_flags & PR_ISSYS) { 6617c478bd9Sstevel@tonic-gate rc = G_SYS; 6627c478bd9Sstevel@tonic-gate goto err; 6637c478bd9Sstevel@tonic-gate } 6647c478bd9Sstevel@tonic-gate #ifndef _LP64 6657c478bd9Sstevel@tonic-gate /* 6667c478bd9Sstevel@tonic-gate * We must be a 64-bit process to deal with a 64-bit process 6677c478bd9Sstevel@tonic-gate */ 6687c478bd9Sstevel@tonic-gate if (P->status.pr_dmodel == PR_MODEL_LP64) { 6697c478bd9Sstevel@tonic-gate rc = G_LP64; 6707c478bd9Sstevel@tonic-gate goto err; 6717c478bd9Sstevel@tonic-gate } 6727c478bd9Sstevel@tonic-gate #endif 6737c478bd9Sstevel@tonic-gate 6747c478bd9Sstevel@tonic-gate /* 6757c478bd9Sstevel@tonic-gate * Remember the status for use by Prelease(). 6767c478bd9Sstevel@tonic-gate */ 6777c478bd9Sstevel@tonic-gate P->orig_status = P->status; /* structure copy */ 6787c478bd9Sstevel@tonic-gate 6797c478bd9Sstevel@tonic-gate /* 6807c478bd9Sstevel@tonic-gate * Before stopping the process, make sure we are not grabbing ourselves. 6817c478bd9Sstevel@tonic-gate * If we are, make sure we are doing it PGRAB_RDONLY. 6827c478bd9Sstevel@tonic-gate */ 6837c478bd9Sstevel@tonic-gate if (pid == getpid()) { 6847c478bd9Sstevel@tonic-gate /* 6857c478bd9Sstevel@tonic-gate * Verify that the process is really ourself: 6867c478bd9Sstevel@tonic-gate * Set a magic number, read it through the 6877c478bd9Sstevel@tonic-gate * /proc file and see if the results match. 6887c478bd9Sstevel@tonic-gate */ 6897c478bd9Sstevel@tonic-gate uint32_t magic1 = 0; 6907c478bd9Sstevel@tonic-gate uint32_t magic2 = 2; 6917c478bd9Sstevel@tonic-gate 6927c478bd9Sstevel@tonic-gate errno = 0; 6937c478bd9Sstevel@tonic-gate 6947c478bd9Sstevel@tonic-gate if (Pread(P, &magic2, sizeof (magic2), (uintptr_t)&magic1) 6957c478bd9Sstevel@tonic-gate == sizeof (magic2) && 6967c478bd9Sstevel@tonic-gate magic2 == 0 && 6977c478bd9Sstevel@tonic-gate (magic1 = 0xfeedbeef) && 6987c478bd9Sstevel@tonic-gate Pread(P, &magic2, sizeof (magic2), (uintptr_t)&magic1) 6997c478bd9Sstevel@tonic-gate == sizeof (magic2) && 7007c478bd9Sstevel@tonic-gate magic2 == 0xfeedbeef && 7017c478bd9Sstevel@tonic-gate !(flags & PGRAB_RDONLY)) { 7027c478bd9Sstevel@tonic-gate rc = G_SELF; 7037c478bd9Sstevel@tonic-gate goto err; 7047c478bd9Sstevel@tonic-gate } 7057c478bd9Sstevel@tonic-gate } 7067c478bd9Sstevel@tonic-gate 7077c478bd9Sstevel@tonic-gate /* 7087c478bd9Sstevel@tonic-gate * If the process is already stopped or has been directed 7097c478bd9Sstevel@tonic-gate * to stop via /proc, do not set run-on-last-close. 7107c478bd9Sstevel@tonic-gate */ 7117c478bd9Sstevel@tonic-gate if (!(P->status.pr_lwp.pr_flags & (PR_ISTOP|PR_DSTOP)) && 7127c478bd9Sstevel@tonic-gate !(flags & PGRAB_RDONLY)) { 7137c478bd9Sstevel@tonic-gate /* 7147c478bd9Sstevel@tonic-gate * Mark the process run-on-last-close so 7157c478bd9Sstevel@tonic-gate * it runs even if we die from SIGKILL. 7167c478bd9Sstevel@tonic-gate */ 7177c478bd9Sstevel@tonic-gate if (Psetflags(P, PR_RLC) != 0) { 7187c478bd9Sstevel@tonic-gate if (errno == EAGAIN) { /* WoV */ 7197c478bd9Sstevel@tonic-gate (void) mutex_destroy(&P->proc_lock); 7207c478bd9Sstevel@tonic-gate goto again; 7217c478bd9Sstevel@tonic-gate } 7227c478bd9Sstevel@tonic-gate if (errno == ENOENT) /* No complaint about zombies */ 7237c478bd9Sstevel@tonic-gate rc = G_ZOMB; 7247c478bd9Sstevel@tonic-gate else { 7257c478bd9Sstevel@tonic-gate dprintf("Pgrab: failed to set RLC\n"); 7267c478bd9Sstevel@tonic-gate rc = G_STRANGE; 7277c478bd9Sstevel@tonic-gate } 7287c478bd9Sstevel@tonic-gate goto err; 7297c478bd9Sstevel@tonic-gate } 7307c478bd9Sstevel@tonic-gate } 7317c478bd9Sstevel@tonic-gate 7327c478bd9Sstevel@tonic-gate /* 7337c478bd9Sstevel@tonic-gate * If a stop directive is pending and the process has not yet stopped, 7347c478bd9Sstevel@tonic-gate * then synchronously wait for the stop directive to take effect. 7357c478bd9Sstevel@tonic-gate * Limit the time spent waiting for the process to stop by iterating 7367c478bd9Sstevel@tonic-gate * at most 10 times. The time-out of 20 ms corresponds to the time 7377c478bd9Sstevel@tonic-gate * between sending the stop directive and the process actually stopped 7387c478bd9Sstevel@tonic-gate * as measured by DTrace on a slow, busy system. If the process doesn't 7397c478bd9Sstevel@tonic-gate * stop voluntarily, clear the PR_DSTOP flag so that the code below 7407c478bd9Sstevel@tonic-gate * forces the process to stop. 7417c478bd9Sstevel@tonic-gate */ 7427c478bd9Sstevel@tonic-gate if (!(flags & PGRAB_RDONLY)) { 7437c478bd9Sstevel@tonic-gate int niter = 0; 7447c478bd9Sstevel@tonic-gate while ((P->status.pr_lwp.pr_flags & (PR_STOPPED|PR_DSTOP)) == 7457c478bd9Sstevel@tonic-gate PR_DSTOP && niter < 10 && 7467c478bd9Sstevel@tonic-gate Pstopstatus(P, PCTWSTOP, 20) != 0) { 7477c478bd9Sstevel@tonic-gate niter++; 7487c478bd9Sstevel@tonic-gate if (flags & PGRAB_NOSTOP) 7497c478bd9Sstevel@tonic-gate break; 7507c478bd9Sstevel@tonic-gate } 7517c478bd9Sstevel@tonic-gate if (niter == 10 && !(flags & PGRAB_NOSTOP)) { 7527c478bd9Sstevel@tonic-gate /* Try it harder down below */ 7537c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_flags &= ~PR_DSTOP; 7547c478bd9Sstevel@tonic-gate } 7557c478bd9Sstevel@tonic-gate } 7567c478bd9Sstevel@tonic-gate 7577c478bd9Sstevel@tonic-gate /* 7587c478bd9Sstevel@tonic-gate * If the process is not already stopped or directed to stop 7597c478bd9Sstevel@tonic-gate * and PGRAB_NOSTOP was not specified, stop the process now. 7607c478bd9Sstevel@tonic-gate */ 7617c478bd9Sstevel@tonic-gate if (!(P->status.pr_lwp.pr_flags & (PR_ISTOP|PR_DSTOP)) && 7627c478bd9Sstevel@tonic-gate !(flags & PGRAB_NOSTOP)) { 7637c478bd9Sstevel@tonic-gate /* 7647c478bd9Sstevel@tonic-gate * Stop the process, get its status and signal/syscall masks. 7657c478bd9Sstevel@tonic-gate */ 7667c478bd9Sstevel@tonic-gate if (((P->status.pr_lwp.pr_flags & PR_STOPPED) && 7677c478bd9Sstevel@tonic-gate Pstopstatus(P, PCDSTOP, 0) != 0) || 7687c478bd9Sstevel@tonic-gate Pstopstatus(P, PCSTOP, 2000) != 0) { 7697c478bd9Sstevel@tonic-gate #ifndef _LP64 7707c478bd9Sstevel@tonic-gate if (errno == EOVERFLOW) { 7717c478bd9Sstevel@tonic-gate rc = G_LP64; 7727c478bd9Sstevel@tonic-gate goto err; 7737c478bd9Sstevel@tonic-gate } 7747c478bd9Sstevel@tonic-gate #endif 7757c478bd9Sstevel@tonic-gate if (P->state == PS_LOST) { /* WoV */ 7767c478bd9Sstevel@tonic-gate (void) mutex_destroy(&P->proc_lock); 7777c478bd9Sstevel@tonic-gate goto again; 7787c478bd9Sstevel@tonic-gate } 7797c478bd9Sstevel@tonic-gate if ((errno != EINTR && errno != ERESTART) || 7807c478bd9Sstevel@tonic-gate (P->state != PS_STOP && 7817c478bd9Sstevel@tonic-gate !(P->status.pr_flags & PR_DSTOP))) { 7827c478bd9Sstevel@tonic-gate if (P->state != PS_RUN && errno != ENOENT) { 7837c478bd9Sstevel@tonic-gate dprintf("Pgrab: failed to PCSTOP\n"); 7847c478bd9Sstevel@tonic-gate rc = G_STRANGE; 7857c478bd9Sstevel@tonic-gate } else { 7867c478bd9Sstevel@tonic-gate rc = G_ZOMB; 7877c478bd9Sstevel@tonic-gate } 7887c478bd9Sstevel@tonic-gate goto err; 7897c478bd9Sstevel@tonic-gate } 7907c478bd9Sstevel@tonic-gate } 7917c478bd9Sstevel@tonic-gate 7927c478bd9Sstevel@tonic-gate /* 7937c478bd9Sstevel@tonic-gate * Process should now either be stopped via /proc or there 7947c478bd9Sstevel@tonic-gate * should be an outstanding stop directive. 7957c478bd9Sstevel@tonic-gate */ 7967c478bd9Sstevel@tonic-gate if (!(P->status.pr_flags & (PR_ISTOP|PR_DSTOP))) { 7977c478bd9Sstevel@tonic-gate dprintf("Pgrab: process is not stopped\n"); 7987c478bd9Sstevel@tonic-gate rc = G_STRANGE; 7997c478bd9Sstevel@tonic-gate goto err; 8007c478bd9Sstevel@tonic-gate } 8017c478bd9Sstevel@tonic-gate #ifndef _LP64 8027c478bd9Sstevel@tonic-gate /* 8037c478bd9Sstevel@tonic-gate * Test this again now because the 32-bit victim process may 8047c478bd9Sstevel@tonic-gate * have exec'd a 64-bit process in the meantime. 8057c478bd9Sstevel@tonic-gate */ 8067c478bd9Sstevel@tonic-gate if (P->status.pr_dmodel == PR_MODEL_LP64) { 8077c478bd9Sstevel@tonic-gate rc = G_LP64; 8087c478bd9Sstevel@tonic-gate goto err; 8097c478bd9Sstevel@tonic-gate } 8107c478bd9Sstevel@tonic-gate #endif 8117c478bd9Sstevel@tonic-gate } 8127c478bd9Sstevel@tonic-gate 8137c478bd9Sstevel@tonic-gate /* 8147c478bd9Sstevel@tonic-gate * Cancel all tracing flags unless the PGRAB_RETAIN flag is set. 8157c478bd9Sstevel@tonic-gate */ 8167c478bd9Sstevel@tonic-gate if (!(flags & PGRAB_RETAIN)) { 8177c478bd9Sstevel@tonic-gate (void) Psysentry(P, 0, FALSE); 8187c478bd9Sstevel@tonic-gate (void) Psysexit(P, 0, FALSE); 8197c478bd9Sstevel@tonic-gate (void) Psignal(P, 0, FALSE); 8207c478bd9Sstevel@tonic-gate (void) Pfault(P, 0, FALSE); 8217c478bd9Sstevel@tonic-gate Psync(P); 8227c478bd9Sstevel@tonic-gate } 8237c478bd9Sstevel@tonic-gate 8247c478bd9Sstevel@tonic-gate *perr = 0; 8257c478bd9Sstevel@tonic-gate return (P); 8267c478bd9Sstevel@tonic-gate 8277c478bd9Sstevel@tonic-gate err: 8287c478bd9Sstevel@tonic-gate Pfree(P); 8297c478bd9Sstevel@tonic-gate *perr = rc; 8307c478bd9Sstevel@tonic-gate return (NULL); 8317c478bd9Sstevel@tonic-gate } 8327c478bd9Sstevel@tonic-gate 8337c478bd9Sstevel@tonic-gate /* 8347c478bd9Sstevel@tonic-gate * Return a printable string corresponding to a Pgrab() error return. 8357c478bd9Sstevel@tonic-gate */ 8367c478bd9Sstevel@tonic-gate const char * 8377c478bd9Sstevel@tonic-gate Pgrab_error(int error) 8387c478bd9Sstevel@tonic-gate { 8397c478bd9Sstevel@tonic-gate const char *str; 8407c478bd9Sstevel@tonic-gate 8417c478bd9Sstevel@tonic-gate switch (error) { 8427c478bd9Sstevel@tonic-gate case G_NOPROC: 8437c478bd9Sstevel@tonic-gate str = "no such process"; 8447c478bd9Sstevel@tonic-gate break; 8457c478bd9Sstevel@tonic-gate case G_NOCORE: 8467c478bd9Sstevel@tonic-gate str = "no such core file"; 8477c478bd9Sstevel@tonic-gate break; 8487c478bd9Sstevel@tonic-gate case G_NOPROCORCORE: 8497c478bd9Sstevel@tonic-gate str = "no such process or core file"; 8507c478bd9Sstevel@tonic-gate break; 8517c478bd9Sstevel@tonic-gate case G_NOEXEC: 8527c478bd9Sstevel@tonic-gate str = "cannot find executable file"; 8537c478bd9Sstevel@tonic-gate break; 8547c478bd9Sstevel@tonic-gate case G_ZOMB: 8557c478bd9Sstevel@tonic-gate str = "zombie process"; 8567c478bd9Sstevel@tonic-gate break; 8577c478bd9Sstevel@tonic-gate case G_PERM: 8587c478bd9Sstevel@tonic-gate str = "permission denied"; 8597c478bd9Sstevel@tonic-gate break; 8607c478bd9Sstevel@tonic-gate case G_BUSY: 8617c478bd9Sstevel@tonic-gate str = "process is traced"; 8627c478bd9Sstevel@tonic-gate break; 8637c478bd9Sstevel@tonic-gate case G_SYS: 8647c478bd9Sstevel@tonic-gate str = "system process"; 8657c478bd9Sstevel@tonic-gate break; 8667c478bd9Sstevel@tonic-gate case G_SELF: 8677c478bd9Sstevel@tonic-gate str = "attempt to grab self"; 8687c478bd9Sstevel@tonic-gate break; 8697c478bd9Sstevel@tonic-gate case G_INTR: 8707c478bd9Sstevel@tonic-gate str = "operation interrupted"; 8717c478bd9Sstevel@tonic-gate break; 8727c478bd9Sstevel@tonic-gate case G_LP64: 8737c478bd9Sstevel@tonic-gate str = "program is _LP64, self is not"; 8747c478bd9Sstevel@tonic-gate break; 8757c478bd9Sstevel@tonic-gate case G_FORMAT: 8767c478bd9Sstevel@tonic-gate str = "file is not an ELF core file"; 8777c478bd9Sstevel@tonic-gate break; 8787c478bd9Sstevel@tonic-gate case G_ELF: 8797c478bd9Sstevel@tonic-gate str = "libelf error"; 8807c478bd9Sstevel@tonic-gate break; 8817c478bd9Sstevel@tonic-gate case G_NOTE: 8827c478bd9Sstevel@tonic-gate str = "core file is corrupt or missing required data"; 8837c478bd9Sstevel@tonic-gate break; 8847c478bd9Sstevel@tonic-gate case G_STRANGE: 8857c478bd9Sstevel@tonic-gate str = "unanticipated system error"; 8867c478bd9Sstevel@tonic-gate break; 8877c478bd9Sstevel@tonic-gate case G_ISAINVAL: 8887c478bd9Sstevel@tonic-gate str = "wrong ELF machine type"; 8897c478bd9Sstevel@tonic-gate break; 8907c478bd9Sstevel@tonic-gate case G_BADLWPS: 8917c478bd9Sstevel@tonic-gate str = "bad lwp specification"; 8927c478bd9Sstevel@tonic-gate break; 8937c478bd9Sstevel@tonic-gate default: 8947c478bd9Sstevel@tonic-gate str = "unknown error"; 8957c478bd9Sstevel@tonic-gate break; 8967c478bd9Sstevel@tonic-gate } 8977c478bd9Sstevel@tonic-gate 8987c478bd9Sstevel@tonic-gate return (str); 8997c478bd9Sstevel@tonic-gate } 9007c478bd9Sstevel@tonic-gate 9017c478bd9Sstevel@tonic-gate /* 9027c478bd9Sstevel@tonic-gate * Free a process control structure. 9037c478bd9Sstevel@tonic-gate * Close the file descriptors but don't do the Prelease logic. 9047c478bd9Sstevel@tonic-gate */ 9057c478bd9Sstevel@tonic-gate void 9067c478bd9Sstevel@tonic-gate Pfree(struct ps_prochandle *P) 9077c478bd9Sstevel@tonic-gate { 9087c478bd9Sstevel@tonic-gate uint_t i; 9097c478bd9Sstevel@tonic-gate 9107c478bd9Sstevel@tonic-gate if (P->core != NULL) { 9117c478bd9Sstevel@tonic-gate extern void __priv_free_info(void *); 9127c478bd9Sstevel@tonic-gate lwp_info_t *nlwp, *lwp = list_next(&P->core->core_lwp_head); 9137c478bd9Sstevel@tonic-gate 9147c478bd9Sstevel@tonic-gate for (i = 0; i < P->core->core_nlwp; i++, lwp = nlwp) { 9157c478bd9Sstevel@tonic-gate nlwp = list_next(lwp); 9167c478bd9Sstevel@tonic-gate #ifdef __sparc 9177c478bd9Sstevel@tonic-gate if (lwp->lwp_gwins != NULL) 9187c478bd9Sstevel@tonic-gate free(lwp->lwp_gwins); 9197c478bd9Sstevel@tonic-gate if (lwp->lwp_xregs != NULL) 9207c478bd9Sstevel@tonic-gate free(lwp->lwp_xregs); 9217c478bd9Sstevel@tonic-gate if (lwp->lwp_asrs != NULL) 9227c478bd9Sstevel@tonic-gate free(lwp->lwp_asrs); 9237c478bd9Sstevel@tonic-gate #endif 9247c478bd9Sstevel@tonic-gate free(lwp); 9257c478bd9Sstevel@tonic-gate } 9267c478bd9Sstevel@tonic-gate 9277c478bd9Sstevel@tonic-gate if (P->core->core_platform != NULL) 9287c478bd9Sstevel@tonic-gate free(P->core->core_platform); 9297c478bd9Sstevel@tonic-gate if (P->core->core_uts != NULL) 9307c478bd9Sstevel@tonic-gate free(P->core->core_uts); 9317c478bd9Sstevel@tonic-gate if (P->core->core_cred != NULL) 9327c478bd9Sstevel@tonic-gate free(P->core->core_cred); 9337c478bd9Sstevel@tonic-gate if (P->core->core_priv != NULL) 9347c478bd9Sstevel@tonic-gate free(P->core->core_priv); 9357c478bd9Sstevel@tonic-gate if (P->core->core_privinfo != NULL) 9367c478bd9Sstevel@tonic-gate __priv_free_info(P->core->core_privinfo); 9377c478bd9Sstevel@tonic-gate if (P->core->core_ppii != NULL) 9387c478bd9Sstevel@tonic-gate free(P->core->core_ppii); 9397c478bd9Sstevel@tonic-gate if (P->core->core_zonename != NULL) 9407c478bd9Sstevel@tonic-gate free(P->core->core_zonename); 9417c478bd9Sstevel@tonic-gate #if defined(__i386) || defined(__amd64) 9427c478bd9Sstevel@tonic-gate if (P->core->core_ldt != NULL) 9437c478bd9Sstevel@tonic-gate free(P->core->core_ldt); 9447c478bd9Sstevel@tonic-gate #endif 9457c478bd9Sstevel@tonic-gate 9467c478bd9Sstevel@tonic-gate free(P->core); 9477c478bd9Sstevel@tonic-gate } 9487c478bd9Sstevel@tonic-gate 9497c478bd9Sstevel@tonic-gate if (P->ucaddrs != NULL) { 9507c478bd9Sstevel@tonic-gate free(P->ucaddrs); 9517c478bd9Sstevel@tonic-gate P->ucaddrs = NULL; 9527c478bd9Sstevel@tonic-gate P->ucnelems = 0; 9537c478bd9Sstevel@tonic-gate } 9547c478bd9Sstevel@tonic-gate 9557c478bd9Sstevel@tonic-gate (void) mutex_lock(&P->proc_lock); 9567c478bd9Sstevel@tonic-gate if (P->hashtab != NULL) { 9577c478bd9Sstevel@tonic-gate struct ps_lwphandle *L; 9587c478bd9Sstevel@tonic-gate for (i = 0; i < HASHSIZE; i++) { 9597c478bd9Sstevel@tonic-gate while ((L = P->hashtab[i]) != NULL) 9607c478bd9Sstevel@tonic-gate Lfree_internal(P, L); 9617c478bd9Sstevel@tonic-gate } 9627c478bd9Sstevel@tonic-gate free(P->hashtab); 9637c478bd9Sstevel@tonic-gate } 9647c478bd9Sstevel@tonic-gate (void) mutex_unlock(&P->proc_lock); 9657c478bd9Sstevel@tonic-gate (void) mutex_destroy(&P->proc_lock); 9667c478bd9Sstevel@tonic-gate 9677c478bd9Sstevel@tonic-gate if (P->agentctlfd >= 0) 9687c478bd9Sstevel@tonic-gate (void) close(P->agentctlfd); 9697c478bd9Sstevel@tonic-gate if (P->agentstatfd >= 0) 9707c478bd9Sstevel@tonic-gate (void) close(P->agentstatfd); 9717c478bd9Sstevel@tonic-gate if (P->ctlfd >= 0) 9727c478bd9Sstevel@tonic-gate (void) close(P->ctlfd); 9737c478bd9Sstevel@tonic-gate if (P->asfd >= 0) 9747c478bd9Sstevel@tonic-gate (void) close(P->asfd); 9757c478bd9Sstevel@tonic-gate if (P->statfd >= 0) 9767c478bd9Sstevel@tonic-gate (void) close(P->statfd); 9777c478bd9Sstevel@tonic-gate Preset_maps(P); 9787c478bd9Sstevel@tonic-gate 9797c478bd9Sstevel@tonic-gate /* clear out the structure as a precaution against reuse */ 9807c478bd9Sstevel@tonic-gate (void) memset(P, 0, sizeof (*P)); 9817c478bd9Sstevel@tonic-gate P->ctlfd = -1; 9827c478bd9Sstevel@tonic-gate P->asfd = -1; 9837c478bd9Sstevel@tonic-gate P->statfd = -1; 9847c478bd9Sstevel@tonic-gate P->agentctlfd = -1; 9857c478bd9Sstevel@tonic-gate P->agentstatfd = -1; 9867c478bd9Sstevel@tonic-gate 9877c478bd9Sstevel@tonic-gate free(P); 9887c478bd9Sstevel@tonic-gate } 9897c478bd9Sstevel@tonic-gate 9907c478bd9Sstevel@tonic-gate /* 9917c478bd9Sstevel@tonic-gate * Return the state of the process, one of the PS_* values. 9927c478bd9Sstevel@tonic-gate */ 9937c478bd9Sstevel@tonic-gate int 9947c478bd9Sstevel@tonic-gate Pstate(struct ps_prochandle *P) 9957c478bd9Sstevel@tonic-gate { 9967c478bd9Sstevel@tonic-gate return (P->state); 9977c478bd9Sstevel@tonic-gate } 9987c478bd9Sstevel@tonic-gate 9997c478bd9Sstevel@tonic-gate /* 10007c478bd9Sstevel@tonic-gate * Return the open address space file descriptor for the process. 10017c478bd9Sstevel@tonic-gate * Clients must not close this file descriptor, not use it 10027c478bd9Sstevel@tonic-gate * after the process is freed. 10037c478bd9Sstevel@tonic-gate */ 10047c478bd9Sstevel@tonic-gate int 10057c478bd9Sstevel@tonic-gate Pasfd(struct ps_prochandle *P) 10067c478bd9Sstevel@tonic-gate { 10077c478bd9Sstevel@tonic-gate return (P->asfd); 10087c478bd9Sstevel@tonic-gate } 10097c478bd9Sstevel@tonic-gate 10107c478bd9Sstevel@tonic-gate /* 10117c478bd9Sstevel@tonic-gate * Return the open control file descriptor for the process. 10127c478bd9Sstevel@tonic-gate * Clients must not close this file descriptor, not use it 10137c478bd9Sstevel@tonic-gate * after the process is freed. 10147c478bd9Sstevel@tonic-gate */ 10157c478bd9Sstevel@tonic-gate int 10167c478bd9Sstevel@tonic-gate Pctlfd(struct ps_prochandle *P) 10177c478bd9Sstevel@tonic-gate { 10187c478bd9Sstevel@tonic-gate return (P->ctlfd); 10197c478bd9Sstevel@tonic-gate } 10207c478bd9Sstevel@tonic-gate 10217c478bd9Sstevel@tonic-gate /* 10227c478bd9Sstevel@tonic-gate * Return a pointer to the process psinfo structure. 10237c478bd9Sstevel@tonic-gate * Clients should not hold on to this pointer indefinitely. 10247c478bd9Sstevel@tonic-gate * It will become invalid on Prelease(). 10257c478bd9Sstevel@tonic-gate */ 10267c478bd9Sstevel@tonic-gate const psinfo_t * 10277c478bd9Sstevel@tonic-gate Ppsinfo(struct ps_prochandle *P) 10287c478bd9Sstevel@tonic-gate { 10297c478bd9Sstevel@tonic-gate if (P->state == PS_IDLE) { 10307c478bd9Sstevel@tonic-gate errno = ENODATA; 10317c478bd9Sstevel@tonic-gate return (NULL); 10327c478bd9Sstevel@tonic-gate } 10337c478bd9Sstevel@tonic-gate 10347c478bd9Sstevel@tonic-gate if (P->state != PS_DEAD && proc_get_psinfo(P->pid, &P->psinfo) == -1) 10357c478bd9Sstevel@tonic-gate return (NULL); 10367c478bd9Sstevel@tonic-gate 10377c478bd9Sstevel@tonic-gate return (&P->psinfo); 10387c478bd9Sstevel@tonic-gate } 10397c478bd9Sstevel@tonic-gate 10407c478bd9Sstevel@tonic-gate /* 10417c478bd9Sstevel@tonic-gate * Return a pointer to the process status structure. 10427c478bd9Sstevel@tonic-gate * Clients should not hold on to this pointer indefinitely. 10437c478bd9Sstevel@tonic-gate * It will become invalid on Prelease(). 10447c478bd9Sstevel@tonic-gate */ 10457c478bd9Sstevel@tonic-gate const pstatus_t * 10467c478bd9Sstevel@tonic-gate Pstatus(struct ps_prochandle *P) 10477c478bd9Sstevel@tonic-gate { 10487c478bd9Sstevel@tonic-gate return (&P->status); 10497c478bd9Sstevel@tonic-gate } 10507c478bd9Sstevel@tonic-gate 10517c478bd9Sstevel@tonic-gate /* 10527c478bd9Sstevel@tonic-gate * Fill in a pointer to a process credentials structure. The ngroups parameter 10537c478bd9Sstevel@tonic-gate * is the number of supplementary group entries allocated in the caller's cred 10547c478bd9Sstevel@tonic-gate * structure. It should equal zero or one unless extra space has been 10557c478bd9Sstevel@tonic-gate * allocated for the group list by the caller. 10567c478bd9Sstevel@tonic-gate */ 10577c478bd9Sstevel@tonic-gate int 10587c478bd9Sstevel@tonic-gate Pcred(struct ps_prochandle *P, prcred_t *pcrp, int ngroups) 10597c478bd9Sstevel@tonic-gate { 10607c478bd9Sstevel@tonic-gate if (P->state == PS_IDLE) { 10617c478bd9Sstevel@tonic-gate errno = ENODATA; 10627c478bd9Sstevel@tonic-gate return (-1); 10637c478bd9Sstevel@tonic-gate } 10647c478bd9Sstevel@tonic-gate 10657c478bd9Sstevel@tonic-gate if (P->state != PS_DEAD) 10667c478bd9Sstevel@tonic-gate return (proc_get_cred(P->pid, pcrp, ngroups)); 10677c478bd9Sstevel@tonic-gate 10687c478bd9Sstevel@tonic-gate if (P->core->core_cred != NULL) { 10697c478bd9Sstevel@tonic-gate /* 10707c478bd9Sstevel@tonic-gate * Avoid returning more supplementary group data than the 10717c478bd9Sstevel@tonic-gate * caller has allocated in their buffer. We expect them to 10727c478bd9Sstevel@tonic-gate * check pr_ngroups afterward and potentially call us again. 10737c478bd9Sstevel@tonic-gate */ 10747c478bd9Sstevel@tonic-gate ngroups = MIN(ngroups, P->core->core_cred->pr_ngroups); 10757c478bd9Sstevel@tonic-gate 10767c478bd9Sstevel@tonic-gate (void) memcpy(pcrp, P->core->core_cred, 10777c478bd9Sstevel@tonic-gate sizeof (prcred_t) + (ngroups - 1) * sizeof (gid_t)); 10787c478bd9Sstevel@tonic-gate 10797c478bd9Sstevel@tonic-gate return (0); 10807c478bd9Sstevel@tonic-gate } 10817c478bd9Sstevel@tonic-gate 10827c478bd9Sstevel@tonic-gate errno = ENODATA; 10837c478bd9Sstevel@tonic-gate return (-1); 10847c478bd9Sstevel@tonic-gate } 10857c478bd9Sstevel@tonic-gate 10867c478bd9Sstevel@tonic-gate #if defined(__i386) || defined(__amd64) 10877c478bd9Sstevel@tonic-gate /* 10887c478bd9Sstevel@tonic-gate * Fill in a pointer to a process LDT structure. 10897c478bd9Sstevel@tonic-gate * The caller provides a buffer of size 'nldt * sizeof (struct ssd)'; 10907c478bd9Sstevel@tonic-gate * If pldt == NULL or nldt == 0, we return the number of existing LDT entries. 10917c478bd9Sstevel@tonic-gate * Otherwise we return the actual number of LDT entries fetched (<= nldt). 10927c478bd9Sstevel@tonic-gate */ 10937c478bd9Sstevel@tonic-gate int 10947c478bd9Sstevel@tonic-gate Pldt(struct ps_prochandle *P, struct ssd *pldt, int nldt) 10957c478bd9Sstevel@tonic-gate { 10967c478bd9Sstevel@tonic-gate if (P->state == PS_IDLE) { 10977c478bd9Sstevel@tonic-gate errno = ENODATA; 10987c478bd9Sstevel@tonic-gate return (-1); 10997c478bd9Sstevel@tonic-gate } 11007c478bd9Sstevel@tonic-gate 11017c478bd9Sstevel@tonic-gate if (P->state != PS_DEAD) 11027c478bd9Sstevel@tonic-gate return (proc_get_ldt(P->pid, pldt, nldt)); 11037c478bd9Sstevel@tonic-gate 11047c478bd9Sstevel@tonic-gate if (pldt == NULL || nldt == 0) 11057c478bd9Sstevel@tonic-gate return (P->core->core_nldt); 11067c478bd9Sstevel@tonic-gate 11077c478bd9Sstevel@tonic-gate if (P->core->core_ldt != NULL) { 11087c478bd9Sstevel@tonic-gate nldt = MIN(nldt, P->core->core_nldt); 11097c478bd9Sstevel@tonic-gate 11107c478bd9Sstevel@tonic-gate (void) memcpy(pldt, P->core->core_ldt, 11117c478bd9Sstevel@tonic-gate nldt * sizeof (struct ssd)); 11127c478bd9Sstevel@tonic-gate 11137c478bd9Sstevel@tonic-gate return (nldt); 11147c478bd9Sstevel@tonic-gate } 11157c478bd9Sstevel@tonic-gate 11167c478bd9Sstevel@tonic-gate errno = ENODATA; 11177c478bd9Sstevel@tonic-gate return (-1); 11187c478bd9Sstevel@tonic-gate } 11197c478bd9Sstevel@tonic-gate #endif /* __i386 */ 11207c478bd9Sstevel@tonic-gate 11217c478bd9Sstevel@tonic-gate /* 11227c478bd9Sstevel@tonic-gate * Fill in a pointer to a process privilege structure. 11237c478bd9Sstevel@tonic-gate */ 11247c478bd9Sstevel@tonic-gate ssize_t 11257c478bd9Sstevel@tonic-gate Ppriv(struct ps_prochandle *P, prpriv_t *pprv, size_t size) 11267c478bd9Sstevel@tonic-gate { 11277c478bd9Sstevel@tonic-gate if (P->state != PS_DEAD) { 11287c478bd9Sstevel@tonic-gate prpriv_t *pp = proc_get_priv(P->pid); 11297c478bd9Sstevel@tonic-gate if (pp != NULL) { 11307c478bd9Sstevel@tonic-gate size = MIN(size, PRIV_PRPRIV_SIZE(pp)); 11317c478bd9Sstevel@tonic-gate (void) memcpy(pprv, pp, size); 11327c478bd9Sstevel@tonic-gate free(pp); 11337c478bd9Sstevel@tonic-gate return (size); 11347c478bd9Sstevel@tonic-gate } 11357c478bd9Sstevel@tonic-gate return (-1); 11367c478bd9Sstevel@tonic-gate } 11377c478bd9Sstevel@tonic-gate 11387c478bd9Sstevel@tonic-gate if (P->core->core_priv != NULL) { 11397c478bd9Sstevel@tonic-gate size = MIN(P->core->core_priv_size, size); 11407c478bd9Sstevel@tonic-gate (void) memcpy(pprv, P->core->core_priv, size); 11417c478bd9Sstevel@tonic-gate return (size); 11427c478bd9Sstevel@tonic-gate } 11437c478bd9Sstevel@tonic-gate errno = ENODATA; 11447c478bd9Sstevel@tonic-gate return (-1); 11457c478bd9Sstevel@tonic-gate } 11467c478bd9Sstevel@tonic-gate 11477c478bd9Sstevel@tonic-gate int 11487c478bd9Sstevel@tonic-gate Psetpriv(struct ps_prochandle *P, prpriv_t *pprv) 11497c478bd9Sstevel@tonic-gate { 11507c478bd9Sstevel@tonic-gate int rc; 11517c478bd9Sstevel@tonic-gate long *ctl; 11527c478bd9Sstevel@tonic-gate size_t sz; 11537c478bd9Sstevel@tonic-gate 11547c478bd9Sstevel@tonic-gate if (P->state == PS_DEAD) { 11557c478bd9Sstevel@tonic-gate errno = EBADF; 11567c478bd9Sstevel@tonic-gate return (-1); 11577c478bd9Sstevel@tonic-gate } 11587c478bd9Sstevel@tonic-gate 11597c478bd9Sstevel@tonic-gate sz = PRIV_PRPRIV_SIZE(pprv) + sizeof (long); 11607c478bd9Sstevel@tonic-gate 11617c478bd9Sstevel@tonic-gate sz = ((sz - 1) / sizeof (long) + 1) * sizeof (long); 11627c478bd9Sstevel@tonic-gate 11637c478bd9Sstevel@tonic-gate ctl = malloc(sz); 11647c478bd9Sstevel@tonic-gate if (ctl == NULL) 11657c478bd9Sstevel@tonic-gate return (-1); 11667c478bd9Sstevel@tonic-gate 11677c478bd9Sstevel@tonic-gate ctl[0] = PCSPRIV; 11687c478bd9Sstevel@tonic-gate 11697c478bd9Sstevel@tonic-gate (void) memcpy(&ctl[1], pprv, PRIV_PRPRIV_SIZE(pprv)); 11707c478bd9Sstevel@tonic-gate 11717c478bd9Sstevel@tonic-gate if (write(P->ctlfd, ctl, sz) != sz) 11727c478bd9Sstevel@tonic-gate rc = -1; 11737c478bd9Sstevel@tonic-gate else 11747c478bd9Sstevel@tonic-gate rc = 0; 11757c478bd9Sstevel@tonic-gate 11767c478bd9Sstevel@tonic-gate free(ctl); 11777c478bd9Sstevel@tonic-gate 11787c478bd9Sstevel@tonic-gate return (rc); 11797c478bd9Sstevel@tonic-gate } 11807c478bd9Sstevel@tonic-gate 11817c478bd9Sstevel@tonic-gate void * 11827c478bd9Sstevel@tonic-gate Pprivinfo(struct ps_prochandle *P) 11837c478bd9Sstevel@tonic-gate { 11847c478bd9Sstevel@tonic-gate /* Use default from libc */ 11857c478bd9Sstevel@tonic-gate if (P->state != PS_DEAD) 11867c478bd9Sstevel@tonic-gate return (NULL); 11877c478bd9Sstevel@tonic-gate 11887c478bd9Sstevel@tonic-gate return (P->core->core_privinfo); 11897c478bd9Sstevel@tonic-gate } 11907c478bd9Sstevel@tonic-gate 11917c478bd9Sstevel@tonic-gate /* 11927c478bd9Sstevel@tonic-gate * Ensure that all cached state is written to the process. 11937c478bd9Sstevel@tonic-gate * The cached state is the LWP's signal mask and registers 11947c478bd9Sstevel@tonic-gate * and the process's tracing flags. 11957c478bd9Sstevel@tonic-gate */ 11967c478bd9Sstevel@tonic-gate void 11977c478bd9Sstevel@tonic-gate Psync(struct ps_prochandle *P) 11987c478bd9Sstevel@tonic-gate { 11997c478bd9Sstevel@tonic-gate int ctlfd = (P->agentctlfd >= 0)? P->agentctlfd : P->ctlfd; 12007c478bd9Sstevel@tonic-gate long cmd[6]; 12017c478bd9Sstevel@tonic-gate iovec_t iov[12]; 12027c478bd9Sstevel@tonic-gate int n = 0; 12037c478bd9Sstevel@tonic-gate 12047c478bd9Sstevel@tonic-gate if (P->flags & SETHOLD) { 12057c478bd9Sstevel@tonic-gate cmd[0] = PCSHOLD; 12067c478bd9Sstevel@tonic-gate iov[n].iov_base = (caddr_t)&cmd[0]; 12077c478bd9Sstevel@tonic-gate iov[n++].iov_len = sizeof (long); 12087c478bd9Sstevel@tonic-gate iov[n].iov_base = (caddr_t)&P->status.pr_lwp.pr_lwphold; 12097c478bd9Sstevel@tonic-gate iov[n++].iov_len = sizeof (P->status.pr_lwp.pr_lwphold); 12107c478bd9Sstevel@tonic-gate } 12117c478bd9Sstevel@tonic-gate if (P->flags & SETREGS) { 12127c478bd9Sstevel@tonic-gate cmd[1] = PCSREG; 12137c478bd9Sstevel@tonic-gate #ifdef __i386 12147c478bd9Sstevel@tonic-gate /* XX64 we should probably restore REG_GS after this */ 12157c478bd9Sstevel@tonic-gate if (ctlfd == P->agentctlfd) 12167c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_reg[GS] = 0; 12177c478bd9Sstevel@tonic-gate #elif defined(__amd64) 12187c478bd9Sstevel@tonic-gate /* XX64 */ 12197c478bd9Sstevel@tonic-gate #endif 12207c478bd9Sstevel@tonic-gate iov[n].iov_base = (caddr_t)&cmd[1]; 12217c478bd9Sstevel@tonic-gate iov[n++].iov_len = sizeof (long); 12227c478bd9Sstevel@tonic-gate iov[n].iov_base = (caddr_t)&P->status.pr_lwp.pr_reg[0]; 12237c478bd9Sstevel@tonic-gate iov[n++].iov_len = sizeof (P->status.pr_lwp.pr_reg); 12247c478bd9Sstevel@tonic-gate } 12257c478bd9Sstevel@tonic-gate if (P->flags & SETSIG) { 12267c478bd9Sstevel@tonic-gate cmd[2] = PCSTRACE; 12277c478bd9Sstevel@tonic-gate iov[n].iov_base = (caddr_t)&cmd[2]; 12287c478bd9Sstevel@tonic-gate iov[n++].iov_len = sizeof (long); 12297c478bd9Sstevel@tonic-gate iov[n].iov_base = (caddr_t)&P->status.pr_sigtrace; 12307c478bd9Sstevel@tonic-gate iov[n++].iov_len = sizeof (P->status.pr_sigtrace); 12317c478bd9Sstevel@tonic-gate } 12327c478bd9Sstevel@tonic-gate if (P->flags & SETFAULT) { 12337c478bd9Sstevel@tonic-gate cmd[3] = PCSFAULT; 12347c478bd9Sstevel@tonic-gate iov[n].iov_base = (caddr_t)&cmd[3]; 12357c478bd9Sstevel@tonic-gate iov[n++].iov_len = sizeof (long); 12367c478bd9Sstevel@tonic-gate iov[n].iov_base = (caddr_t)&P->status.pr_flttrace; 12377c478bd9Sstevel@tonic-gate iov[n++].iov_len = sizeof (P->status.pr_flttrace); 12387c478bd9Sstevel@tonic-gate } 12397c478bd9Sstevel@tonic-gate if (P->flags & SETENTRY) { 12407c478bd9Sstevel@tonic-gate cmd[4] = PCSENTRY; 12417c478bd9Sstevel@tonic-gate iov[n].iov_base = (caddr_t)&cmd[4]; 12427c478bd9Sstevel@tonic-gate iov[n++].iov_len = sizeof (long); 12437c478bd9Sstevel@tonic-gate iov[n].iov_base = (caddr_t)&P->status.pr_sysentry; 12447c478bd9Sstevel@tonic-gate iov[n++].iov_len = sizeof (P->status.pr_sysentry); 12457c478bd9Sstevel@tonic-gate } 12467c478bd9Sstevel@tonic-gate if (P->flags & SETEXIT) { 12477c478bd9Sstevel@tonic-gate cmd[5] = PCSEXIT; 12487c478bd9Sstevel@tonic-gate iov[n].iov_base = (caddr_t)&cmd[5]; 12497c478bd9Sstevel@tonic-gate iov[n++].iov_len = sizeof (long); 12507c478bd9Sstevel@tonic-gate iov[n].iov_base = (caddr_t)&P->status.pr_sysexit; 12517c478bd9Sstevel@tonic-gate iov[n++].iov_len = sizeof (P->status.pr_sysexit); 12527c478bd9Sstevel@tonic-gate } 12537c478bd9Sstevel@tonic-gate 12547c478bd9Sstevel@tonic-gate if (n == 0 || writev(ctlfd, iov, n) < 0) 12557c478bd9Sstevel@tonic-gate return; /* nothing to do or write failed */ 12567c478bd9Sstevel@tonic-gate 12577c478bd9Sstevel@tonic-gate P->flags &= ~(SETSIG|SETFAULT|SETENTRY|SETEXIT|SETHOLD|SETREGS); 12587c478bd9Sstevel@tonic-gate } 12597c478bd9Sstevel@tonic-gate 12607c478bd9Sstevel@tonic-gate /* 12617c478bd9Sstevel@tonic-gate * Reopen the /proc file (after PS_LOST). 12627c478bd9Sstevel@tonic-gate */ 12637c478bd9Sstevel@tonic-gate int 12647c478bd9Sstevel@tonic-gate Preopen(struct ps_prochandle *P) 12657c478bd9Sstevel@tonic-gate { 12667c478bd9Sstevel@tonic-gate int fd; 12677c478bd9Sstevel@tonic-gate char procname[100]; 12687c478bd9Sstevel@tonic-gate char *fname; 12697c478bd9Sstevel@tonic-gate 12707c478bd9Sstevel@tonic-gate if (P->state == PS_DEAD || P->state == PS_IDLE) 12717c478bd9Sstevel@tonic-gate return (0); 12727c478bd9Sstevel@tonic-gate 12737c478bd9Sstevel@tonic-gate if (P->agentcnt > 0) { 12747c478bd9Sstevel@tonic-gate P->agentcnt = 1; 12757c478bd9Sstevel@tonic-gate Pdestroy_agent(P); 12767c478bd9Sstevel@tonic-gate } 12777c478bd9Sstevel@tonic-gate 12787c478bd9Sstevel@tonic-gate (void) sprintf(procname, "/proc/%d/", (int)P->pid); 12797c478bd9Sstevel@tonic-gate fname = procname + strlen(procname); 12807c478bd9Sstevel@tonic-gate 12817c478bd9Sstevel@tonic-gate (void) strcpy(fname, "as"); 12827c478bd9Sstevel@tonic-gate if ((fd = open(procname, O_RDWR)) < 0 || 12837c478bd9Sstevel@tonic-gate close(P->asfd) < 0 || 12847c478bd9Sstevel@tonic-gate (fd = dupfd(fd, P->asfd)) != P->asfd) { 12857c478bd9Sstevel@tonic-gate dprintf("Preopen: failed to open %s: %s\n", 12867c478bd9Sstevel@tonic-gate procname, strerror(errno)); 12877c478bd9Sstevel@tonic-gate if (fd >= 0) 12887c478bd9Sstevel@tonic-gate (void) close(fd); 12897c478bd9Sstevel@tonic-gate return (-1); 12907c478bd9Sstevel@tonic-gate } 12917c478bd9Sstevel@tonic-gate P->asfd = fd; 12927c478bd9Sstevel@tonic-gate 12937c478bd9Sstevel@tonic-gate (void) strcpy(fname, "status"); 12947c478bd9Sstevel@tonic-gate if ((fd = open(procname, O_RDONLY)) < 0 || 12957c478bd9Sstevel@tonic-gate close(P->statfd) < 0 || 12967c478bd9Sstevel@tonic-gate (fd = dupfd(fd, P->statfd)) != P->statfd) { 12977c478bd9Sstevel@tonic-gate dprintf("Preopen: failed to open %s: %s\n", 12987c478bd9Sstevel@tonic-gate procname, strerror(errno)); 12997c478bd9Sstevel@tonic-gate if (fd >= 0) 13007c478bd9Sstevel@tonic-gate (void) close(fd); 13017c478bd9Sstevel@tonic-gate return (-1); 13027c478bd9Sstevel@tonic-gate } 13037c478bd9Sstevel@tonic-gate P->statfd = fd; 13047c478bd9Sstevel@tonic-gate 13057c478bd9Sstevel@tonic-gate (void) strcpy(fname, "ctl"); 13067c478bd9Sstevel@tonic-gate if ((fd = open(procname, O_WRONLY)) < 0 || 13077c478bd9Sstevel@tonic-gate close(P->ctlfd) < 0 || 13087c478bd9Sstevel@tonic-gate (fd = dupfd(fd, P->ctlfd)) != P->ctlfd) { 13097c478bd9Sstevel@tonic-gate dprintf("Preopen: failed to open %s: %s\n", 13107c478bd9Sstevel@tonic-gate procname, strerror(errno)); 13117c478bd9Sstevel@tonic-gate if (fd >= 0) 13127c478bd9Sstevel@tonic-gate (void) close(fd); 13137c478bd9Sstevel@tonic-gate return (-1); 13147c478bd9Sstevel@tonic-gate } 13157c478bd9Sstevel@tonic-gate P->ctlfd = fd; 13167c478bd9Sstevel@tonic-gate 13177c478bd9Sstevel@tonic-gate /* 13187c478bd9Sstevel@tonic-gate * Set the state to PS_RUN and wait for the process to stop so that 13197c478bd9Sstevel@tonic-gate * we re-read the status from the new P->statfd. If this fails, Pwait 13207c478bd9Sstevel@tonic-gate * will reset the state to PS_LOST and we fail the reopen. Before 13217c478bd9Sstevel@tonic-gate * returning, we also forge a bit of P->status to allow the debugger to 13227c478bd9Sstevel@tonic-gate * see that we are PS_LOST following a successful exec. 13237c478bd9Sstevel@tonic-gate */ 13247c478bd9Sstevel@tonic-gate P->state = PS_RUN; 13257c478bd9Sstevel@tonic-gate if (Pwait(P, 0) == -1) { 13267c478bd9Sstevel@tonic-gate #ifdef _ILP32 13277c478bd9Sstevel@tonic-gate if (errno == EOVERFLOW) 13287c478bd9Sstevel@tonic-gate P->status.pr_dmodel = PR_MODEL_LP64; 13297c478bd9Sstevel@tonic-gate #endif 13307c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_why = PR_SYSEXIT; 13317c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_what = SYS_execve; 13327c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_errno = 0; 13337c478bd9Sstevel@tonic-gate return (-1); 13347c478bd9Sstevel@tonic-gate } 13357c478bd9Sstevel@tonic-gate 13367c478bd9Sstevel@tonic-gate /* 13377c478bd9Sstevel@tonic-gate * The process should be stopped on exec (REQUESTED) 13387c478bd9Sstevel@tonic-gate * or else should be stopped on exit from exec() (SYSEXIT) 13397c478bd9Sstevel@tonic-gate */ 13407c478bd9Sstevel@tonic-gate if (P->state == PS_STOP && 13417c478bd9Sstevel@tonic-gate (P->status.pr_lwp.pr_why == PR_REQUESTED || 13427c478bd9Sstevel@tonic-gate (P->status.pr_lwp.pr_why == PR_SYSEXIT && 13437c478bd9Sstevel@tonic-gate (P->status.pr_lwp.pr_what == SYS_exec || 13447c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_what == SYS_execve)))) { 13457c478bd9Sstevel@tonic-gate /* fake up stop-on-exit-from-execve */ 13467c478bd9Sstevel@tonic-gate if (P->status.pr_lwp.pr_why == PR_REQUESTED) { 13477c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_why = PR_SYSEXIT; 13487c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_what = SYS_execve; 13497c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_errno = 0; 13507c478bd9Sstevel@tonic-gate } 13517c478bd9Sstevel@tonic-gate } else { 13527c478bd9Sstevel@tonic-gate dprintf("Preopen: expected REQUESTED or " 13537c478bd9Sstevel@tonic-gate "SYSEXIT(SYS_execve) stop\n"); 13547c478bd9Sstevel@tonic-gate } 13557c478bd9Sstevel@tonic-gate 13567c478bd9Sstevel@tonic-gate return (0); 13577c478bd9Sstevel@tonic-gate } 13587c478bd9Sstevel@tonic-gate 13597c478bd9Sstevel@tonic-gate /* 13607c478bd9Sstevel@tonic-gate * Define all settable flags other than the microstate accounting flags. 13617c478bd9Sstevel@tonic-gate */ 13627c478bd9Sstevel@tonic-gate #define ALL_SETTABLE_FLAGS (PR_FORK|PR_RLC|PR_KLC|PR_ASYNC|PR_BPTADJ|PR_PTRACE) 13637c478bd9Sstevel@tonic-gate 13647c478bd9Sstevel@tonic-gate /* 13657c478bd9Sstevel@tonic-gate * Restore /proc tracing flags to their original values 13667c478bd9Sstevel@tonic-gate * in preparation for releasing the process. 13677c478bd9Sstevel@tonic-gate * Also called by Pcreate() to clear all tracing flags. 13687c478bd9Sstevel@tonic-gate */ 13697c478bd9Sstevel@tonic-gate static void 13707c478bd9Sstevel@tonic-gate restore_tracing_flags(struct ps_prochandle *P) 13717c478bd9Sstevel@tonic-gate { 13727c478bd9Sstevel@tonic-gate long flags; 13737c478bd9Sstevel@tonic-gate long cmd[4]; 13747c478bd9Sstevel@tonic-gate iovec_t iov[8]; 13757c478bd9Sstevel@tonic-gate 13767c478bd9Sstevel@tonic-gate if (P->flags & CREATED) { 13777c478bd9Sstevel@tonic-gate /* we created this process; clear all tracing flags */ 13787c478bd9Sstevel@tonic-gate premptyset(&P->status.pr_sigtrace); 13797c478bd9Sstevel@tonic-gate premptyset(&P->status.pr_flttrace); 13807c478bd9Sstevel@tonic-gate premptyset(&P->status.pr_sysentry); 13817c478bd9Sstevel@tonic-gate premptyset(&P->status.pr_sysexit); 13827c478bd9Sstevel@tonic-gate if ((P->status.pr_flags & ALL_SETTABLE_FLAGS) != 0) 13837c478bd9Sstevel@tonic-gate (void) Punsetflags(P, ALL_SETTABLE_FLAGS); 13847c478bd9Sstevel@tonic-gate } else { 13857c478bd9Sstevel@tonic-gate /* we grabbed the process; restore its tracing flags */ 13867c478bd9Sstevel@tonic-gate P->status.pr_sigtrace = P->orig_status.pr_sigtrace; 13877c478bd9Sstevel@tonic-gate P->status.pr_flttrace = P->orig_status.pr_flttrace; 13887c478bd9Sstevel@tonic-gate P->status.pr_sysentry = P->orig_status.pr_sysentry; 13897c478bd9Sstevel@tonic-gate P->status.pr_sysexit = P->orig_status.pr_sysexit; 13907c478bd9Sstevel@tonic-gate if ((P->status.pr_flags & ALL_SETTABLE_FLAGS) != 13917c478bd9Sstevel@tonic-gate (flags = (P->orig_status.pr_flags & ALL_SETTABLE_FLAGS))) { 13927c478bd9Sstevel@tonic-gate (void) Punsetflags(P, ALL_SETTABLE_FLAGS); 13937c478bd9Sstevel@tonic-gate if (flags) 13947c478bd9Sstevel@tonic-gate (void) Psetflags(P, flags); 13957c478bd9Sstevel@tonic-gate } 13967c478bd9Sstevel@tonic-gate } 13977c478bd9Sstevel@tonic-gate 13987c478bd9Sstevel@tonic-gate cmd[0] = PCSTRACE; 13997c478bd9Sstevel@tonic-gate iov[0].iov_base = (caddr_t)&cmd[0]; 14007c478bd9Sstevel@tonic-gate iov[0].iov_len = sizeof (long); 14017c478bd9Sstevel@tonic-gate iov[1].iov_base = (caddr_t)&P->status.pr_sigtrace; 14027c478bd9Sstevel@tonic-gate iov[1].iov_len = sizeof (P->status.pr_sigtrace); 14037c478bd9Sstevel@tonic-gate 14047c478bd9Sstevel@tonic-gate cmd[1] = PCSFAULT; 14057c478bd9Sstevel@tonic-gate iov[2].iov_base = (caddr_t)&cmd[1]; 14067c478bd9Sstevel@tonic-gate iov[2].iov_len = sizeof (long); 14077c478bd9Sstevel@tonic-gate iov[3].iov_base = (caddr_t)&P->status.pr_flttrace; 14087c478bd9Sstevel@tonic-gate iov[3].iov_len = sizeof (P->status.pr_flttrace); 14097c478bd9Sstevel@tonic-gate 14107c478bd9Sstevel@tonic-gate cmd[2] = PCSENTRY; 14117c478bd9Sstevel@tonic-gate iov[4].iov_base = (caddr_t)&cmd[2]; 14127c478bd9Sstevel@tonic-gate iov[4].iov_len = sizeof (long); 14137c478bd9Sstevel@tonic-gate iov[5].iov_base = (caddr_t)&P->status.pr_sysentry; 14147c478bd9Sstevel@tonic-gate iov[5].iov_len = sizeof (P->status.pr_sysentry); 14157c478bd9Sstevel@tonic-gate 14167c478bd9Sstevel@tonic-gate cmd[3] = PCSEXIT; 14177c478bd9Sstevel@tonic-gate iov[6].iov_base = (caddr_t)&cmd[3]; 14187c478bd9Sstevel@tonic-gate iov[6].iov_len = sizeof (long); 14197c478bd9Sstevel@tonic-gate iov[7].iov_base = (caddr_t)&P->status.pr_sysexit; 14207c478bd9Sstevel@tonic-gate iov[7].iov_len = sizeof (P->status.pr_sysexit); 14217c478bd9Sstevel@tonic-gate 14227c478bd9Sstevel@tonic-gate (void) writev(P->ctlfd, iov, 8); 14237c478bd9Sstevel@tonic-gate 14247c478bd9Sstevel@tonic-gate P->flags &= ~(SETSIG|SETFAULT|SETENTRY|SETEXIT); 14257c478bd9Sstevel@tonic-gate } 14267c478bd9Sstevel@tonic-gate 14277c478bd9Sstevel@tonic-gate /* 14287c478bd9Sstevel@tonic-gate * Release the process. Frees the process control structure. 14297c478bd9Sstevel@tonic-gate * flags: 14307c478bd9Sstevel@tonic-gate * PRELEASE_CLEAR Clear all tracing flags. 14317c478bd9Sstevel@tonic-gate * PRELEASE_RETAIN Retain current tracing flags. 14327c478bd9Sstevel@tonic-gate * PRELEASE_HANG Leave the process stopped and abandoned. 14337c478bd9Sstevel@tonic-gate * PRELEASE_KILL Terminate the process with SIGKILL. 14347c478bd9Sstevel@tonic-gate */ 14357c478bd9Sstevel@tonic-gate void 14367c478bd9Sstevel@tonic-gate Prelease(struct ps_prochandle *P, int flags) 14377c478bd9Sstevel@tonic-gate { 14387c478bd9Sstevel@tonic-gate if (P->state == PS_DEAD) { 14397c478bd9Sstevel@tonic-gate dprintf("Prelease: releasing handle %p PS_DEAD of pid %d\n", 14407c478bd9Sstevel@tonic-gate (void *)P, (int)P->pid); 14417c478bd9Sstevel@tonic-gate Pfree(P); 14427c478bd9Sstevel@tonic-gate return; 14437c478bd9Sstevel@tonic-gate } 14447c478bd9Sstevel@tonic-gate 14457c478bd9Sstevel@tonic-gate if (P->state == PS_IDLE) { 14467c478bd9Sstevel@tonic-gate file_info_t *fptr = list_next(&P->file_head); 14477c478bd9Sstevel@tonic-gate dprintf("Prelease: releasing handle %p PS_IDLE of file %s\n", 14487c478bd9Sstevel@tonic-gate (void *)P, fptr->file_pname); 14497c478bd9Sstevel@tonic-gate Pfree(P); 14507c478bd9Sstevel@tonic-gate return; 14517c478bd9Sstevel@tonic-gate } 14527c478bd9Sstevel@tonic-gate 14537c478bd9Sstevel@tonic-gate dprintf("Prelease: releasing handle %p pid %d\n", 14547c478bd9Sstevel@tonic-gate (void *)P, (int)P->pid); 14557c478bd9Sstevel@tonic-gate 14567c478bd9Sstevel@tonic-gate if (P->ctlfd == -1) { 14577c478bd9Sstevel@tonic-gate Pfree(P); 14587c478bd9Sstevel@tonic-gate return; 14597c478bd9Sstevel@tonic-gate } 14607c478bd9Sstevel@tonic-gate 14617c478bd9Sstevel@tonic-gate if (P->agentcnt > 0) { 14627c478bd9Sstevel@tonic-gate P->agentcnt = 1; 14637c478bd9Sstevel@tonic-gate Pdestroy_agent(P); 14647c478bd9Sstevel@tonic-gate } 14657c478bd9Sstevel@tonic-gate 14667c478bd9Sstevel@tonic-gate /* 14677c478bd9Sstevel@tonic-gate * Attempt to stop the process. 14687c478bd9Sstevel@tonic-gate */ 14697c478bd9Sstevel@tonic-gate P->state = PS_RUN; 14707c478bd9Sstevel@tonic-gate (void) Pstop(P, 1000); 14717c478bd9Sstevel@tonic-gate 14727c478bd9Sstevel@tonic-gate if (flags & PRELEASE_KILL) { 14737c478bd9Sstevel@tonic-gate if (P->state == PS_STOP) 14747c478bd9Sstevel@tonic-gate (void) Psetrun(P, SIGKILL, 0); 14757c478bd9Sstevel@tonic-gate (void) kill(P->pid, SIGKILL); 14767c478bd9Sstevel@tonic-gate Pfree(P); 14777c478bd9Sstevel@tonic-gate return; 14787c478bd9Sstevel@tonic-gate } 14797c478bd9Sstevel@tonic-gate 14807c478bd9Sstevel@tonic-gate /* 14817c478bd9Sstevel@tonic-gate * If we lost control, all we can do now is close the files. 14827c478bd9Sstevel@tonic-gate * In this case, the last close sets the process running. 14837c478bd9Sstevel@tonic-gate */ 14847c478bd9Sstevel@tonic-gate if (P->state != PS_STOP && 14857c478bd9Sstevel@tonic-gate (P->status.pr_lwp.pr_flags & (PR_ISTOP|PR_DSTOP)) == 0) { 14867c478bd9Sstevel@tonic-gate Pfree(P); 14877c478bd9Sstevel@tonic-gate return; 14887c478bd9Sstevel@tonic-gate } 14897c478bd9Sstevel@tonic-gate 14907c478bd9Sstevel@tonic-gate /* 14917c478bd9Sstevel@tonic-gate * We didn't lose control; we do more. 14927c478bd9Sstevel@tonic-gate */ 14937c478bd9Sstevel@tonic-gate Psync(P); 14947c478bd9Sstevel@tonic-gate 14957c478bd9Sstevel@tonic-gate if (flags & PRELEASE_CLEAR) 14967c478bd9Sstevel@tonic-gate P->flags |= CREATED; 14977c478bd9Sstevel@tonic-gate 14987c478bd9Sstevel@tonic-gate if (!(flags & PRELEASE_RETAIN)) 14997c478bd9Sstevel@tonic-gate restore_tracing_flags(P); 15007c478bd9Sstevel@tonic-gate 15017c478bd9Sstevel@tonic-gate if (flags & PRELEASE_HANG) { 15027c478bd9Sstevel@tonic-gate /* Leave the process stopped and abandoned */ 15037c478bd9Sstevel@tonic-gate (void) Punsetflags(P, PR_RLC|PR_KLC); 15047c478bd9Sstevel@tonic-gate Pfree(P); 15057c478bd9Sstevel@tonic-gate return; 15067c478bd9Sstevel@tonic-gate } 15077c478bd9Sstevel@tonic-gate 15087c478bd9Sstevel@tonic-gate /* 15097c478bd9Sstevel@tonic-gate * Set the process running if we created it or if it was 15107c478bd9Sstevel@tonic-gate * not originally stopped or directed to stop via /proc 15117c478bd9Sstevel@tonic-gate * or if we were given the PRELEASE_CLEAR flag. 15127c478bd9Sstevel@tonic-gate */ 15137c478bd9Sstevel@tonic-gate if ((P->flags & CREATED) || 15147c478bd9Sstevel@tonic-gate (P->orig_status.pr_lwp.pr_flags & (PR_ISTOP|PR_DSTOP)) == 0) { 15157c478bd9Sstevel@tonic-gate (void) Psetflags(P, PR_RLC); 15167c478bd9Sstevel@tonic-gate /* 15177c478bd9Sstevel@tonic-gate * We do this repeatedly because the process may have 15187c478bd9Sstevel@tonic-gate * more than one LWP stopped on an event of interest. 15197c478bd9Sstevel@tonic-gate * This makes sure all of them are set running. 15207c478bd9Sstevel@tonic-gate */ 15217c478bd9Sstevel@tonic-gate do { 15227c478bd9Sstevel@tonic-gate if (Psetrun(P, 0, 0) == -1 && errno == EBUSY) 15237c478bd9Sstevel@tonic-gate break; /* Agent LWP may be stuck */ 15247c478bd9Sstevel@tonic-gate } while (Pstopstatus(P, PCNULL, 0) == 0 && 15257c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_flags & (PR_ISTOP|PR_DSTOP)); 15267c478bd9Sstevel@tonic-gate 15277c478bd9Sstevel@tonic-gate if (P->status.pr_lwp.pr_flags & (PR_ISTOP|PR_DSTOP)) 15287c478bd9Sstevel@tonic-gate dprintf("Prelease: failed to set process running\n"); 15297c478bd9Sstevel@tonic-gate } 15307c478bd9Sstevel@tonic-gate 15317c478bd9Sstevel@tonic-gate Pfree(P); 15327c478bd9Sstevel@tonic-gate } 15337c478bd9Sstevel@tonic-gate 15347c478bd9Sstevel@tonic-gate /* debugging */ 15357c478bd9Sstevel@tonic-gate void 15367c478bd9Sstevel@tonic-gate prldump(const char *caller, lwpstatus_t *lsp) 15377c478bd9Sstevel@tonic-gate { 15387c478bd9Sstevel@tonic-gate char name[32]; 15397c478bd9Sstevel@tonic-gate uint32_t bits; 15407c478bd9Sstevel@tonic-gate 15417c478bd9Sstevel@tonic-gate switch (lsp->pr_why) { 15427c478bd9Sstevel@tonic-gate case PR_REQUESTED: 15437c478bd9Sstevel@tonic-gate dprintf("%s: REQUESTED\n", caller); 15447c478bd9Sstevel@tonic-gate break; 15457c478bd9Sstevel@tonic-gate case PR_SIGNALLED: 15467c478bd9Sstevel@tonic-gate dprintf("%s: SIGNALLED %s\n", caller, 15477c478bd9Sstevel@tonic-gate proc_signame(lsp->pr_what, name, sizeof (name))); 15487c478bd9Sstevel@tonic-gate break; 15497c478bd9Sstevel@tonic-gate case PR_FAULTED: 15507c478bd9Sstevel@tonic-gate dprintf("%s: FAULTED %s\n", caller, 15517c478bd9Sstevel@tonic-gate proc_fltname(lsp->pr_what, name, sizeof (name))); 15527c478bd9Sstevel@tonic-gate break; 15537c478bd9Sstevel@tonic-gate case PR_SYSENTRY: 15547c478bd9Sstevel@tonic-gate dprintf("%s: SYSENTRY %s\n", caller, 15557c478bd9Sstevel@tonic-gate proc_sysname(lsp->pr_what, name, sizeof (name))); 15567c478bd9Sstevel@tonic-gate break; 15577c478bd9Sstevel@tonic-gate case PR_SYSEXIT: 15587c478bd9Sstevel@tonic-gate dprintf("%s: SYSEXIT %s\n", caller, 15597c478bd9Sstevel@tonic-gate proc_sysname(lsp->pr_what, name, sizeof (name))); 15607c478bd9Sstevel@tonic-gate break; 15617c478bd9Sstevel@tonic-gate case PR_JOBCONTROL: 15627c478bd9Sstevel@tonic-gate dprintf("%s: JOBCONTROL %s\n", caller, 15637c478bd9Sstevel@tonic-gate proc_signame(lsp->pr_what, name, sizeof (name))); 15647c478bd9Sstevel@tonic-gate break; 15657c478bd9Sstevel@tonic-gate case PR_SUSPENDED: 15667c478bd9Sstevel@tonic-gate dprintf("%s: SUSPENDED\n", caller); 15677c478bd9Sstevel@tonic-gate break; 15687c478bd9Sstevel@tonic-gate default: 15697c478bd9Sstevel@tonic-gate dprintf("%s: Unknown\n", caller); 15707c478bd9Sstevel@tonic-gate break; 15717c478bd9Sstevel@tonic-gate } 15727c478bd9Sstevel@tonic-gate 15737c478bd9Sstevel@tonic-gate if (lsp->pr_cursig) 15747c478bd9Sstevel@tonic-gate dprintf("%s: p_cursig = %d\n", caller, lsp->pr_cursig); 15757c478bd9Sstevel@tonic-gate 15767c478bd9Sstevel@tonic-gate bits = *((uint32_t *)&lsp->pr_lwppend); 15777c478bd9Sstevel@tonic-gate if (bits) 15787c478bd9Sstevel@tonic-gate dprintf("%s: pr_lwppend = 0x%.8X\n", caller, bits); 15797c478bd9Sstevel@tonic-gate } 15807c478bd9Sstevel@tonic-gate 15817c478bd9Sstevel@tonic-gate /* debugging */ 15827c478bd9Sstevel@tonic-gate static void 15837c478bd9Sstevel@tonic-gate prdump(struct ps_prochandle *P) 15847c478bd9Sstevel@tonic-gate { 15857c478bd9Sstevel@tonic-gate uint32_t bits; 15867c478bd9Sstevel@tonic-gate 15877c478bd9Sstevel@tonic-gate prldump("Pstopstatus", &P->status.pr_lwp); 15887c478bd9Sstevel@tonic-gate 15897c478bd9Sstevel@tonic-gate bits = *((uint32_t *)&P->status.pr_sigpend); 15907c478bd9Sstevel@tonic-gate if (bits) 15917c478bd9Sstevel@tonic-gate dprintf("Pstopstatus: pr_sigpend = 0x%.8X\n", bits); 15927c478bd9Sstevel@tonic-gate } 15937c478bd9Sstevel@tonic-gate 15947c478bd9Sstevel@tonic-gate /* 15957c478bd9Sstevel@tonic-gate * Wait for the specified process to stop or terminate. 15967c478bd9Sstevel@tonic-gate * Or, just get the current status (PCNULL). 15977c478bd9Sstevel@tonic-gate * Or, direct it to stop and get the current status (PCDSTOP). 15987c478bd9Sstevel@tonic-gate * If the agent LWP exists, do these things to the agent, 15997c478bd9Sstevel@tonic-gate * else do these things to the process as a whole. 16007c478bd9Sstevel@tonic-gate */ 16017c478bd9Sstevel@tonic-gate int 16027c478bd9Sstevel@tonic-gate Pstopstatus(struct ps_prochandle *P, 16037c478bd9Sstevel@tonic-gate long request, /* PCNULL, PCDSTOP, PCSTOP, PCWSTOP */ 16047c478bd9Sstevel@tonic-gate uint_t msec) /* if non-zero, timeout in milliseconds */ 16057c478bd9Sstevel@tonic-gate { 16067c478bd9Sstevel@tonic-gate int ctlfd = (P->agentctlfd >= 0)? P->agentctlfd : P->ctlfd; 16077c478bd9Sstevel@tonic-gate long ctl[3]; 16087c478bd9Sstevel@tonic-gate ssize_t rc; 16097c478bd9Sstevel@tonic-gate int err; 16107c478bd9Sstevel@tonic-gate int old_state = P->state; 16117c478bd9Sstevel@tonic-gate 16127c478bd9Sstevel@tonic-gate switch (P->state) { 16137c478bd9Sstevel@tonic-gate case PS_RUN: 16147c478bd9Sstevel@tonic-gate break; 16157c478bd9Sstevel@tonic-gate case PS_STOP: 16167c478bd9Sstevel@tonic-gate if (request != PCNULL && request != PCDSTOP) 16177c478bd9Sstevel@tonic-gate return (0); 16187c478bd9Sstevel@tonic-gate break; 16197c478bd9Sstevel@tonic-gate case PS_LOST: 16207c478bd9Sstevel@tonic-gate if (request != PCNULL) { 16217c478bd9Sstevel@tonic-gate errno = EAGAIN; 16227c478bd9Sstevel@tonic-gate return (-1); 16237c478bd9Sstevel@tonic-gate } 16247c478bd9Sstevel@tonic-gate break; 16257c478bd9Sstevel@tonic-gate case PS_UNDEAD: 16267c478bd9Sstevel@tonic-gate case PS_DEAD: 16277c478bd9Sstevel@tonic-gate case PS_IDLE: 16287c478bd9Sstevel@tonic-gate if (request != PCNULL) { 16297c478bd9Sstevel@tonic-gate errno = ENOENT; 16307c478bd9Sstevel@tonic-gate return (-1); 16317c478bd9Sstevel@tonic-gate } 16327c478bd9Sstevel@tonic-gate break; 16337c478bd9Sstevel@tonic-gate default: /* corrupted state */ 16347c478bd9Sstevel@tonic-gate dprintf("Pstopstatus: corrupted state: %d\n", P->state); 16357c478bd9Sstevel@tonic-gate errno = EINVAL; 16367c478bd9Sstevel@tonic-gate return (-1); 16377c478bd9Sstevel@tonic-gate } 16387c478bd9Sstevel@tonic-gate 16397c478bd9Sstevel@tonic-gate ctl[0] = PCDSTOP; 16407c478bd9Sstevel@tonic-gate ctl[1] = PCTWSTOP; 16417c478bd9Sstevel@tonic-gate ctl[2] = (long)msec; 16427c478bd9Sstevel@tonic-gate rc = 0; 16437c478bd9Sstevel@tonic-gate switch (request) { 16447c478bd9Sstevel@tonic-gate case PCSTOP: 16457c478bd9Sstevel@tonic-gate rc = write(ctlfd, &ctl[0], 3*sizeof (long)); 16467c478bd9Sstevel@tonic-gate break; 16477c478bd9Sstevel@tonic-gate case PCWSTOP: 16487c478bd9Sstevel@tonic-gate rc = write(ctlfd, &ctl[1], 2*sizeof (long)); 16497c478bd9Sstevel@tonic-gate break; 16507c478bd9Sstevel@tonic-gate case PCDSTOP: 16517c478bd9Sstevel@tonic-gate rc = write(ctlfd, &ctl[0], 1*sizeof (long)); 16527c478bd9Sstevel@tonic-gate break; 16537c478bd9Sstevel@tonic-gate case PCNULL: 16547c478bd9Sstevel@tonic-gate if (P->state == PS_DEAD || P->state == PS_IDLE) 16557c478bd9Sstevel@tonic-gate return (0); 16567c478bd9Sstevel@tonic-gate break; 16577c478bd9Sstevel@tonic-gate default: /* programming error */ 16587c478bd9Sstevel@tonic-gate errno = EINVAL; 16597c478bd9Sstevel@tonic-gate return (-1); 16607c478bd9Sstevel@tonic-gate } 16617c478bd9Sstevel@tonic-gate err = (rc < 0)? errno : 0; 16627c478bd9Sstevel@tonic-gate Psync(P); 16637c478bd9Sstevel@tonic-gate 16647c478bd9Sstevel@tonic-gate if (P->agentstatfd < 0) { 16657c478bd9Sstevel@tonic-gate if (pread(P->statfd, &P->status, 16667c478bd9Sstevel@tonic-gate sizeof (P->status), (off_t)0) < 0) 16677c478bd9Sstevel@tonic-gate err = errno; 16687c478bd9Sstevel@tonic-gate } else { 16697c478bd9Sstevel@tonic-gate if (pread(P->agentstatfd, &P->status.pr_lwp, 16707c478bd9Sstevel@tonic-gate sizeof (P->status.pr_lwp), (off_t)0) < 0) 16717c478bd9Sstevel@tonic-gate err = errno; 16727c478bd9Sstevel@tonic-gate P->status.pr_flags = P->status.pr_lwp.pr_flags; 16737c478bd9Sstevel@tonic-gate } 16747c478bd9Sstevel@tonic-gate 16757c478bd9Sstevel@tonic-gate if (err) { 16767c478bd9Sstevel@tonic-gate switch (err) { 16777c478bd9Sstevel@tonic-gate case EINTR: /* user typed ctl-C */ 16787c478bd9Sstevel@tonic-gate case ERESTART: 16797c478bd9Sstevel@tonic-gate dprintf("Pstopstatus: EINTR\n"); 16807c478bd9Sstevel@tonic-gate break; 16817c478bd9Sstevel@tonic-gate case EAGAIN: /* we lost control of the the process */ 16827c478bd9Sstevel@tonic-gate case EOVERFLOW: 16837c478bd9Sstevel@tonic-gate dprintf("Pstopstatus: PS_LOST, errno=%d\n", err); 16847c478bd9Sstevel@tonic-gate P->state = PS_LOST; 16857c478bd9Sstevel@tonic-gate break; 16867c478bd9Sstevel@tonic-gate default: /* check for dead process */ 16877c478bd9Sstevel@tonic-gate if (_libproc_debug) { 16887c478bd9Sstevel@tonic-gate const char *errstr; 16897c478bd9Sstevel@tonic-gate 16907c478bd9Sstevel@tonic-gate switch (request) { 16917c478bd9Sstevel@tonic-gate case PCNULL: 16927c478bd9Sstevel@tonic-gate errstr = "Pstopstatus PCNULL"; break; 16937c478bd9Sstevel@tonic-gate case PCSTOP: 16947c478bd9Sstevel@tonic-gate errstr = "Pstopstatus PCSTOP"; break; 16957c478bd9Sstevel@tonic-gate case PCDSTOP: 16967c478bd9Sstevel@tonic-gate errstr = "Pstopstatus PCDSTOP"; break; 16977c478bd9Sstevel@tonic-gate case PCWSTOP: 16987c478bd9Sstevel@tonic-gate errstr = "Pstopstatus PCWSTOP"; break; 16997c478bd9Sstevel@tonic-gate default: 17007c478bd9Sstevel@tonic-gate errstr = "Pstopstatus PC???"; break; 17017c478bd9Sstevel@tonic-gate } 17027c478bd9Sstevel@tonic-gate dprintf("%s: %s\n", errstr, strerror(err)); 17037c478bd9Sstevel@tonic-gate } 17047c478bd9Sstevel@tonic-gate deadcheck(P); 17057c478bd9Sstevel@tonic-gate break; 17067c478bd9Sstevel@tonic-gate } 17077c478bd9Sstevel@tonic-gate if (err != EINTR && err != ERESTART) { 17087c478bd9Sstevel@tonic-gate errno = err; 17097c478bd9Sstevel@tonic-gate return (-1); 17107c478bd9Sstevel@tonic-gate } 17117c478bd9Sstevel@tonic-gate } 17127c478bd9Sstevel@tonic-gate 17137c478bd9Sstevel@tonic-gate if (!(P->status.pr_flags & PR_STOPPED)) { 17147c478bd9Sstevel@tonic-gate P->state = PS_RUN; 17157c478bd9Sstevel@tonic-gate if (request == PCNULL || request == PCDSTOP || msec != 0) 17167c478bd9Sstevel@tonic-gate return (0); 17177c478bd9Sstevel@tonic-gate dprintf("Pstopstatus: process is not stopped\n"); 17187c478bd9Sstevel@tonic-gate errno = EPROTO; 17197c478bd9Sstevel@tonic-gate return (-1); 17207c478bd9Sstevel@tonic-gate } 17217c478bd9Sstevel@tonic-gate 17227c478bd9Sstevel@tonic-gate P->state = PS_STOP; 17237c478bd9Sstevel@tonic-gate 17247c478bd9Sstevel@tonic-gate if (_libproc_debug) /* debugging */ 17257c478bd9Sstevel@tonic-gate prdump(P); 17267c478bd9Sstevel@tonic-gate 17277c478bd9Sstevel@tonic-gate /* 17287c478bd9Sstevel@tonic-gate * If the process was already stopped coming into Pstopstatus(), 17297c478bd9Sstevel@tonic-gate * then don't use its PC to set P->sysaddr since it may have been 17307c478bd9Sstevel@tonic-gate * changed since the time the process originally stopped. 17317c478bd9Sstevel@tonic-gate */ 17327c478bd9Sstevel@tonic-gate if (old_state == PS_STOP) 17337c478bd9Sstevel@tonic-gate return (0); 17347c478bd9Sstevel@tonic-gate 17357c478bd9Sstevel@tonic-gate switch (P->status.pr_lwp.pr_why) { 17367c478bd9Sstevel@tonic-gate case PR_SYSENTRY: 17377c478bd9Sstevel@tonic-gate case PR_SYSEXIT: 17387c478bd9Sstevel@tonic-gate if (Pissyscall_prev(P, P->status.pr_lwp.pr_reg[R_PC], 17397c478bd9Sstevel@tonic-gate &P->sysaddr) == 0) 17407c478bd9Sstevel@tonic-gate P->sysaddr = P->status.pr_lwp.pr_reg[R_PC]; 17417c478bd9Sstevel@tonic-gate break; 17427c478bd9Sstevel@tonic-gate case PR_REQUESTED: 17437c478bd9Sstevel@tonic-gate case PR_SIGNALLED: 17447c478bd9Sstevel@tonic-gate case PR_FAULTED: 17457c478bd9Sstevel@tonic-gate case PR_JOBCONTROL: 17467c478bd9Sstevel@tonic-gate case PR_SUSPENDED: 17477c478bd9Sstevel@tonic-gate break; 17487c478bd9Sstevel@tonic-gate default: 17497c478bd9Sstevel@tonic-gate errno = EPROTO; 17507c478bd9Sstevel@tonic-gate return (-1); 17517c478bd9Sstevel@tonic-gate } 17527c478bd9Sstevel@tonic-gate 17537c478bd9Sstevel@tonic-gate return (0); 17547c478bd9Sstevel@tonic-gate } 17557c478bd9Sstevel@tonic-gate 17567c478bd9Sstevel@tonic-gate /* 17577c478bd9Sstevel@tonic-gate * Wait for the process to stop for any reason. 17587c478bd9Sstevel@tonic-gate */ 17597c478bd9Sstevel@tonic-gate int 17607c478bd9Sstevel@tonic-gate Pwait(struct ps_prochandle *P, uint_t msec) 17617c478bd9Sstevel@tonic-gate { 17627c478bd9Sstevel@tonic-gate return (Pstopstatus(P, PCWSTOP, msec)); 17637c478bd9Sstevel@tonic-gate } 17647c478bd9Sstevel@tonic-gate 17657c478bd9Sstevel@tonic-gate /* 17667c478bd9Sstevel@tonic-gate * Direct the process to stop; wait for it to stop. 17677c478bd9Sstevel@tonic-gate */ 17687c478bd9Sstevel@tonic-gate int 17697c478bd9Sstevel@tonic-gate Pstop(struct ps_prochandle *P, uint_t msec) 17707c478bd9Sstevel@tonic-gate { 17717c478bd9Sstevel@tonic-gate return (Pstopstatus(P, PCSTOP, msec)); 17727c478bd9Sstevel@tonic-gate } 17737c478bd9Sstevel@tonic-gate 17747c478bd9Sstevel@tonic-gate /* 17757c478bd9Sstevel@tonic-gate * Direct the process to stop; don't wait. 17767c478bd9Sstevel@tonic-gate */ 17777c478bd9Sstevel@tonic-gate int 17787c478bd9Sstevel@tonic-gate Pdstop(struct ps_prochandle *P) 17797c478bd9Sstevel@tonic-gate { 17807c478bd9Sstevel@tonic-gate return (Pstopstatus(P, PCDSTOP, 0)); 17817c478bd9Sstevel@tonic-gate } 17827c478bd9Sstevel@tonic-gate 17837c478bd9Sstevel@tonic-gate static void 17847c478bd9Sstevel@tonic-gate deadcheck(struct ps_prochandle *P) 17857c478bd9Sstevel@tonic-gate { 17867c478bd9Sstevel@tonic-gate int fd; 17877c478bd9Sstevel@tonic-gate void *buf; 17887c478bd9Sstevel@tonic-gate size_t size; 17897c478bd9Sstevel@tonic-gate 17907c478bd9Sstevel@tonic-gate if (P->statfd < 0) 17917c478bd9Sstevel@tonic-gate P->state = PS_UNDEAD; 17927c478bd9Sstevel@tonic-gate else { 17937c478bd9Sstevel@tonic-gate if (P->agentstatfd < 0) { 17947c478bd9Sstevel@tonic-gate fd = P->statfd; 17957c478bd9Sstevel@tonic-gate buf = &P->status; 17967c478bd9Sstevel@tonic-gate size = sizeof (P->status); 17977c478bd9Sstevel@tonic-gate } else { 17987c478bd9Sstevel@tonic-gate fd = P->agentstatfd; 17997c478bd9Sstevel@tonic-gate buf = &P->status.pr_lwp; 18007c478bd9Sstevel@tonic-gate size = sizeof (P->status.pr_lwp); 18017c478bd9Sstevel@tonic-gate } 18027c478bd9Sstevel@tonic-gate while (pread(fd, buf, size, (off_t)0) != size) { 18037c478bd9Sstevel@tonic-gate switch (errno) { 18047c478bd9Sstevel@tonic-gate default: 18057c478bd9Sstevel@tonic-gate P->state = PS_UNDEAD; 18067c478bd9Sstevel@tonic-gate break; 18077c478bd9Sstevel@tonic-gate case EINTR: 18087c478bd9Sstevel@tonic-gate case ERESTART: 18097c478bd9Sstevel@tonic-gate continue; 18107c478bd9Sstevel@tonic-gate case EAGAIN: 18117c478bd9Sstevel@tonic-gate P->state = PS_LOST; 18127c478bd9Sstevel@tonic-gate break; 18137c478bd9Sstevel@tonic-gate } 18147c478bd9Sstevel@tonic-gate break; 18157c478bd9Sstevel@tonic-gate } 18167c478bd9Sstevel@tonic-gate P->status.pr_flags = P->status.pr_lwp.pr_flags; 18177c478bd9Sstevel@tonic-gate } 18187c478bd9Sstevel@tonic-gate } 18197c478bd9Sstevel@tonic-gate 18207c478bd9Sstevel@tonic-gate /* 18217c478bd9Sstevel@tonic-gate * Get the value of one register from stopped process. 18227c478bd9Sstevel@tonic-gate */ 18237c478bd9Sstevel@tonic-gate int 18247c478bd9Sstevel@tonic-gate Pgetareg(struct ps_prochandle *P, int regno, prgreg_t *preg) 18257c478bd9Sstevel@tonic-gate { 18267c478bd9Sstevel@tonic-gate if (regno < 0 || regno >= NPRGREG) { 18277c478bd9Sstevel@tonic-gate errno = EINVAL; 18287c478bd9Sstevel@tonic-gate return (-1); 18297c478bd9Sstevel@tonic-gate } 18307c478bd9Sstevel@tonic-gate 18317c478bd9Sstevel@tonic-gate if (P->state == PS_IDLE) { 18327c478bd9Sstevel@tonic-gate errno = ENODATA; 18337c478bd9Sstevel@tonic-gate return (-1); 18347c478bd9Sstevel@tonic-gate } 18357c478bd9Sstevel@tonic-gate 18367c478bd9Sstevel@tonic-gate if (P->state != PS_STOP && P->state != PS_DEAD) { 18377c478bd9Sstevel@tonic-gate errno = EBUSY; 18387c478bd9Sstevel@tonic-gate return (-1); 18397c478bd9Sstevel@tonic-gate } 18407c478bd9Sstevel@tonic-gate 18417c478bd9Sstevel@tonic-gate *preg = P->status.pr_lwp.pr_reg[regno]; 18427c478bd9Sstevel@tonic-gate return (0); 18437c478bd9Sstevel@tonic-gate } 18447c478bd9Sstevel@tonic-gate 18457c478bd9Sstevel@tonic-gate /* 18467c478bd9Sstevel@tonic-gate * Put value of one register into stopped process. 18477c478bd9Sstevel@tonic-gate */ 18487c478bd9Sstevel@tonic-gate int 18497c478bd9Sstevel@tonic-gate Pputareg(struct ps_prochandle *P, int regno, prgreg_t reg) 18507c478bd9Sstevel@tonic-gate { 18517c478bd9Sstevel@tonic-gate if (regno < 0 || regno >= NPRGREG) { 18527c478bd9Sstevel@tonic-gate errno = EINVAL; 18537c478bd9Sstevel@tonic-gate return (-1); 18547c478bd9Sstevel@tonic-gate } 18557c478bd9Sstevel@tonic-gate 18567c478bd9Sstevel@tonic-gate if (P->state != PS_STOP) { 18577c478bd9Sstevel@tonic-gate errno = EBUSY; 18587c478bd9Sstevel@tonic-gate return (-1); 18597c478bd9Sstevel@tonic-gate } 18607c478bd9Sstevel@tonic-gate 18617c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_reg[regno] = reg; 18627c478bd9Sstevel@tonic-gate P->flags |= SETREGS; /* set registers before continuing */ 18637c478bd9Sstevel@tonic-gate return (0); 18647c478bd9Sstevel@tonic-gate } 18657c478bd9Sstevel@tonic-gate 18667c478bd9Sstevel@tonic-gate int 18677c478bd9Sstevel@tonic-gate Psetrun(struct ps_prochandle *P, 18687c478bd9Sstevel@tonic-gate int sig, /* signal to pass to process */ 18697c478bd9Sstevel@tonic-gate int flags) /* PRSTEP|PRSABORT|PRSTOP|PRCSIG|PRCFAULT */ 18707c478bd9Sstevel@tonic-gate { 18717c478bd9Sstevel@tonic-gate int ctlfd = (P->agentctlfd >= 0) ? P->agentctlfd : P->ctlfd; 18727c478bd9Sstevel@tonic-gate int sbits = (PR_DSTOP | PR_ISTOP | PR_ASLEEP); 18737c478bd9Sstevel@tonic-gate 18747c478bd9Sstevel@tonic-gate long ctl[1 + /* PCCFAULT */ 18757c478bd9Sstevel@tonic-gate 1 + sizeof (siginfo_t)/sizeof (long) + /* PCSSIG/PCCSIG */ 18767c478bd9Sstevel@tonic-gate 2 ]; /* PCRUN */ 18777c478bd9Sstevel@tonic-gate 18787c478bd9Sstevel@tonic-gate long *ctlp = ctl; 18797c478bd9Sstevel@tonic-gate size_t size; 18807c478bd9Sstevel@tonic-gate 18817c478bd9Sstevel@tonic-gate if (P->state != PS_STOP && (P->status.pr_lwp.pr_flags & sbits) == 0) { 18827c478bd9Sstevel@tonic-gate errno = EBUSY; 18837c478bd9Sstevel@tonic-gate return (-1); 18847c478bd9Sstevel@tonic-gate } 18857c478bd9Sstevel@tonic-gate 18867c478bd9Sstevel@tonic-gate Psync(P); /* flush tracing flags and registers */ 18877c478bd9Sstevel@tonic-gate 18887c478bd9Sstevel@tonic-gate if (flags & PRCFAULT) { /* clear current fault */ 18897c478bd9Sstevel@tonic-gate *ctlp++ = PCCFAULT; 18907c478bd9Sstevel@tonic-gate flags &= ~PRCFAULT; 18917c478bd9Sstevel@tonic-gate } 18927c478bd9Sstevel@tonic-gate 18937c478bd9Sstevel@tonic-gate if (flags & PRCSIG) { /* clear current signal */ 18947c478bd9Sstevel@tonic-gate *ctlp++ = PCCSIG; 18957c478bd9Sstevel@tonic-gate flags &= ~PRCSIG; 18967c478bd9Sstevel@tonic-gate } else if (sig && sig != P->status.pr_lwp.pr_cursig) { 18977c478bd9Sstevel@tonic-gate /* make current signal */ 18987c478bd9Sstevel@tonic-gate siginfo_t *infop; 18997c478bd9Sstevel@tonic-gate 19007c478bd9Sstevel@tonic-gate *ctlp++ = PCSSIG; 19017c478bd9Sstevel@tonic-gate infop = (siginfo_t *)ctlp; 19027c478bd9Sstevel@tonic-gate (void) memset(infop, 0, sizeof (*infop)); 19037c478bd9Sstevel@tonic-gate infop->si_signo = sig; 19047c478bd9Sstevel@tonic-gate ctlp += sizeof (siginfo_t) / sizeof (long); 19057c478bd9Sstevel@tonic-gate } 19067c478bd9Sstevel@tonic-gate 19077c478bd9Sstevel@tonic-gate *ctlp++ = PCRUN; 19087c478bd9Sstevel@tonic-gate *ctlp++ = flags; 19097c478bd9Sstevel@tonic-gate size = (char *)ctlp - (char *)ctl; 19107c478bd9Sstevel@tonic-gate 19117c478bd9Sstevel@tonic-gate P->info_valid = 0; /* will need to update map and file info */ 19127c478bd9Sstevel@tonic-gate 19137c478bd9Sstevel@tonic-gate /* 19147c478bd9Sstevel@tonic-gate * If we've cached ucontext-list information while we were stopped, 19157c478bd9Sstevel@tonic-gate * free it now. 19167c478bd9Sstevel@tonic-gate */ 19177c478bd9Sstevel@tonic-gate if (P->ucaddrs != NULL) { 19187c478bd9Sstevel@tonic-gate free(P->ucaddrs); 19197c478bd9Sstevel@tonic-gate P->ucaddrs = NULL; 19207c478bd9Sstevel@tonic-gate P->ucnelems = 0; 19217c478bd9Sstevel@tonic-gate } 19227c478bd9Sstevel@tonic-gate 19237c478bd9Sstevel@tonic-gate if (write(ctlfd, ctl, size) != size) { 19247c478bd9Sstevel@tonic-gate /* If it is dead or lost, return the real status, not PS_RUN */ 19257c478bd9Sstevel@tonic-gate if (errno == ENOENT || errno == EAGAIN) { 19267c478bd9Sstevel@tonic-gate (void) Pstopstatus(P, PCNULL, 0); 19277c478bd9Sstevel@tonic-gate return (0); 19287c478bd9Sstevel@tonic-gate } 19297c478bd9Sstevel@tonic-gate /* If it is not in a jobcontrol stop, issue an error message */ 19307c478bd9Sstevel@tonic-gate if (errno != EBUSY || 19317c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_why != PR_JOBCONTROL) { 19327c478bd9Sstevel@tonic-gate dprintf("Psetrun: %s\n", strerror(errno)); 19337c478bd9Sstevel@tonic-gate return (-1); 19347c478bd9Sstevel@tonic-gate } 19357c478bd9Sstevel@tonic-gate /* Otherwise pretend that the job-stopped process is running */ 19367c478bd9Sstevel@tonic-gate } 19377c478bd9Sstevel@tonic-gate 19387c478bd9Sstevel@tonic-gate P->state = PS_RUN; 19397c478bd9Sstevel@tonic-gate return (0); 19407c478bd9Sstevel@tonic-gate } 19417c478bd9Sstevel@tonic-gate 19427c478bd9Sstevel@tonic-gate ssize_t 19437c478bd9Sstevel@tonic-gate Pread(struct ps_prochandle *P, 19447c478bd9Sstevel@tonic-gate void *buf, /* caller's buffer */ 19457c478bd9Sstevel@tonic-gate size_t nbyte, /* number of bytes to read */ 19467c478bd9Sstevel@tonic-gate uintptr_t address) /* address in process */ 19477c478bd9Sstevel@tonic-gate { 19487c478bd9Sstevel@tonic-gate return (P->ops->p_pread(P, buf, nbyte, address)); 19497c478bd9Sstevel@tonic-gate } 19507c478bd9Sstevel@tonic-gate 19517c478bd9Sstevel@tonic-gate ssize_t 19527c478bd9Sstevel@tonic-gate Pread_string(struct ps_prochandle *P, 19537c478bd9Sstevel@tonic-gate char *buf, /* caller's buffer */ 19547c478bd9Sstevel@tonic-gate size_t size, /* upper limit on bytes to read */ 19557c478bd9Sstevel@tonic-gate uintptr_t addr) /* address in process */ 19567c478bd9Sstevel@tonic-gate { 19577c478bd9Sstevel@tonic-gate enum { STRSZ = 40 }; 19587c478bd9Sstevel@tonic-gate char string[STRSZ + 1]; 19597c478bd9Sstevel@tonic-gate ssize_t leng = 0; 19607c478bd9Sstevel@tonic-gate int nbyte; 19617c478bd9Sstevel@tonic-gate 19627c478bd9Sstevel@tonic-gate if (size < 2) { 19637c478bd9Sstevel@tonic-gate errno = EINVAL; 19647c478bd9Sstevel@tonic-gate return (-1); 19657c478bd9Sstevel@tonic-gate } 19667c478bd9Sstevel@tonic-gate 19677c478bd9Sstevel@tonic-gate size--; /* ensure trailing null fits in buffer */ 19687c478bd9Sstevel@tonic-gate 19697c478bd9Sstevel@tonic-gate *buf = '\0'; 19707c478bd9Sstevel@tonic-gate string[STRSZ] = '\0'; 19717c478bd9Sstevel@tonic-gate 19727c478bd9Sstevel@tonic-gate for (nbyte = STRSZ; nbyte == STRSZ && leng < size; addr += STRSZ) { 19737c478bd9Sstevel@tonic-gate if ((nbyte = P->ops->p_pread(P, string, STRSZ, addr)) <= 0) { 19747c478bd9Sstevel@tonic-gate buf[leng] = '\0'; 19757c478bd9Sstevel@tonic-gate return (leng ? leng : -1); 19767c478bd9Sstevel@tonic-gate } 19777c478bd9Sstevel@tonic-gate if ((nbyte = strlen(string)) > 0) { 19787c478bd9Sstevel@tonic-gate if (leng + nbyte > size) 19797c478bd9Sstevel@tonic-gate nbyte = size - leng; 19807c478bd9Sstevel@tonic-gate (void) strncpy(buf + leng, string, nbyte); 19817c478bd9Sstevel@tonic-gate leng += nbyte; 19827c478bd9Sstevel@tonic-gate } 19837c478bd9Sstevel@tonic-gate } 19847c478bd9Sstevel@tonic-gate buf[leng] = '\0'; 19857c478bd9Sstevel@tonic-gate return (leng); 19867c478bd9Sstevel@tonic-gate } 19877c478bd9Sstevel@tonic-gate 19887c478bd9Sstevel@tonic-gate ssize_t 19897c478bd9Sstevel@tonic-gate Pwrite(struct ps_prochandle *P, 19907c478bd9Sstevel@tonic-gate const void *buf, /* caller's buffer */ 19917c478bd9Sstevel@tonic-gate size_t nbyte, /* number of bytes to write */ 19927c478bd9Sstevel@tonic-gate uintptr_t address) /* address in process */ 19937c478bd9Sstevel@tonic-gate { 19947c478bd9Sstevel@tonic-gate return (P->ops->p_pwrite(P, buf, nbyte, address)); 19957c478bd9Sstevel@tonic-gate } 19967c478bd9Sstevel@tonic-gate 19977c478bd9Sstevel@tonic-gate int 19987c478bd9Sstevel@tonic-gate Pclearsig(struct ps_prochandle *P) 19997c478bd9Sstevel@tonic-gate { 20007c478bd9Sstevel@tonic-gate int ctlfd = (P->agentctlfd >= 0)? P->agentctlfd : P->ctlfd; 20017c478bd9Sstevel@tonic-gate long ctl = PCCSIG; 20027c478bd9Sstevel@tonic-gate 20037c478bd9Sstevel@tonic-gate if (write(ctlfd, &ctl, sizeof (ctl)) != sizeof (ctl)) 20047c478bd9Sstevel@tonic-gate return (-1); 20057c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_cursig = 0; 20067c478bd9Sstevel@tonic-gate return (0); 20077c478bd9Sstevel@tonic-gate } 20087c478bd9Sstevel@tonic-gate 20097c478bd9Sstevel@tonic-gate int 20107c478bd9Sstevel@tonic-gate Pclearfault(struct ps_prochandle *P) 20117c478bd9Sstevel@tonic-gate { 20127c478bd9Sstevel@tonic-gate int ctlfd = (P->agentctlfd >= 0)? P->agentctlfd : P->ctlfd; 20137c478bd9Sstevel@tonic-gate long ctl = PCCFAULT; 20147c478bd9Sstevel@tonic-gate 20157c478bd9Sstevel@tonic-gate if (write(ctlfd, &ctl, sizeof (ctl)) != sizeof (ctl)) 20167c478bd9Sstevel@tonic-gate return (-1); 20177c478bd9Sstevel@tonic-gate return (0); 20187c478bd9Sstevel@tonic-gate } 20197c478bd9Sstevel@tonic-gate 20207c478bd9Sstevel@tonic-gate /* 20217c478bd9Sstevel@tonic-gate * Set a breakpoint trap, return original instruction. 20227c478bd9Sstevel@tonic-gate */ 20237c478bd9Sstevel@tonic-gate int 20247c478bd9Sstevel@tonic-gate Psetbkpt(struct ps_prochandle *P, uintptr_t address, ulong_t *saved) 20257c478bd9Sstevel@tonic-gate { 20267c478bd9Sstevel@tonic-gate long ctl[1 + sizeof (priovec_t) / sizeof (long) + /* PCREAD */ 20277c478bd9Sstevel@tonic-gate 1 + sizeof (priovec_t) / sizeof (long)]; /* PCWRITE */ 20287c478bd9Sstevel@tonic-gate long *ctlp = ctl; 20297c478bd9Sstevel@tonic-gate size_t size; 20307c478bd9Sstevel@tonic-gate priovec_t *iovp; 20317c478bd9Sstevel@tonic-gate instr_t bpt = BPT; 20327c478bd9Sstevel@tonic-gate instr_t old; 20337c478bd9Sstevel@tonic-gate 20347c478bd9Sstevel@tonic-gate if (P->state == PS_DEAD || P->state == PS_UNDEAD || 20357c478bd9Sstevel@tonic-gate P->state == PS_IDLE) { 20367c478bd9Sstevel@tonic-gate errno = ENOENT; 20377c478bd9Sstevel@tonic-gate return (-1); 20387c478bd9Sstevel@tonic-gate } 20397c478bd9Sstevel@tonic-gate 20407c478bd9Sstevel@tonic-gate /* fetch the old instruction */ 20417c478bd9Sstevel@tonic-gate *ctlp++ = PCREAD; 20427c478bd9Sstevel@tonic-gate iovp = (priovec_t *)ctlp; 20437c478bd9Sstevel@tonic-gate iovp->pio_base = &old; 20447c478bd9Sstevel@tonic-gate iovp->pio_len = sizeof (old); 20457c478bd9Sstevel@tonic-gate iovp->pio_offset = address; 20467c478bd9Sstevel@tonic-gate ctlp += sizeof (priovec_t) / sizeof (long); 20477c478bd9Sstevel@tonic-gate 20487c478bd9Sstevel@tonic-gate /* write the BPT instruction */ 20497c478bd9Sstevel@tonic-gate *ctlp++ = PCWRITE; 20507c478bd9Sstevel@tonic-gate iovp = (priovec_t *)ctlp; 20517c478bd9Sstevel@tonic-gate iovp->pio_base = &bpt; 20527c478bd9Sstevel@tonic-gate iovp->pio_len = sizeof (bpt); 20537c478bd9Sstevel@tonic-gate iovp->pio_offset = address; 20547c478bd9Sstevel@tonic-gate ctlp += sizeof (priovec_t) / sizeof (long); 20557c478bd9Sstevel@tonic-gate 20567c478bd9Sstevel@tonic-gate size = (char *)ctlp - (char *)ctl; 20577c478bd9Sstevel@tonic-gate if (write(P->ctlfd, ctl, size) != size) 20587c478bd9Sstevel@tonic-gate return (-1); 20597c478bd9Sstevel@tonic-gate 20607c478bd9Sstevel@tonic-gate /* 20617c478bd9Sstevel@tonic-gate * Fail if there was already a breakpoint there from another debugger 20627c478bd9Sstevel@tonic-gate * or DTrace's user-level tracing on x86. 20637c478bd9Sstevel@tonic-gate */ 2064*e4586ebfSmws if (old == BPT) { 2065*e4586ebfSmws errno = EBUSY; 2066*e4586ebfSmws return (-1); 2067*e4586ebfSmws } 20687c478bd9Sstevel@tonic-gate 20697c478bd9Sstevel@tonic-gate *saved = (ulong_t)old; 20707c478bd9Sstevel@tonic-gate return (0); 20717c478bd9Sstevel@tonic-gate } 20727c478bd9Sstevel@tonic-gate 20737c478bd9Sstevel@tonic-gate /* 20747c478bd9Sstevel@tonic-gate * Restore original instruction where a breakpoint was set. 20757c478bd9Sstevel@tonic-gate */ 20767c478bd9Sstevel@tonic-gate int 20777c478bd9Sstevel@tonic-gate Pdelbkpt(struct ps_prochandle *P, uintptr_t address, ulong_t saved) 20787c478bd9Sstevel@tonic-gate { 20797c478bd9Sstevel@tonic-gate instr_t old = (instr_t)saved; 20807c478bd9Sstevel@tonic-gate instr_t cur; 20817c478bd9Sstevel@tonic-gate 20827c478bd9Sstevel@tonic-gate if (P->state == PS_DEAD || P->state == PS_UNDEAD || 20837c478bd9Sstevel@tonic-gate P->state == PS_IDLE) { 20847c478bd9Sstevel@tonic-gate errno = ENOENT; 20857c478bd9Sstevel@tonic-gate return (-1); 20867c478bd9Sstevel@tonic-gate } 20877c478bd9Sstevel@tonic-gate 20887c478bd9Sstevel@tonic-gate /* 20897c478bd9Sstevel@tonic-gate * If the breakpoint instruction we had placed has been overwritten 20907c478bd9Sstevel@tonic-gate * with a new instruction, then don't try to replace it with the 20917c478bd9Sstevel@tonic-gate * old instruction. Doing do can cause problems with self-modifying 20927c478bd9Sstevel@tonic-gate * code -- PLTs for example. If the Pread() fails, we assume that we 20937c478bd9Sstevel@tonic-gate * should proceed though most likely the Pwrite() will also fail. 20947c478bd9Sstevel@tonic-gate */ 20957c478bd9Sstevel@tonic-gate if (Pread(P, &cur, sizeof (cur), address) == sizeof (cur) && 20967c478bd9Sstevel@tonic-gate cur != BPT) 20977c478bd9Sstevel@tonic-gate return (0); 20987c478bd9Sstevel@tonic-gate 20997c478bd9Sstevel@tonic-gate if (Pwrite(P, &old, sizeof (old), address) != sizeof (old)) 21007c478bd9Sstevel@tonic-gate return (-1); 21017c478bd9Sstevel@tonic-gate 21027c478bd9Sstevel@tonic-gate return (0); 21037c478bd9Sstevel@tonic-gate } 21047c478bd9Sstevel@tonic-gate 21057c478bd9Sstevel@tonic-gate /* 21067c478bd9Sstevel@tonic-gate * Common code for Pxecbkpt() and Lxecbkpt(). 21077c478bd9Sstevel@tonic-gate * Develop the array of requests that will do the job, then 21087c478bd9Sstevel@tonic-gate * write them to the specified control file descriptor. 21097c478bd9Sstevel@tonic-gate * Return the non-zero errno if the write fails. 21107c478bd9Sstevel@tonic-gate */ 21117c478bd9Sstevel@tonic-gate static int 21127c478bd9Sstevel@tonic-gate execute_bkpt( 21137c478bd9Sstevel@tonic-gate int ctlfd, /* process or LWP control file descriptor */ 21147c478bd9Sstevel@tonic-gate const fltset_t *faultset, /* current set of traced faults */ 21157c478bd9Sstevel@tonic-gate const sigset_t *sigmask, /* current signal mask */ 21167c478bd9Sstevel@tonic-gate uintptr_t address, /* address of breakpint */ 21177c478bd9Sstevel@tonic-gate ulong_t saved) /* the saved instruction */ 21187c478bd9Sstevel@tonic-gate { 21197c478bd9Sstevel@tonic-gate long ctl[ 21207c478bd9Sstevel@tonic-gate 1 + sizeof (sigset_t) / sizeof (long) + /* PCSHOLD */ 21217c478bd9Sstevel@tonic-gate 1 + sizeof (fltset_t) / sizeof (long) + /* PCSFAULT */ 21227c478bd9Sstevel@tonic-gate 1 + sizeof (priovec_t) / sizeof (long) + /* PCWRITE */ 21237c478bd9Sstevel@tonic-gate 2 + /* PCRUN */ 21247c478bd9Sstevel@tonic-gate 1 + /* PCWSTOP */ 21257c478bd9Sstevel@tonic-gate 1 + /* PCCFAULT */ 21267c478bd9Sstevel@tonic-gate 1 + sizeof (priovec_t) / sizeof (long) + /* PCWRITE */ 21277c478bd9Sstevel@tonic-gate 1 + sizeof (fltset_t) / sizeof (long) + /* PCSFAULT */ 21287c478bd9Sstevel@tonic-gate 1 + sizeof (sigset_t) / sizeof (long)]; /* PCSHOLD */ 21297c478bd9Sstevel@tonic-gate long *ctlp = ctl; 21307c478bd9Sstevel@tonic-gate sigset_t unblock; 21317c478bd9Sstevel@tonic-gate size_t size; 21327c478bd9Sstevel@tonic-gate ssize_t ssize; 21337c478bd9Sstevel@tonic-gate priovec_t *iovp; 21347c478bd9Sstevel@tonic-gate sigset_t *holdp; 21357c478bd9Sstevel@tonic-gate fltset_t *faultp; 21367c478bd9Sstevel@tonic-gate instr_t old = (instr_t)saved; 21377c478bd9Sstevel@tonic-gate instr_t bpt = BPT; 21387c478bd9Sstevel@tonic-gate int error = 0; 21397c478bd9Sstevel@tonic-gate 21407c478bd9Sstevel@tonic-gate /* block our signals for the duration */ 21417c478bd9Sstevel@tonic-gate (void) sigprocmask(SIG_BLOCK, &blockable_sigs, &unblock); 21427c478bd9Sstevel@tonic-gate 21437c478bd9Sstevel@tonic-gate /* hold posted signals */ 21447c478bd9Sstevel@tonic-gate *ctlp++ = PCSHOLD; 21457c478bd9Sstevel@tonic-gate holdp = (sigset_t *)ctlp; 21467c478bd9Sstevel@tonic-gate prfillset(holdp); 21477c478bd9Sstevel@tonic-gate prdelset(holdp, SIGKILL); 21487c478bd9Sstevel@tonic-gate prdelset(holdp, SIGSTOP); 21497c478bd9Sstevel@tonic-gate ctlp += sizeof (sigset_t) / sizeof (long); 21507c478bd9Sstevel@tonic-gate 21517c478bd9Sstevel@tonic-gate /* force tracing of FLTTRACE */ 21527c478bd9Sstevel@tonic-gate if (!(prismember(faultset, FLTTRACE))) { 21537c478bd9Sstevel@tonic-gate *ctlp++ = PCSFAULT; 21547c478bd9Sstevel@tonic-gate faultp = (fltset_t *)ctlp; 21557c478bd9Sstevel@tonic-gate *faultp = *faultset; 21567c478bd9Sstevel@tonic-gate praddset(faultp, FLTTRACE); 21577c478bd9Sstevel@tonic-gate ctlp += sizeof (fltset_t) / sizeof (long); 21587c478bd9Sstevel@tonic-gate } 21597c478bd9Sstevel@tonic-gate 21607c478bd9Sstevel@tonic-gate /* restore the old instruction */ 21617c478bd9Sstevel@tonic-gate *ctlp++ = PCWRITE; 21627c478bd9Sstevel@tonic-gate iovp = (priovec_t *)ctlp; 21637c478bd9Sstevel@tonic-gate iovp->pio_base = &old; 21647c478bd9Sstevel@tonic-gate iovp->pio_len = sizeof (old); 21657c478bd9Sstevel@tonic-gate iovp->pio_offset = address; 21667c478bd9Sstevel@tonic-gate ctlp += sizeof (priovec_t) / sizeof (long); 21677c478bd9Sstevel@tonic-gate 21687c478bd9Sstevel@tonic-gate /* clear current signal and fault; set running w/ single-step */ 21697c478bd9Sstevel@tonic-gate *ctlp++ = PCRUN; 21707c478bd9Sstevel@tonic-gate *ctlp++ = PRCSIG | PRCFAULT | PRSTEP; 21717c478bd9Sstevel@tonic-gate 21727c478bd9Sstevel@tonic-gate /* wait for stop, cancel the fault */ 21737c478bd9Sstevel@tonic-gate *ctlp++ = PCWSTOP; 21747c478bd9Sstevel@tonic-gate *ctlp++ = PCCFAULT; 21757c478bd9Sstevel@tonic-gate 21767c478bd9Sstevel@tonic-gate /* restore the breakpoint trap */ 21777c478bd9Sstevel@tonic-gate *ctlp++ = PCWRITE; 21787c478bd9Sstevel@tonic-gate iovp = (priovec_t *)ctlp; 21797c478bd9Sstevel@tonic-gate iovp->pio_base = &bpt; 21807c478bd9Sstevel@tonic-gate iovp->pio_len = sizeof (bpt); 21817c478bd9Sstevel@tonic-gate iovp->pio_offset = address; 21827c478bd9Sstevel@tonic-gate ctlp += sizeof (priovec_t) / sizeof (long); 21837c478bd9Sstevel@tonic-gate 21847c478bd9Sstevel@tonic-gate /* restore fault tracing set */ 21857c478bd9Sstevel@tonic-gate if (!(prismember(faultset, FLTTRACE))) { 21867c478bd9Sstevel@tonic-gate *ctlp++ = PCSFAULT; 21877c478bd9Sstevel@tonic-gate *(fltset_t *)ctlp = *faultset; 21887c478bd9Sstevel@tonic-gate ctlp += sizeof (fltset_t) / sizeof (long); 21897c478bd9Sstevel@tonic-gate } 21907c478bd9Sstevel@tonic-gate 21917c478bd9Sstevel@tonic-gate /* restore the hold mask */ 21927c478bd9Sstevel@tonic-gate *ctlp++ = PCSHOLD; 21937c478bd9Sstevel@tonic-gate *(sigset_t *)ctlp = *sigmask; 21947c478bd9Sstevel@tonic-gate ctlp += sizeof (sigset_t) / sizeof (long); 21957c478bd9Sstevel@tonic-gate 21967c478bd9Sstevel@tonic-gate size = (char *)ctlp - (char *)ctl; 21977c478bd9Sstevel@tonic-gate if ((ssize = write(ctlfd, ctl, size)) != size) 21987c478bd9Sstevel@tonic-gate error = (ssize == -1)? errno : EINTR; 21997c478bd9Sstevel@tonic-gate (void) sigprocmask(SIG_SETMASK, &unblock, NULL); 22007c478bd9Sstevel@tonic-gate return (error); 22017c478bd9Sstevel@tonic-gate } 22027c478bd9Sstevel@tonic-gate 22037c478bd9Sstevel@tonic-gate /* 22047c478bd9Sstevel@tonic-gate * Step over a breakpoint, i.e., execute the instruction that 22057c478bd9Sstevel@tonic-gate * really belongs at the breakpoint location (the current %pc) 22067c478bd9Sstevel@tonic-gate * and leave the process stopped at the next instruction. 22077c478bd9Sstevel@tonic-gate */ 22087c478bd9Sstevel@tonic-gate int 22097c478bd9Sstevel@tonic-gate Pxecbkpt(struct ps_prochandle *P, ulong_t saved) 22107c478bd9Sstevel@tonic-gate { 22117c478bd9Sstevel@tonic-gate int ctlfd = (P->agentctlfd >= 0)? P->agentctlfd : P->ctlfd; 22127c478bd9Sstevel@tonic-gate int rv, error; 22137c478bd9Sstevel@tonic-gate 22147c478bd9Sstevel@tonic-gate if (P->state != PS_STOP) { 22157c478bd9Sstevel@tonic-gate errno = EBUSY; 22167c478bd9Sstevel@tonic-gate return (-1); 22177c478bd9Sstevel@tonic-gate } 22187c478bd9Sstevel@tonic-gate 22197c478bd9Sstevel@tonic-gate Psync(P); 22207c478bd9Sstevel@tonic-gate 22217c478bd9Sstevel@tonic-gate error = execute_bkpt(ctlfd, 22227c478bd9Sstevel@tonic-gate &P->status.pr_flttrace, &P->status.pr_lwp.pr_lwphold, 22237c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_reg[R_PC], saved); 22247c478bd9Sstevel@tonic-gate rv = Pstopstatus(P, PCNULL, 0); 22257c478bd9Sstevel@tonic-gate 22267c478bd9Sstevel@tonic-gate if (error != 0) { 22277c478bd9Sstevel@tonic-gate if (P->status.pr_lwp.pr_why == PR_JOBCONTROL && 22287c478bd9Sstevel@tonic-gate error == EBUSY) { /* jobcontrol stop -- back off */ 22297c478bd9Sstevel@tonic-gate P->state = PS_RUN; 22307c478bd9Sstevel@tonic-gate return (0); 22317c478bd9Sstevel@tonic-gate } 22327c478bd9Sstevel@tonic-gate if (error == ENOENT) 22337c478bd9Sstevel@tonic-gate return (0); 22347c478bd9Sstevel@tonic-gate errno = error; 22357c478bd9Sstevel@tonic-gate return (-1); 22367c478bd9Sstevel@tonic-gate } 22377c478bd9Sstevel@tonic-gate 22387c478bd9Sstevel@tonic-gate return (rv); 22397c478bd9Sstevel@tonic-gate } 22407c478bd9Sstevel@tonic-gate 22417c478bd9Sstevel@tonic-gate /* 22427c478bd9Sstevel@tonic-gate * Install the watchpoint described by wp. 22437c478bd9Sstevel@tonic-gate */ 22447c478bd9Sstevel@tonic-gate int 22457c478bd9Sstevel@tonic-gate Psetwapt(struct ps_prochandle *P, const prwatch_t *wp) 22467c478bd9Sstevel@tonic-gate { 22477c478bd9Sstevel@tonic-gate long ctl[1 + sizeof (prwatch_t) / sizeof (long)]; 22487c478bd9Sstevel@tonic-gate prwatch_t *cwp = (prwatch_t *)&ctl[1]; 22497c478bd9Sstevel@tonic-gate 22507c478bd9Sstevel@tonic-gate if (P->state == PS_DEAD || P->state == PS_UNDEAD || 22517c478bd9Sstevel@tonic-gate P->state == PS_IDLE) { 22527c478bd9Sstevel@tonic-gate errno = ENOENT; 22537c478bd9Sstevel@tonic-gate return (-1); 22547c478bd9Sstevel@tonic-gate } 22557c478bd9Sstevel@tonic-gate 22567c478bd9Sstevel@tonic-gate ctl[0] = PCWATCH; 22577c478bd9Sstevel@tonic-gate cwp->pr_vaddr = wp->pr_vaddr; 22587c478bd9Sstevel@tonic-gate cwp->pr_size = wp->pr_size; 22597c478bd9Sstevel@tonic-gate cwp->pr_wflags = wp->pr_wflags; 22607c478bd9Sstevel@tonic-gate 22617c478bd9Sstevel@tonic-gate if (write(P->ctlfd, ctl, sizeof (ctl)) != sizeof (ctl)) 22627c478bd9Sstevel@tonic-gate return (-1); 22637c478bd9Sstevel@tonic-gate 22647c478bd9Sstevel@tonic-gate return (0); 22657c478bd9Sstevel@tonic-gate } 22667c478bd9Sstevel@tonic-gate 22677c478bd9Sstevel@tonic-gate /* 22687c478bd9Sstevel@tonic-gate * Remove the watchpoint described by wp. 22697c478bd9Sstevel@tonic-gate */ 22707c478bd9Sstevel@tonic-gate int 22717c478bd9Sstevel@tonic-gate Pdelwapt(struct ps_prochandle *P, const prwatch_t *wp) 22727c478bd9Sstevel@tonic-gate { 22737c478bd9Sstevel@tonic-gate long ctl[1 + sizeof (prwatch_t) / sizeof (long)]; 22747c478bd9Sstevel@tonic-gate prwatch_t *cwp = (prwatch_t *)&ctl[1]; 22757c478bd9Sstevel@tonic-gate 22767c478bd9Sstevel@tonic-gate if (P->state == PS_DEAD || P->state == PS_UNDEAD || 22777c478bd9Sstevel@tonic-gate P->state == PS_IDLE) { 22787c478bd9Sstevel@tonic-gate errno = ENOENT; 22797c478bd9Sstevel@tonic-gate return (-1); 22807c478bd9Sstevel@tonic-gate } 22817c478bd9Sstevel@tonic-gate 22827c478bd9Sstevel@tonic-gate ctl[0] = PCWATCH; 22837c478bd9Sstevel@tonic-gate cwp->pr_vaddr = wp->pr_vaddr; 22847c478bd9Sstevel@tonic-gate cwp->pr_size = wp->pr_size; 22857c478bd9Sstevel@tonic-gate cwp->pr_wflags = 0; 22867c478bd9Sstevel@tonic-gate 22877c478bd9Sstevel@tonic-gate if (write(P->ctlfd, ctl, sizeof (ctl)) != sizeof (ctl)) 22887c478bd9Sstevel@tonic-gate return (-1); 22897c478bd9Sstevel@tonic-gate 22907c478bd9Sstevel@tonic-gate return (0); 22917c478bd9Sstevel@tonic-gate } 22927c478bd9Sstevel@tonic-gate 22937c478bd9Sstevel@tonic-gate /* 22947c478bd9Sstevel@tonic-gate * Common code for Pxecwapt() and Lxecwapt(). Develop the array of requests 22957c478bd9Sstevel@tonic-gate * that will do the job, then write them to the specified control file 22967c478bd9Sstevel@tonic-gate * descriptor. Return the non-zero errno if the write fails. 22977c478bd9Sstevel@tonic-gate */ 22987c478bd9Sstevel@tonic-gate static int 22997c478bd9Sstevel@tonic-gate execute_wapt( 23007c478bd9Sstevel@tonic-gate int ctlfd, /* process or LWP control file descriptor */ 23017c478bd9Sstevel@tonic-gate const fltset_t *faultset, /* current set of traced faults */ 23027c478bd9Sstevel@tonic-gate const sigset_t *sigmask, /* current signal mask */ 23037c478bd9Sstevel@tonic-gate const prwatch_t *wp) /* watchpoint descriptor */ 23047c478bd9Sstevel@tonic-gate { 23057c478bd9Sstevel@tonic-gate long ctl[ 23067c478bd9Sstevel@tonic-gate 1 + sizeof (sigset_t) / sizeof (long) + /* PCSHOLD */ 23077c478bd9Sstevel@tonic-gate 1 + sizeof (fltset_t) / sizeof (long) + /* PCSFAULT */ 23087c478bd9Sstevel@tonic-gate 1 + sizeof (prwatch_t) / sizeof (long) + /* PCWATCH */ 23097c478bd9Sstevel@tonic-gate 2 + /* PCRUN */ 23107c478bd9Sstevel@tonic-gate 1 + /* PCWSTOP */ 23117c478bd9Sstevel@tonic-gate 1 + /* PCCFAULT */ 23127c478bd9Sstevel@tonic-gate 1 + sizeof (prwatch_t) / sizeof (long) + /* PCWATCH */ 23137c478bd9Sstevel@tonic-gate 1 + sizeof (fltset_t) / sizeof (long) + /* PCSFAULT */ 23147c478bd9Sstevel@tonic-gate 1 + sizeof (sigset_t) / sizeof (long)]; /* PCSHOLD */ 23157c478bd9Sstevel@tonic-gate 23167c478bd9Sstevel@tonic-gate long *ctlp = ctl; 23177c478bd9Sstevel@tonic-gate int error = 0; 23187c478bd9Sstevel@tonic-gate 23197c478bd9Sstevel@tonic-gate sigset_t unblock; 23207c478bd9Sstevel@tonic-gate sigset_t *holdp; 23217c478bd9Sstevel@tonic-gate fltset_t *faultp; 23227c478bd9Sstevel@tonic-gate prwatch_t *prw; 23237c478bd9Sstevel@tonic-gate ssize_t ssize; 23247c478bd9Sstevel@tonic-gate size_t size; 23257c478bd9Sstevel@tonic-gate 23267c478bd9Sstevel@tonic-gate (void) sigprocmask(SIG_BLOCK, &blockable_sigs, &unblock); 23277c478bd9Sstevel@tonic-gate 23287c478bd9Sstevel@tonic-gate /* 23297c478bd9Sstevel@tonic-gate * Hold all posted signals in the victim process prior to stepping. 23307c478bd9Sstevel@tonic-gate */ 23317c478bd9Sstevel@tonic-gate *ctlp++ = PCSHOLD; 23327c478bd9Sstevel@tonic-gate holdp = (sigset_t *)ctlp; 23337c478bd9Sstevel@tonic-gate prfillset(holdp); 23347c478bd9Sstevel@tonic-gate prdelset(holdp, SIGKILL); 23357c478bd9Sstevel@tonic-gate prdelset(holdp, SIGSTOP); 23367c478bd9Sstevel@tonic-gate ctlp += sizeof (sigset_t) / sizeof (long); 23377c478bd9Sstevel@tonic-gate 23387c478bd9Sstevel@tonic-gate /* 23397c478bd9Sstevel@tonic-gate * Force tracing of FLTTRACE since we need to single step. 23407c478bd9Sstevel@tonic-gate */ 23417c478bd9Sstevel@tonic-gate if (!(prismember(faultset, FLTTRACE))) { 23427c478bd9Sstevel@tonic-gate *ctlp++ = PCSFAULT; 23437c478bd9Sstevel@tonic-gate faultp = (fltset_t *)ctlp; 23447c478bd9Sstevel@tonic-gate *faultp = *faultset; 23457c478bd9Sstevel@tonic-gate praddset(faultp, FLTTRACE); 23467c478bd9Sstevel@tonic-gate ctlp += sizeof (fltset_t) / sizeof (long); 23477c478bd9Sstevel@tonic-gate } 23487c478bd9Sstevel@tonic-gate 23497c478bd9Sstevel@tonic-gate /* 23507c478bd9Sstevel@tonic-gate * Clear only the current watchpoint by setting pr_wflags to zero. 23517c478bd9Sstevel@tonic-gate */ 23527c478bd9Sstevel@tonic-gate *ctlp++ = PCWATCH; 23537c478bd9Sstevel@tonic-gate prw = (prwatch_t *)ctlp; 23547c478bd9Sstevel@tonic-gate prw->pr_vaddr = wp->pr_vaddr; 23557c478bd9Sstevel@tonic-gate prw->pr_size = wp->pr_size; 23567c478bd9Sstevel@tonic-gate prw->pr_wflags = 0; 23577c478bd9Sstevel@tonic-gate ctlp += sizeof (prwatch_t) / sizeof (long); 23587c478bd9Sstevel@tonic-gate 23597c478bd9Sstevel@tonic-gate /* 23607c478bd9Sstevel@tonic-gate * Clear the current signal and fault; set running with single-step. 23617c478bd9Sstevel@tonic-gate * Then wait for the victim to stop and cancel the FLTTRACE. 23627c478bd9Sstevel@tonic-gate */ 23637c478bd9Sstevel@tonic-gate *ctlp++ = PCRUN; 23647c478bd9Sstevel@tonic-gate *ctlp++ = PRCSIG | PRCFAULT | PRSTEP; 23657c478bd9Sstevel@tonic-gate *ctlp++ = PCWSTOP; 23667c478bd9Sstevel@tonic-gate *ctlp++ = PCCFAULT; 23677c478bd9Sstevel@tonic-gate 23687c478bd9Sstevel@tonic-gate /* 23697c478bd9Sstevel@tonic-gate * Restore the current watchpoint. 23707c478bd9Sstevel@tonic-gate */ 23717c478bd9Sstevel@tonic-gate *ctlp++ = PCWATCH; 23727c478bd9Sstevel@tonic-gate (void) memcpy(ctlp, wp, sizeof (prwatch_t)); 23737c478bd9Sstevel@tonic-gate ctlp += sizeof (prwatch_t) / sizeof (long); 23747c478bd9Sstevel@tonic-gate 23757c478bd9Sstevel@tonic-gate /* 23767c478bd9Sstevel@tonic-gate * Restore fault tracing set if we modified it. 23777c478bd9Sstevel@tonic-gate */ 23787c478bd9Sstevel@tonic-gate if (!(prismember(faultset, FLTTRACE))) { 23797c478bd9Sstevel@tonic-gate *ctlp++ = PCSFAULT; 23807c478bd9Sstevel@tonic-gate *(fltset_t *)ctlp = *faultset; 23817c478bd9Sstevel@tonic-gate ctlp += sizeof (fltset_t) / sizeof (long); 23827c478bd9Sstevel@tonic-gate } 23837c478bd9Sstevel@tonic-gate 23847c478bd9Sstevel@tonic-gate /* 23857c478bd9Sstevel@tonic-gate * Restore the hold mask to the current hold mask (i.e. the one 23867c478bd9Sstevel@tonic-gate * before we executed any of the previous operations). 23877c478bd9Sstevel@tonic-gate */ 23887c478bd9Sstevel@tonic-gate *ctlp++ = PCSHOLD; 23897c478bd9Sstevel@tonic-gate *(sigset_t *)ctlp = *sigmask; 23907c478bd9Sstevel@tonic-gate ctlp += sizeof (sigset_t) / sizeof (long); 23917c478bd9Sstevel@tonic-gate 23927c478bd9Sstevel@tonic-gate size = (char *)ctlp - (char *)ctl; 23937c478bd9Sstevel@tonic-gate if ((ssize = write(ctlfd, ctl, size)) != size) 23947c478bd9Sstevel@tonic-gate error = (ssize == -1)? errno : EINTR; 23957c478bd9Sstevel@tonic-gate (void) sigprocmask(SIG_SETMASK, &unblock, NULL); 23967c478bd9Sstevel@tonic-gate return (error); 23977c478bd9Sstevel@tonic-gate } 23987c478bd9Sstevel@tonic-gate 23997c478bd9Sstevel@tonic-gate /* 24007c478bd9Sstevel@tonic-gate * Step over a watchpoint, i.e., execute the instruction that was stopped by 24017c478bd9Sstevel@tonic-gate * the watchpoint, and then leave the LWP stopped at the next instruction. 24027c478bd9Sstevel@tonic-gate */ 24037c478bd9Sstevel@tonic-gate int 24047c478bd9Sstevel@tonic-gate Pxecwapt(struct ps_prochandle *P, const prwatch_t *wp) 24057c478bd9Sstevel@tonic-gate { 24067c478bd9Sstevel@tonic-gate int ctlfd = (P->agentctlfd >= 0)? P->agentctlfd : P->ctlfd; 24077c478bd9Sstevel@tonic-gate int rv, error; 24087c478bd9Sstevel@tonic-gate 24097c478bd9Sstevel@tonic-gate if (P->state != PS_STOP) { 24107c478bd9Sstevel@tonic-gate errno = EBUSY; 24117c478bd9Sstevel@tonic-gate return (-1); 24127c478bd9Sstevel@tonic-gate } 24137c478bd9Sstevel@tonic-gate 24147c478bd9Sstevel@tonic-gate Psync(P); 24157c478bd9Sstevel@tonic-gate error = execute_wapt(ctlfd, 24167c478bd9Sstevel@tonic-gate &P->status.pr_flttrace, &P->status.pr_lwp.pr_lwphold, wp); 24177c478bd9Sstevel@tonic-gate rv = Pstopstatus(P, PCNULL, 0); 24187c478bd9Sstevel@tonic-gate 24197c478bd9Sstevel@tonic-gate if (error != 0) { 24207c478bd9Sstevel@tonic-gate if (P->status.pr_lwp.pr_why == PR_JOBCONTROL && 24217c478bd9Sstevel@tonic-gate error == EBUSY) { /* jobcontrol stop -- back off */ 24227c478bd9Sstevel@tonic-gate P->state = PS_RUN; 24237c478bd9Sstevel@tonic-gate return (0); 24247c478bd9Sstevel@tonic-gate } 24257c478bd9Sstevel@tonic-gate if (error == ENOENT) 24267c478bd9Sstevel@tonic-gate return (0); 24277c478bd9Sstevel@tonic-gate errno = error; 24287c478bd9Sstevel@tonic-gate return (-1); 24297c478bd9Sstevel@tonic-gate } 24307c478bd9Sstevel@tonic-gate 24317c478bd9Sstevel@tonic-gate return (rv); 24327c478bd9Sstevel@tonic-gate } 24337c478bd9Sstevel@tonic-gate 24347c478bd9Sstevel@tonic-gate int 24357c478bd9Sstevel@tonic-gate Psetflags(struct ps_prochandle *P, long flags) 24367c478bd9Sstevel@tonic-gate { 24377c478bd9Sstevel@tonic-gate int rc; 24387c478bd9Sstevel@tonic-gate long ctl[2]; 24397c478bd9Sstevel@tonic-gate 24407c478bd9Sstevel@tonic-gate ctl[0] = PCSET; 24417c478bd9Sstevel@tonic-gate ctl[1] = flags; 24427c478bd9Sstevel@tonic-gate 24437c478bd9Sstevel@tonic-gate if (write(P->ctlfd, ctl, 2*sizeof (long)) != 2*sizeof (long)) { 24447c478bd9Sstevel@tonic-gate rc = -1; 24457c478bd9Sstevel@tonic-gate } else { 24467c478bd9Sstevel@tonic-gate P->status.pr_flags |= flags; 24477c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_flags |= flags; 24487c478bd9Sstevel@tonic-gate rc = 0; 24497c478bd9Sstevel@tonic-gate } 24507c478bd9Sstevel@tonic-gate 24517c478bd9Sstevel@tonic-gate return (rc); 24527c478bd9Sstevel@tonic-gate } 24537c478bd9Sstevel@tonic-gate 24547c478bd9Sstevel@tonic-gate int 24557c478bd9Sstevel@tonic-gate Punsetflags(struct ps_prochandle *P, long flags) 24567c478bd9Sstevel@tonic-gate { 24577c478bd9Sstevel@tonic-gate int rc; 24587c478bd9Sstevel@tonic-gate long ctl[2]; 24597c478bd9Sstevel@tonic-gate 24607c478bd9Sstevel@tonic-gate ctl[0] = PCUNSET; 24617c478bd9Sstevel@tonic-gate ctl[1] = flags; 24627c478bd9Sstevel@tonic-gate 24637c478bd9Sstevel@tonic-gate if (write(P->ctlfd, ctl, 2*sizeof (long)) != 2*sizeof (long)) { 24647c478bd9Sstevel@tonic-gate rc = -1; 24657c478bd9Sstevel@tonic-gate } else { 24667c478bd9Sstevel@tonic-gate P->status.pr_flags &= ~flags; 24677c478bd9Sstevel@tonic-gate P->status.pr_lwp.pr_flags &= ~flags; 24687c478bd9Sstevel@tonic-gate rc = 0; 24697c478bd9Sstevel@tonic-gate } 24707c478bd9Sstevel@tonic-gate 24717c478bd9Sstevel@tonic-gate return (rc); 24727c478bd9Sstevel@tonic-gate } 24737c478bd9Sstevel@tonic-gate 24747c478bd9Sstevel@tonic-gate /* 24757c478bd9Sstevel@tonic-gate * Common function to allow clients to manipulate the action to be taken 24767c478bd9Sstevel@tonic-gate * on receipt of a signal, receipt of machine fault, entry to a system call, 24777c478bd9Sstevel@tonic-gate * or exit from a system call. We make use of our private prset_* functions 24787c478bd9Sstevel@tonic-gate * in order to make this code be common. The 'which' parameter identifies 24797c478bd9Sstevel@tonic-gate * the code for the event of interest (0 means change the entire set), and 24807c478bd9Sstevel@tonic-gate * the 'stop' parameter is a boolean indicating whether the process should 24817c478bd9Sstevel@tonic-gate * stop when the event of interest occurs. The previous value is returned 24827c478bd9Sstevel@tonic-gate * to the caller; -1 is returned if an error occurred. 24837c478bd9Sstevel@tonic-gate */ 24847c478bd9Sstevel@tonic-gate static int 24857c478bd9Sstevel@tonic-gate Psetaction(struct ps_prochandle *P, void *sp, size_t size, 24867c478bd9Sstevel@tonic-gate uint_t flag, int max, int which, int stop) 24877c478bd9Sstevel@tonic-gate { 24887c478bd9Sstevel@tonic-gate int oldval; 24897c478bd9Sstevel@tonic-gate 24907c478bd9Sstevel@tonic-gate if (which < 0 || which > max) { 24917c478bd9Sstevel@tonic-gate errno = EINVAL; 24927c478bd9Sstevel@tonic-gate return (-1); 24937c478bd9Sstevel@tonic-gate } 24947c478bd9Sstevel@tonic-gate 24957c478bd9Sstevel@tonic-gate if (P->state == PS_DEAD || P->state == PS_UNDEAD || 24967c478bd9Sstevel@tonic-gate P->state == PS_IDLE) { 24977c478bd9Sstevel@tonic-gate errno = ENOENT; 24987c478bd9Sstevel@tonic-gate return (-1); 24997c478bd9Sstevel@tonic-gate } 25007c478bd9Sstevel@tonic-gate 25017c478bd9Sstevel@tonic-gate oldval = prset_ismember(sp, size, which) ? TRUE : FALSE; 25027c478bd9Sstevel@tonic-gate 25037c478bd9Sstevel@tonic-gate if (stop) { 25047c478bd9Sstevel@tonic-gate if (which == 0) { 25057c478bd9Sstevel@tonic-gate prset_fill(sp, size); 25067c478bd9Sstevel@tonic-gate P->flags |= flag; 25077c478bd9Sstevel@tonic-gate } else if (!oldval) { 25087c478bd9Sstevel@tonic-gate prset_add(sp, size, which); 25097c478bd9Sstevel@tonic-gate P->flags |= flag; 25107c478bd9Sstevel@tonic-gate } 25117c478bd9Sstevel@tonic-gate } else { 25127c478bd9Sstevel@tonic-gate if (which == 0) { 25137c478bd9Sstevel@tonic-gate prset_empty(sp, size); 25147c478bd9Sstevel@tonic-gate P->flags |= flag; 25157c478bd9Sstevel@tonic-gate } else if (oldval) { 25167c478bd9Sstevel@tonic-gate prset_del(sp, size, which); 25177c478bd9Sstevel@tonic-gate P->flags |= flag; 25187c478bd9Sstevel@tonic-gate } 25197c478bd9Sstevel@tonic-gate } 25207c478bd9Sstevel@tonic-gate 25217c478bd9Sstevel@tonic-gate if (P->state == PS_RUN) 25227c478bd9Sstevel@tonic-gate Psync(P); 25237c478bd9Sstevel@tonic-gate 25247c478bd9Sstevel@tonic-gate return (oldval); 25257c478bd9Sstevel@tonic-gate } 25267c478bd9Sstevel@tonic-gate 25277c478bd9Sstevel@tonic-gate /* 25287c478bd9Sstevel@tonic-gate * Set action on specified signal. 25297c478bd9Sstevel@tonic-gate */ 25307c478bd9Sstevel@tonic-gate int 25317c478bd9Sstevel@tonic-gate Psignal(struct ps_prochandle *P, int which, int stop) 25327c478bd9Sstevel@tonic-gate { 25337c478bd9Sstevel@tonic-gate int oldval; 25347c478bd9Sstevel@tonic-gate 25357c478bd9Sstevel@tonic-gate if (which == SIGKILL && stop != 0) { 25367c478bd9Sstevel@tonic-gate errno = EINVAL; 25377c478bd9Sstevel@tonic-gate return (-1); 25387c478bd9Sstevel@tonic-gate } 25397c478bd9Sstevel@tonic-gate 25407c478bd9Sstevel@tonic-gate oldval = Psetaction(P, &P->status.pr_sigtrace, sizeof (sigset_t), 25417c478bd9Sstevel@tonic-gate SETSIG, PRMAXSIG, which, stop); 25427c478bd9Sstevel@tonic-gate 25437c478bd9Sstevel@tonic-gate if (oldval != -1 && which == 0 && stop != 0) 25447c478bd9Sstevel@tonic-gate prdelset(&P->status.pr_sigtrace, SIGKILL); 25457c478bd9Sstevel@tonic-gate 25467c478bd9Sstevel@tonic-gate return (oldval); 25477c478bd9Sstevel@tonic-gate } 25487c478bd9Sstevel@tonic-gate 25497c478bd9Sstevel@tonic-gate /* 25507c478bd9Sstevel@tonic-gate * Set all signal tracing flags. 25517c478bd9Sstevel@tonic-gate */ 25527c478bd9Sstevel@tonic-gate void 25537c478bd9Sstevel@tonic-gate Psetsignal(struct ps_prochandle *P, const sigset_t *set) 25547c478bd9Sstevel@tonic-gate { 25557c478bd9Sstevel@tonic-gate if (P->state == PS_DEAD || P->state == PS_UNDEAD || 25567c478bd9Sstevel@tonic-gate P->state == PS_IDLE) 25577c478bd9Sstevel@tonic-gate return; 25587c478bd9Sstevel@tonic-gate 25597c478bd9Sstevel@tonic-gate P->status.pr_sigtrace = *set; 25607c478bd9Sstevel@tonic-gate P->flags |= SETSIG; 25617c478bd9Sstevel@tonic-gate 25627c478bd9Sstevel@tonic-gate if (P->state == PS_RUN) 25637c478bd9Sstevel@tonic-gate Psync(P); 25647c478bd9Sstevel@tonic-gate } 25657c478bd9Sstevel@tonic-gate 25667c478bd9Sstevel@tonic-gate /* 25677c478bd9Sstevel@tonic-gate * Set action on specified fault. 25687c478bd9Sstevel@tonic-gate */ 25697c478bd9Sstevel@tonic-gate int 25707c478bd9Sstevel@tonic-gate Pfault(struct ps_prochandle *P, int which, int stop) 25717c478bd9Sstevel@tonic-gate { 25727c478bd9Sstevel@tonic-gate return (Psetaction(P, &P->status.pr_flttrace, sizeof (fltset_t), 25737c478bd9Sstevel@tonic-gate SETFAULT, PRMAXFAULT, which, stop)); 25747c478bd9Sstevel@tonic-gate } 25757c478bd9Sstevel@tonic-gate 25767c478bd9Sstevel@tonic-gate /* 25777c478bd9Sstevel@tonic-gate * Set all machine fault tracing flags. 25787c478bd9Sstevel@tonic-gate */ 25797c478bd9Sstevel@tonic-gate void 25807c478bd9Sstevel@tonic-gate Psetfault(struct ps_prochandle *P, const fltset_t *set) 25817c478bd9Sstevel@tonic-gate { 25827c478bd9Sstevel@tonic-gate if (P->state == PS_DEAD || P->state == PS_UNDEAD || 25837c478bd9Sstevel@tonic-gate P->state == PS_IDLE) 25847c478bd9Sstevel@tonic-gate return; 25857c478bd9Sstevel@tonic-gate 25867c478bd9Sstevel@tonic-gate P->status.pr_flttrace = *set; 25877c478bd9Sstevel@tonic-gate P->flags |= SETFAULT; 25887c478bd9Sstevel@tonic-gate 25897c478bd9Sstevel@tonic-gate if (P->state == PS_RUN) 25907c478bd9Sstevel@tonic-gate Psync(P); 25917c478bd9Sstevel@tonic-gate } 25927c478bd9Sstevel@tonic-gate 25937c478bd9Sstevel@tonic-gate /* 25947c478bd9Sstevel@tonic-gate * Set action on specified system call entry. 25957c478bd9Sstevel@tonic-gate */ 25967c478bd9Sstevel@tonic-gate int 25977c478bd9Sstevel@tonic-gate Psysentry(struct ps_prochandle *P, int which, int stop) 25987c478bd9Sstevel@tonic-gate { 25997c478bd9Sstevel@tonic-gate return (Psetaction(P, &P->status.pr_sysentry, sizeof (sysset_t), 26007c478bd9Sstevel@tonic-gate SETENTRY, PRMAXSYS, which, stop)); 26017c478bd9Sstevel@tonic-gate } 26027c478bd9Sstevel@tonic-gate 26037c478bd9Sstevel@tonic-gate /* 26047c478bd9Sstevel@tonic-gate * Set all system call entry tracing flags. 26057c478bd9Sstevel@tonic-gate */ 26067c478bd9Sstevel@tonic-gate void 26077c478bd9Sstevel@tonic-gate Psetsysentry(struct ps_prochandle *P, const sysset_t *set) 26087c478bd9Sstevel@tonic-gate { 26097c478bd9Sstevel@tonic-gate if (P->state == PS_DEAD || P->state == PS_UNDEAD || 26107c478bd9Sstevel@tonic-gate P->state == PS_IDLE) 26117c478bd9Sstevel@tonic-gate return; 26127c478bd9Sstevel@tonic-gate 26137c478bd9Sstevel@tonic-gate P->status.pr_sysentry = *set; 26147c478bd9Sstevel@tonic-gate P->flags |= SETENTRY; 26157c478bd9Sstevel@tonic-gate 26167c478bd9Sstevel@tonic-gate if (P->state == PS_RUN) 26177c478bd9Sstevel@tonic-gate Psync(P); 26187c478bd9Sstevel@tonic-gate } 26197c478bd9Sstevel@tonic-gate 26207c478bd9Sstevel@tonic-gate /* 26217c478bd9Sstevel@tonic-gate * Set action on specified system call exit. 26227c478bd9Sstevel@tonic-gate */ 26237c478bd9Sstevel@tonic-gate int 26247c478bd9Sstevel@tonic-gate Psysexit(struct ps_prochandle *P, int which, int stop) 26257c478bd9Sstevel@tonic-gate { 26267c478bd9Sstevel@tonic-gate return (Psetaction(P, &P->status.pr_sysexit, sizeof (sysset_t), 26277c478bd9Sstevel@tonic-gate SETEXIT, PRMAXSYS, which, stop)); 26287c478bd9Sstevel@tonic-gate } 26297c478bd9Sstevel@tonic-gate 26307c478bd9Sstevel@tonic-gate /* 26317c478bd9Sstevel@tonic-gate * Set all system call exit tracing flags. 26327c478bd9Sstevel@tonic-gate */ 26337c478bd9Sstevel@tonic-gate void 26347c478bd9Sstevel@tonic-gate Psetsysexit(struct ps_prochandle *P, const sysset_t *set) 26357c478bd9Sstevel@tonic-gate { 26367c478bd9Sstevel@tonic-gate if (P->state == PS_DEAD || P->state == PS_UNDEAD || 26377c478bd9Sstevel@tonic-gate P->state == PS_IDLE) 26387c478bd9Sstevel@tonic-gate return; 26397c478bd9Sstevel@tonic-gate 26407c478bd9Sstevel@tonic-gate P->status.pr_sysexit = *set; 26417c478bd9Sstevel@tonic-gate P->flags |= SETEXIT; 26427c478bd9Sstevel@tonic-gate 26437c478bd9Sstevel@tonic-gate if (P->state == PS_RUN) 26447c478bd9Sstevel@tonic-gate Psync(P); 26457c478bd9Sstevel@tonic-gate } 26467c478bd9Sstevel@tonic-gate 26477c478bd9Sstevel@tonic-gate /* 26487c478bd9Sstevel@tonic-gate * Utility function to read the contents of a file that contains a 26497c478bd9Sstevel@tonic-gate * prheader_t at the start (/proc/pid/lstatus or /proc/pid/lpsinfo). 26507c478bd9Sstevel@tonic-gate * Returns a malloc()d buffer or NULL on failure. 26517c478bd9Sstevel@tonic-gate */ 26527c478bd9Sstevel@tonic-gate static prheader_t * 26537c478bd9Sstevel@tonic-gate read_lfile(struct ps_prochandle *P, const char *lname) 26547c478bd9Sstevel@tonic-gate { 26557c478bd9Sstevel@tonic-gate prheader_t *Lhp; 26567c478bd9Sstevel@tonic-gate char lpath[64]; 26577c478bd9Sstevel@tonic-gate struct stat64 statb; 26587c478bd9Sstevel@tonic-gate int fd; 26597c478bd9Sstevel@tonic-gate size_t size; 26607c478bd9Sstevel@tonic-gate ssize_t rval; 26617c478bd9Sstevel@tonic-gate 26627c478bd9Sstevel@tonic-gate (void) snprintf(lpath, sizeof (lpath), "/proc/%d/%s", 26637c478bd9Sstevel@tonic-gate (int)P->status.pr_pid, lname); 26647c478bd9Sstevel@tonic-gate if ((fd = open(lpath, O_RDONLY)) < 0 || fstat64(fd, &statb) != 0) { 26657c478bd9Sstevel@tonic-gate if (fd >= 0) 26667c478bd9Sstevel@tonic-gate (void) close(fd); 26677c478bd9Sstevel@tonic-gate return (NULL); 26687c478bd9Sstevel@tonic-gate } 26697c478bd9Sstevel@tonic-gate 26707c478bd9Sstevel@tonic-gate /* 26717c478bd9Sstevel@tonic-gate * 'size' is just the initial guess at the buffer size. 26727c478bd9Sstevel@tonic-gate * It will have to grow if the number of lwps increases 26737c478bd9Sstevel@tonic-gate * while we are looking at the process. 26747c478bd9Sstevel@tonic-gate * 'size' must be larger than the actual file size. 26757c478bd9Sstevel@tonic-gate */ 26767c478bd9Sstevel@tonic-gate size = statb.st_size + 32; 26777c478bd9Sstevel@tonic-gate 26787c478bd9Sstevel@tonic-gate for (;;) { 26797c478bd9Sstevel@tonic-gate if ((Lhp = malloc(size)) == NULL) 26807c478bd9Sstevel@tonic-gate break; 26817c478bd9Sstevel@tonic-gate if ((rval = pread(fd, Lhp, size, 0)) < 0 || 26827c478bd9Sstevel@tonic-gate rval <= sizeof (prheader_t)) { 26837c478bd9Sstevel@tonic-gate free(Lhp); 26847c478bd9Sstevel@tonic-gate Lhp = NULL; 26857c478bd9Sstevel@tonic-gate break; 26867c478bd9Sstevel@tonic-gate } 26877c478bd9Sstevel@tonic-gate if (rval < size) 26887c478bd9Sstevel@tonic-gate break; 26897c478bd9Sstevel@tonic-gate /* need a bigger buffer */ 26907c478bd9Sstevel@tonic-gate free(Lhp); 26917c478bd9Sstevel@tonic-gate size *= 2; 26927c478bd9Sstevel@tonic-gate } 26937c478bd9Sstevel@tonic-gate 26947c478bd9Sstevel@tonic-gate (void) close(fd); 26957c478bd9Sstevel@tonic-gate return (Lhp); 26967c478bd9Sstevel@tonic-gate } 26977c478bd9Sstevel@tonic-gate 26987c478bd9Sstevel@tonic-gate /* 26997c478bd9Sstevel@tonic-gate * LWP iteration interface. 27007c478bd9Sstevel@tonic-gate */ 27017c478bd9Sstevel@tonic-gate int 27027c478bd9Sstevel@tonic-gate Plwp_iter(struct ps_prochandle *P, proc_lwp_f *func, void *cd) 27037c478bd9Sstevel@tonic-gate { 27047c478bd9Sstevel@tonic-gate prheader_t *Lhp; 27057c478bd9Sstevel@tonic-gate lwpstatus_t *Lsp; 27067c478bd9Sstevel@tonic-gate long nlwp; 27077c478bd9Sstevel@tonic-gate int rv; 27087c478bd9Sstevel@tonic-gate 27097c478bd9Sstevel@tonic-gate switch (P->state) { 27107c478bd9Sstevel@tonic-gate case PS_RUN: 27117c478bd9Sstevel@tonic-gate (void) Pstopstatus(P, PCNULL, 0); 27127c478bd9Sstevel@tonic-gate break; 27137c478bd9Sstevel@tonic-gate 27147c478bd9Sstevel@tonic-gate case PS_STOP: 27157c478bd9Sstevel@tonic-gate Psync(P); 27167c478bd9Sstevel@tonic-gate break; 27177c478bd9Sstevel@tonic-gate 27187c478bd9Sstevel@tonic-gate case PS_IDLE: 27197c478bd9Sstevel@tonic-gate errno = ENODATA; 27207c478bd9Sstevel@tonic-gate return (-1); 27217c478bd9Sstevel@tonic-gate } 27227c478bd9Sstevel@tonic-gate 27237c478bd9Sstevel@tonic-gate /* 27247c478bd9Sstevel@tonic-gate * For either live processes or cores, the single LWP case is easy: 27257c478bd9Sstevel@tonic-gate * the pstatus_t contains the lwpstatus_t for the only LWP. 27267c478bd9Sstevel@tonic-gate */ 27277c478bd9Sstevel@tonic-gate if (P->status.pr_nlwp <= 1) 27287c478bd9Sstevel@tonic-gate return (func(cd, &P->status.pr_lwp)); 27297c478bd9Sstevel@tonic-gate 27307c478bd9Sstevel@tonic-gate /* 27317c478bd9Sstevel@tonic-gate * For the core file multi-LWP case, we just iterate through the 27327c478bd9Sstevel@tonic-gate * list of LWP structs we read in from the core file. 27337c478bd9Sstevel@tonic-gate */ 27347c478bd9Sstevel@tonic-gate if (P->state == PS_DEAD) { 27357c478bd9Sstevel@tonic-gate lwp_info_t *lwp = list_prev(&P->core->core_lwp_head); 27367c478bd9Sstevel@tonic-gate uint_t i; 27377c478bd9Sstevel@tonic-gate 27387c478bd9Sstevel@tonic-gate for (i = 0; i < P->core->core_nlwp; i++, lwp = list_prev(lwp)) { 27397c478bd9Sstevel@tonic-gate if (lwp->lwp_psinfo.pr_sname != 'Z' && 27407c478bd9Sstevel@tonic-gate (rv = func(cd, &lwp->lwp_status)) != 0) 27417c478bd9Sstevel@tonic-gate break; 27427c478bd9Sstevel@tonic-gate } 27437c478bd9Sstevel@tonic-gate 27447c478bd9Sstevel@tonic-gate return (rv); 27457c478bd9Sstevel@tonic-gate } 27467c478bd9Sstevel@tonic-gate 27477c478bd9Sstevel@tonic-gate /* 27487c478bd9Sstevel@tonic-gate * For the live process multi-LWP case, we have to work a little 27497c478bd9Sstevel@tonic-gate * harder: the /proc/pid/lstatus file has the array of LWP structs. 27507c478bd9Sstevel@tonic-gate */ 27517c478bd9Sstevel@tonic-gate if ((Lhp = read_lfile(P, "lstatus")) == NULL) 27527c478bd9Sstevel@tonic-gate return (-1); 27537c478bd9Sstevel@tonic-gate 27547c478bd9Sstevel@tonic-gate for (nlwp = Lhp->pr_nent, Lsp = (lwpstatus_t *)(uintptr_t)(Lhp + 1); 27557c478bd9Sstevel@tonic-gate nlwp > 0; 27567c478bd9Sstevel@tonic-gate nlwp--, Lsp = (lwpstatus_t *)((uintptr_t)Lsp + Lhp->pr_entsize)) { 27577c478bd9Sstevel@tonic-gate if ((rv = func(cd, Lsp)) != 0) 27587c478bd9Sstevel@tonic-gate break; 27597c478bd9Sstevel@tonic-gate } 27607c478bd9Sstevel@tonic-gate 27617c478bd9Sstevel@tonic-gate free(Lhp); 27627c478bd9Sstevel@tonic-gate return (rv); 27637c478bd9Sstevel@tonic-gate } 27647c478bd9Sstevel@tonic-gate 27657c478bd9Sstevel@tonic-gate /* 27667c478bd9Sstevel@tonic-gate * Extended LWP iteration interface. 27677c478bd9Sstevel@tonic-gate * Iterate over all LWPs, active and zombie. 27687c478bd9Sstevel@tonic-gate */ 27697c478bd9Sstevel@tonic-gate int 27707c478bd9Sstevel@tonic-gate Plwp_iter_all(struct ps_prochandle *P, proc_lwp_all_f *func, void *cd) 27717c478bd9Sstevel@tonic-gate { 27727c478bd9Sstevel@tonic-gate prheader_t *Lhp = NULL; 27737c478bd9Sstevel@tonic-gate lwpstatus_t *Lsp; 27747c478bd9Sstevel@tonic-gate lwpstatus_t *sp; 27757c478bd9Sstevel@tonic-gate prheader_t *Lphp = NULL; 27767c478bd9Sstevel@tonic-gate lwpsinfo_t *Lpsp; 27777c478bd9Sstevel@tonic-gate long nstat; 27787c478bd9Sstevel@tonic-gate long ninfo; 27797c478bd9Sstevel@tonic-gate int rv; 27807c478bd9Sstevel@tonic-gate 27817c478bd9Sstevel@tonic-gate retry: 27827c478bd9Sstevel@tonic-gate if (Lhp != NULL) 27837c478bd9Sstevel@tonic-gate free(Lhp); 27847c478bd9Sstevel@tonic-gate if (Lphp != NULL) 27857c478bd9Sstevel@tonic-gate free(Lphp); 27867c478bd9Sstevel@tonic-gate if (P->state == PS_RUN) 27877c478bd9Sstevel@tonic-gate (void) Pstopstatus(P, PCNULL, 0); 27887c478bd9Sstevel@tonic-gate (void) Ppsinfo(P); 27897c478bd9Sstevel@tonic-gate 27907c478bd9Sstevel@tonic-gate if (P->state == PS_STOP) 27917c478bd9Sstevel@tonic-gate Psync(P); 27927c478bd9Sstevel@tonic-gate 27937c478bd9Sstevel@tonic-gate /* 27947c478bd9Sstevel@tonic-gate * For either live processes or cores, the single LWP case is easy: 27957c478bd9Sstevel@tonic-gate * the pstatus_t contains the lwpstatus_t for the only LWP and 27967c478bd9Sstevel@tonic-gate * the psinfo_t contains the lwpsinfo_t for the only LWP. 27977c478bd9Sstevel@tonic-gate */ 27987c478bd9Sstevel@tonic-gate if (P->status.pr_nlwp + P->status.pr_nzomb <= 1) 27997c478bd9Sstevel@tonic-gate return (func(cd, &P->status.pr_lwp, &P->psinfo.pr_lwp)); 28007c478bd9Sstevel@tonic-gate 28017c478bd9Sstevel@tonic-gate /* 28027c478bd9Sstevel@tonic-gate * For the core file multi-LWP case, we just iterate through the 28037c478bd9Sstevel@tonic-gate * list of LWP structs we read in from the core file. 28047c478bd9Sstevel@tonic-gate */ 28057c478bd9Sstevel@tonic-gate if (P->state == PS_DEAD) { 28067c478bd9Sstevel@tonic-gate lwp_info_t *lwp = list_prev(&P->core->core_lwp_head); 28077c478bd9Sstevel@tonic-gate uint_t i; 28087c478bd9Sstevel@tonic-gate 28097c478bd9Sstevel@tonic-gate for (i = 0; i < P->core->core_nlwp; i++, lwp = list_prev(lwp)) { 28107c478bd9Sstevel@tonic-gate sp = (lwp->lwp_psinfo.pr_sname == 'Z')? NULL : 28117c478bd9Sstevel@tonic-gate &lwp->lwp_status; 28127c478bd9Sstevel@tonic-gate if ((rv = func(cd, sp, &lwp->lwp_psinfo)) != 0) 28137c478bd9Sstevel@tonic-gate break; 28147c478bd9Sstevel@tonic-gate } 28157c478bd9Sstevel@tonic-gate 28167c478bd9Sstevel@tonic-gate return (rv); 28177c478bd9Sstevel@tonic-gate } 28187c478bd9Sstevel@tonic-gate 28197c478bd9Sstevel@tonic-gate /* 28207c478bd9Sstevel@tonic-gate * For the live process multi-LWP case, we have to work a little 28217c478bd9Sstevel@tonic-gate * harder: the /proc/pid/lstatus file has the array of lwpstatus_t's 28227c478bd9Sstevel@tonic-gate * and the /proc/pid/lpsinfo file has the array of lwpsinfo_t's. 28237c478bd9Sstevel@tonic-gate */ 28247c478bd9Sstevel@tonic-gate if ((Lhp = read_lfile(P, "lstatus")) == NULL) 28257c478bd9Sstevel@tonic-gate return (-1); 28267c478bd9Sstevel@tonic-gate if ((Lphp = read_lfile(P, "lpsinfo")) == NULL) { 28277c478bd9Sstevel@tonic-gate free(Lhp); 28287c478bd9Sstevel@tonic-gate return (-1); 28297c478bd9Sstevel@tonic-gate } 28307c478bd9Sstevel@tonic-gate 28317c478bd9Sstevel@tonic-gate /* 28327c478bd9Sstevel@tonic-gate * If we are looking at a running process, or one we do not control, 28337c478bd9Sstevel@tonic-gate * the active and zombie lwps in the process may have changed since 28347c478bd9Sstevel@tonic-gate * we read the process status structure. If so, just start over. 28357c478bd9Sstevel@tonic-gate */ 28367c478bd9Sstevel@tonic-gate if (Lhp->pr_nent != P->status.pr_nlwp || 28377c478bd9Sstevel@tonic-gate Lphp->pr_nent != P->status.pr_nlwp + P->status.pr_nzomb) 28387c478bd9Sstevel@tonic-gate goto retry; 28397c478bd9Sstevel@tonic-gate 28407c478bd9Sstevel@tonic-gate /* 28417c478bd9Sstevel@tonic-gate * To be perfectly safe, prescan the two arrays, checking consistency. 28427c478bd9Sstevel@tonic-gate * We rely on /proc giving us lwpstatus_t's and lwpsinfo_t's in the 28437c478bd9Sstevel@tonic-gate * same order (the lwp directory order) in their respective files. 28447c478bd9Sstevel@tonic-gate * We also rely on there being (possibly) more lwpsinfo_t's than 28457c478bd9Sstevel@tonic-gate * lwpstatus_t's (the extra lwpsinfo_t's are for zombie lwps). 28467c478bd9Sstevel@tonic-gate */ 28477c478bd9Sstevel@tonic-gate Lsp = (lwpstatus_t *)(uintptr_t)(Lhp + 1); 28487c478bd9Sstevel@tonic-gate Lpsp = (lwpsinfo_t *)(uintptr_t)(Lphp + 1); 28497c478bd9Sstevel@tonic-gate nstat = Lhp->pr_nent; 28507c478bd9Sstevel@tonic-gate for (ninfo = Lphp->pr_nent; ninfo != 0; ninfo--) { 28517c478bd9Sstevel@tonic-gate if (Lpsp->pr_sname != 'Z') { 28527c478bd9Sstevel@tonic-gate /* 28537c478bd9Sstevel@tonic-gate * Not a zombie lwp; check for matching lwpids. 28547c478bd9Sstevel@tonic-gate */ 28557c478bd9Sstevel@tonic-gate if (nstat == 0 || Lsp->pr_lwpid != Lpsp->pr_lwpid) 28567c478bd9Sstevel@tonic-gate goto retry; 28577c478bd9Sstevel@tonic-gate Lsp = (lwpstatus_t *)((uintptr_t)Lsp + Lhp->pr_entsize); 28587c478bd9Sstevel@tonic-gate nstat--; 28597c478bd9Sstevel@tonic-gate } 28607c478bd9Sstevel@tonic-gate Lpsp = (lwpsinfo_t *)((uintptr_t)Lpsp + Lphp->pr_entsize); 28617c478bd9Sstevel@tonic-gate } 28627c478bd9Sstevel@tonic-gate if (nstat != 0) 28637c478bd9Sstevel@tonic-gate goto retry; 28647c478bd9Sstevel@tonic-gate 28657c478bd9Sstevel@tonic-gate /* 28667c478bd9Sstevel@tonic-gate * Rescan, this time for real. 28677c478bd9Sstevel@tonic-gate */ 28687c478bd9Sstevel@tonic-gate Lsp = (lwpstatus_t *)(uintptr_t)(Lhp + 1); 28697c478bd9Sstevel@tonic-gate Lpsp = (lwpsinfo_t *)(uintptr_t)(Lphp + 1); 28707c478bd9Sstevel@tonic-gate for (ninfo = Lphp->pr_nent; ninfo != 0; ninfo--) { 28717c478bd9Sstevel@tonic-gate if (Lpsp->pr_sname != 'Z') { 28727c478bd9Sstevel@tonic-gate sp = Lsp; 28737c478bd9Sstevel@tonic-gate Lsp = (lwpstatus_t *)((uintptr_t)Lsp + Lhp->pr_entsize); 28747c478bd9Sstevel@tonic-gate } else { 28757c478bd9Sstevel@tonic-gate sp = NULL; 28767c478bd9Sstevel@tonic-gate } 28777c478bd9Sstevel@tonic-gate if ((rv = func(cd, sp, Lpsp)) != 0) 28787c478bd9Sstevel@tonic-gate break; 28797c478bd9Sstevel@tonic-gate Lpsp = (lwpsinfo_t *)((uintptr_t)Lpsp + Lphp->pr_entsize); 28807c478bd9Sstevel@tonic-gate } 28817c478bd9Sstevel@tonic-gate 28827c478bd9Sstevel@tonic-gate free(Lhp); 28837c478bd9Sstevel@tonic-gate free(Lphp); 28847c478bd9Sstevel@tonic-gate return (rv); 28857c478bd9Sstevel@tonic-gate } 28867c478bd9Sstevel@tonic-gate 28877c478bd9Sstevel@tonic-gate core_content_t 28887c478bd9Sstevel@tonic-gate Pcontent(struct ps_prochandle *P) 28897c478bd9Sstevel@tonic-gate { 28907c478bd9Sstevel@tonic-gate if (P->state == PS_DEAD) 28917c478bd9Sstevel@tonic-gate return (P->core->core_content); 28927c478bd9Sstevel@tonic-gate if (P->state == PS_IDLE) 28937c478bd9Sstevel@tonic-gate return (CC_CONTENT_TEXT | CC_CONTENT_DATA | CC_CONTENT_CTF); 28947c478bd9Sstevel@tonic-gate 28957c478bd9Sstevel@tonic-gate return (CC_CONTENT_ALL); 28967c478bd9Sstevel@tonic-gate } 28977c478bd9Sstevel@tonic-gate 28987c478bd9Sstevel@tonic-gate /* 28997c478bd9Sstevel@tonic-gate * ================================================================= 29007c478bd9Sstevel@tonic-gate * The remainder of the functions in this file are for the 29017c478bd9Sstevel@tonic-gate * control of individual LWPs in the controlled process. 29027c478bd9Sstevel@tonic-gate * ================================================================= 29037c478bd9Sstevel@tonic-gate */ 29047c478bd9Sstevel@tonic-gate 29057c478bd9Sstevel@tonic-gate /* 29067c478bd9Sstevel@tonic-gate * Find an entry in the process hash table for the specified lwpid. 29077c478bd9Sstevel@tonic-gate * The entry will either point to an existing struct ps_lwphandle 29087c478bd9Sstevel@tonic-gate * or it will point to an empty slot for a new struct ps_lwphandle. 29097c478bd9Sstevel@tonic-gate */ 29107c478bd9Sstevel@tonic-gate static struct ps_lwphandle ** 29117c478bd9Sstevel@tonic-gate Lfind(struct ps_prochandle *P, lwpid_t lwpid) 29127c478bd9Sstevel@tonic-gate { 29137c478bd9Sstevel@tonic-gate struct ps_lwphandle **Lp; 29147c478bd9Sstevel@tonic-gate struct ps_lwphandle *L; 29157c478bd9Sstevel@tonic-gate 29167c478bd9Sstevel@tonic-gate for (Lp = &P->hashtab[lwpid % (HASHSIZE - 1)]; 29177c478bd9Sstevel@tonic-gate (L = *Lp) != NULL; Lp = &L->lwp_hash) 29187c478bd9Sstevel@tonic-gate if (L->lwp_id == lwpid) 29197c478bd9Sstevel@tonic-gate break; 29207c478bd9Sstevel@tonic-gate return (Lp); 29217c478bd9Sstevel@tonic-gate } 29227c478bd9Sstevel@tonic-gate 29237c478bd9Sstevel@tonic-gate /* 29247c478bd9Sstevel@tonic-gate * Grab an LWP contained within the controlled process. 29257c478bd9Sstevel@tonic-gate * Return an opaque pointer to its LWP control structure. 29267c478bd9Sstevel@tonic-gate * perr: pointer to error return code. 29277c478bd9Sstevel@tonic-gate */ 29287c478bd9Sstevel@tonic-gate struct ps_lwphandle * 29297c478bd9Sstevel@tonic-gate Lgrab(struct ps_prochandle *P, lwpid_t lwpid, int *perr) 29307c478bd9Sstevel@tonic-gate { 29317c478bd9Sstevel@tonic-gate struct ps_lwphandle **Lp; 29327c478bd9Sstevel@tonic-gate struct ps_lwphandle *L; 29337c478bd9Sstevel@tonic-gate int fd; 29347c478bd9Sstevel@tonic-gate char procname[100]; 29357c478bd9Sstevel@tonic-gate char *fname; 29367c478bd9Sstevel@tonic-gate int rc = 0; 29377c478bd9Sstevel@tonic-gate 29387c478bd9Sstevel@tonic-gate (void) mutex_lock(&P->proc_lock); 29397c478bd9Sstevel@tonic-gate 29407c478bd9Sstevel@tonic-gate if (P->state == PS_UNDEAD || P->state == PS_IDLE) 29417c478bd9Sstevel@tonic-gate rc = G_NOPROC; 29427c478bd9Sstevel@tonic-gate else if (P->hashtab == NULL && 29437c478bd9Sstevel@tonic-gate (P->hashtab = calloc(HASHSIZE, sizeof (struct ps_lwphandle *))) 29447c478bd9Sstevel@tonic-gate == NULL) 29457c478bd9Sstevel@tonic-gate rc = G_STRANGE; 29467c478bd9Sstevel@tonic-gate else if (*(Lp = Lfind(P, lwpid)) != NULL) 29477c478bd9Sstevel@tonic-gate rc = G_BUSY; 29487c478bd9Sstevel@tonic-gate else if ((L = malloc(sizeof (struct ps_lwphandle))) == NULL) 29497c478bd9Sstevel@tonic-gate rc = G_STRANGE; 29507c478bd9Sstevel@tonic-gate if (rc) { 29517c478bd9Sstevel@tonic-gate *perr = rc; 29527c478bd9Sstevel@tonic-gate (void) mutex_unlock(&P->proc_lock); 29537c478bd9Sstevel@tonic-gate return (NULL); 29547c478bd9Sstevel@tonic-gate } 29557c478bd9Sstevel@tonic-gate 29567c478bd9Sstevel@tonic-gate (void) memset(L, 0, sizeof (*L)); 29577c478bd9Sstevel@tonic-gate L->lwp_ctlfd = -1; 29587c478bd9Sstevel@tonic-gate L->lwp_statfd = -1; 29597c478bd9Sstevel@tonic-gate L->lwp_proc = P; 29607c478bd9Sstevel@tonic-gate L->lwp_id = lwpid; 29617c478bd9Sstevel@tonic-gate *Lp = L; /* insert into the hash table */ 29627c478bd9Sstevel@tonic-gate 29637c478bd9Sstevel@tonic-gate if (P->state == PS_DEAD) { /* core file */ 29647c478bd9Sstevel@tonic-gate if (getlwpstatus(P, lwpid, &L->lwp_status) == -1) { 29657c478bd9Sstevel@tonic-gate rc = G_NOPROC; 29667c478bd9Sstevel@tonic-gate goto err; 29677c478bd9Sstevel@tonic-gate } 29687c478bd9Sstevel@tonic-gate L->lwp_state = PS_DEAD; 29697c478bd9Sstevel@tonic-gate *perr = 0; 29707c478bd9Sstevel@tonic-gate (void) mutex_unlock(&P->proc_lock); 29717c478bd9Sstevel@tonic-gate return (L); 29727c478bd9Sstevel@tonic-gate } 29737c478bd9Sstevel@tonic-gate 29747c478bd9Sstevel@tonic-gate /* 29757c478bd9Sstevel@tonic-gate * Open the /proc/<pid>/lwp/<lwpid> files 29767c478bd9Sstevel@tonic-gate */ 29777c478bd9Sstevel@tonic-gate (void) sprintf(procname, "/proc/%d/lwp/%d/", (int)P->pid, (int)lwpid); 29787c478bd9Sstevel@tonic-gate fname = procname + strlen(procname); 29797c478bd9Sstevel@tonic-gate (void) set_minfd(); 29807c478bd9Sstevel@tonic-gate 29817c478bd9Sstevel@tonic-gate (void) strcpy(fname, "lwpstatus"); 29827c478bd9Sstevel@tonic-gate if ((fd = open(procname, O_RDONLY)) < 0 || 29837c478bd9Sstevel@tonic-gate (fd = dupfd(fd, 0)) < 0) { 29847c478bd9Sstevel@tonic-gate switch (errno) { 29857c478bd9Sstevel@tonic-gate case ENOENT: 29867c478bd9Sstevel@tonic-gate rc = G_NOPROC; 29877c478bd9Sstevel@tonic-gate break; 29887c478bd9Sstevel@tonic-gate default: 29897c478bd9Sstevel@tonic-gate dprintf("Lgrab: failed to open %s: %s\n", 29907c478bd9Sstevel@tonic-gate procname, strerror(errno)); 29917c478bd9Sstevel@tonic-gate rc = G_STRANGE; 29927c478bd9Sstevel@tonic-gate break; 29937c478bd9Sstevel@tonic-gate } 29947c478bd9Sstevel@tonic-gate goto err; 29957c478bd9Sstevel@tonic-gate } 29967c478bd9Sstevel@tonic-gate L->lwp_statfd = fd; 29977c478bd9Sstevel@tonic-gate 29987c478bd9Sstevel@tonic-gate if (pread(fd, &L->lwp_status, sizeof (L->lwp_status), (off_t)0) < 0) { 29997c478bd9Sstevel@tonic-gate switch (errno) { 30007c478bd9Sstevel@tonic-gate case ENOENT: 30017c478bd9Sstevel@tonic-gate rc = G_NOPROC; 30027c478bd9Sstevel@tonic-gate break; 30037c478bd9Sstevel@tonic-gate default: 30047c478bd9Sstevel@tonic-gate dprintf("Lgrab: failed to read %s: %s\n", 30057c478bd9Sstevel@tonic-gate procname, strerror(errno)); 30067c478bd9Sstevel@tonic-gate rc = G_STRANGE; 30077c478bd9Sstevel@tonic-gate break; 30087c478bd9Sstevel@tonic-gate } 30097c478bd9Sstevel@tonic-gate goto err; 30107c478bd9Sstevel@tonic-gate } 30117c478bd9Sstevel@tonic-gate 30127c478bd9Sstevel@tonic-gate (void) strcpy(fname, "lwpctl"); 30137c478bd9Sstevel@tonic-gate if ((fd = open(procname, O_WRONLY)) < 0 || 30147c478bd9Sstevel@tonic-gate (fd = dupfd(fd, 0)) < 0) { 30157c478bd9Sstevel@tonic-gate switch (errno) { 30167c478bd9Sstevel@tonic-gate case ENOENT: 30177c478bd9Sstevel@tonic-gate rc = G_NOPROC; 30187c478bd9Sstevel@tonic-gate break; 30197c478bd9Sstevel@tonic-gate default: 30207c478bd9Sstevel@tonic-gate dprintf("Lgrab: failed to open %s: %s\n", 30217c478bd9Sstevel@tonic-gate procname, strerror(errno)); 30227c478bd9Sstevel@tonic-gate rc = G_STRANGE; 30237c478bd9Sstevel@tonic-gate break; 30247c478bd9Sstevel@tonic-gate } 30257c478bd9Sstevel@tonic-gate goto err; 30267c478bd9Sstevel@tonic-gate } 30277c478bd9Sstevel@tonic-gate L->lwp_ctlfd = fd; 30287c478bd9Sstevel@tonic-gate 30297c478bd9Sstevel@tonic-gate L->lwp_state = 30307c478bd9Sstevel@tonic-gate ((L->lwp_status.pr_flags & (PR_STOPPED|PR_ISTOP)) 30317c478bd9Sstevel@tonic-gate == (PR_STOPPED|PR_ISTOP))? 30327c478bd9Sstevel@tonic-gate PS_STOP : PS_RUN; 30337c478bd9Sstevel@tonic-gate 30347c478bd9Sstevel@tonic-gate *perr = 0; 30357c478bd9Sstevel@tonic-gate (void) mutex_unlock(&P->proc_lock); 30367c478bd9Sstevel@tonic-gate return (L); 30377c478bd9Sstevel@tonic-gate 30387c478bd9Sstevel@tonic-gate err: 30397c478bd9Sstevel@tonic-gate Lfree_internal(P, L); 30407c478bd9Sstevel@tonic-gate *perr = rc; 30417c478bd9Sstevel@tonic-gate (void) mutex_unlock(&P->proc_lock); 30427c478bd9Sstevel@tonic-gate return (NULL); 30437c478bd9Sstevel@tonic-gate } 30447c478bd9Sstevel@tonic-gate 30457c478bd9Sstevel@tonic-gate /* 30467c478bd9Sstevel@tonic-gate * Return a printable string corresponding to an Lgrab() error return. 30477c478bd9Sstevel@tonic-gate */ 30487c478bd9Sstevel@tonic-gate const char * 30497c478bd9Sstevel@tonic-gate Lgrab_error(int error) 30507c478bd9Sstevel@tonic-gate { 30517c478bd9Sstevel@tonic-gate const char *str; 30527c478bd9Sstevel@tonic-gate 30537c478bd9Sstevel@tonic-gate switch (error) { 30547c478bd9Sstevel@tonic-gate case G_NOPROC: 30557c478bd9Sstevel@tonic-gate str = "no such LWP"; 30567c478bd9Sstevel@tonic-gate break; 30577c478bd9Sstevel@tonic-gate case G_BUSY: 30587c478bd9Sstevel@tonic-gate str = "LWP already grabbed"; 30597c478bd9Sstevel@tonic-gate break; 30607c478bd9Sstevel@tonic-gate case G_STRANGE: 30617c478bd9Sstevel@tonic-gate str = "unanticipated system error"; 30627c478bd9Sstevel@tonic-gate break; 30637c478bd9Sstevel@tonic-gate default: 30647c478bd9Sstevel@tonic-gate str = "unknown error"; 30657c478bd9Sstevel@tonic-gate break; 30667c478bd9Sstevel@tonic-gate } 30677c478bd9Sstevel@tonic-gate 30687c478bd9Sstevel@tonic-gate return (str); 30697c478bd9Sstevel@tonic-gate } 30707c478bd9Sstevel@tonic-gate 30717c478bd9Sstevel@tonic-gate /* 30727c478bd9Sstevel@tonic-gate * Free an LWP control structure. 30737c478bd9Sstevel@tonic-gate */ 30747c478bd9Sstevel@tonic-gate void 30757c478bd9Sstevel@tonic-gate Lfree(struct ps_lwphandle *L) 30767c478bd9Sstevel@tonic-gate { 30777c478bd9Sstevel@tonic-gate struct ps_prochandle *P = L->lwp_proc; 30787c478bd9Sstevel@tonic-gate 30797c478bd9Sstevel@tonic-gate (void) mutex_lock(&P->proc_lock); 30807c478bd9Sstevel@tonic-gate Lfree_internal(P, L); 30817c478bd9Sstevel@tonic-gate (void) mutex_unlock(&P->proc_lock); 30827c478bd9Sstevel@tonic-gate } 30837c478bd9Sstevel@tonic-gate 30847c478bd9Sstevel@tonic-gate static void 30857c478bd9Sstevel@tonic-gate Lfree_internal(struct ps_prochandle *P, struct ps_lwphandle *L) 30867c478bd9Sstevel@tonic-gate { 30877c478bd9Sstevel@tonic-gate *Lfind(P, L->lwp_id) = L->lwp_hash; /* delete from hash table */ 30887c478bd9Sstevel@tonic-gate if (L->lwp_ctlfd >= 0) 30897c478bd9Sstevel@tonic-gate (void) close(L->lwp_ctlfd); 30907c478bd9Sstevel@tonic-gate if (L->lwp_statfd >= 0) 30917c478bd9Sstevel@tonic-gate (void) close(L->lwp_statfd); 30927c478bd9Sstevel@tonic-gate 30937c478bd9Sstevel@tonic-gate /* clear out the structure as a precaution against reuse */ 30947c478bd9Sstevel@tonic-gate (void) memset(L, 0, sizeof (*L)); 30957c478bd9Sstevel@tonic-gate L->lwp_ctlfd = -1; 30967c478bd9Sstevel@tonic-gate L->lwp_statfd = -1; 30977c478bd9Sstevel@tonic-gate 30987c478bd9Sstevel@tonic-gate free(L); 30997c478bd9Sstevel@tonic-gate } 31007c478bd9Sstevel@tonic-gate 31017c478bd9Sstevel@tonic-gate /* 31027c478bd9Sstevel@tonic-gate * Return the state of the process, one of the PS_* values. 31037c478bd9Sstevel@tonic-gate */ 31047c478bd9Sstevel@tonic-gate int 31057c478bd9Sstevel@tonic-gate Lstate(struct ps_lwphandle *L) 31067c478bd9Sstevel@tonic-gate { 31077c478bd9Sstevel@tonic-gate return (L->lwp_state); 31087c478bd9Sstevel@tonic-gate } 31097c478bd9Sstevel@tonic-gate 31107c478bd9Sstevel@tonic-gate /* 31117c478bd9Sstevel@tonic-gate * Return the open control file descriptor for the LWP. 31127c478bd9Sstevel@tonic-gate * Clients must not close this file descriptor, nor use it 31137c478bd9Sstevel@tonic-gate * after the LWP is freed. 31147c478bd9Sstevel@tonic-gate */ 31157c478bd9Sstevel@tonic-gate int 31167c478bd9Sstevel@tonic-gate Lctlfd(struct ps_lwphandle *L) 31177c478bd9Sstevel@tonic-gate { 31187c478bd9Sstevel@tonic-gate return (L->lwp_ctlfd); 31197c478bd9Sstevel@tonic-gate } 31207c478bd9Sstevel@tonic-gate 31217c478bd9Sstevel@tonic-gate /* 31227c478bd9Sstevel@tonic-gate * Return a pointer to the LWP lwpsinfo structure. 31237c478bd9Sstevel@tonic-gate * Clients should not hold on to this pointer indefinitely. 31247c478bd9Sstevel@tonic-gate * It will become invalid on Lfree(). 31257c478bd9Sstevel@tonic-gate */ 31267c478bd9Sstevel@tonic-gate const lwpsinfo_t * 31277c478bd9Sstevel@tonic-gate Lpsinfo(struct ps_lwphandle *L) 31287c478bd9Sstevel@tonic-gate { 31297c478bd9Sstevel@tonic-gate if (Plwp_getpsinfo(L->lwp_proc, L->lwp_id, &L->lwp_psinfo) == -1) 31307c478bd9Sstevel@tonic-gate return (NULL); 31317c478bd9Sstevel@tonic-gate 31327c478bd9Sstevel@tonic-gate return (&L->lwp_psinfo); 31337c478bd9Sstevel@tonic-gate } 31347c478bd9Sstevel@tonic-gate 31357c478bd9Sstevel@tonic-gate /* 31367c478bd9Sstevel@tonic-gate * Return a pointer to the LWP status structure. 31377c478bd9Sstevel@tonic-gate * Clients should not hold on to this pointer indefinitely. 31387c478bd9Sstevel@tonic-gate * It will become invalid on Lfree(). 31397c478bd9Sstevel@tonic-gate */ 31407c478bd9Sstevel@tonic-gate const lwpstatus_t * 31417c478bd9Sstevel@tonic-gate Lstatus(struct ps_lwphandle *L) 31427c478bd9Sstevel@tonic-gate { 31437c478bd9Sstevel@tonic-gate return (&L->lwp_status); 31447c478bd9Sstevel@tonic-gate } 31457c478bd9Sstevel@tonic-gate 31467c478bd9Sstevel@tonic-gate /* 31477c478bd9Sstevel@tonic-gate * Given an LWP handle, return the process handle. 31487c478bd9Sstevel@tonic-gate */ 31497c478bd9Sstevel@tonic-gate struct ps_prochandle * 31507c478bd9Sstevel@tonic-gate Lprochandle(struct ps_lwphandle *L) 31517c478bd9Sstevel@tonic-gate { 31527c478bd9Sstevel@tonic-gate return (L->lwp_proc); 31537c478bd9Sstevel@tonic-gate } 31547c478bd9Sstevel@tonic-gate 31557c478bd9Sstevel@tonic-gate /* 31567c478bd9Sstevel@tonic-gate * Ensure that all cached state is written to the LWP. 31577c478bd9Sstevel@tonic-gate * The cached state is the LWP's signal mask and registers. 31587c478bd9Sstevel@tonic-gate */ 31597c478bd9Sstevel@tonic-gate void 31607c478bd9Sstevel@tonic-gate Lsync(struct ps_lwphandle *L) 31617c478bd9Sstevel@tonic-gate { 31627c478bd9Sstevel@tonic-gate int ctlfd = L->lwp_ctlfd; 31637c478bd9Sstevel@tonic-gate long cmd[2]; 31647c478bd9Sstevel@tonic-gate iovec_t iov[4]; 31657c478bd9Sstevel@tonic-gate int n = 0; 31667c478bd9Sstevel@tonic-gate 31677c478bd9Sstevel@tonic-gate if (L->lwp_flags & SETHOLD) { 31687c478bd9Sstevel@tonic-gate cmd[0] = PCSHOLD; 31697c478bd9Sstevel@tonic-gate iov[n].iov_base = (caddr_t)&cmd[0]; 31707c478bd9Sstevel@tonic-gate iov[n++].iov_len = sizeof (long); 31717c478bd9Sstevel@tonic-gate iov[n].iov_base = (caddr_t)&L->lwp_status.pr_lwphold; 31727c478bd9Sstevel@tonic-gate iov[n++].iov_len = sizeof (L->lwp_status.pr_lwphold); 31737c478bd9Sstevel@tonic-gate } 31747c478bd9Sstevel@tonic-gate if (L->lwp_flags & SETREGS) { 31757c478bd9Sstevel@tonic-gate cmd[1] = PCSREG; 31767c478bd9Sstevel@tonic-gate iov[n].iov_base = (caddr_t)&cmd[1]; 31777c478bd9Sstevel@tonic-gate iov[n++].iov_len = sizeof (long); 31787c478bd9Sstevel@tonic-gate iov[n].iov_base = (caddr_t)&L->lwp_status.pr_reg[0]; 31797c478bd9Sstevel@tonic-gate iov[n++].iov_len = sizeof (L->lwp_status.pr_reg); 31807c478bd9Sstevel@tonic-gate } 31817c478bd9Sstevel@tonic-gate 31827c478bd9Sstevel@tonic-gate if (n == 0 || writev(ctlfd, iov, n) < 0) 31837c478bd9Sstevel@tonic-gate return; /* nothing to do or write failed */ 31847c478bd9Sstevel@tonic-gate 31857c478bd9Sstevel@tonic-gate L->lwp_flags &= ~(SETHOLD|SETREGS); 31867c478bd9Sstevel@tonic-gate } 31877c478bd9Sstevel@tonic-gate 31887c478bd9Sstevel@tonic-gate /* 31897c478bd9Sstevel@tonic-gate * Wait for the specified LWP to stop or terminate. 31907c478bd9Sstevel@tonic-gate * Or, just get the current status (PCNULL). 31917c478bd9Sstevel@tonic-gate * Or, direct it to stop and get the current status (PCDSTOP). 31927c478bd9Sstevel@tonic-gate */ 31937c478bd9Sstevel@tonic-gate static int 31947c478bd9Sstevel@tonic-gate Lstopstatus(struct ps_lwphandle *L, 31957c478bd9Sstevel@tonic-gate long request, /* PCNULL, PCDSTOP, PCSTOP, PCWSTOP */ 31967c478bd9Sstevel@tonic-gate uint_t msec) /* if non-zero, timeout in milliseconds */ 31977c478bd9Sstevel@tonic-gate { 31987c478bd9Sstevel@tonic-gate int ctlfd = L->lwp_ctlfd; 31997c478bd9Sstevel@tonic-gate long ctl[3]; 32007c478bd9Sstevel@tonic-gate ssize_t rc; 32017c478bd9Sstevel@tonic-gate int err; 32027c478bd9Sstevel@tonic-gate 32037c478bd9Sstevel@tonic-gate switch (L->lwp_state) { 32047c478bd9Sstevel@tonic-gate case PS_RUN: 32057c478bd9Sstevel@tonic-gate break; 32067c478bd9Sstevel@tonic-gate case PS_STOP: 32077c478bd9Sstevel@tonic-gate if (request != PCNULL && request != PCDSTOP) 32087c478bd9Sstevel@tonic-gate return (0); 32097c478bd9Sstevel@tonic-gate break; 32107c478bd9Sstevel@tonic-gate case PS_LOST: 32117c478bd9Sstevel@tonic-gate if (request != PCNULL) { 32127c478bd9Sstevel@tonic-gate errno = EAGAIN; 32137c478bd9Sstevel@tonic-gate return (-1); 32147c478bd9Sstevel@tonic-gate } 32157c478bd9Sstevel@tonic-gate break; 32167c478bd9Sstevel@tonic-gate case PS_UNDEAD: 32177c478bd9Sstevel@tonic-gate case PS_DEAD: 32187c478bd9Sstevel@tonic-gate if (request != PCNULL) { 32197c478bd9Sstevel@tonic-gate errno = ENOENT; 32207c478bd9Sstevel@tonic-gate return (-1); 32217c478bd9Sstevel@tonic-gate } 32227c478bd9Sstevel@tonic-gate break; 32237c478bd9Sstevel@tonic-gate default: /* corrupted state */ 32247c478bd9Sstevel@tonic-gate dprintf("Lstopstatus: corrupted state: %d\n", L->lwp_state); 32257c478bd9Sstevel@tonic-gate errno = EINVAL; 32267c478bd9Sstevel@tonic-gate return (-1); 32277c478bd9Sstevel@tonic-gate } 32287c478bd9Sstevel@tonic-gate 32297c478bd9Sstevel@tonic-gate ctl[0] = PCDSTOP; 32307c478bd9Sstevel@tonic-gate ctl[1] = PCTWSTOP; 32317c478bd9Sstevel@tonic-gate ctl[2] = (long)msec; 32327c478bd9Sstevel@tonic-gate rc = 0; 32337c478bd9Sstevel@tonic-gate switch (request) { 32347c478bd9Sstevel@tonic-gate case PCSTOP: 32357c478bd9Sstevel@tonic-gate rc = write(ctlfd, &ctl[0], 3*sizeof (long)); 32367c478bd9Sstevel@tonic-gate break; 32377c478bd9Sstevel@tonic-gate case PCWSTOP: 32387c478bd9Sstevel@tonic-gate rc = write(ctlfd, &ctl[1], 2*sizeof (long)); 32397c478bd9Sstevel@tonic-gate break; 32407c478bd9Sstevel@tonic-gate case PCDSTOP: 32417c478bd9Sstevel@tonic-gate rc = write(ctlfd, &ctl[0], 1*sizeof (long)); 32427c478bd9Sstevel@tonic-gate break; 32437c478bd9Sstevel@tonic-gate case PCNULL: 32447c478bd9Sstevel@tonic-gate if (L->lwp_state == PS_DEAD) 32457c478bd9Sstevel@tonic-gate return (0); /* Nothing else to do for cores */ 32467c478bd9Sstevel@tonic-gate break; 32477c478bd9Sstevel@tonic-gate default: /* programming error */ 32487c478bd9Sstevel@tonic-gate errno = EINVAL; 32497c478bd9Sstevel@tonic-gate return (-1); 32507c478bd9Sstevel@tonic-gate } 32517c478bd9Sstevel@tonic-gate err = (rc < 0)? errno : 0; 32527c478bd9Sstevel@tonic-gate Lsync(L); 32537c478bd9Sstevel@tonic-gate 32547c478bd9Sstevel@tonic-gate if (pread(L->lwp_statfd, &L->lwp_status, 32557c478bd9Sstevel@tonic-gate sizeof (L->lwp_status), (off_t)0) < 0) 32567c478bd9Sstevel@tonic-gate err = errno; 32577c478bd9Sstevel@tonic-gate 32587c478bd9Sstevel@tonic-gate if (err) { 32597c478bd9Sstevel@tonic-gate switch (err) { 32607c478bd9Sstevel@tonic-gate case EINTR: /* user typed ctl-C */ 32617c478bd9Sstevel@tonic-gate case ERESTART: 32627c478bd9Sstevel@tonic-gate dprintf("Lstopstatus: EINTR\n"); 32637c478bd9Sstevel@tonic-gate break; 32647c478bd9Sstevel@tonic-gate case EAGAIN: /* we lost control of the the process */ 32657c478bd9Sstevel@tonic-gate dprintf("Lstopstatus: EAGAIN\n"); 32667c478bd9Sstevel@tonic-gate L->lwp_state = PS_LOST; 32677c478bd9Sstevel@tonic-gate errno = err; 32687c478bd9Sstevel@tonic-gate return (-1); 32697c478bd9Sstevel@tonic-gate default: 32707c478bd9Sstevel@tonic-gate if (_libproc_debug) { 32717c478bd9Sstevel@tonic-gate const char *errstr; 32727c478bd9Sstevel@tonic-gate 32737c478bd9Sstevel@tonic-gate switch (request) { 32747c478bd9Sstevel@tonic-gate case PCNULL: 32757c478bd9Sstevel@tonic-gate errstr = "Lstopstatus PCNULL"; break; 32767c478bd9Sstevel@tonic-gate case PCSTOP: 32777c478bd9Sstevel@tonic-gate errstr = "Lstopstatus PCSTOP"; break; 32787c478bd9Sstevel@tonic-gate case PCDSTOP: 32797c478bd9Sstevel@tonic-gate errstr = "Lstopstatus PCDSTOP"; break; 32807c478bd9Sstevel@tonic-gate case PCWSTOP: 32817c478bd9Sstevel@tonic-gate errstr = "Lstopstatus PCWSTOP"; break; 32827c478bd9Sstevel@tonic-gate default: 32837c478bd9Sstevel@tonic-gate errstr = "Lstopstatus PC???"; break; 32847c478bd9Sstevel@tonic-gate } 32857c478bd9Sstevel@tonic-gate dprintf("%s: %s\n", errstr, strerror(err)); 32867c478bd9Sstevel@tonic-gate } 32877c478bd9Sstevel@tonic-gate L->lwp_state = PS_UNDEAD; 32887c478bd9Sstevel@tonic-gate errno = err; 32897c478bd9Sstevel@tonic-gate return (-1); 32907c478bd9Sstevel@tonic-gate } 32917c478bd9Sstevel@tonic-gate } 32927c478bd9Sstevel@tonic-gate 32937c478bd9Sstevel@tonic-gate if ((L->lwp_status.pr_flags & (PR_STOPPED|PR_ISTOP)) 32947c478bd9Sstevel@tonic-gate != (PR_STOPPED|PR_ISTOP)) { 32957c478bd9Sstevel@tonic-gate L->lwp_state = PS_RUN; 32967c478bd9Sstevel@tonic-gate if (request == PCNULL || request == PCDSTOP || msec != 0) 32977c478bd9Sstevel@tonic-gate return (0); 32987c478bd9Sstevel@tonic-gate dprintf("Lstopstatus: LWP is not stopped\n"); 32997c478bd9Sstevel@tonic-gate errno = EPROTO; 33007c478bd9Sstevel@tonic-gate return (-1); 33017c478bd9Sstevel@tonic-gate } 33027c478bd9Sstevel@tonic-gate 33037c478bd9Sstevel@tonic-gate L->lwp_state = PS_STOP; 33047c478bd9Sstevel@tonic-gate 33057c478bd9Sstevel@tonic-gate if (_libproc_debug) /* debugging */ 33067c478bd9Sstevel@tonic-gate prldump("Lstopstatus", &L->lwp_status); 33077c478bd9Sstevel@tonic-gate 33087c478bd9Sstevel@tonic-gate switch (L->lwp_status.pr_why) { 33097c478bd9Sstevel@tonic-gate case PR_SYSENTRY: 33107c478bd9Sstevel@tonic-gate case PR_SYSEXIT: 33117c478bd9Sstevel@tonic-gate case PR_REQUESTED: 33127c478bd9Sstevel@tonic-gate case PR_SIGNALLED: 33137c478bd9Sstevel@tonic-gate case PR_FAULTED: 33147c478bd9Sstevel@tonic-gate case PR_JOBCONTROL: 33157c478bd9Sstevel@tonic-gate case PR_SUSPENDED: 33167c478bd9Sstevel@tonic-gate break; 33177c478bd9Sstevel@tonic-gate default: 33187c478bd9Sstevel@tonic-gate errno = EPROTO; 33197c478bd9Sstevel@tonic-gate return (-1); 33207c478bd9Sstevel@tonic-gate } 33217c478bd9Sstevel@tonic-gate 33227c478bd9Sstevel@tonic-gate return (0); 33237c478bd9Sstevel@tonic-gate } 33247c478bd9Sstevel@tonic-gate 33257c478bd9Sstevel@tonic-gate /* 33267c478bd9Sstevel@tonic-gate * Wait for the LWP to stop for any reason. 33277c478bd9Sstevel@tonic-gate */ 33287c478bd9Sstevel@tonic-gate int 33297c478bd9Sstevel@tonic-gate Lwait(struct ps_lwphandle *L, uint_t msec) 33307c478bd9Sstevel@tonic-gate { 33317c478bd9Sstevel@tonic-gate return (Lstopstatus(L, PCWSTOP, msec)); 33327c478bd9Sstevel@tonic-gate } 33337c478bd9Sstevel@tonic-gate 33347c478bd9Sstevel@tonic-gate /* 33357c478bd9Sstevel@tonic-gate * Direct the LWP to stop; wait for it to stop. 33367c478bd9Sstevel@tonic-gate */ 33377c478bd9Sstevel@tonic-gate int 33387c478bd9Sstevel@tonic-gate Lstop(struct ps_lwphandle *L, uint_t msec) 33397c478bd9Sstevel@tonic-gate { 33407c478bd9Sstevel@tonic-gate return (Lstopstatus(L, PCSTOP, msec)); 33417c478bd9Sstevel@tonic-gate } 33427c478bd9Sstevel@tonic-gate 33437c478bd9Sstevel@tonic-gate /* 33447c478bd9Sstevel@tonic-gate * Direct the LWP to stop; don't wait. 33457c478bd9Sstevel@tonic-gate */ 33467c478bd9Sstevel@tonic-gate int 33477c478bd9Sstevel@tonic-gate Ldstop(struct ps_lwphandle *L) 33487c478bd9Sstevel@tonic-gate { 33497c478bd9Sstevel@tonic-gate return (Lstopstatus(L, PCDSTOP, 0)); 33507c478bd9Sstevel@tonic-gate } 33517c478bd9Sstevel@tonic-gate 33527c478bd9Sstevel@tonic-gate /* 33537c478bd9Sstevel@tonic-gate * Get the value of one register from stopped LWP. 33547c478bd9Sstevel@tonic-gate */ 33557c478bd9Sstevel@tonic-gate int 33567c478bd9Sstevel@tonic-gate Lgetareg(struct ps_lwphandle *L, int regno, prgreg_t *preg) 33577c478bd9Sstevel@tonic-gate { 33587c478bd9Sstevel@tonic-gate if (regno < 0 || regno >= NPRGREG) { 33597c478bd9Sstevel@tonic-gate errno = EINVAL; 33607c478bd9Sstevel@tonic-gate return (-1); 33617c478bd9Sstevel@tonic-gate } 33627c478bd9Sstevel@tonic-gate 33637c478bd9Sstevel@tonic-gate if (L->lwp_state != PS_STOP) { 33647c478bd9Sstevel@tonic-gate errno = EBUSY; 33657c478bd9Sstevel@tonic-gate return (-1); 33667c478bd9Sstevel@tonic-gate } 33677c478bd9Sstevel@tonic-gate 33687c478bd9Sstevel@tonic-gate *preg = L->lwp_status.pr_reg[regno]; 33697c478bd9Sstevel@tonic-gate return (0); 33707c478bd9Sstevel@tonic-gate } 33717c478bd9Sstevel@tonic-gate 33727c478bd9Sstevel@tonic-gate /* 33737c478bd9Sstevel@tonic-gate * Put value of one register into stopped LWP. 33747c478bd9Sstevel@tonic-gate */ 33757c478bd9Sstevel@tonic-gate int 33767c478bd9Sstevel@tonic-gate Lputareg(struct ps_lwphandle *L, int regno, prgreg_t reg) 33777c478bd9Sstevel@tonic-gate { 33787c478bd9Sstevel@tonic-gate if (regno < 0 || regno >= NPRGREG) { 33797c478bd9Sstevel@tonic-gate errno = EINVAL; 33807c478bd9Sstevel@tonic-gate return (-1); 33817c478bd9Sstevel@tonic-gate } 33827c478bd9Sstevel@tonic-gate 33837c478bd9Sstevel@tonic-gate if (L->lwp_state != PS_STOP) { 33847c478bd9Sstevel@tonic-gate errno = EBUSY; 33857c478bd9Sstevel@tonic-gate return (-1); 33867c478bd9Sstevel@tonic-gate } 33877c478bd9Sstevel@tonic-gate 33887c478bd9Sstevel@tonic-gate L->lwp_status.pr_reg[regno] = reg; 33897c478bd9Sstevel@tonic-gate L->lwp_flags |= SETREGS; /* set registers before continuing */ 33907c478bd9Sstevel@tonic-gate return (0); 33917c478bd9Sstevel@tonic-gate } 33927c478bd9Sstevel@tonic-gate 33937c478bd9Sstevel@tonic-gate int 33947c478bd9Sstevel@tonic-gate Lsetrun(struct ps_lwphandle *L, 33957c478bd9Sstevel@tonic-gate int sig, /* signal to pass to LWP */ 33967c478bd9Sstevel@tonic-gate int flags) /* PRSTEP|PRSABORT|PRSTOP|PRCSIG|PRCFAULT */ 33977c478bd9Sstevel@tonic-gate { 33987c478bd9Sstevel@tonic-gate int ctlfd = L->lwp_ctlfd; 33997c478bd9Sstevel@tonic-gate int sbits = (PR_DSTOP | PR_ISTOP | PR_ASLEEP); 34007c478bd9Sstevel@tonic-gate 34017c478bd9Sstevel@tonic-gate long ctl[1 + /* PCCFAULT */ 34027c478bd9Sstevel@tonic-gate 1 + sizeof (siginfo_t)/sizeof (long) + /* PCSSIG/PCCSIG */ 34037c478bd9Sstevel@tonic-gate 2 ]; /* PCRUN */ 34047c478bd9Sstevel@tonic-gate 34057c478bd9Sstevel@tonic-gate long *ctlp = ctl; 34067c478bd9Sstevel@tonic-gate size_t size; 34077c478bd9Sstevel@tonic-gate 34087c478bd9Sstevel@tonic-gate if (L->lwp_state != PS_STOP && 34097c478bd9Sstevel@tonic-gate (L->lwp_status.pr_flags & sbits) == 0) { 34107c478bd9Sstevel@tonic-gate errno = EBUSY; 34117c478bd9Sstevel@tonic-gate return (-1); 34127c478bd9Sstevel@tonic-gate } 34137c478bd9Sstevel@tonic-gate 34147c478bd9Sstevel@tonic-gate Lsync(L); /* flush registers */ 34157c478bd9Sstevel@tonic-gate 34167c478bd9Sstevel@tonic-gate if (flags & PRCFAULT) { /* clear current fault */ 34177c478bd9Sstevel@tonic-gate *ctlp++ = PCCFAULT; 34187c478bd9Sstevel@tonic-gate flags &= ~PRCFAULT; 34197c478bd9Sstevel@tonic-gate } 34207c478bd9Sstevel@tonic-gate 34217c478bd9Sstevel@tonic-gate if (flags & PRCSIG) { /* clear current signal */ 34227c478bd9Sstevel@tonic-gate *ctlp++ = PCCSIG; 34237c478bd9Sstevel@tonic-gate flags &= ~PRCSIG; 34247c478bd9Sstevel@tonic-gate } else if (sig && sig != L->lwp_status.pr_cursig) { 34257c478bd9Sstevel@tonic-gate /* make current signal */ 34267c478bd9Sstevel@tonic-gate siginfo_t *infop; 34277c478bd9Sstevel@tonic-gate 34287c478bd9Sstevel@tonic-gate *ctlp++ = PCSSIG; 34297c478bd9Sstevel@tonic-gate infop = (siginfo_t *)ctlp; 34307c478bd9Sstevel@tonic-gate (void) memset(infop, 0, sizeof (*infop)); 34317c478bd9Sstevel@tonic-gate infop->si_signo = sig; 34327c478bd9Sstevel@tonic-gate ctlp += sizeof (siginfo_t) / sizeof (long); 34337c478bd9Sstevel@tonic-gate } 34347c478bd9Sstevel@tonic-gate 34357c478bd9Sstevel@tonic-gate *ctlp++ = PCRUN; 34367c478bd9Sstevel@tonic-gate *ctlp++ = flags; 34377c478bd9Sstevel@tonic-gate size = (char *)ctlp - (char *)ctl; 34387c478bd9Sstevel@tonic-gate 34397c478bd9Sstevel@tonic-gate L->lwp_proc->info_valid = 0; /* will need to update map and file info */ 34407c478bd9Sstevel@tonic-gate L->lwp_proc->state = PS_RUN; 34417c478bd9Sstevel@tonic-gate L->lwp_state = PS_RUN; 34427c478bd9Sstevel@tonic-gate 34437c478bd9Sstevel@tonic-gate if (write(ctlfd, ctl, size) != size) { 34447c478bd9Sstevel@tonic-gate /* Pretend that a job-stopped LWP is running */ 34457c478bd9Sstevel@tonic-gate if (errno != EBUSY || L->lwp_status.pr_why != PR_JOBCONTROL) 34467c478bd9Sstevel@tonic-gate return (Lstopstatus(L, PCNULL, 0)); 34477c478bd9Sstevel@tonic-gate } 34487c478bd9Sstevel@tonic-gate 34497c478bd9Sstevel@tonic-gate return (0); 34507c478bd9Sstevel@tonic-gate } 34517c478bd9Sstevel@tonic-gate 34527c478bd9Sstevel@tonic-gate int 34537c478bd9Sstevel@tonic-gate Lclearsig(struct ps_lwphandle *L) 34547c478bd9Sstevel@tonic-gate { 34557c478bd9Sstevel@tonic-gate int ctlfd = L->lwp_ctlfd; 34567c478bd9Sstevel@tonic-gate long ctl = PCCSIG; 34577c478bd9Sstevel@tonic-gate 34587c478bd9Sstevel@tonic-gate if (write(ctlfd, &ctl, sizeof (ctl)) != sizeof (ctl)) 34597c478bd9Sstevel@tonic-gate return (-1); 34607c478bd9Sstevel@tonic-gate L->lwp_status.pr_cursig = 0; 34617c478bd9Sstevel@tonic-gate return (0); 34627c478bd9Sstevel@tonic-gate } 34637c478bd9Sstevel@tonic-gate 34647c478bd9Sstevel@tonic-gate int 34657c478bd9Sstevel@tonic-gate Lclearfault(struct ps_lwphandle *L) 34667c478bd9Sstevel@tonic-gate { 34677c478bd9Sstevel@tonic-gate int ctlfd = L->lwp_ctlfd; 34687c478bd9Sstevel@tonic-gate long ctl = PCCFAULT; 34697c478bd9Sstevel@tonic-gate 34707c478bd9Sstevel@tonic-gate if (write(ctlfd, &ctl, sizeof (ctl)) != sizeof (ctl)) 34717c478bd9Sstevel@tonic-gate return (-1); 34727c478bd9Sstevel@tonic-gate return (0); 34737c478bd9Sstevel@tonic-gate } 34747c478bd9Sstevel@tonic-gate 34757c478bd9Sstevel@tonic-gate /* 34767c478bd9Sstevel@tonic-gate * Step over a breakpoint, i.e., execute the instruction that 34777c478bd9Sstevel@tonic-gate * really belongs at the breakpoint location (the current %pc) 34787c478bd9Sstevel@tonic-gate * and leave the LWP stopped at the next instruction. 34797c478bd9Sstevel@tonic-gate */ 34807c478bd9Sstevel@tonic-gate int 34817c478bd9Sstevel@tonic-gate Lxecbkpt(struct ps_lwphandle *L, ulong_t saved) 34827c478bd9Sstevel@tonic-gate { 34837c478bd9Sstevel@tonic-gate struct ps_prochandle *P = L->lwp_proc; 34847c478bd9Sstevel@tonic-gate int rv, error; 34857c478bd9Sstevel@tonic-gate 34867c478bd9Sstevel@tonic-gate if (L->lwp_state != PS_STOP) { 34877c478bd9Sstevel@tonic-gate errno = EBUSY; 34887c478bd9Sstevel@tonic-gate return (-1); 34897c478bd9Sstevel@tonic-gate } 34907c478bd9Sstevel@tonic-gate 34917c478bd9Sstevel@tonic-gate Lsync(L); 34927c478bd9Sstevel@tonic-gate error = execute_bkpt(L->lwp_ctlfd, 34937c478bd9Sstevel@tonic-gate &P->status.pr_flttrace, &L->lwp_status.pr_lwphold, 34947c478bd9Sstevel@tonic-gate L->lwp_status.pr_reg[R_PC], saved); 34957c478bd9Sstevel@tonic-gate rv = Lstopstatus(L, PCNULL, 0); 34967c478bd9Sstevel@tonic-gate 34977c478bd9Sstevel@tonic-gate if (error != 0) { 34987c478bd9Sstevel@tonic-gate if (L->lwp_status.pr_why == PR_JOBCONTROL && 34997c478bd9Sstevel@tonic-gate error == EBUSY) { /* jobcontrol stop -- back off */ 35007c478bd9Sstevel@tonic-gate L->lwp_state = PS_RUN; 35017c478bd9Sstevel@tonic-gate return (0); 35027c478bd9Sstevel@tonic-gate } 35037c478bd9Sstevel@tonic-gate if (error == ENOENT) 35047c478bd9Sstevel@tonic-gate return (0); 35057c478bd9Sstevel@tonic-gate errno = error; 35067c478bd9Sstevel@tonic-gate return (-1); 35077c478bd9Sstevel@tonic-gate } 35087c478bd9Sstevel@tonic-gate 35097c478bd9Sstevel@tonic-gate return (rv); 35107c478bd9Sstevel@tonic-gate } 35117c478bd9Sstevel@tonic-gate 35127c478bd9Sstevel@tonic-gate /* 35137c478bd9Sstevel@tonic-gate * Step over a watchpoint, i.e., execute the instruction that was stopped by 35147c478bd9Sstevel@tonic-gate * the watchpoint, and then leave the LWP stopped at the next instruction. 35157c478bd9Sstevel@tonic-gate */ 35167c478bd9Sstevel@tonic-gate int 35177c478bd9Sstevel@tonic-gate Lxecwapt(struct ps_lwphandle *L, const prwatch_t *wp) 35187c478bd9Sstevel@tonic-gate { 35197c478bd9Sstevel@tonic-gate struct ps_prochandle *P = L->lwp_proc; 35207c478bd9Sstevel@tonic-gate int rv, error; 35217c478bd9Sstevel@tonic-gate 35227c478bd9Sstevel@tonic-gate if (L->lwp_state != PS_STOP) { 35237c478bd9Sstevel@tonic-gate errno = EBUSY; 35247c478bd9Sstevel@tonic-gate return (-1); 35257c478bd9Sstevel@tonic-gate } 35267c478bd9Sstevel@tonic-gate 35277c478bd9Sstevel@tonic-gate Lsync(L); 35287c478bd9Sstevel@tonic-gate error = execute_wapt(L->lwp_ctlfd, 35297c478bd9Sstevel@tonic-gate &P->status.pr_flttrace, &L->lwp_status.pr_lwphold, wp); 35307c478bd9Sstevel@tonic-gate rv = Lstopstatus(L, PCNULL, 0); 35317c478bd9Sstevel@tonic-gate 35327c478bd9Sstevel@tonic-gate if (error != 0) { 35337c478bd9Sstevel@tonic-gate if (L->lwp_status.pr_why == PR_JOBCONTROL && 35347c478bd9Sstevel@tonic-gate error == EBUSY) { /* jobcontrol stop -- back off */ 35357c478bd9Sstevel@tonic-gate L->lwp_state = PS_RUN; 35367c478bd9Sstevel@tonic-gate return (0); 35377c478bd9Sstevel@tonic-gate } 35387c478bd9Sstevel@tonic-gate if (error == ENOENT) 35397c478bd9Sstevel@tonic-gate return (0); 35407c478bd9Sstevel@tonic-gate errno = error; 35417c478bd9Sstevel@tonic-gate return (-1); 35427c478bd9Sstevel@tonic-gate } 35437c478bd9Sstevel@tonic-gate 35447c478bd9Sstevel@tonic-gate return (rv); 35457c478bd9Sstevel@tonic-gate } 35467c478bd9Sstevel@tonic-gate 35477c478bd9Sstevel@tonic-gate int 35487c478bd9Sstevel@tonic-gate Lstack(struct ps_lwphandle *L, stack_t *stkp) 35497c478bd9Sstevel@tonic-gate { 35507c478bd9Sstevel@tonic-gate struct ps_prochandle *P = L->lwp_proc; 35517c478bd9Sstevel@tonic-gate uintptr_t addr = L->lwp_status.pr_ustack; 35527c478bd9Sstevel@tonic-gate 35537c478bd9Sstevel@tonic-gate if (P->status.pr_dmodel == PR_MODEL_NATIVE) { 35547c478bd9Sstevel@tonic-gate if (Pread(P, stkp, sizeof (*stkp), addr) != sizeof (*stkp)) 35557c478bd9Sstevel@tonic-gate return (-1); 35567c478bd9Sstevel@tonic-gate #ifdef _LP64 35577c478bd9Sstevel@tonic-gate } else { 35587c478bd9Sstevel@tonic-gate stack32_t stk32; 35597c478bd9Sstevel@tonic-gate 35607c478bd9Sstevel@tonic-gate if (Pread(P, &stk32, sizeof (stk32), addr) != sizeof (stk32)) 35617c478bd9Sstevel@tonic-gate return (-1); 35627c478bd9Sstevel@tonic-gate 35637c478bd9Sstevel@tonic-gate stack_32_to_n(&stk32, stkp); 35647c478bd9Sstevel@tonic-gate #endif 35657c478bd9Sstevel@tonic-gate } 35667c478bd9Sstevel@tonic-gate 35677c478bd9Sstevel@tonic-gate return (0); 35687c478bd9Sstevel@tonic-gate } 35697c478bd9Sstevel@tonic-gate 35707c478bd9Sstevel@tonic-gate int 35717c478bd9Sstevel@tonic-gate Lmain_stack(struct ps_lwphandle *L, stack_t *stkp) 35727c478bd9Sstevel@tonic-gate { 35737c478bd9Sstevel@tonic-gate struct ps_prochandle *P = L->lwp_proc; 35747c478bd9Sstevel@tonic-gate 35757c478bd9Sstevel@tonic-gate if (Lstack(L, stkp) != 0) 35767c478bd9Sstevel@tonic-gate return (-1); 35777c478bd9Sstevel@tonic-gate 35787c478bd9Sstevel@tonic-gate /* 35797c478bd9Sstevel@tonic-gate * If the SS_ONSTACK flag is set then this LWP is operating on the 35807c478bd9Sstevel@tonic-gate * alternate signal stack. We can recover the original stack from 35817c478bd9Sstevel@tonic-gate * pr_oldcontext. 35827c478bd9Sstevel@tonic-gate */ 35837c478bd9Sstevel@tonic-gate if (!(stkp->ss_flags & SS_ONSTACK)) 35847c478bd9Sstevel@tonic-gate return (0); 35857c478bd9Sstevel@tonic-gate 35867c478bd9Sstevel@tonic-gate if (P->status.pr_dmodel == PR_MODEL_NATIVE) { 35877c478bd9Sstevel@tonic-gate ucontext_t *ctxp = (void *)L->lwp_status.pr_oldcontext; 35887c478bd9Sstevel@tonic-gate 35897c478bd9Sstevel@tonic-gate if (Pread(P, stkp, sizeof (*stkp), 35907c478bd9Sstevel@tonic-gate (uintptr_t)&ctxp->uc_stack) != sizeof (*stkp)) 35917c478bd9Sstevel@tonic-gate return (-1); 35927c478bd9Sstevel@tonic-gate #ifdef _LP64 35937c478bd9Sstevel@tonic-gate } else { 35947c478bd9Sstevel@tonic-gate ucontext32_t *ctxp = (void *)L->lwp_status.pr_oldcontext; 35957c478bd9Sstevel@tonic-gate stack32_t stk32; 35967c478bd9Sstevel@tonic-gate 35977c478bd9Sstevel@tonic-gate if (Pread(P, &stk32, sizeof (stk32), 35987c478bd9Sstevel@tonic-gate (uintptr_t)&ctxp->uc_stack) != sizeof (stk32)) 35997c478bd9Sstevel@tonic-gate return (-1); 36007c478bd9Sstevel@tonic-gate 36017c478bd9Sstevel@tonic-gate stack_32_to_n(&stk32, stkp); 36027c478bd9Sstevel@tonic-gate #endif 36037c478bd9Sstevel@tonic-gate } 36047c478bd9Sstevel@tonic-gate 36057c478bd9Sstevel@tonic-gate return (0); 36067c478bd9Sstevel@tonic-gate } 36077c478bd9Sstevel@tonic-gate 36087c478bd9Sstevel@tonic-gate int 36097c478bd9Sstevel@tonic-gate Lalt_stack(struct ps_lwphandle *L, stack_t *stkp) 36107c478bd9Sstevel@tonic-gate { 36117c478bd9Sstevel@tonic-gate if (L->lwp_status.pr_altstack.ss_flags & SS_DISABLE) { 36127c478bd9Sstevel@tonic-gate errno = ENODATA; 36137c478bd9Sstevel@tonic-gate return (-1); 36147c478bd9Sstevel@tonic-gate } 36157c478bd9Sstevel@tonic-gate 36167c478bd9Sstevel@tonic-gate *stkp = L->lwp_status.pr_altstack; 36177c478bd9Sstevel@tonic-gate 36187c478bd9Sstevel@tonic-gate return (0); 36197c478bd9Sstevel@tonic-gate } 36207c478bd9Sstevel@tonic-gate 36217c478bd9Sstevel@tonic-gate /* 36227c478bd9Sstevel@tonic-gate * Add a mapping to the given proc handle. Resizes the array as appropriate and 36237c478bd9Sstevel@tonic-gate * manages reference counts on the given file_info_t. 36247c478bd9Sstevel@tonic-gate * 36257c478bd9Sstevel@tonic-gate * The 'map_relocate' member is used to tell Psort_mappings() that the 36267c478bd9Sstevel@tonic-gate * associated file_map pointer needs to be relocated after the mappings have 36277c478bd9Sstevel@tonic-gate * been sorted. It is only set for the first mapping, and has no meaning 36287c478bd9Sstevel@tonic-gate * outside these two functions. 36297c478bd9Sstevel@tonic-gate */ 36307c478bd9Sstevel@tonic-gate int 36317c478bd9Sstevel@tonic-gate Padd_mapping(struct ps_prochandle *P, off64_t off, file_info_t *fp, 36327c478bd9Sstevel@tonic-gate prmap_t *pmap) 36337c478bd9Sstevel@tonic-gate { 36347c478bd9Sstevel@tonic-gate map_info_t *mp; 36357c478bd9Sstevel@tonic-gate 36367c478bd9Sstevel@tonic-gate if (P->map_count == P->map_alloc) { 36377c478bd9Sstevel@tonic-gate size_t next = P->map_alloc ? P->map_alloc * 2 : 16; 36387c478bd9Sstevel@tonic-gate 36397c478bd9Sstevel@tonic-gate if ((P->mappings = realloc(P->mappings, 36407c478bd9Sstevel@tonic-gate next * sizeof (map_info_t))) == NULL) 36417c478bd9Sstevel@tonic-gate return (-1); 36427c478bd9Sstevel@tonic-gate 36437c478bd9Sstevel@tonic-gate P->map_alloc = next; 36447c478bd9Sstevel@tonic-gate } 36457c478bd9Sstevel@tonic-gate 36467c478bd9Sstevel@tonic-gate mp = &P->mappings[P->map_count++]; 36477c478bd9Sstevel@tonic-gate 36487c478bd9Sstevel@tonic-gate mp->map_offset = off; 36497c478bd9Sstevel@tonic-gate mp->map_pmap = *pmap; 36507c478bd9Sstevel@tonic-gate mp->map_relocate = 0; 36517c478bd9Sstevel@tonic-gate if ((mp->map_file = fp) != NULL) { 36527c478bd9Sstevel@tonic-gate if (fp->file_map == NULL) { 36537c478bd9Sstevel@tonic-gate fp->file_map = mp; 36547c478bd9Sstevel@tonic-gate mp->map_relocate = 1; 36557c478bd9Sstevel@tonic-gate } 36567c478bd9Sstevel@tonic-gate fp->file_ref++; 36577c478bd9Sstevel@tonic-gate } 36587c478bd9Sstevel@tonic-gate 36597c478bd9Sstevel@tonic-gate return (0); 36607c478bd9Sstevel@tonic-gate } 36617c478bd9Sstevel@tonic-gate 36627c478bd9Sstevel@tonic-gate static int 36637c478bd9Sstevel@tonic-gate map_sort(const void *a, const void *b) 36647c478bd9Sstevel@tonic-gate { 36657c478bd9Sstevel@tonic-gate const map_info_t *ap = a, *bp = b; 36667c478bd9Sstevel@tonic-gate 36677c478bd9Sstevel@tonic-gate if (ap->map_pmap.pr_vaddr < bp->map_pmap.pr_vaddr) 36687c478bd9Sstevel@tonic-gate return (-1); 36697c478bd9Sstevel@tonic-gate else if (ap->map_pmap.pr_vaddr > bp->map_pmap.pr_vaddr) 36707c478bd9Sstevel@tonic-gate return (1); 36717c478bd9Sstevel@tonic-gate else 36727c478bd9Sstevel@tonic-gate return (0); 36737c478bd9Sstevel@tonic-gate } 36747c478bd9Sstevel@tonic-gate 36757c478bd9Sstevel@tonic-gate /* 36767c478bd9Sstevel@tonic-gate * Sort the current set of mappings. Should be called during target 36777c478bd9Sstevel@tonic-gate * initialization after all calls to Padd_mapping() have been made. 36787c478bd9Sstevel@tonic-gate */ 36797c478bd9Sstevel@tonic-gate void 36807c478bd9Sstevel@tonic-gate Psort_mappings(struct ps_prochandle *P) 36817c478bd9Sstevel@tonic-gate { 36827c478bd9Sstevel@tonic-gate int i; 36837c478bd9Sstevel@tonic-gate map_info_t *mp; 36847c478bd9Sstevel@tonic-gate 36857c478bd9Sstevel@tonic-gate qsort(P->mappings, P->map_count, sizeof (map_info_t), map_sort); 36867c478bd9Sstevel@tonic-gate 36877c478bd9Sstevel@tonic-gate /* 36887c478bd9Sstevel@tonic-gate * Update all the file_map pointers to refer to the new locations. 36897c478bd9Sstevel@tonic-gate */ 36907c478bd9Sstevel@tonic-gate for (i = 0; i < P->map_count; i++) { 36917c478bd9Sstevel@tonic-gate mp = &P->mappings[i]; 36927c478bd9Sstevel@tonic-gate if (mp->map_relocate) 36937c478bd9Sstevel@tonic-gate mp->map_file->file_map = mp; 36947c478bd9Sstevel@tonic-gate mp->map_relocate = 0; 36957c478bd9Sstevel@tonic-gate } 36967c478bd9Sstevel@tonic-gate } 3697