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