projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
convert VOP_UNLOCK and vrele into vput's; add proc parameter to union_dircache
[unix-history] / usr / src / sys / kern / sys_process.c
diff --git a/usr/src/sys/kern/sys_process.c b/usr/src/sys/kern/sys_process.c
index ae72501..041a40b 100644 (file)
--- a/usr/src/sys/kern/sys_process.c
+++ b/usr/src/sys/kern/sys_process.c
@@ -1,20 +1,34 @@
-/*     sys_process.c   5.9     83/05/18        */
-
-#include "../machine/reg.h"
-#include "../machine/psl.h"
-#include "../machine/pte.h"
-
-#include "../h/param.h"
-#include "../h/systm.h"
-#include "../h/dir.h"
-#include "../h/user.h"
-#include "../h/proc.h"
-#include "../h/inode.h"
-#include "../h/text.h"
-#include "../h/seg.h"
-#include "../h/vm.h"
-#include "../h/buf.h"
-#include "../h/acct.h"
+/*-
+ * Copyright (c) 1982, 1986, 1989, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ * (c) UNIX System Laboratories, Inc.
+ * All or some portions of this file are derived from material licensed
+ * to the University of California by American Telephone and Telegraph
+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with
+ * the permission of UNIX System Laboratories, Inc.
+ *
+ * %sccs.include.proprietary.c%
+ *
+ *     @(#)sys_process.c       8.6 (Berkeley) %G%
+ */
+
+#define IPCREG
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/proc.h>
+#include <sys/vnode.h>
+#include <sys/buf.h>
+#include <sys/ptrace.h>
+
+#include <sys/mount.h>
+#include <sys/syscallargs.h>
+
+#include <machine/reg.h>
+#include <machine/psl.h>
+#include <vm/vm.h>
+#include <vm/vm_page.h>
+
+#include <sys/user.h>
 
 /*
  * Priority for tracing
 
 /*
  * Priority for tracing
@@ -32,188 +46,254 @@
 struct {
        int     ip_lock;
        int     ip_req;
 struct {
        int     ip_lock;
        int     ip_req;
-       int     *ip_addr;
+       caddr_t ip_addr;
        int     ip_data;
 } ipc;
 
 /*
        int     ip_data;
 } ipc;
 
 /*
- * sys-trace system call.
+ * Process debugging system call.
  */
  */
-ptrace()
+ptrace(curp, uap, retval)
+       struct proc *curp;
+       struct ptrace_args /* {
+               syscallarg(int) req;
+               syscallarg(pid_t) pid;
+               syscallarg(caddr_t) addr;
+               syscallarg(int) data;
+       } */ *uap;
+       register_t *retval;
 {
        register struct proc *p;
 {
        register struct proc *p;
-       register struct a {
-               int     req;
-               int     pid;
-               int     *addr;
-               int     data;
-       } *uap;
-
-       uap = (struct a *)u.u_ap;
-       if (uap->req <= 0) {
-               u.u_procp->p_flag |= STRC;
-               return;
+       int error;
+
+       if (SCARG(uap, req) <= 0) {
+               curp->p_flag |= P_TRACED;
+               return (0);
        }
        }
-       p = pfind(uap->pid);
-       if (p == 0 || p->p_stat != SSTOP || p->p_ppid != u.u_procp->p_pid ||
-           !(p->p_flag & STRC)) {
-               u.u_error = ESRCH;
-               return;
+       p = pfind(SCARG(uap, pid));
+       if (p == 0)
+               return (ESRCH);
+       if (SCARG(uap, req) == PT_ATTACH) {
+               /*
+                * Must be root if the process has used set user or group
+                * privileges or does not belong to the real user.  Must
+                * not be already traced.  Can't attach to ourselves.
+                */
+               if ((p->p_flag & P_SUGID ||
+                   p->p_cred->p_ruid != curp->p_cred->p_ruid) &&
+                   (error = suser(p->p_ucred, &p->p_acflag)) != 0)
+                       return (error);
+               if (p->p_flag & P_TRACED)
+                       return (EALREADY);      /* ??? */
+               if (p->p_pid == curp->p_pid)
+                       return (EINVAL);
+               /*
+                * It would be nice if the tracing relationship was separate
+                * from the parent relationship but that would require
+                * another set of links in the proc struct or for "wait"
+                * to scan the entire proc table.  To make life easier,
+                * we just re-parent the process we're trying to trace.
+                * The old parent is remembered so we can put things back
+                * on a "detach".
+                */
+               p->p_flag |= P_TRACED;
+               p->p_oppid = p->p_pptr->p_pid;
+               proc_reparent(p, curp);
+               psignal(p, SIGSTOP);
+               return (0);
        }
        }
+       if (p->p_stat != SSTOP || p->p_pptr != curp || !(p->p_flag & P_TRACED))
+               return (ESRCH);
        while (ipc.ip_lock)
                sleep((caddr_t)&ipc, IPCPRI);
        ipc.ip_lock = p->p_pid;
        while (ipc.ip_lock)
                sleep((caddr_t)&ipc, IPCPRI);
        ipc.ip_lock = p->p_pid;
-       ipc.ip_data = uap->data;
-       ipc.ip_addr = uap->addr;
-       ipc.ip_req = uap->req;
-       p->p_flag &= ~SWTED;
+       ipc.ip_data = SCARG(uap, data);
+       ipc.ip_addr = SCARG(uap, addr);
+       ipc.ip_req = SCARG(uap, req);
+       p->p_flag &= ~P_WAITED;
        while (ipc.ip_req > 0) {
                if (p->p_stat==SSTOP)
        while (ipc.ip_req > 0) {
                if (p->p_stat==SSTOP)
-                       setrun(p);
+                       setrunnable(p);
                sleep((caddr_t)&ipc, IPCPRI);
        }
                sleep((caddr_t)&ipc, IPCPRI);
        }
-       u.u_r.r_val1 = ipc.ip_data;
-       if (ipc.ip_req < 0)
-               u.u_error = EIO;
+       *retval = ipc.ip_data;
        ipc.ip_lock = 0;
        wakeup((caddr_t)&ipc);
        ipc.ip_lock = 0;
        wakeup((caddr_t)&ipc);
+       if (ipc.ip_req < 0)
+               return (EIO);
+       return (0);
 }
 
 }
 
-#ifdef vax
-#define        NIPCREG 16
-#endif
-#ifdef sun
-#define        NIPCREG 17
-#endif
-int ipcreg[NIPCREG] =
-#ifdef vax
-       {R0,R1,R2,R3,R4,R5,R6,R7,R8,R9,R10,R11,AP,FP,SP,PC};
-#endif
-#ifdef sun
-       {R0,R1,R2,R3,R4,R5,R6,R7,AR0,AR1,AR2,AR3,AR4,AR5,AR6,AR7,PC};
+#define        PHYSOFF(p, o) ((caddr_t)(p) + (o))
+#if defined(hp300) || defined(luna68k)
+#define PHYSALIGNED(a) (((int)(a) & (sizeof(short) - 1)) == 0)
+#else
+#define PHYSALIGNED(a) (((int)(a) & (sizeof(int) - 1)) == 0)
 #endif
 
 #endif
 
-#define        PHYSOFF(p, o) \
-       ((physadr)(p)+((o)/sizeof(((physadr)0)->r[0])))
+#if defined(i386)
+#undef        PC
+#undef        SP
+#undef        PS
+#undef        R0
+#undef        R1
+
+#define       PC      tEIP
+#define       SP      tESP
+#define       PS      tEFLAGS
+#define       R0      tEDX
+#define       R1      tECX
+#endif
 
 /*
 
 /*
- * Code that the child process
- * executes to implement the command
- * of the parent process in tracing.
+ * Transmit a tracing request from the parent to the child process
+ * being debugged. This code runs in the context of the child process
+ * to fulfill the command requested by the parent.
  */
  */
-procxmt()
+trace_req(p)
+       register struct proc *p;
 {
 {
-       register int i;
-       register *p;
-       register struct text *xp;
+       register int i, *poff, *regs;
+       extern char kstack[];
 
 
-       if (ipc.ip_lock != u.u_procp->p_pid)
+       if (ipc.ip_lock != p->p_pid)
                return (0);
                return (0);
-       u.u_procp->p_slptime = 0;
+       p->p_slptime = 0;
+       regs = p->p_md.md_regs;
+       p->p_addr->u_kproc.kp_proc.p_md.md_regs = regs; /* u.u_ar0 */
        i = ipc.ip_req;
        ipc.ip_req = 0;
        switch (i) {
 
        i = ipc.ip_req;
        ipc.ip_req = 0;
        switch (i) {
 
-       /* read user I */
-       case 1:
+       case PT_READ_I:                 /* read the child's text space */
                if (!useracc((caddr_t)ipc.ip_addr, 4, B_READ))
                        goto error;
                ipc.ip_data = fuiword((caddr_t)ipc.ip_addr);
                break;
 
                if (!useracc((caddr_t)ipc.ip_addr, 4, B_READ))
                        goto error;
                ipc.ip_data = fuiword((caddr_t)ipc.ip_addr);
                break;
 
-       /* read user D */
-       case 2:
+       case PT_READ_D:                 /* read the child's data space */
                if (!useracc((caddr_t)ipc.ip_addr, 4, B_READ))
                        goto error;
                ipc.ip_data = fuword((caddr_t)ipc.ip_addr);
                break;
 
                if (!useracc((caddr_t)ipc.ip_addr, 4, B_READ))
                        goto error;
                ipc.ip_data = fuword((caddr_t)ipc.ip_addr);
                break;
 
-       /* read u */
-       case 3:
+       case PT_READ_U:                 /* read the child's u. */
                i = (int)ipc.ip_addr;
                i = (int)ipc.ip_addr;
-               if (i<0 || i >= ctob(UPAGES))
+               if ((u_int) i > ctob(UPAGES)-sizeof(int) || !PHYSALIGNED(i))
                        goto error;
                        goto error;
-               ipc.ip_data = *(int *)PHYSOFF(&u, i);
+               ipc.ip_data = *(int *)PHYSOFF(p->p_addr, i);
                break;
 
                break;
 
-       /* write user I */
-       /* Must set up to allow writing */
-       case 4:
-               /*
-                * If text, must assure exclusive use
-                */
-               if (xp = u.u_procp->p_textp) {
-                       if (xp->x_count!=1 || xp->x_iptr->i_mode&ISVTX)
-                               goto error;
-                       xp->x_iptr->i_flag &= ~ITEXT;
-               }
-               i = -1;
+       case PT_WRITE_I:                /* write the child's text space */
                if ((i = suiword((caddr_t)ipc.ip_addr, ipc.ip_data)) < 0) {
                if ((i = suiword((caddr_t)ipc.ip_addr, ipc.ip_data)) < 0) {
-                       if (chgprot((caddr_t)ipc.ip_addr, RW) &&
-                           chgprot((caddr_t)ipc.ip_addr+(sizeof(int)-1), RW))
+                       vm_offset_t sa, ea;
+                       int rv;
+
+                       sa = trunc_page((vm_offset_t)ipc.ip_addr);
+                       ea = round_page((vm_offset_t)ipc.ip_addr+sizeof(int));
+                       rv = vm_map_protect(&p->p_vmspace->vm_map, sa, ea,
+                                       VM_PROT_DEFAULT, FALSE);
+                       if (rv == KERN_SUCCESS) {
                                i = suiword((caddr_t)ipc.ip_addr, ipc.ip_data);
                                i = suiword((caddr_t)ipc.ip_addr, ipc.ip_data);
-                       (void) chgprot((caddr_t)ipc.ip_addr, RO);
-                       (void) chgprot((caddr_t)ipc.ip_addr+(sizeof(int)-1), RO);
+                               (void) vm_map_protect(&p->p_vmspace->vm_map,
+                                       sa, ea, VM_PROT_READ|VM_PROT_EXECUTE,
+                                       FALSE);
+                       }
                }
                if (i < 0)
                        goto error;
                }
                if (i < 0)
                        goto error;
-               if (xp)
-                       xp->x_flag |= XWRIT;
                break;
 
                break;
 
-       /* write user D */
-       case 5:
+       case PT_WRITE_D:                /* write the child's data space */
                if (suword((caddr_t)ipc.ip_addr, 0) < 0)
                        goto error;
                (void) suword((caddr_t)ipc.ip_addr, ipc.ip_data);
                break;
 
                if (suword((caddr_t)ipc.ip_addr, 0) < 0)
                        goto error;
                (void) suword((caddr_t)ipc.ip_addr, ipc.ip_data);
                break;
 
-       /* write u */
-       case 6:
+       case PT_WRITE_U:                /* write the child's u. */
                i = (int)ipc.ip_addr;
                i = (int)ipc.ip_addr;
-               p = (int *)PHYSOFF(&u, i);
+#ifdef mips
+               poff = (int *)PHYSOFF(p->p_addr, i);
+#else
+               poff = (int *)PHYSOFF(kstack, i);
+#endif
                for (i=0; i<NIPCREG; i++)
                for (i=0; i<NIPCREG; i++)
-                       if (p == &u.u_ar0[ipcreg[i]])
+                       if (poff == &regs[ipcreg[i]])
                                goto ok;
                                goto ok;
-               if (p == &u.u_ar0[PS]) {
+#if defined(hp300) || defined(luna68k)
+               /*
+                * In the new frame layout, PS/PC are skewed by 2 bytes.
+                */
+               regs = (int *)((short *)regs + 1);
+               if (poff == &regs[PC])
+                       goto ok;
+#endif
+               if (poff == &regs[PS]) {
                        ipc.ip_data |= PSL_USERSET;
                        ipc.ip_data |= PSL_USERSET;
-                       ipc.ip_data &=  ~PSL_USERCLR;
-#ifdef sun
-                       if (ipc.ip_data & PSL_T)
-                               traceon();
-                       else
-                               traceoff();
+                       ipc.ip_data &= ~PSL_USERCLR;
+#ifdef PSL_CM_CLR
+                       if (ipc.ip_data & PSL_CM)
+                               ipc.ip_data &= ~PSL_CM_CLR;
 #endif
                        goto ok;
                }
 #endif
                        goto ok;
                }
+#if defined(hp300) || defined(luna68k)
+#ifdef FPCOPROC
+               if (poff >= (int *)&((struct user *)kstack)->u_pcb.pcb_fpregs.fpf_regs &&
+                   poff <= (int *)&((struct user *)kstack)->u_pcb.pcb_fpregs.fpf_fpiar)
+                       goto ok;
+#endif
+#endif
                goto error;
 
        ok:
                goto error;
 
        ok:
-               *p = ipc.ip_data;
+               *poff = ipc.ip_data;
                break;
 
                break;
 
-       /* set signal and continue */
-       /* one version causes a trace-trap */
-       case 9:
-       case 7:
+       case PT_STEP:                   /* single step the child */
+       case PT_CONTINUE:               /* continue the child */
+#ifndef mips
+               regs = (int *)((short *)regs + 1);
+#endif
+               if ((unsigned)ipc.ip_data >= NSIG)
+                       goto error;
                if ((int)ipc.ip_addr != 1)
                if ((int)ipc.ip_addr != 1)
-                       u.u_ar0[PC] = (int)ipc.ip_addr;
-               if ((unsigned)ipc.ip_data > NSIG)
+                       regs[PC] = (int)ipc.ip_addr;
+               p->p_xstat = ipc.ip_data;       /* see issignal */
+#ifdef mips
+               if (i == PT_STEP && cpu_singlestep(p))
                        goto error;
                        goto error;
-               u.u_procp->p_cursig = ipc.ip_data;      /* see issig */
-               if (i == 9) 
-#ifdef sun
-                       traceon();
 #else
 #else
-                       u.u_ar0[PS] |= PSL_T;
+#ifdef PSL_T
+               /* need something more machine independent here... */
+               if (i == PT_STEP) 
+                       regs[PS] |= PSL_T;
+#endif
 #endif
                wakeup((caddr_t)&ipc);
                return (1);
 
 #endif
                wakeup((caddr_t)&ipc);
                return (1);
 
-       /* force exit */
-       case 8:
+       case PT_KILL:                   /* kill the child process */
                wakeup((caddr_t)&ipc);
                wakeup((caddr_t)&ipc);
-               exit(u.u_procp->p_cursig);
+               exit1(p, (int)p->p_xstat);
+
+       case PT_DETACH:                 /* stop tracing the child */
+               regs = (int *)((short *)regs + 1);
+               if ((unsigned)ipc.ip_data >= NSIG)
+                       goto error;
+               if ((int)ipc.ip_addr != 1)
+                       regs[PC] = (int)ipc.ip_addr;
+               p->p_xstat = ipc.ip_data;       /* see issignal */
+               p->p_flag &= ~P_TRACED;
+               if (p->p_oppid != p->p_pptr->p_pid) {
+                        register struct proc *pp = pfind(p->p_oppid);
+
+                        if (pp)
+                                proc_reparent(p, pp);
+               }
+               p->p_oppid = 0;
+               wakeup((caddr_t)&ipc);
+               return (1);
 
        default:
        error:
 
        default:
        error:
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.