lib/libproc/proc_util.c

   1 /*-
   2  * Copyright (c) 2010 The FreeBSD Foundation
   3  * Copyright (c) 2008 John Birrell (jb@freebsd.org)
   4  * All rights reserved.
   5  *
   6  * Portions of this software were developed by Rui Paulo under sponsorship
   7  * from the FreeBSD Foundation.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  *
  30  * $FreeBSD$
  31  */
  32
  33 #include <sys/types.h>
  34 #include <sys/ptrace.h>
  35 #include <sys/wait.h>
  36 #include <err.h>
  37 #include <errno.h>
  38 #include <signal.h>
  39 #include <string.h>
  40 #include <unistd.h>
  41 #include "_libproc.h"
  42
  43 int
  44 proc_clearflags(struct proc_handle *phdl, int mask)
  45 {
  46
  47         if (phdl == NULL)
  48                 return (EINVAL);
  49
  50         phdl->flags &= ~mask;
  51
  52         return (0);
  53 }
  54
  55 /*
  56  * NB: we return -1 as the Solaris libproc Psetrun() function.
  57  */
  58 int
  59 proc_continue(struct proc_handle *phdl)
  60 {
  61         int pending = 0;
  62
  63         if (phdl == NULL)
  64                 return (-1);
  65
  66         if (phdl->status == PS_STOP && WSTOPSIG(phdl->wstat) != SIGTRAP)
  67                 pending = WSTOPSIG(phdl->wstat);
  68         if (ptrace(PT_CONTINUE, phdl->pid, (caddr_t)(uintptr_t)1, pending) != 0)
  69                 return (-1);
  70
  71         phdl->status = PS_RUN;
  72
  73         return (0);
  74 }
  75
  76 int
  77 proc_detach(struct proc_handle *phdl, int reason)
  78 {
  79         int status;
  80
  81         if (phdl == NULL)
  82                 return (EINVAL);
  83         if (reason == PRELEASE_KILL) {
  84                 kill(phdl->pid, SIGKILL);
  85                 return (0);
  86         }
  87         if (ptrace(PT_DETACH, phdl->pid, 0, 0) != 0 && errno == ESRCH)
  88                 return (0);
  89         if (errno == EBUSY) {
  90                 kill(phdl->pid, SIGSTOP);
  91                 waitpid(phdl->pid, &status, WUNTRACED);
  92                 ptrace(PT_DETACH, phdl->pid, 0, 0);
  93                 kill(phdl->pid, SIGCONT);
  94                 return (0);
  95         }
  96
  97         return (0);
  98 }
  99
 100 int
 101 proc_getflags(struct proc_handle *phdl)
 102 {
 103
 104         if (phdl == NULL)
 105                 return (-1);
 106
 107         return(phdl->flags);
 108 }
 109
 110 int
 111 proc_setflags(struct proc_handle *phdl, int mask)
 112 {
 113
 114         if (phdl == NULL)
 115                 return (EINVAL);
 116
 117         phdl->flags |= mask;
 118
 119         return (0);
 120 }
 121
 122 int
 123 proc_state(struct proc_handle *phdl)
 124 {
 125
 126         if (phdl == NULL)
 127                 return (-1);
 128
 129         return (phdl->status);
 130 }
 131
 132 pid_t
 133 proc_getpid(struct proc_handle *phdl)
 134 {
 135
 136         if (phdl == NULL)
 137                 return (-1);
 138
 139         return (phdl->pid);
 140 }
 141
 142 int
 143 proc_getmodel(struct proc_handle *phdl)
 144 {
 145
 146         if (phdl == NULL)
 147                 return (-1);
 148
 149         return (phdl->model);
 150 }
 151
 152 int
 153 proc_wstatus(struct proc_handle *phdl)
 154 {
 155         int status;
 156
 157         if (phdl == NULL)
 158                 return (-1);
 159         if (waitpid(phdl->pid, &status, WUNTRACED) < 0) {
 160                 if (errno != EINTR)
 161                         DPRINTF("waitpid");
 162                 return (-1);
 163         }
 164         if (WIFSTOPPED(status))
 165                 phdl->status = PS_STOP;
 166         if (WIFEXITED(status) || WIFSIGNALED(status))
 167                 phdl->status = PS_UNDEAD;
 168         phdl->wstat = status;
 169
 170         return (phdl->status);
 171 }
 172
 173 int
 174 proc_getwstat(struct proc_handle *phdl)
 175 {
 176
 177         if (phdl == NULL)
 178                 return (-1);
 179
 180         return (phdl->wstat);
 181 }
 182
 183 char *
 184 proc_signame(int sig, char *name, size_t namesz)
 185 {
 186
 187         strlcpy(name, strsignal(sig), namesz);
 188
 189         return (name);
 190 }
 191
 192 int
 193 proc_read(struct proc_handle *phdl, void *buf, size_t size, size_t addr)
 194 {
 195         struct ptrace_io_desc piod;
 196
 197         if (phdl == NULL)
 198                 return (-1);
 199         piod.piod_op = PIOD_READ_D;
 200         piod.piod_len = size;
 201         piod.piod_addr = (void *)buf;
 202         piod.piod_offs = (void *)addr;
 203
 204         if (ptrace(PT_IO, phdl->pid, (caddr_t)&piod, 0) < 0)
 205                 return (-1);
 206         return (piod.piod_len);
 207 }
 208
 209 const lwpstatus_t *
 210 proc_getlwpstatus(struct proc_handle *phdl)
 211 {
 212         struct ptrace_lwpinfo lwpinfo;
 213         lwpstatus_t *psp = &phdl->lwps;
 214         siginfo_t *siginfo;
 215
 216         if (phdl == NULL)
 217                 return (NULL);
 218         if (ptrace(PT_LWPINFO, phdl->pid, (caddr_t)&lwpinfo,
 219             sizeof(lwpinfo)) < 0)
 220                 return (NULL);
 221         siginfo = &lwpinfo.pl_siginfo;
 222         if (lwpinfo.pl_event == PL_EVENT_SIGNAL &&
 223             (lwpinfo.pl_flags & PL_FLAG_SI) != 0) {
 224                 if (siginfo->si_signo == SIGTRAP &&
 225                     (siginfo->si_code == TRAP_BRKPT ||
 226                     siginfo->si_code == TRAP_TRACE)) {
 227                         psp->pr_why = PR_FAULTED;
 228                         psp->pr_what = FLTBPT;
 229                 } else {
 230                         psp->pr_why = PR_SIGNALLED;
 231                         psp->pr_what = siginfo->si_signo;
 232                 }
 233         } else if (lwpinfo.pl_flags & PL_FLAG_SCE) {
 234                 psp->pr_why = PR_SYSENTRY;
 235         } else if (lwpinfo.pl_flags & PL_FLAG_SCX) {
 236                 psp->pr_why = PR_SYSEXIT;
 237         }
 238
 239         return (psp);
 240 }