github.com/Arquivotheca.Solaris-2.5
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
7c4988eac04ead06b3cf551ed900841cdca0f938
Arquivotheca.Solaris-2.5/cmd/ptools/libproc/pcontrol.c
seta75D 7c4988eac0 Init
2021-10-11 19:38:01 -03:00

1600 lines
36 KiB
C
Executable File
Raw Blame History

#ident "@(#)pcontrol.c 1.2 95/06/26 SMI"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <ctype.h>
#include <fcntl.h>
#include <string.h>
#include <memory.h>
#include <errno.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <sys/fault.h>
#include <sys/syscall.h>
#include "pcontrol.h"
#include "ramdata.h"
/* Process Management */
/* This module is carefully coded to contain only read-only data */
/* All read/write data is defined in ramdata.c (see also ramdata.h) */
/*
* Function prototypes for static routines in this module.
*/
#if defined(__STDC__)
static void deadcheck( process_t * );
static int execute( process_t * , int );
static int checksyscall( process_t * );
#else /* defined(__STDC__) */
static void deadcheck();
static int execute();
static int checksyscall();
#endif /* defined(__STDC__) */
static int
dupfd(fd, dfd)
register int fd;
register int dfd;
{
/*
* Make sure fd not one of 0, 1, or 2.
* This allows the program to work when spawned by init(1m).
* Also, if dfd is non-zero, dup the fd to be dfd.
*/
if (dfd > 0 || (0 <= fd && fd <= 2)) {
if (dfd <= 0)
dfd = 3;
dfd = fcntl(fd, F_DUPFD, dfd);
(void) close(fd);
fd = dfd;
}
/*
* Mark it close-on-exec so any created process doesn't inherit it.
*/
if (fd >= 0)
(void) fcntl(fd, F_SETFD, 1);
return (fd);
}
int
Pcreate(P, args) /* create new controlled process */
register process_t *P; /* program table entry */
char **args; /* argument array, including the command name */
{
register int i;
register int upid;
register int fd;
char procname[100];
upid = fork();
if (upid == 0) { /* child process */
(void) pause(); /* wait for PRSABORT from parent */
/* if running setuid or setgid, reset credentials to normal */
if ((i = getgid()) != getegid())
(void) setgid(i);
if ((i = getuid()) != geteuid())
(void) setuid(i);
(void) execvp(*args, args); /* execute the command */
_exit(127);
}
if (upid == -1) { /* failure */
perror("Pcreate fork()");
return -1;
}
/* initialize the process structure */
(void) memset((char *)P, 0, sizeof(*P));
P->cntrl = TRUE;
P->child = TRUE;
P->state = PS_RUN;
P->upid = upid;
P->pfd = -1;
P->lwpfd = -1;
/* open the /proc/upid file */
(void) sprintf(procname, "%s/%d", procdir, upid);
/* exclusive open prevents others from interfering */
if ((fd = open(procname, (O_RDWR|O_EXCL))) < 0
|| (fd = dupfd(fd, 0)) < 0) {
perror("Pcreate open()");
(void) kill(upid, SIGKILL);
return -1;
}
P->pfd = fd;
/* mark it run-on-last-close so it runs even if we die on a signal */
if (Ioctl(fd, PIOCSRLC, 0) == -1)
perror("Pcreate PIOCSRLC");
(void) Pstop(P); /* stop the controlled process */
for (;;) { /* wait for process to sleep in pause() */
if (P->state == PS_STOP
&& P->why.pr_why == PR_REQUESTED
&& (P->why.pr_flags & PR_ASLEEP)
&& Pgetsysnum(P) == SYS_pause)
break;
if (P->state != PS_STOP /* interrupt or process died */
|| Psetrun(P, 0, PRSTOP) != 0) { /* can't restart */
int sig = SIGKILL;
(void) Ioctl(fd, PIOCKILL, (int)&sig); /* kill ! */
(void) close(fd);
(void) kill(upid, sig); /* kill !! */
P->state = PS_DEAD;
P->pfd = -1;
return -1;
}
(void) Pwait(P);
/* dumpwhy(P, 0); */
}
(void) Psysentry(P, SYS_exit, 1); /* catch these sys calls */
(void) Psysentry(P, SYS_exec, 1);
(void) Psysentry(P, SYS_execve, 1);
/* kick it off the pause() */
if (Psetrun(P, 0, PRSABORT) == -1) {
int sig = SIGKILL;
perror("Pcreate PIOCRUN");
(void) Ioctl(fd, PIOCKILL, (int)&sig);
(void) kill(upid, sig);
(void) close(fd);
P->state = PS_DEAD;
P->pfd = -1;
return -1;
}
(void) Pwait(P); /* wait for exec() or exit() */
return 0;
}
int
Pgrab(P, upid, force) /* grab existing process */
register process_t *P; /* program table entry */
register pid_t upid; /* UNIX process ID */
int force; /* if TRUE, grab regardless */
{
register int pfd = -1;
int err;
int rc;
prstatus_t prstat;
int ruid;
struct prcred prcred;
char procname[100];
again: /* Come back here if we lose it in the Window of Vulnerability */
if (pfd >= 0) {
(void) close(pfd);
pfd = -1;
}
(void) memset((char *)P, 0, sizeof(*P));
P->pfd = -1;
P->lwpfd = -1;
/* generate the /proc/upid filename */
(void) sprintf(procname, "%s/%d", procdir, upid);
/* Request exclusive open to avoid grabbing someone else's */
/* process and to prevent others from interfering afterwards. */
/* If this fails and the 'force' flag is set, attempt to */
/* open non-exclusively (effective only for the super-user). */
if (((pfd = open(procname, (O_RDWR|O_EXCL))) < 0
&& (pfd = (force? open(procname, O_RDWR) : -1)) < 0)
|| (pfd = dupfd(pfd, 0)) < 0) {
switch (errno) {
case EBUSY:
return G_BUSY;
case ENOENT:
return G_NOPROC;
case EACCES:
case EPERM:
return G_PERM;
default:
perror("Pgrab open()");
return G_STRANGE;
}
}
/* ---------------------------------------------------- */
/* We are now in the Window of Vulnerability (WoV). */
/* The process may exec() a setuid/setgid or unreadable */
/* object file between the open() and the PIOCSTOP. */
/* We will get EAGAIN in this case and must start over. */
/* ---------------------------------------------------- */
/* Verify process credentials in case we are running setuid root. */
/* We only verify that our real uid matches the process's real uid. */
/* This means that the user really did create the process, even */
/* if using a different group id (via newgrp(1) for example). */
if (Ioctl(pfd, PIOCCRED, (int)&prcred) == -1) {
if (errno == EAGAIN) /* WoV */
goto again;
if (errno == ENOENT) /* Don't complain about zombies */
rc = G_NOPROC;
else {
perror("Pgrab PIOCCRED");
rc = G_STRANGE;
}
(void) close(pfd);
return rc;
}
if ((ruid = getuid()) != 0 /* super-user allowed anything */
&& ruid != prcred.pr_ruid) { /* credentials check failed */
(void) close(pfd);
errno = EACCES;
return G_PERM;
}
/* get the ps information, even if it is a system process or ourself */
if (Ioctl(pfd, PIOCPSINFO, (int)&P->psinfo) == -1) {
if (errno == EAGAIN) /* WoV */
goto again;
if (errno == ENOENT) /* Don't complain about zombies */
rc = G_NOPROC;
else {
perror("Pgrab PIOCPSINFO");
rc = G_STRANGE;
}
(void) close(pfd);
return rc;
}
/*
* Get the process's status.
*/
if (Ioctl(pfd, PIOCSTATUS, (int)&prstat) != 0) {
if (errno == EAGAIN) /* WoV */
goto again;
if (errno == ENOENT) /* Don't complain about zombies */
rc = G_ZOMB;
else {
perror("Pgrab PIOCSTATUS");
rc = G_STRANGE;
}
(void) close(pfd);
return rc;
}
/*
* If the process is a system process, we can't control it.
*/
if (prstat.pr_flags & PR_ISSYS) {
(void) close(pfd);
return G_SYS;
}
P->cntrl = TRUE;
P->child = FALSE;
P->state = PS_RUN;
P->upid = upid;
P->pfd = pfd;
/* before stopping the process, make sure it's not ourself */
if (upid == getpid()) {
/*
* Verify that the process is really ourself:
* Set a magic number, read it through the
* /proc file and see if the results match.
*/
long magic1 = 0;
long magic2 = 2;
errno = 0;
if (Pread(P, (long)&magic1, (char *)&magic2, sizeof(magic2))
== sizeof(magic2)
&& magic2 == 0
&& (magic1 = 0xfeedbeef)
&& Pread(P, (long)&magic1, (char *)&magic2, sizeof(magic2))
== sizeof(magic2)
&& magic2 == 0xfeedbeef) {
(void) close(pfd);
(void) memset((char *)P, 0, sizeof(*P));
P->pfd = -1;
P->lwpfd = -1;
return G_SELF;
}
}
/*
* If the process is already stopped or has been directed
* to stop via /proc, do not set run-on-last-close.
*/
if (prstat.pr_flags & (PR_ISTOP|PR_DSTOP)) {
(void) Pstatus(P, PIOCSTATUS, 0);
goto out;
}
/*
* Mark the process run-on-last-close so
* it runs even if we die from SIGKILL.
*/
if (Ioctl(pfd, PIOCSRLC, 0) != 0) {
if (errno == EAGAIN) /* WoV */
goto again;
if (errno == ENOENT) /* Don't complain about zombies */
rc = G_ZOMB;
else {
perror("Pgrab PIOCSRLC");
rc = G_STRANGE;
}
(void) close(pfd);
(void) memset((char *)P, 0, sizeof(*P));
P->pfd = -1;
P->lwpfd = -1;
return rc;
}
/* Stop the process, get its status and its signal/syscall masks. */
if (Pstatus(P, PIOCSTOP, 2) != 0) {
if (P->state == PS_LOST) /* WoV */
goto again;
if ((errno != EINTR && errno != ERESTART)
|| (P->state != PS_STOP && !(P->why.pr_flags & PR_DSTOP))) {
if (P->state != PS_RUN && errno != ENOENT) {
perror("Pgrab PIOCSTOP");
rc = G_STRANGE;
} else {
rc = G_ZOMB;
}
(void) close(pfd);
(void) memset((char *)P, 0, sizeof(*P));
P->pfd = -1;
P->lwpfd = -1;
return rc;
}
}
out:
/*
* Process should either be stopped via /proc or
* there should be an outstanding stop directive.
*/
if (P->state != PS_STOP
&& (P->why.pr_flags & (PR_ISTOP|PR_DSTOP)) == 0) {
(void) fprintf(stderr, "Pgrab: process is not stopped\n");
(void) close(pfd);
return G_STRANGE;
}
/* Process is or will be stopped, these will "certainly" not fail */
rc = 0;
if (Ioctl(pfd, PIOCGTRACE, (int)&P->sigmask) == -1) {
perror("Pgrab PIOCGTRACE");
rc = G_STRANGE;
} else if (Ioctl(pfd, PIOCGFAULT, (int)&P->faultmask) == -1) {
perror("Pgrab PIOCGFAULT");
rc = G_STRANGE;
} else if (Ioctl(pfd, PIOCGENTRY, (int)&P->sysentry) == -1) {
perror("Pgrab PIOCGENTRY");
rc = G_STRANGE;
} else if (Ioctl(pfd, PIOCGEXIT, (int)&P->sysexit) == -1) {
perror("Pgrab PIOCGEXIT");
rc = G_STRANGE;
}
if (rc) {
(void) close(pfd);
(void) memset((char *)P, 0, sizeof(*P));
P->pfd = -1;
P->lwpfd = -1;
}
return rc;
}
/*
* Ensure that the lwp's signal mask and the
* lwp registers are flushed to the lwp.
*/
static int
Psync(P)
register process_t *P;
{
int fd = (P->lwpfd >= 0)? P->lwpfd : P->pfd;
int rc = 0;
if (P->sethold && Ioctl(fd, PIOCSHOLD, (int)&P->why.pr_sighold) != 0)
rc = -1;
if (P->setregs && Ioctl(fd, PIOCSREG, (int)&P->REG[0]) != 0)
rc = -1;
P->sethold = FALSE;
P->setregs = FALSE;
return rc;
}
int
Pchoose(P) /* choose an lwp for further operations */
register process_t *P;
{
int fd;
id_t *lwpid;
int nlwp;
int i;
Punchoose(P);
nlwp = P->why.pr_nlwp;
if (nlwp <= 0)
nlwp = 1;
lwpid = malloc((nlwp+1)*sizeof(id_t));
if (Ioctl(P->pfd, PIOCLWPIDS, (int)lwpid) != 0) {
free(lwpid);
return -1;
}
/* search for an lwp --- */
for (i = 0; i < nlwp; i++) {
/* open the lwp file */
if ((fd = Ioctl(P->pfd, PIOCOPENLWP, (int)&lwpid[i])) < 0
|| (fd = dupfd(fd, 0)) < 0)
continue;
P->lwpfd = fd;
/* get the lwp status */
if (Pstatus(P, PIOCSTATUS, 0) != 0)
break;
/* avoid the aslwp, if possible */
if ((P->why.pr_flags & PR_ASLWP) && P->why.pr_nlwp > 1) {
Punchoose(P);
continue;
}
/* we have the lwp we want */
free(lwpid);
return 0;
}
Punchoose(P);
free(lwpid);
return -1;
}
/* undo Pchoose() */
void
Punchoose(P)
register process_t *P;
{
(void) Psync(P);
if (P->lwpfd >= 0)
(void) close(P->lwpfd);
P->lwpfd = -1;
/* refresh the process status */
(void) Pstatus(P, PIOCSTATUS, 0);
}
int
Preopen(P, force) /* reopen the /proc file (after PS_LOST) */
register process_t *P;
int force; /* if TRUE, grab regardless */
{
register int fd;
char procname[100];
if (P->lwpfd >= 0)
(void) close(P->lwpfd);
P->lwpfd = -1;
/* reopen the /proc/upid file */
(void) sprintf(procname, "%s/%ld", procdir, P->upid);
if (((fd = open(procname, (O_RDWR|O_EXCL))) < 0
&& (fd = (force? open(procname, O_RDWR) : -1)) < 0)
|| close(P->pfd) < 0
|| (fd = dupfd(fd, P->pfd)) < 0) {
if (debugflag)
perror("Preopen open()");
(void) close(P->pfd);
P->pfd = -1;
return -1;
}
P->pfd = fd;
/* set run-on-last-close so it runs even if we die from SIGKILL */
if (Ioctl(fd, PIOCSRLC, 0) == -1)
perror("Preopen PIOCSRLC");
P->state = PS_RUN;
/* process should be stopped on exec (REQUESTED) */
/* or else should be stopped on exit from exec() (SYSEXIT) */
if (Pwait(P) == 0
&& P->state == PS_STOP
&& (P->why.pr_why == PR_REQUESTED
|| (P->why.pr_why == PR_SYSEXIT
&& (P->why.pr_what == SYS_exec || P->why.pr_what == SYS_execve)))) {
/* fake up stop-on-exit-from-execve */
if (P->why.pr_why == PR_REQUESTED) {
P->why.pr_why = PR_SYSEXIT;
P->why.pr_what = SYS_execve;
}
}
else {
(void) fprintf(stderr,
"Preopen: expected REQUESTED or SYSEXIT(SYS_execve) stop\n");
}
return 0;
}
int
Prelease(P) /* release process to run freely */
register process_t *P;
{
int jsig = P->jsig;
if (P->pfd < 0)
return -1;
/* attempt to stop it if we have to reset its registers */
if (P->sethold || P->setregs) {
register int count;
for (count = 10;
count > 0 && (P->state == PS_RUN || P->state == PS_STEP);
count--) {
(void) Pstop(P);
}
}
/* if we lost control, all we can do is close the file */
if (P->state == PS_STOP) {
/* we didn't lose it, set the registers */
if (Psync(P) != 0)
perror("Prelease PIOCSHOLD/PIOCSREG");
}
(void) Ioctl(P->pfd, PIOCRFORK, 0);
(void) Ioctl(P->pfd, PIOCSRLC, 0);
if (jsig)
(void) Ioctl(P->pfd, PIOCKILL, (int)&jsig);
/* closing the files sets the process running */
if (P->lwpfd >= 0)
(void) close(P->lwpfd);
if (P->pfd >= 0)
(void) close(P->pfd);
/* zap the process structure */
(void) memset((char *)P, 0, sizeof(*P));
P->pfd = -1;
P->lwpfd = -1;
return 0;
}
int
Phang(P) /* release process but leave it stopped */
register process_t *P;
{
register int count;
long flags;
sysset_t sysset;
sigset_t sigset;
fltset_t fltset;
if (P->pfd < 0)
return -1;
if (debugflag)
(void) fprintf(stderr, "Phang: releasing pid # %ld\n",
P->upid);
/* attempt to stop it */
for (count = 10;
count > 0 && (P->state == PS_RUN || P->state == PS_STEP);
count--)
(void) Pstop(P);
/* if we lost control, all we can do is close the file */
if (P->state == PS_STOP) {
/* we didn't lose it; do more */
if (Psync(P) != 0)
perror("Phang PIOCSHOLD/PIOCSREG");
/* no run-on-last-close or kill-on-last-close*/
flags = PR_RLC|PR_KLC| /* PR_ASYNC| */ PR_PCOMPAT;
if (Ioctl(P->pfd, PIOCRESET, (int)&flags) != 0)
perror("Phang PIOCRESET");
/* inherit-on-fork */
flags = PR_FORK;
if (Ioctl(P->pfd, PIOCSET, (int)&flags) != 0)
perror("Phang PIOCSET");
/* no signal tracing */
premptyset(&sigset);
if (ioctl(P->pfd, PIOCSTRACE, (int)&sigset) != 0)
perror("Phang PIOCSTRACE");
/* no fault tracing */
premptyset(&fltset);
if (ioctl(P->pfd, PIOCSFAULT, (int)&fltset) != 0)
perror("Phang PIOCSFAULT");
/* no syscall tracing */
premptyset(&sysset);
if (ioctl(P->pfd, PIOCSENTRY, (int)&sysset) != 0)
perror("Phang PIOCSENTRY");
premptyset(&sysset);
if (ioctl(P->pfd, PIOCSEXIT, (int)&sysset) != 0)
perror("Phang PIOCSENTRY");
}
if (P->lwpfd >= 0)
(void) close(P->lwpfd);
if (P->pfd >= 0)
(void) close(P->pfd);
/* zap the process structure */
(void) memset((char *)P, 0, sizeof(*P));
P->pfd = -1;
P->lwpfd = -1;
return 0;
}
int
Pwait(P) /* wait for process to stop for any reason */
register process_t *P;
{
return Pstatus(P, PIOCWSTOP, 0);
}
int
Pstop(P) /* direct process to stop; wait for it to stop */
register process_t *P;
{
return Pstatus(P, PIOCSTOP, 0);
}
int
Pstatus(P, request, sec) /* wait for specified process to stop or terminate */
register process_t *P; /* program table entry */
register int request; /* PIOCSTATUS, PIOCSTOP, PIOCWSTOP */
unsigned sec; /* if non-zero, alarm timeout in seconds */
{
register int status = 0;
int err = 0;
int pfd = (P->lwpfd >= 0)? P->lwpfd : P->pfd;
switch (P->state) {
case PS_NULL:
case PS_LOST:
case PS_DEAD:
return -1;
case PS_STOP:
if (request != PIOCSTATUS)
return 0;
}
switch (request) {
case PIOCSTATUS:
case PIOCSTOP:
case PIOCWSTOP:
break;
default:
/* programming error */
(void) fprintf(stderr, "Pstatus: illegal request\n");
return -1;
}
timeout = FALSE;
if (sec)
(void) alarm(sec);
if (Ioctl(pfd, request, (int)&P->why) != 0) {
err = errno;
if (sec)
(void) alarm(0);
if (request != PIOCSTATUS && (err == EINTR || err == ERESTART)
&& Ioctl(pfd, PIOCSTATUS, (int)&P->why) != 0)
err = errno;
}
else if (sec)
(void) alarm(0);
if (err) {
switch (err) {
case EINTR: /* timeout or user typed DEL */
case ERESTART:
break;
case EAGAIN: /* we lost control of the the process */
P->state = PS_LOST;
break;
default: /* check for dead process */
if (err != ENOENT) {
CONST char * errstr;
switch (request) {
case PIOCSTATUS:
errstr = "Pstatus PIOCSTATUS"; break;
case PIOCSTOP:
errstr = "Pstatus PIOCSTOP"; break;
case PIOCWSTOP:
errstr = "Pstatus PIOCWSTOP"; break;
default:
errstr = "Pstatus PIOC???"; break;
}
perror(errstr);
}
deadcheck(P);
break;
}
if (!timeout || (err != EINTR && err != ERESTART)) {
errno = err;
return -1;
}
}
if (!(P->why.pr_flags&PR_STOPPED)) {
if (request == PIOCSTATUS || timeout) {
timeout = FALSE;
return 0;
}
(void) fprintf(stderr, "Pstatus: process is not stopped\n");
return -1;
}
P->state = PS_STOP;
timeout = FALSE;
switch (P->why.pr_why) {
case PR_REQUESTED:
case PR_SIGNALLED:
case PR_FAULTED:
case PR_JOBCONTROL:
#ifdef PR_SUSPENDED
case PR_SUSPENDED:
#endif
break;
case PR_SYSENTRY:
/* remember syscall address */
#if sparc
#if nono
P->sysaddr = P->REG[R_PC];
#endif
break;
#endif
case PR_SYSEXIT:
#if nono
P->sysaddr = P->REG[R_PC]-sizeof(syscall_t);
#endif
break;
default:
status = -1;
break;
}
return status;
}
int
Pgetsysnum(P) /* determine which syscall number we are at */
register process_t *P;
{
register int syscall = -1;
#if u3b2 || u3b5
if (Pgetareg(P,0)==0 && (P->REG[0]&0x7c)==4 && Pgetareg(P,1)==0)
syscall = (P->REG[1] & 0x7ff8) >> 3;
#endif
#if mc68k
if (Pgetareg(P,0) == 0)
syscall = P->REG[0] & 0xffff;
#endif
#if sparc || i386
syscall = P->why.pr_syscall;
#endif
return syscall;
}
int
Psetsysnum(P, syscall) /* we are at a syscall trap, prepare to issue syscall */
register process_t *P;
register int syscall;
{
#if i386
P->REG[R_R0] = syscall;
if (Pputareg(P,R_R0))
syscall = -1;
#endif
#if u3b2 || u3b5
P->REG[0] = 4;
P->REG[1] = syscall<<3;
if (Pputareg(P,0) || Pputareg(P,1))
syscall = -1;
#endif
#if mc68k
P->REG[0] = syscall;
if (Pputareg(P,0))
syscall = -1;
#endif
#if sparc
P->REG[R_G1] = syscall;
if (Pputareg(P,R_G1))
syscall = -1;
#endif
return syscall;
}
static void
deadcheck(P)
register process_t *P;
{
int pfd = (P->lwpfd >= 0)? P->lwpfd : P->pfd;
if (pfd < 0)
P->state = PS_DEAD;
else {
while (Ioctl(pfd, PIOCSTATUS, (int)&P->why) != 0) {
switch (errno) {
default:
/* process or lwp is dead */
P->state = PS_DEAD;
break;
case EINTR:
case ERESTART:
continue;
case EAGAIN:
P->state = PS_LOST;
break;
}
break;
}
}
}
int
Pgetregs(P) /* get values of registers from stopped process */
register process_t *P;
{
if (P->state != PS_STOP)
return -1;
return 0; /* registers are always available */
}
int
Pgetareg(P, reg) /* get the value of one register from stopped process */
register process_t *P;
register int reg; /* register number */
{
if (reg < 0 || reg >= NGREG) {
(void) fprintf(stderr,
"Pgetareg(): invalid register number, %d\n", reg);
return -1;
}
if (P->state != PS_STOP)
return -1;
return 0; /* registers are always available */
}
int
Pputregs(P) /* put values of registers into stopped process */
register process_t *P;
{
if (P->state != PS_STOP)
return -1;
P->setregs = TRUE; /* set registers before continuing */
return 0;
}
int
Pputareg(P, reg) /* put value of one register into stopped process */
register process_t *P;
register int reg; /* register number */
{
if (reg < 0 || reg >= NGREG) {
(void) fprintf(stderr,
"Pputareg(): invalid register number, %d\n", reg);
return -1;
}
if (P->state != PS_STOP)
return -1;
P->setregs = TRUE; /* set registers before continuing */
return 0;
}
int
Psetrun(P, sig, flags)
register process_t *P;
int sig; /* signal to pass to process */
register int flags; /* flags: PRCSIG|PRCFAULT|PRSTEP|PRSABORT|PRSTOP */
{
register int request; /* for setting signal */
register int why = P->why.pr_why;
int pfd = (P->lwpfd >= 0)? P->lwpfd : P->pfd;
siginfo_t info;
struct prrun prrun;
if (sig < 0 || sig > PRMAXSIG
|| P->state != PS_STOP)
return -1;
if (sig) {
if (flags & PRCSIG)
request = PIOCKILL;
else {
switch (why) {
case PR_REQUESTED:
case PR_SIGNALLED:
request = PIOCSSIG;
break;
default:
request = PIOCKILL;
break;
}
}
}
/* must be initialized to zero */
(void) memset((char *)&prrun, 0, sizeof(prrun));
(void) memset((char *)&info, 0, sizeof(info));
info.si_signo = sig;
prrun.pr_flags = flags & ~(PRSTRACE|PRSHOLD|PRSFAULT|PRSVADDR);
if (P->setsig) {
prrun.pr_flags |= PRSTRACE;
prrun.pr_trace = P->sigmask;
}
if (P->sethold) {
prrun.pr_flags |= PRSHOLD;
prrun.pr_sighold = P->why.pr_sighold;
}
if (P->setfault) {
prrun.pr_flags |= PRSFAULT;
prrun.pr_fault = P->faultmask;
}
while ((P->setentry && Ioctl(pfd, PIOCSENTRY, (int)&P->sysentry) == -1)
|| (P->setexit && Ioctl(pfd, PIOCSEXIT, (int)&P->sysexit) == -1)
|| (P->setregs && Ioctl(pfd, PIOCSREG, (int)&P->REG[0]) == -1)
|| (sig && Ioctl(pfd, request, (int)&info) == -1)) {
if (errno != EBUSY || Ioctl(pfd, PIOCWSTOP, 0) != 0)
goto bad;
}
P->setentry = FALSE;
P->setexit = FALSE;
P->setregs = FALSE;
if (Ioctl(pfd, PIOCRUN, prrun.pr_flags? (int)&prrun : 0) == -1) {
if ((why != PR_SIGNALLED && why != PR_JOBCONTROL)
|| errno != EBUSY)
goto bad;
goto out; /* ptrace()ed or jobcontrol stop -- back off */
}
P->setsig = FALSE;
P->sethold = FALSE;
P->setfault = FALSE;
out:
P->state = (flags&PRSTEP)? PS_STEP : PS_RUN;
return 0;
bad:
if (errno == ENOENT)
goto out;
perror("Psetrun");
return -1;
}
int
Pstart(P, sig)
register process_t *P;
int sig; /* signal to pass to process */
{
return Psetrun(P, sig, 0);
}
int
Pterm(P)
register process_t *P;
{
int sig = SIGKILL;
if (P->state == PS_STOP)
(void) Pstart(P, SIGKILL);
(void) Ioctl(P->pfd, PIOCKILL, (int)&sig); /* make sure */
(void) kill((int)P->upid, SIGKILL); /* make double sure */
if (P->lwpfd >= 0)
(void) close(P->lwpfd);
if (P->pfd >= 0)
(void) close(P->pfd);
/* zap the process structure */
(void) memset((char *)P, 0, sizeof(*P));
P->pfd = -1;
P->lwpfd = -1;
return 0;
}
int
Pread(P, address, buf, nbyte)
register process_t *P;
long address; /* address in process */
char *buf; /* caller's buffer */
int nbyte; /* number of bytes to read */
{
if (nbyte <= 0)
return 0;
return pread(P->pfd, buf, (unsigned)nbyte, (off_t)address);
}
int
Pwrite(P, address, buf, nbyte)
register process_t *P;
long address; /* address in process */
CONST char *buf; /* caller's buffer */
int nbyte; /* number of bytes to write */
{
if (nbyte <= 0)
return 0;
return pwrite(P->pfd, buf, (unsigned)nbyte, (off_t)address);
}
int
Psignal(P, which, stop) /* action on specified signal */
register process_t *P; /* program table exit */
register int which; /* signal number */
register int stop; /* if TRUE, stop process; else let it go */
{
register int oldval;
if (which <= 0 || which > PRMAXSIG || (which == SIGKILL && stop))
return -1;
oldval = prismember(&P->sigmask, which)? TRUE : FALSE;
if (stop) { /* stop process on receipt of signal */
if (!oldval) {
praddset(&P->sigmask, which);
P->setsig = TRUE;
}
}
else { /* let process continue on receipt of signal */
if (oldval) {
prdelset(&P->sigmask, which);
P->setsig = TRUE;
}
}
return oldval;
}
int
Pfault(P, which, stop) /* action on specified fault */
register process_t *P; /* program table exit */
register int which; /* fault number */
register int stop; /* if TRUE, stop process; else let it go */
{
register int oldval;
if (which <= 0 || which > PRMAXFAULT)
return -1;
oldval = prismember(&P->faultmask, which)? TRUE : FALSE;
if (stop) { /* stop process on receipt of fault */
if (!oldval) {
praddset(&P->faultmask, which);
P->setfault = TRUE;
}
}
else { /* let process continue on receipt of fault */
if (oldval) {
prdelset(&P->faultmask, which);
P->setfault = TRUE;
}
}
return oldval;
}
int
Psysentry(P, which, stop) /* action on specified system call entry */
register process_t *P; /* program table entry */
register int which; /* system call number */
register int stop; /* if TRUE, stop process; else let it go */
{
register int oldval;
if (which <= 0 || which > PRMAXSYS)
return -1;
oldval = prismember(&P->sysentry, which)? TRUE : FALSE;
if (stop) { /* stop process on sys call */
if (!oldval) {
praddset(&P->sysentry, which);
P->setentry = TRUE;
}
}
else { /* don't stop process on sys call */
if (oldval) {
prdelset(&P->sysentry, which);
P->setentry = TRUE;
}
}
return oldval;
}
int
Psysexit(P, which, stop) /* action on specified system call exit */
register process_t *P; /* program table exit */
register int which; /* system call number */
register int stop; /* if TRUE, stop process; else let it go */
{
register int oldval;
if (which <= 0 || which > PRMAXSYS)
return -1;
oldval = prismember(&P->sysexit, which)? TRUE : FALSE;
if (stop) { /* stop process on sys call exit */
if (!oldval) {
praddset(&P->sysexit, which);
P->setexit = TRUE;
}
}
else { /* don't stop process on sys call exit */
if (oldval) {
prdelset(&P->sysexit, which);
P->setexit = TRUE;
}
}
return oldval;
}
static int
execute(P, sysindex) /* execute the syscall instruction */
register process_t *P; /* process control structure */
int sysindex; /* system call index */
{
int pfd = (P->lwpfd >= 0)? P->lwpfd : P->pfd;
sigset_t hold; /* mask of held signals */
int sentry; /* old value of stop-on-syscall-entry */
sysset_t entryset;
/* move current signal back to pending */
if (P->why.pr_cursig) {
int sig = P->why.pr_cursig;
(void) Ioctl(pfd, PIOCSSIG, 0);
(void) Ioctl(pfd, PIOCKILL, (int)&sig);
P->why.pr_cursig = 0;
}
#if 1
entryset = P->sysentry;
prfillset(&P->sysentry);
P->setentry = TRUE;
#else
sentry = Psysentry(P, sysindex, TRUE); /* set stop-on-syscall-entry */
#endif
hold = P->why.pr_sighold; /* remember signal hold mask */
prfillset(&P->why.pr_sighold); /* hold all signals */
P->sethold = TRUE;
if (Psetrun(P, 0, PRCSIG) == -1)
goto bad;
while (P->state == PS_RUN)
(void) Pwait(P);
if (P->state != PS_STOP)
goto bad;
P->why.pr_sighold = hold; /* restore hold mask */
P->sethold = TRUE;
#if 1
P->sysentry = entryset;
P->setentry = TRUE;
#else
(void) Psysentry(P, sysindex, sentry); /* restore sysentry stop */
#endif
if (P->why.pr_why == PR_SYSENTRY
&& P->why.pr_what == sysindex)
return 0;
bad:
fprintf(stderr, "execute(): expected %d/%d, got %d/%d\n",
PR_SYSENTRY, sysindex, P->why.pr_why, P->why.pr_what);
return -1;
}
/* worst-case alignment for objects on the stack */
#if i386 /* stack grows down, non-aligned */
#define ALIGN(sp) (sp)
#define ARGOFF 1
#endif
#if u3b2 /* stack grows up, word-aligned */
#define ALIGN(sp) (((sp) + sizeof(int) - 1) & ~(sizeof(int) - 1))
#define ARGOFF 0
#endif
#if sparc /* stack grows down, doubleword-aligned */
#define ALIGN(sp) ((sp) & ~(2*sizeof(int) - 1))
#define ARGOFF 0
#endif
struct sysret /* perform system call in controlled process */
Psyscall(P, sysindex, nargs, argp)
register process_t *P; /* process control structure */
int sysindex; /* system call index */
register int nargs; /* number of arguments to system call */
struct argdes *argp; /* argument descriptor array */
{
register struct argdes *adp; /* pointer to argument descriptor */
struct sysret rval; /* return value */
register int i; /* general index value */
register int Perr = 0; /* local error number */
int sexit; /* old value of stop-on-syscall-exit */
greg_t sp; /* adjusted stack pointer */
greg_t ap; /* adjusted argument pointer */
gregset_t savedreg; /* remembered registers */
int arglist[MAXARGS+2]; /* syscall arglist */
int why; /* reason for stopping */
int what; /* detailed reason (syscall, signal) */
sigset_t block, unblock;
int waschosen = FALSE;
/* block (hold) all signals for the duration. */
(void) sigfillset(&block);
(void) sigemptyset(&unblock);
(void) sigprocmask(SIG_BLOCK, &block, &unblock);
rval.errno = 0; /* initialize return value */
rval.r0 = 0;
rval.r1 = 0;
/* if necessary, choose an lwp from the process to do all the work */
if (P->lwpfd < 0) {
if (Pchoose(P) != 0)
goto bad8;
waschosen = TRUE;
}
why = P->why.pr_why;
what = P->why.pr_what;
if (sysindex <= 0 || sysindex > PRMAXSYS /* programming error */
|| nargs < 0 || nargs > MAXARGS)
goto bad1;
if (P->state != PS_STOP /* check state of process */
|| (P->why.pr_flags & PR_ASLEEP)
|| Pgetregs(P) != 0)
goto bad2;
for (i = 0; i < NGREG; i++) /* remember registers */
savedreg[i] = P->REG[i];
if (checksyscall(P)) /* bad text ? */
goto bad3;
/* validate arguments and compute the stack frame parameters --- */
sp = savedreg[R_SP]; /* begin with the current stack pointer */
sp = ALIGN(sp);
for (i=0, adp=argp; i<nargs; i++, adp++) { /* for each argument */
rval.r0 = i; /* in case of error */
switch (adp->type) {
default: /* programming error */
goto bad4;
case AT_BYVAL: /* simple argument */
break;
case AT_BYREF: /* must allocate space */
switch (adp->inout) {
case AI_INPUT:
case AI_OUTPUT:
case AI_INOUT:
if (adp->object == NULL)
goto bad5; /* programming error */
break;
default: /* programming error */
goto bad6;
}
/* allocate stack space for BYREF argument */
if (adp->len <= 0 || adp->len > MAXARGL)
goto bad7; /* programming error */
#if u3b2 /* upward stack growth */
adp->value = sp; /* stack address for object */
sp = ALIGN(sp + adp->len);
#elif sparc || i386 /* downward stack growth */
sp = ALIGN(sp - adp->len);
adp->value = sp; /* stack address for object */
#endif
break;
}
}
rval.r0 = 0; /* in case of error */
#if u3b2
ap = sp; /* address of arg list */
sp += sizeof(int)*(nargs+2); /* space for arg list + CALL parms */
#endif
#if i386
ap = sp; /* address of arg list */
sp -= sizeof(int)*(nargs+2); /* space for arg list + CALL parms */
#endif
#if sparc
sp -= (nargs>6)? sizeof(int)*(16+1+nargs) : sizeof(int)*(16+1+6);
sp = ALIGN(sp);
ap = sp+(16+1)*sizeof(int); /* address of arg dump area */
#endif
/* point of no return */
/* special treatment of stopped-on-syscall-entry */
/* move the process to the stopped-on-syscall-exit state */
if (why == PR_SYSENTRY) {
/* arrange to reissue sys call */
#if !sparc
savedreg[R_PC] -= sizeof(syscall_t);
#endif
sexit = Psysexit(P, what, TRUE); /* catch this syscall exit */
if (Psetrun(P, 0, PRSABORT) != 0 /* abort sys call */
|| Pwait(P) != 0
|| P->state != PS_STOP
|| P->why.pr_why != PR_SYSEXIT
|| P->why.pr_what != what
|| Pgetareg(P, R_PS) != 0
|| Pgetareg(P, 0) != 0
|| (P->REG[R_PS] & ERRBIT) == 0
|| (P->REG[R_R0] != EINTR && P->REG[R_R0] != ERESTART)) {
(void) fprintf(stderr,
"Psyscall(): cannot abort sys call\n");
(void) Psysexit(P, what, sexit);
goto bad9;
}
(void) Psysexit(P, what, sexit);/* restore previous exit trap */
}
/* perform the system call entry, adjusting %sp */
/* this moves the process to the stopped-on-syscall-entry state */
/* just before the arguments to the sys call are fetched */
(void) Psetsysnum(P, sysindex);
P->REG[R_SP] = sp;
P->REG[R_PC] = P->sysaddr; /* address of syscall */
#if sparc
P->REG[R_nPC] = P->sysaddr+sizeof(syscall_t);
#elif u3b2
P->REG[R_AP] = ap;
#endif
(void) Pputregs(P);
if (execute(P, sysindex) != 0 /* execute the syscall instruction */
#if sparc
|| P->REG[R_PC] != P->sysaddr
|| P->REG[R_nPC] != P->sysaddr+sizeof(syscall_t)
#else
|| P->REG[R_PC] != P->sysaddr+sizeof(syscall_t)
#endif
)
goto bad10;
/* stopped at syscall entry; copy arguments to stack frame */
for (i=0, adp=argp; i<nargs; i++, adp++) { /* for each argument */
rval.r0 = i; /* in case of error */
if (adp->type != AT_BYVAL
&& adp->inout != AI_OUTPUT) {
/* copy input byref parameter to process */
if (Pwrite(P, (long)adp->value, adp->object, adp->len)
!= adp->len)
goto bad17;
}
arglist[ARGOFF+i] = adp->value;
#if sparc
if (i < 6) {
P->REG[R_O0+i] = adp->value;
Pputareg(P, R_O0+i);
}
#endif
}
rval.r0 = 0; /* in case of error */
#if i386
arglist[0] = savedreg[R_PC]; /* CALL parameters */
if (Pwrite(P, (long)sp, (char *)&arglist[0], (int)sizeof(int)*(nargs+1))
!= sizeof(int)*(nargs+1))
goto bad18;
#endif
#if u3b2
arglist[nargs] = savedreg[R_PC]; /* CALL parameters */
arglist[nargs+1] = savedreg[R_AP];
if (Pwrite(P, (long)ap, (char *)&arglist[0], (int)sizeof(int)*(nargs+2))
!= sizeof(int)*(nargs+2))
goto bad18;
#endif
#if sparc
if (nargs > 6
&& Pwrite(P, (long)ap, (char *)&arglist[0], (int)sizeof(int)*nargs)
!= sizeof(int)*nargs)
goto bad18;
#endif
/* complete the system call */
/* this moves the process to the stopped-on-syscall-exit state */
sexit = Psysexit(P, sysindex, TRUE); /* catch this syscall exit */
do { /* allow process to receive signals in sys call */
if (Psetrun(P, 0, 0) == -1)
goto bad21;
while (P->state == PS_RUN)
(void) Pwait(P);
} while (P->state == PS_STOP && P->why.pr_why == PR_SIGNALLED);
(void) Psysexit(P, sysindex, sexit); /* restore original setting */
if (P->state != PS_STOP
|| P->why.pr_why != PR_SYSEXIT)
goto bad22;
if (P->why.pr_what != sysindex)
goto bad23;
#if sparc
if (P->REG[R_PC] != P->sysaddr+sizeof(syscall_t)
|| P->REG[R_nPC] != P->sysaddr+2*sizeof(syscall_t))
#else
if (P->REG[R_PC] != P->sysaddr+sizeof(syscall_t))
#endif
goto bad24;
/* fetch output arguments back from process */
#if u3b2
if (Pread(P, (long)ap, (char *)&arglist[0], (int)sizeof(int)*(nargs+2))
!= sizeof(int)*(nargs+2))
goto bad25;
#endif
#if i386
if (Pread(P, (long)sp, (char *)&arglist[0], (int)sizeof(int)*(nargs+1))
!= sizeof(int)*(nargs+1))
goto bad25;
#endif
for (i=0, adp=argp; i<nargs; i++, adp++) { /* for each argument */
rval.r0 = i; /* in case of error */
if (adp->type != AT_BYVAL
&& adp->inout != AI_INPUT) {
/* copy output byref parameter from process */
if (Pread(P, (long)adp->value, adp->object, adp->len)
!= adp->len)
goto bad26;
}
adp->value = arglist[ARGOFF+i];
}
/* get the return values from the syscall */
if (P->REG[R_PS] & ERRBIT) { /* error */
rval.errno = P->REG[R_R0];
rval.r0 = -1;
}
else { /* normal return */
rval.r0 = P->REG[R_R0];
rval.r1 = P->REG[R_R1];
}
goto good;
bad26: Perr++;
bad25: Perr++;
bad24: Perr++;
bad23: Perr++;
bad22: Perr++;
bad21: Perr++;
Perr++;
Perr++;
bad18: Perr++;
bad17: Perr++;
Perr++;
Perr++;
Perr++;
Perr++;
Perr++;
Perr++;
bad10: Perr++;
bad9: Perr++;
Perr += 8;
rval.errno = -Perr; /* local errors are negative */
good:
/* restore process to its previous state (almost) */
for (i = 0; i < NGREG; i++) /* restore remembered registers */
P->REG[i] = savedreg[i];
(void) Pputregs(P);
if (why == PR_SYSENTRY /* special treatment */
&& execute(P, what) != 0) { /* get back to the syscall */
(void) fprintf(stderr,
"Psyscall(): cannot reissue sys call\n");
if (Perr == 0)
rval.errno = -27;
}
P->why.pr_why = why;
P->why.pr_what = what;
goto out;
bad8: Perr++;
bad7: Perr++;
bad6: Perr++;
bad5: Perr++;
bad4: Perr++;
bad3: Perr++;
bad2: Perr++;
bad1: Perr++;
rval.errno = -Perr; /* local errors are negative */
out:
/* if we chose an lwp for the operation, unchoose it now */
if (waschosen)
Punchoose(P);
/* unblock (release) all signals before returning */
(void) sigprocmask(SIG_SETMASK, &unblock, (sigset_t *)NULL);
return rval;
}
static int
checksyscall(P) /* check syscall instruction in process */
process_t *P;
{
/* this should always succeed--we always have a good syscall address */
syscall_t instr; /* holds one syscall instruction */
return(
(Pread(P,P->sysaddr,(char *)&instr,sizeof(instr)) == sizeof(instr)
#if i386
&& instr[0] == SYSCALL
#else
&& instr == (syscall_t)SYSCALL
#endif
)? 0 : -1 );
}
int
Ioctl(fd, request, arg) /* deal with RFS congestion */
int fd;
int request;
int arg;
{
register int rc;
for(;;) {
if ((rc = ioctl(fd, request, arg)) != -1
|| errno != ENOMEM)
return rc;
}
}
Reference in New Issue View Git Blame Copy Permalink