minix/servers/pm/trace.c

   1 /* This file handles the process manager's part of debugging, using the
   2  * ptrace system call. Most of the commands are passed on to the system
   3  * task for completion.
   4  *
   5  * The debugging commands available are:
   6  * T_STOP       stop the process
   7  * T_OK         enable tracing by parent for this process
   8  * T_GETINS     return value from instruction space
   9  * T_GETDATA    return value from data space
  10  * T_GETUSER    return value from user process table
  11  * T_SETINS     set value in instruction space
  12  * T_SETDATA    set value in data space
  13  * T_SETUSER    set value in user process table
  14  * T_RESUME     resume execution
  15  * T_EXIT       exit
  16  * T_STEP       set trace bit
  17  * T_SYSCALL    trace system call
  18  * T_ATTACH     attach to an existing process
  19  * T_DETACH     detach from a traced process
  20  * T_SETOPT     set trace options
  21  * T_GETRANGE   get range of values
  22  * T_SETRANGE   set range of values
  23  *
  24  * The T_OK, T_ATTACH, T_EXIT, and T_SETOPT commands are handled here, and the
  25  * T_RESUME, T_STEP, T_SYSCALL, and T_DETACH commands are partially handled
  26  * here and completed by the system task. The rest are handled entirely by the
  27  * system task.
  28  */
  29
  30 #include "pm.h"
  31 #include <minix/com.h>
  32 #include <minix/callnr.h>
  33 #include <sys/ptrace.h>
  34 #include <sys/wait.h>
  35 #include <signal.h>
  36 #include "mproc.h"
  37
  38 /*===========================================================================*
  39  *                              do_trace                                     *
  40  *===========================================================================*/
  41 int
  42 do_trace(void)
  43 {
  44   register struct mproc *child;
  45   struct ptrace_range pr;
  46   int i, r, req;
  47
  48   req = m_in.m_lc_pm_ptrace.req;
  49
  50   /* The T_OK call is made by the child fork of the debugger before it execs
  51    * the process to be traced. The T_ATTACH call is made by the debugger itself
  52    * to attach to an existing process.
  53    */
  54   switch (req) {
  55   case T_OK:            /* enable tracing by parent for this proc */
  56         if (mp->mp_tracer != NO_TRACER) return(EBUSY);
  57
  58         mp->mp_tracer = mp->mp_parent;
  59         mp->mp_reply.m_pm_lc_ptrace.data = 0;
  60         return(OK);
  61
  62   case T_ATTACH:        /* attach to an existing process */
  63         if ((child = find_proc(m_in.m_lc_pm_ptrace.pid)) == NULL) return(ESRCH);
  64         if (child->mp_flags & EXITING) return(ESRCH);
  65
  66         /* For non-root processes, user and group ID must match. */
  67         if (mp->mp_effuid != SUPER_USER &&
  68                 (mp->mp_effuid != child->mp_effuid ||
  69                  mp->mp_effgid != child->mp_effgid ||
  70                  child->mp_effuid != child->mp_realuid ||
  71                  child->mp_effgid != child->mp_realgid)) return(EPERM);
  72
  73         /* Only root may trace system servers. */
  74         if (mp->mp_effuid != SUPER_USER && (child->mp_flags & PRIV_PROC))
  75                 return(EPERM);
  76
  77         /* System servers may not trace anyone. They can use sys_trace(). */
  78         if (mp->mp_flags & PRIV_PROC) return(EPERM);
  79
  80         /* Can't trace self, PM or VM. */
  81         if (child == mp || child->mp_endpoint == PM_PROC_NR ||
  82                 child->mp_endpoint == VM_PROC_NR) return(EPERM);
  83
  84         /* Can't trace a process that is already being traced. */
  85         if (child->mp_tracer != NO_TRACER) return(EBUSY);
  86
  87         child->mp_tracer = who_p;
  88         child->mp_trace_flags = TO_NOEXEC;
  89
  90         sig_proc(child, SIGSTOP, TRUE /*trace*/, FALSE /* ksig */);
  91
  92         mp->mp_reply.m_pm_lc_ptrace.data = 0;
  93         return(OK);
  94
  95   case T_STOP:          /* stop the process */
  96         /* This call is not exposed to user programs, because its effect can be
  97          * achieved better by sending the traced process a signal with kill(2).
  98          */
  99         return(EINVAL);
 100
 101   case T_READB_INS:     /* special hack for reading text segments */
 102         if (mp->mp_effuid != SUPER_USER) return(EPERM);
 103         if ((child = find_proc(m_in.m_lc_pm_ptrace.pid)) == NULL) return(ESRCH);
 104         if (child->mp_flags & EXITING) return(ESRCH);
 105
 106         r = sys_trace(req, child->mp_endpoint, m_in.m_lc_pm_ptrace.addr,
 107                 &m_in.m_lc_pm_ptrace.data);
 108         if (r != OK) return(r);
 109
 110         mp->mp_reply.m_pm_lc_ptrace.data = m_in.m_lc_pm_ptrace.data;
 111         return(OK);
 112
 113   case T_WRITEB_INS:    /* special hack for patching text segments */
 114         if (mp->mp_effuid != SUPER_USER) return(EPERM);
 115         if ((child = find_proc(m_in.m_lc_pm_ptrace.pid)) == NULL) return(ESRCH);
 116         if (child->mp_flags & EXITING) return(ESRCH);
 117
 118 #if 0
 119         /* Should check for shared text */
 120
 121         /* Make sure the text segment is not used as a source for shared
 122          * text.
 123          */
 124         child->mp_ino = 0;
 125         child->mp_dev = 0;
 126         child->mp_ctime = 0;
 127 #endif
 128
 129         r = sys_trace(req, child->mp_endpoint, m_in.m_lc_pm_ptrace.addr,
 130                 &m_in.m_lc_pm_ptrace.data);
 131         if (r != OK) return(r);
 132
 133         mp->mp_reply.m_pm_lc_ptrace.data = m_in.m_lc_pm_ptrace.data;
 134         return(OK);
 135   }
 136
 137   /* All the other calls are made by the tracing process to control execution
 138    * of the child. For all these calls, the child must be stopped.
 139    */
 140   if ((child = find_proc(m_in.m_lc_pm_ptrace.pid)) == NULL) return(ESRCH);
 141   if (child->mp_flags & EXITING) return(ESRCH);
 142   if (child->mp_tracer != who_p) return(ESRCH);
 143   if (!(child->mp_flags & TRACE_STOPPED)) return(EBUSY);
 144
 145   switch (req) {
 146   case T_EXIT:          /* exit */
 147         child->mp_flags |= TRACE_EXIT;
 148
 149         /* Defer the exit if the traced process has a call pending. */
 150         if (child->mp_flags & (VFS_CALL | EVENT_CALL))
 151                 child->mp_exitstatus = m_in.m_lc_pm_ptrace.data; /* save it */
 152         else
 153                 exit_proc(child, m_in.m_lc_pm_ptrace.data,
 154                         FALSE /*dump_core*/);
 155
 156         /* Do not reply to the caller until VFS has processed the exit
 157          * request.
 158          */
 159         return(SUSPEND);
 160
 161   case T_SETOPT:        /* set trace options */
 162         child->mp_trace_flags = m_in.m_lc_pm_ptrace.data;
 163
 164         mp->mp_reply.m_pm_lc_ptrace.data = 0;
 165         return(OK);
 166
 167   case T_GETRANGE:
 168   case T_SETRANGE:      /* get/set range of values */
 169         r = sys_datacopy(who_e, m_in.m_lc_pm_ptrace.addr, SELF, (vir_bytes)&pr,
 170                 (phys_bytes)sizeof(pr));
 171         if (r != OK) return(r);
 172
 173         if (pr.pr_space != TS_INS && pr.pr_space != TS_DATA) return(EINVAL);
 174         if (pr.pr_size == 0 || pr.pr_size > LONG_MAX) return(EINVAL);
 175
 176         if (req == T_GETRANGE)
 177                 r = sys_vircopy(child->mp_endpoint, (vir_bytes) pr.pr_addr,
 178                         who_e, (vir_bytes) pr.pr_ptr,
 179                         (phys_bytes) pr.pr_size, 0);
 180         else
 181                 r = sys_vircopy(who_e, (vir_bytes) pr.pr_ptr,
 182                         child->mp_endpoint, (vir_bytes) pr.pr_addr,
 183                         (phys_bytes) pr.pr_size, 0);
 184
 185         if (r != OK) return(r);
 186
 187         mp->mp_reply.m_pm_lc_ptrace.data = 0;
 188         return(OK);
 189
 190   case T_DETACH:        /* detach from traced process */
 191         if (m_in.m_lc_pm_ptrace.data < 0 || m_in.m_lc_pm_ptrace.data >= _NSIG)
 192                 return(EINVAL);
 193
 194         child->mp_tracer = NO_TRACER;
 195
 196         /* Let all tracer-pending signals through the filter. */
 197         for (i = 1; i < _NSIG; i++) {
 198                 if (sigismember(&child->mp_sigtrace, i)) {
 199                         sigdelset(&child->mp_sigtrace, i);
 200                         check_sig(child->mp_pid, i, FALSE /* ksig */);
 201                 }
 202         }
 203
 204         if (m_in.m_lc_pm_ptrace.data > 0) {             /* issue signal */
 205                 sig_proc(child, m_in.m_lc_pm_ptrace.data, TRUE /*trace*/,
 206                         FALSE /* ksig */);
 207         }
 208
 209         /* Resume the child as if nothing ever happened. */
 210         child->mp_flags &= ~TRACE_STOPPED;
 211         child->mp_trace_flags = 0;
 212
 213         check_pending(child);
 214
 215         break;
 216
 217   case T_RESUME:
 218   case T_STEP:
 219   case T_SYSCALL:       /* resume execution */
 220         if (m_in.m_lc_pm_ptrace.data < 0 || m_in.m_lc_pm_ptrace.data >= _NSIG)
 221                 return(EINVAL);
 222
 223         if (m_in.m_lc_pm_ptrace.data > 0) {             /* issue signal */
 224                 sig_proc(child, m_in.m_lc_pm_ptrace.data, FALSE /*trace*/,
 225                         FALSE /* ksig */);
 226         }
 227
 228         /* If there are any other signals waiting to be delivered,
 229          * feign a successful resumption.
 230          */
 231         for (i = 1; i < _NSIG; i++) {
 232                 if (sigismember(&child->mp_sigtrace, i)) {
 233                         mp->mp_reply.m_pm_lc_ptrace.data = 0;
 234                         return(OK);
 235                 }
 236         }
 237
 238         child->mp_flags &= ~TRACE_STOPPED;
 239
 240         check_pending(child);
 241
 242         break;
 243   }
 244   r = sys_trace(req, child->mp_endpoint, m_in.m_lc_pm_ptrace.addr,
 245         &m_in.m_lc_pm_ptrace.data);
 246   if (r != OK) return(r);
 247
 248   mp->mp_reply.m_pm_lc_ptrace.data = m_in.m_lc_pm_ptrace.data;
 249   return(OK);
 250 }
 251
 252 /*===========================================================================*
 253  *                              trace_stop                                   *
 254  *===========================================================================*/
 255 void
 256 trace_stop(register struct mproc *rmp, int signo)
 257 {
 258 /* A traced process got a signal so stop it. */
 259
 260   register struct mproc *rpmp = mproc + rmp->mp_tracer;
 261   int r;
 262
 263   r = sys_trace(T_STOP, rmp->mp_endpoint, 0L, (long *) 0);
 264   if (r != OK) panic("sys_trace failed: %d", r);
 265
 266   rmp->mp_flags |= TRACE_STOPPED;
 267   if (wait_test(rpmp, rmp)) {
 268         /* TODO: rusage support */
 269
 270         sigdelset(&rmp->mp_sigtrace, signo);
 271
 272         rpmp->mp_flags &= ~WAITING;     /* parent is no longer waiting */
 273         rpmp->mp_reply.m_pm_lc_wait4.status = W_STOPCODE(signo);
 274         reply(rmp->mp_tracer, rmp->mp_pid);
 275   }
 276 }