xref: /titanic_51/usr/src/lib/libpctx/common/libpctx.c (revision b3697b90e692e3e5d859fb77d285d4c056d99eda)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*
28  * This file contains a set of generic routines for periodically
29  * sampling the state of another process, or tree of processes.
30  *
31  * It is built upon the infrastructure provided by libproc.
32  */
33 
34 #include <sys/wait.h>
35 #include <sys/syscall.h>
36 #include <sys/time.h>
37 #include <libproc.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <errno.h>
41 #include <unistd.h>
42 #include <signal.h>
43 #include <string.h>
44 #include <strings.h>
45 #include <limits.h>
46 #include <ctype.h>
47 #include <libintl.h>
48 #include <libcpc.h>
49 #include <sys/cpc_impl.h>
50 
51 #include "libpctx.h"
52 
53 struct __pctx {
54 	pctx_errfn_t *errfn;
55 	struct ps_prochandle *Pr;
56 	void *uarg;
57 	pctx_sysc_execfn_t *exec;
58 	pctx_sysc_forkfn_t *fork;
59 	pctx_sysc_exitfn_t *exit;
60 	pctx_sysc_lwp_createfn_t *lwp_create;
61 	pctx_init_lwpfn_t *init_lwp;
62 	pctx_fini_lwpfn_t *fini_lwp;
63 	pctx_sysc_lwp_exitfn_t *lwp_exit;
64 	int verbose;
65 	int created;
66 	int sigblocked;
67 	int terminate;
68 	sigset_t savedset;
69 	cpc_t *cpc;
70 };
71 
72 static void (*pctx_cpc_callback)(cpc_t *cpc, struct __pctx *pctx);
73 
74 static void
75 pctx_default_errfn(const char *fn, const char *fmt, va_list ap)
76 {
77 	(void) fprintf(stderr, "libpctx: pctx_%s: ", fn);
78 	(void) vfprintf(stderr, fmt, ap);
79 }
80 
81 /*PRINTFLIKE3*/
82 static void
83 pctx_error(pctx_t *pctx, const char *fn, const char *fmt, ...)
84 {
85 	va_list ap;
86 
87 	va_start(ap, fmt);
88 	pctx->errfn(fn, fmt, ap);
89 	va_end(ap);
90 }
91 
92 /*
93  * Create a new process and bind the user args for it
94  */
95 pctx_t *
96 pctx_create(
97     const char *filename,
98     char *const *argv,
99     void *arg,
100     int verbose,
101     pctx_errfn_t *errfn)
102 {
103 	static const char fn[] = "create";
104 	int err;
105 	pctx_t *pctx;
106 
107 	pctx = calloc(1, sizeof (*pctx));
108 	pctx->uarg = arg;
109 	pctx->verbose = verbose;
110 	pctx->terminate = 0;
111 	pctx->errfn = errfn ? errfn : pctx_default_errfn;
112 
113 	if ((pctx->Pr = Pcreate(filename, argv, &err, 0, 0)) == NULL) {
114 		switch (err) {
115 		case C_PERM:
116 			pctx_error(pctx, fn, gettext("cannot trace set-id or "
117 			    "unreadable program '%s'\n"), filename);
118 			break;
119 		case C_LP64:
120 			pctx_error(pctx, fn, gettext("cannot control LP64 "
121 			    "program '%s'\n"), filename);
122 			break;
123 		case C_NOEXEC:
124 			pctx_error(pctx, fn, gettext("cannot execute "
125 			    "program '%s'\n"), filename);
126 			break;
127 		case C_NOENT:
128 			pctx_error(pctx, fn, gettext("cannot find"
129 			    "program '%s'\n"), filename);
130 			break;
131 		case C_FORK:
132 			pctx_error(pctx, fn, gettext("cannot fork, "
133 			    "program '%s'\n"), filename);
134 			break;
135 		default:
136 			pctx_error(pctx, fn, gettext("%s, program '%s'\n"),
137 			    Pcreate_error(err), filename);
138 			break;
139 		}
140 		free(pctx);
141 		return (NULL);
142 	}
143 
144 	if (Psysentry(pctx->Pr, SYS_exit, 1) == -1) {
145 		pctx_error(pctx, fn,
146 		    gettext("can't stop-on-exit() program '%s'\n"), filename);
147 		Prelease(pctx->Pr, PRELEASE_KILL);
148 		free(pctx);
149 		return (NULL);
150 	}
151 	/*
152 	 * Set kill-on-last-close so the controlled process
153 	 * dies if we die.
154 	 */
155 	pctx->created = 1;
156 	(void) Psetflags(pctx->Pr, PR_KLC);
157 	(void) pctx_set_events(pctx, PCTX_NULL_EVENT);
158 
159 	return (pctx);
160 }
161 
162 /*
163  * Capture an existing process and bind the user args for it
164  */
165 pctx_t *
166 pctx_capture(pid_t pid, void *arg, int verbose, pctx_errfn_t *errfn)
167 {
168 	static const char fn[] = "capture";
169 	int err;
170 	pctx_t *pctx;
171 
172 	pctx = calloc(1, sizeof (*pctx));
173 	pctx->uarg = arg;
174 	pctx->verbose = verbose;
175 	pctx->errfn = errfn ? errfn : pctx_default_errfn;
176 
177 	if ((pctx->Pr = Pgrab(pid, 0, &err)) == NULL) {
178 		switch (err) {
179 		case G_NOPROC:
180 			pctx_error(pctx, fn,
181 			    gettext("pid %d doesn't exist\n"), (int)pid);
182 			break;
183 		case G_ZOMB:
184 			pctx_error(pctx, fn,
185 			    gettext("pid %d is a zombie\n"), (int)pid);
186 			break;
187 		case G_PERM:
188 			pctx_error(pctx, fn,
189 			    gettext("pid %d: permission denied\n"), (int)pid);
190 			break;
191 		case G_BUSY:
192 			pctx_error(pctx, fn,
193 			    gettext("pid %d is already being traced\n"),
194 			    (int)pid);
195 			break;
196 		case G_SYS:
197 			pctx_error(pctx, fn,
198 			    gettext("pid %d is a system process\n"), (int)pid);
199 			break;
200 		case G_SELF:
201 			pctx_error(pctx, fn,
202 			    gettext("cannot capture self!\n"));
203 			break;
204 		case G_LP64:
205 			pctx_error(pctx, fn, gettext("cannot control LP64 "
206 			    "process, pid %d\n"), (int)pid);
207 			break;
208 		default:
209 			pctx_error(pctx, fn, gettext("%s: pid %d\n"),
210 			    Pgrab_error(err), (int)pid);
211 			break;
212 		}
213 		free(pctx);
214 		return (NULL);
215 	}
216 
217 	if (Psysentry(pctx->Pr, SYS_exit, 1) == -1) {
218 		pctx_error(pctx, fn,
219 		    gettext("can't stop-on-exit() pid %d\n"), (int)pid);
220 		Prelease(pctx->Pr, PRELEASE_CLEAR);
221 		free(pctx);
222 		return (NULL);
223 	}
224 
225 	/*
226 	 * Set run-on-last-close so the controlled process
227 	 * runs even if we die on a signal.  This is because
228 	 * we grabbed an existing process - it would be impolite
229 	 * to cause it to die if we exit prematurely.
230 	 */
231 	pctx->created = 0;
232 	(void) Psetflags(pctx->Pr, PR_RLC);
233 	(void) pctx_set_events(pctx, PCTX_NULL_EVENT);
234 
235 	return (pctx);
236 }
237 
238 /*ARGSUSED*/
239 static void
240 default_void(pctx_t *pctx)
241 {}
242 
243 /*ARGSUSED*/
244 static int
245 default_int(pctx_t *pctx)
246 {
247 	return (0);
248 }
249 
250 int
251 pctx_set_events(pctx_t *pctx, ...)
252 {
253 	static const char fn[] = "set_events";
254 	va_list pvar;
255 	int error = 0;
256 	pctx_event_t event;
257 
258 	va_start(pvar, pctx);
259 	do {
260 		switch (event = (pctx_event_t)va_arg(pvar, pctx_event_t)) {
261 		case PCTX_NULL_EVENT:
262 			break;
263 		case PCTX_SYSC_EXEC_EVENT:
264 			pctx->exec = (pctx_sysc_execfn_t *)
265 			    va_arg(pvar, pctx_sysc_execfn_t *);
266 			break;
267 		case PCTX_SYSC_FORK_EVENT:
268 			pctx->fork = (pctx_sysc_forkfn_t *)
269 			    va_arg(pvar, pctx_sysc_forkfn_t *);
270 			break;
271 		case PCTX_SYSC_EXIT_EVENT:	/* always intercepted */
272 			pctx->exit = (pctx_sysc_exitfn_t *)
273 			    va_arg(pvar, pctx_sysc_exitfn_t *);
274 			break;
275 		case PCTX_SYSC_LWP_CREATE_EVENT:
276 			pctx->lwp_create = (pctx_sysc_lwp_createfn_t *)
277 			    va_arg(pvar, pctx_sysc_lwp_createfn_t *);
278 			break;
279 		case PCTX_INIT_LWP_EVENT:
280 			pctx->init_lwp = (pctx_init_lwpfn_t *)
281 			    va_arg(pvar, pctx_init_lwpfn_t *);
282 			break;
283 		case PCTX_FINI_LWP_EVENT:
284 			pctx->fini_lwp = (pctx_fini_lwpfn_t *)
285 			    va_arg(pvar, pctx_fini_lwpfn_t *);
286 			break;
287 		case PCTX_SYSC_LWP_EXIT_EVENT:
288 			pctx->lwp_exit = (pctx_sysc_lwp_exitfn_t *)
289 			    va_arg(pvar, pctx_sysc_lwp_exitfn_t *);
290 			break;
291 		default:
292 			pctx_error(pctx, fn,
293 			    gettext("unknown event type %x\n"), event);
294 			error = -1;
295 			break;
296 		}
297 	} while (event != PCTX_NULL_EVENT && error == 0);
298 	va_end(pvar);
299 
300 	if (error != 0)
301 		return (error);
302 
303 	if (pctx->exec == NULL)
304 		pctx->exec = (pctx_sysc_execfn_t *)default_int;
305 	if (pctx->fork == NULL)
306 		pctx->fork = (pctx_sysc_forkfn_t *)default_void;
307 	if (pctx->exit == NULL)
308 		pctx->exit = (pctx_sysc_exitfn_t *)default_void;
309 	if (pctx->lwp_create == NULL)
310 		pctx->lwp_create = (pctx_sysc_lwp_createfn_t *)default_int;
311 	if (pctx->init_lwp == NULL)
312 		pctx->init_lwp = (pctx_init_lwpfn_t *)default_int;
313 	if (pctx->fini_lwp == NULL)
314 		pctx->fini_lwp = (pctx_fini_lwpfn_t *)default_int;
315 	if (pctx->lwp_exit == NULL)
316 		pctx->lwp_exit = (pctx_sysc_lwp_exitfn_t *)default_int;
317 
318 	if (pctx->fork != (pctx_sysc_forkfn_t *)default_void) {
319 		(void) Psysexit(pctx->Pr, SYS_vfork, 1);
320 		(void) Psysexit(pctx->Pr, SYS_forksys, 1);
321 		if (Psetflags(pctx->Pr, PR_FORK) == -1)
322 			error = -1;
323 	} else {
324 		(void) Psysexit(pctx->Pr, SYS_vfork, 0);
325 		(void) Psysexit(pctx->Pr, SYS_forksys, 0);
326 		if (Punsetflags(pctx->Pr, PR_FORK) == -1)
327 			error = -1;
328 	}
329 
330 	/*
331 	 * exec causes termination of all but the exec-ing lwp,
332 	 * and resets the lwpid to one in the new address space.
333 	 */
334 	if (pctx->exec != (pctx_sysc_execfn_t *)default_int ||
335 	    pctx->fini_lwp != (pctx_fini_lwpfn_t *)default_int ||
336 	    pctx->init_lwp != (pctx_init_lwpfn_t *)default_int) {
337 		(void) Psysexit(pctx->Pr, SYS_execve, 1);
338 		(void) Psysentry(pctx->Pr, SYS_execve, 1);
339 	} else {
340 		(void) Psysexit(pctx->Pr, SYS_execve, 0);
341 		(void) Psysentry(pctx->Pr, SYS_execve, 0);
342 	}
343 
344 	(void) Psysexit(pctx->Pr, SYS_lwp_create,
345 	    pctx->lwp_create != (pctx_sysc_lwp_createfn_t *)default_int ||
346 	    pctx->init_lwp != (pctx_init_lwpfn_t *)default_int);
347 
348 	(void) Psysentry(pctx->Pr, SYS_lwp_exit,
349 	    pctx->lwp_exit != (pctx_sysc_lwp_exitfn_t *)default_int ||
350 	    pctx->fini_lwp != (pctx_fini_lwpfn_t *)default_int);
351 
352 	return (0);
353 }
354 
355 static sigset_t termsig;
356 
357 static void
358 __libpctx_init(void)
359 {
360 	/*
361 	 * Initialize the signal set used to shield ourselves from
362 	 * death-by-terminal-signal while the agent lwp is running.
363 	 */
364 	(void) sigemptyset(&termsig);
365 	(void) sigaddset(&termsig, SIGHUP);
366 	(void) sigaddset(&termsig, SIGTERM);
367 	(void) sigaddset(&termsig, SIGINT);
368 	(void) sigaddset(&termsig, SIGQUIT);
369 }
370 
371 #pragma init(__libpctx_init)
372 
373 static void
374 pctx_begin_syscalls(pctx_t *pctx)
375 {
376 	if (pctx->Pr == NULL)
377 		return;
378 	if (pctx->sigblocked++ == 0) {
379 		(void) sigprocmask(SIG_BLOCK, &termsig, &pctx->savedset);
380 		(void) Pcreate_agent(pctx->Pr);
381 	}
382 }
383 
384 static void
385 pctx_end_syscalls(pctx_t *pctx)
386 {
387 	if (pctx->Pr == NULL)
388 		return;
389 	if (--pctx->sigblocked == 0) {
390 		(void) Pdestroy_agent(pctx->Pr);
391 		(void) sigprocmask(SIG_SETMASK, &pctx->savedset, NULL);
392 	}
393 }
394 
395 /*
396  * Iterate over the valid lwpids in the process, invoking the
397  * action function on each one.
398  */
399 static int
400 pctx_lwpiterate(pctx_t *pctx, int (*action)(pctx_t *, pid_t, id_t, void *))
401 {
402 	const pstatus_t *pstatus;
403 	char lstatus[64];
404 	struct stat statb;
405 	lwpstatus_t *lwps;
406 	prheader_t *prh;
407 	int fd, nlwp;
408 	int ret = 0;
409 
410 	if (action == (int (*)(pctx_t *, pid_t, id_t, void *))default_int)
411 		return (0);
412 
413 	pstatus = Pstatus(pctx->Pr);
414 	if (pstatus->pr_nlwp <= 1) {
415 		pctx_begin_syscalls(pctx);
416 		ret = action(pctx, pstatus->pr_pid, 1, pctx->uarg);
417 		pctx_end_syscalls(pctx);
418 		return (ret);
419 	}
420 
421 	(void) snprintf(lstatus, sizeof (lstatus),
422 	    "/proc/%d/lstatus", (int)pstatus->pr_pid);
423 
424 	if ((fd = open(lstatus, O_RDONLY)) < 0 ||
425 	    fstat(fd, &statb) != 0) {
426 		if (fd >= 0)
427 			(void) close(fd);
428 		return (-1);
429 	}
430 
431 	prh = malloc(statb.st_size);
432 	if (read(fd, prh, statb.st_size) <
433 	    sizeof (prheader_t) + sizeof (lwpstatus_t)) {
434 		(void) close(fd);
435 		free(prh);
436 		return (-1);
437 	}
438 	(void) close(fd);
439 
440 	/* LINTED pointer cast may result in improper alignment */
441 	lwps = (lwpstatus_t *)(prh + 1);
442 	pctx_begin_syscalls(pctx);
443 	for (nlwp = prh->pr_nent; nlwp > 0; nlwp--) {
444 		if (action(pctx,
445 		    pstatus->pr_pid, lwps->pr_lwpid, pctx->uarg) != 0)
446 			ret = -1;
447 		/* LINTED pointer cast may result in improper alignment */
448 		lwps = (lwpstatus_t *)((char *)lwps + prh->pr_entsize);
449 	}
450 	pctx_end_syscalls(pctx);
451 	free(prh);
452 	return (ret);
453 }
454 
455 /*
456  * Free any associated state, but leave the process stopped if it
457  * is still under our control.  (If it isn't under our control,
458  * it should just run to completion when we do our last close)
459  */
460 static void
461 pctx_free(pctx_t *pctx)
462 {
463 	if (pctx->cpc != NULL && pctx_cpc_callback != NULL)
464 		(*pctx_cpc_callback)(pctx->cpc, pctx);
465 	if (pctx->Pr) {
466 		Pfree(pctx->Pr);
467 		pctx->Pr = NULL;
468 	}
469 	pctx->errfn = pctx_default_errfn;
470 }
471 
472 /*
473  * Completely release the process from our control and discard all our state
474  */
475 void
476 pctx_release(pctx_t *pctx)
477 {
478 	if (pctx->Pr) {
479 		Prelease(pctx->Pr, PRELEASE_CLEAR);
480 		pctx->Pr = NULL;
481 	}
482 
483 	pctx_free(pctx);
484 	bzero(pctx, sizeof (*pctx));
485 	free(pctx);
486 }
487 
488 static void
489 msincr(struct timeval *tv, uint_t msec)
490 {
491 	tv->tv_sec += msec / MILLISEC;
492 	tv->tv_usec += (msec % MILLISEC) * MILLISEC;
493 	if (tv->tv_usec > MICROSEC) {
494 		tv->tv_sec++;
495 		tv->tv_usec -= MICROSEC;
496 	}
497 }
498 
499 static uint_t
500 msdiff(struct timeval *tva, struct timeval *tvb)
501 {
502 	time_t sdiff = tva->tv_sec - tvb->tv_sec;
503 	suseconds_t udiff = tva->tv_usec - tvb->tv_usec;
504 
505 	if (sdiff < 0)
506 		return (0);
507 	if (udiff < 0) {
508 		udiff += MICROSEC;
509 		sdiff--;
510 	}
511 	if (sdiff < 0)
512 		return (0);
513 	if (sdiff >= (INT_MAX / MILLISEC))
514 		return ((uint_t)INT_MAX);
515 	return ((uint_t)(sdiff * MILLISEC + udiff / MILLISEC));
516 }
517 
518 int
519 pctx_run(
520 	pctx_t *pctx,
521 	uint_t msec,
522 	uint_t nsamples,
523 	int (*tick)(pctx_t *, pid_t, id_t, void *))
524 {
525 	static const char fn[] = "run";
526 	struct timeval tvgoal, tvnow;
527 	uint_t mswait = 0;
528 	int running = 1;
529 	const pstatus_t *pstatus;
530 	psinfo_t psinfo;
531 	void (*sigsaved)();
532 	id_t lwpid;
533 	pid_t pid = Pstatus(pctx->Pr)->pr_pid;
534 	int pstate;
535 
536 	if (msec == 0)
537 		nsamples = 0;
538 	if (nsamples == 0)
539 		nsamples = UINT_MAX;
540 
541 	/*
542 	 * Casually discard any knowledge of the children we create
543 	 */
544 	sigsaved = signal(SIGCHLD, SIG_IGN);
545 
546 	/*
547 	 * Since we've just "discovered" this process which might have
548 	 * been running for weeks, deliver some init_lwp events so
549 	 * that our caller gets a handle on the process.
550 	 */
551 	if (pctx_lwpiterate(pctx, pctx->init_lwp) != 0) {
552 		if (pctx->verbose)
553 			pctx_error(pctx, fn,
554 			    gettext("%d: lwp discovery failed\n"), (int)pid);
555 		goto bailout;
556 	}
557 
558 	if (msec != 0) {
559 		/*
560 		 * tvgoal represents the time at which the sample
561 		 * should next be taken.
562 		 */
563 		(void) gettimeofday(&tvgoal, 0);
564 		msincr(&tvgoal, msec);
565 	}
566 
567 	/*
568 	 * The event handling loop continues while running is 1.
569 	 * running becomes 0 when either the controlled process has
570 	 * exited successfully or the number of time samples has expired.
571 	 * Otherwise, if an error has occurred, running becomes -1.
572 	 */
573 	while (running == 1 && !pctx->terminate) {
574 
575 		if (Psetrun(pctx->Pr, 0, 0) != 0) {
576 			if (pctx->verbose)
577 				pctx_error(pctx, fn,
578 				    gettext("%d: Psetrun\n"), (int)pid);
579 			break;
580 		}
581 
582 		if (msec != 0) {
583 			/*
584 			 * This timing loop attempts to estimate the number
585 			 * of milliseconds between our "goal" time (when
586 			 * we should stop the process and run the tick
587 			 * routine) and the current time.
588 			 *
589 			 * If we ever find ourselves running behind i.e. we
590 			 * missed our goal, then we skip ahead to the next
591 			 * goal instead.
592 			 */
593 			do {
594 				(void) gettimeofday(&tvnow, 0);
595 				if ((mswait = msdiff(&tvgoal, &tvnow)) == 0) {
596 					msincr(&tvgoal, msec);
597 					/*
598 					 * Skip ahead to the next goal, unless
599 					 * there is only one more sample left
600 					 * to take.
601 					 */
602 					if (nsamples != 1)
603 						nsamples--;
604 				}
605 			} while (mswait == 0 && !pctx->terminate);
606 		}
607 
608 		if (pctx->terminate)
609 			goto bailout;
610 		else
611 			(void) Pwait(pctx->Pr, mswait);
612 
613 checkstate:
614 		switch (pstate = Pstate(pctx->Pr)) {
615 		case PS_RUN:
616 			/*
617 			 * Try again, but wait for up to 5 seconds.
618 			 */
619 			if (Pstop(pctx->Pr, 5 * MILLISEC) == -1 ||
620 			    (pstate = Pstate(pctx->Pr)) != PS_STOP) {
621 				pctx_error(pctx, fn,
622 				    gettext("%d: won't stop\n"), (int)pid);
623 			}
624 			break;
625 		case PS_STOP:
626 			break;
627 		case PS_LOST:
628 			/*
629 			 * Lost control - probably execed a setuid/setgid
630 			 * executable.  Try and get control back again,
631 			 * else bail ..
632 			 */
633 			(void) Preopen(pctx->Pr);
634 			if ((pstate = Pstate(pctx->Pr)) != PS_LOST)
635 				goto checkstate;
636 			pctx_error(pctx, fn,
637 			    gettext("%d: execed a program that cannot "
638 			    "be tracked\n"), (int)pid);
639 			running = -1;
640 			break;
641 		case PS_UNDEAD:
642 		case PS_DEAD:
643 			if (pctx->verbose)
644 				pctx_error(pctx, fn,
645 				    gettext("%d: process terminated\n"),
646 				    (int)pid);
647 			running = -1;
648 			break;
649 		default:
650 			if (pctx->verbose)
651 				pctx_error(pctx, fn,
652 				    gettext("%d: process state 0x%x?\n"),
653 				    (int)pid, pstate);
654 			break;
655 		}
656 
657 		if (pstate != PS_STOP)
658 			break;
659 
660 		pstatus = Pstatus(pctx->Pr);
661 		lwpid = pstatus->pr_lwp.pr_lwpid;
662 		switch (pstatus->pr_lwp.pr_why) {
663 		case PR_REQUESTED:
664 			msincr(&tvgoal, msec);
665 			if (pstatus->pr_flags & PR_VFORKP) {
666 				/*
667 				 * The process is in a vfork stupor until
668 				 * its child releases it via an exec.
669 				 * Don't sample it while it's in this state
670 				 * - we won't be able to create the agent.
671 				 */
672 				break;
673 			}
674 			if (pctx_lwpiterate(pctx, tick) != 0)
675 				running = -1;
676 			if (running == 1 && --nsamples == 0)
677 				running = 0;
678 			break;
679 		case PR_SYSENTRY:
680 			switch (pstatus->pr_lwp.pr_what) {
681 			case SYS_lwp_exit:
682 				pctx_begin_syscalls(pctx);
683 				(void) pctx->fini_lwp(pctx,
684 				    pid, lwpid, pctx->uarg);
685 				(void) pctx->lwp_exit(pctx,
686 				    pid, lwpid, pctx->uarg);
687 				pctx_end_syscalls(pctx);
688 				break;
689 			case SYS_exit:
690 				if (pctx_lwpiterate(pctx, pctx->fini_lwp)
691 				    != 0)
692 					running = -1;
693 				pctx->exit(pctx, pid, lwpid,
694 				    (int)pstatus->pr_lwp.pr_sysarg[0],
695 				    pctx->uarg);
696 				if (running == 1)
697 					running = 0;
698 				break;
699 			case SYS_execve:
700 				(void) pctx_lwpiterate(pctx, pctx->fini_lwp);
701 				break;
702 			default:
703 				pctx_error(pctx, fn,
704 				    "warning - pid %d sysentry(%d)\n",
705 				    (int)pid, pstatus->pr_lwp.pr_what);
706 				break;
707 			}
708 			break;
709 		case PR_SYSEXIT:
710 			switch (pstatus->pr_lwp.pr_what) {
711 			case SYS_execve:
712 				if (pstatus->pr_lwp.pr_errno) {
713 					/*
714 					 * The exec failed completely.
715 					 * Reinstate the lwps we fini'd
716 					 * at exec entrance
717 					 */
718 					if (pctx_lwpiterate(pctx,
719 					    pctx->init_lwp) == 0)
720 						running = 1;
721 					else
722 						running = -1;
723 					break;
724 				}
725 				if (pctx->exec == (pctx_sysc_execfn_t *)
726 				    default_int) {
727 					running = 0;
728 					break;
729 				}
730 				(void) memcpy(&psinfo,
731 				    Ppsinfo(pctx->Pr), sizeof (psinfo));
732 				proc_unctrl_psinfo(&psinfo);
733 				pctx_begin_syscalls(pctx);
734 				if (pctx->exec(pctx, pid, lwpid,
735 				    psinfo.pr_psargs, pctx->uarg) != 0)
736 					running = -1;
737 				if (running == 1 && pctx->init_lwp(pctx,
738 				    pid, 1, pctx->uarg) != 0)
739 					running = -1;
740 				pctx_end_syscalls(pctx);
741 				break;
742 			case SYS_lwp_create:
743 				if (pstatus->pr_lwp.pr_errno ||
744 				    pstatus->pr_lwp.pr_rval1)
745 					break;
746 				pctx_begin_syscalls(pctx);
747 				if (pctx->init_lwp(pctx, pid, lwpid,
748 				    pctx->uarg) != 0)
749 					running = -1;
750 				if (running == 1 && pctx->lwp_create(pctx,
751 				    pid, lwpid, pctx->uarg) != 0)
752 					running = -1;
753 				pctx_end_syscalls(pctx);
754 				break;
755 			case SYS_vfork:
756 			case SYS_forksys:
757 				if (pstatus->pr_lwp.pr_errno)
758 					break;
759 				(void) fflush(NULL);
760 				switch (fork1()) {
761 					pid_t ppid;
762 					int wascreated;
763 					pctx_sysc_forkfn_t *forkfn;
764 				case 0:
765 					ppid = pid;
766 					pid = pstatus->pr_lwp.pr_rval1;
767 					wascreated = pctx->created;
768 					forkfn = pctx->fork;
769 					pctx_free(pctx);
770 					pctx = pctx_capture(pid, pctx->uarg,
771 					    pctx->verbose, pctx->errfn);
772 					if (pctx != NULL) {
773 						if (wascreated) {
774 							/*
775 							 * Set kill on last
776 							 * close so -all-
777 							 * children die.
778 							 */
779 							pctx->created = 1;
780 							(void) Psetflags(
781 							    pctx->Pr, PR_KLC);
782 						}
783 						(*forkfn)(pctx, ppid, pid,
784 						    lwpid, pctx->uarg);
785 						pctx_release(pctx);
786 						_exit(0);
787 					} else {
788 						_exit(1);
789 					}
790 					/*NOTREACHED*/
791 				case -1:
792 					pctx_error(pctx, fn,
793 					    "cannot follow pid %d: %s\n",
794 					    (int)pstatus->pr_lwp.pr_rval1,
795 					    strerror(errno));
796 					break;
797 				default:
798 					break;
799 				}
800 				break;
801 			default:
802 				pctx_error(pctx, fn, gettext(
803 				    "warning - pid %d sysexit(%d)\n"),
804 				    (int)pid, pstatus->pr_lwp.pr_what);
805 				break;
806 			}
807 			break;
808 		case PR_SIGNALLED:
809 			if (pctx->verbose)
810 				pctx_error(pctx, fn,
811 				    gettext("pid %d - signalled\n"), (int)pid);
812 			break;
813 		case PR_JOBCONTROL:
814 			if (pctx->verbose)
815 				pctx_error(pctx, fn,
816 				    gettext("pid %d - job control stop\n"),
817 				    (int)pid);
818 			running = -1;
819 			break;
820 		case PR_FAULTED:
821 			if (pctx->verbose)
822 				pctx_error(pctx, fn,
823 				    gettext("pid %d - faulted\n"), (int)pid);
824 			break;
825 		case PR_SUSPENDED:
826 			if (pctx->verbose)
827 				pctx_error(pctx, fn,
828 				    gettext("pid %d - suspended\n"), (int)pid);
829 			break;
830 		case PR_CHECKPOINT:
831 			if (pctx->verbose)
832 				pctx_error(pctx, fn,
833 				    gettext("pid %d - checkpoint\n"),
834 				    (int)pid);
835 			break;
836 		default:
837 			if (pctx->verbose)
838 				pctx_error(pctx, fn,
839 				    gettext("pid %d - reason %d\n"),
840 				    (int)pid, pstatus->pr_lwp.pr_why);
841 			running = -1;
842 			break;
843 		}
844 	}
845 
846 bailout:
847 	(void) signal(SIGCHLD, sigsaved);
848 
849 	if (pctx->terminate)
850 		return (0);
851 
852 	switch (running) {
853 	case 0:
854 		return (0);
855 	case -1:
856 		return (-1);
857 	default:
858 		pctx_error(pctx, fn, gettext("lost control of pid %d\n"),
859 		    (int)pid);
860 		pctx_free(pctx);
861 		return (-1);
862 	}
863 }
864 
865 /*
866  * Execute the private 'cpc' system call in the context of the
867  * controlled process.
868  */
869 int
870 __pctx_cpc(pctx_t *pctx, cpc_t *cpc,
871     int cmd, id_t lwpid, void *data1, void *data2, void *data3, int bufsize)
872 {
873 	sysret_t rval;
874 	argdes_t argd[5];
875 	argdes_t *adp = &argd[0];
876 	int error;
877 
878 	/*
879 	 * Keep track of the relationship between cpc_t and pctx_t here.
880 	 * We store the last cpc_t used by libpctx, so that when this pctx is
881 	 * destroyed, libpctx can notify libcpc.
882 	 */
883 
884 	if (pctx->cpc != NULL && pctx->cpc != cpc && pctx_cpc_callback != NULL)
885 		(*pctx_cpc_callback)(pctx->cpc, pctx);
886 	pctx->cpc = cpc;
887 
888 	/*
889 	 * cmd and lwpid are passed in by value no matter what the command is.
890 	 */
891 	adp->arg_value = cmd;
892 	adp->arg_object = NULL;
893 	adp->arg_type = AT_BYVAL;
894 	adp->arg_inout = AI_INPUT;
895 	adp->arg_size = 0;
896 	adp++;
897 
898 	adp->arg_value = lwpid;
899 	adp->arg_object = NULL;
900 	adp->arg_type = AT_BYVAL;
901 	adp->arg_inout = AI_INPUT;
902 	adp->arg_size = 0;
903 	adp++;
904 
905 	switch (cmd) {
906 	case CPC_BIND:
907 		adp->arg_value = 0;
908 		adp->arg_object = data1;
909 		adp->arg_type = AT_BYREF;
910 		adp->arg_inout = AI_INPUT;
911 		adp->arg_size = (size_t)data2;
912 		adp++;
913 
914 		adp->arg_value = (size_t)data2;
915 		adp->arg_object = NULL;
916 		adp->arg_type = AT_BYVAL;
917 		adp->arg_inout = AI_INPUT;
918 		adp->arg_size = 0;
919 		adp++;
920 
921 		adp->arg_value = 0;
922 		adp->arg_object = data3;
923 		adp->arg_type = AT_BYREF;
924 		adp->arg_inout = AI_INOUT;
925 		adp->arg_size = sizeof (int);
926 
927 		break;
928 	case CPC_SAMPLE:
929 		adp->arg_value = 0;
930 		adp->arg_object = data1;
931 		adp->arg_type = AT_BYREF;
932 		adp->arg_inout = AI_OUTPUT;
933 		adp->arg_size = bufsize;
934 		adp++;
935 
936 		adp->arg_value = 0;
937 		adp->arg_object = data2;
938 		adp->arg_type = AT_BYREF;
939 		adp->arg_inout = AI_OUTPUT;
940 		adp->arg_size = sizeof (hrtime_t);
941 		adp++;
942 
943 		adp->arg_value = 0;
944 		adp->arg_object = data3;
945 		adp->arg_type = AT_BYREF;
946 		adp->arg_inout = AI_OUTPUT;
947 		adp->arg_size = sizeof (uint64_t);
948 
949 		break;
950 	default:
951 		adp->arg_value = 0;
952 		adp->arg_object = 0;
953 		adp->arg_type = AT_BYVAL;
954 		adp->arg_inout = AI_INPUT;
955 		adp->arg_size = 0;
956 		adp++;
957 
958 		adp->arg_value = 0;
959 		adp->arg_object = 0;
960 		adp->arg_type = AT_BYVAL;
961 		adp->arg_inout = AI_INPUT;
962 		adp->arg_size = 0;
963 		adp++;
964 
965 		adp->arg_value = 0;
966 		adp->arg_object = 0;
967 		adp->arg_type = AT_BYVAL;
968 		adp->arg_inout = AI_INPUT;
969 		adp->arg_size = 0;
970 
971 		break;
972 	}
973 
974 	error = Psyscall(pctx->Pr, &rval, SYS_cpc, 5, &argd[0]);
975 
976 	if (error) {
977 		errno = error > 0 ? error : ENOSYS;
978 		return (-1);
979 	}
980 	return (rval.sys_rval1);
981 }
982 
983 /*
984  * libcpc-private hook used to register a callback. The callback is used to
985  * notify libcpc when a pctx handle is invalidated.
986  */
987 void
988 __pctx_cpc_register_callback(void (*arg)(struct __cpc *, struct __pctx *))
989 {
990 	pctx_cpc_callback = arg;
991 }
992 
993 /*
994  * Tell pctx_run to bail out immediately
995  */
996 void
997 pctx_terminate(struct __pctx *pctx)
998 {
999 	pctx->terminate = 1;
1000 }
1001