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 599ca7b..041a40b 100644 (file)
--- a/usr/src/sys/kern/sys_process.c
+++ b/usr/src/sys/kern/sys_process.c
@@ -1,28 +1,34 @@
-/*
- * Copyright (c) 1982, 1986 Regents of the University of California.
- * All rights reserved.  The Berkeley software License Agreement
- * specifies the terms and conditions for redistribution.
+/*-
+ * 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       7.3 (Berkeley) %G%
+ *     @(#)sys_process.c       8.6 (Berkeley) %G%
  */
 
 #define IPCREG
  */
 
 #define IPCREG
-#include "../machine/reg.h"
-#include "../machine/psl.h"
-#include "../machine/pte.h"
-
-#include "param.h"
-#include "systm.h"
-#include "dir.h"
-#include "user.h"
-#include "proc.h"
-#include "inode.h"
-#include "text.h"
-#include "seg.h"
-#include "vm.h"
-#include "buf.h"
-#include "acct.h"
-#include "ptrace.h"
+#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
@@ -40,70 +46,121 @@
 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);
 }
 
 }
 
-#define        PHYSOFF(p, o) \
-       ((physadr)(p)+((o)/sizeof(((physadr)0)->r[0])))
+#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
+
+#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) {
@@ -122,41 +179,29 @@ procxmt()
 
        case PT_READ_U:                 /* read the child's u. */
                i = (int)ipc.ip_addr;
 
        case PT_READ_U:                 /* read the child's u. */
                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;
 
        case PT_WRITE_I:                /* write the child's text space */
                break;
 
        case PT_WRITE_I:                /* write the child's text space */
-               /*
-                * 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_flag |= XTRC;
-               }
-               i = -1;
                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 defined(tahoe)
-               /* make sure the old value is not in cache */
-               ckeyrelease(u.u_procp->p_ckey);
-               u.u_procp->p_ckey = getcodekey();
-#endif
-               if (xp) {
-                       xp->x_flag |= XWRIT;
-#if defined(tahoe)
-                       xp->x_ckey = u.u_procp->p_ckey;
-#endif
-               }
                break;
 
        case PT_WRITE_D:                /* write the child's data space */
                break;
 
        case PT_WRITE_D:                /* write the child's data space */
@@ -167,36 +212,88 @@ procxmt()
 
        case PT_WRITE_U:                /* write the child's u. */
                i = (int)ipc.ip_addr;
 
        case PT_WRITE_U:                /* write the child's u. */
                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;
+                       ipc.ip_data &= ~PSL_USERCLR;
+#ifdef PSL_CM_CLR
+                       if (ipc.ip_data & PSL_CM)
+                               ipc.ip_data &= ~PSL_CM_CLR;
+#endif
                        goto ok;
                }
                        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;
 
        case PT_STEP:                   /* single step the child */
        case PT_CONTINUE:               /* continue the child */
                break;
 
        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 */
+#else
+#ifdef PSL_T
+               /* need something more machine independent here... */
                if (i == PT_STEP) 
                if (i == PT_STEP) 
-                       u.u_ar0[PS] |= PSL_T;
+                       regs[PS] |= PSL_T;
+#endif
+#endif
                wakeup((caddr_t)&ipc);
                return (1);
 
        case PT_KILL:                   /* kill the child process */
                wakeup((caddr_t)&ipc);
                wakeup((caddr_t)&ipc);
                return (1);
 
        case PT_KILL:                   /* kill the child process */
                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.