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_wstatus(struct proc_handle *phdl)
 144 {
 145         int status;
 146
 147         if (phdl == NULL)
 148                 return (-1);
 149         if (waitpid(phdl->pid, &status, WUNTRACED) < 0) {
 150                 if (errno != EINTR)
 151                         DPRINTF("waitpid");
 152                 return (-1);
 153         }
 154         if (WIFSTOPPED(status))
 155                 phdl->status = PS_STOP;
 156         if (WIFEXITED(status) || WIFSIGNALED(status))
 157                 phdl->status = PS_UNDEAD;
 158         phdl->wstat = status;
 159
 160         return (phdl->status);
 161 }
 162
 163 int
 164 proc_getwstat(struct proc_handle *phdl)
 165 {
 166
 167         if (phdl == NULL)
 168                 return (-1);
 169
 170         return (phdl->wstat);
 171 }
 172
 173 char *
 174 proc_signame(int sig, char *name, size_t namesz)
 175 {
 176
 177         strlcpy(name, strsignal(sig), namesz);
 178
 179         return (name);
 180 }
 181
 182 int
 183 proc_read(struct proc_handle *phdl, void *buf, size_t size, size_t addr)
 184 {
 185         struct ptrace_io_desc piod;
 186
 187         if (phdl == NULL)
 188                 return (-1);
 189         piod.piod_op = PIOD_READ_D;
 190         piod.piod_len = size;
 191         piod.piod_addr = (void *)buf;
 192         piod.piod_offs = (void *)addr;
 193
 194         if (ptrace(PT_IO, phdl->pid, (caddr_t)&piod, 0) < 0)
 195                 return (-1);
 196         return (piod.piod_len);
 197 }
 198
 199 const lwpstatus_t *
 200 proc_getlwpstatus(struct proc_handle *phdl)
 201 {
 202         struct ptrace_lwpinfo lwpinfo;
 203         lwpstatus_t *psp = &phdl->lwps;
 204         siginfo_t *siginfo;
 205
 206         if (phdl == NULL)
 207                 return (NULL);
 208         if (ptrace(PT_LWPINFO, phdl->pid, (caddr_t)&lwpinfo,
 209             sizeof(lwpinfo)) < 0)
 210                 return (NULL);
 211         siginfo = &lwpinfo.pl_siginfo;
 212         if (lwpinfo.pl_event == PL_EVENT_SIGNAL &&
 213             (lwpinfo.pl_flags & PL_FLAG_SI) != 0) {
 214                 if (siginfo->si_signo == SIGTRAP &&
 215                     (siginfo->si_code == TRAP_BRKPT ||
 216                     siginfo->si_code == TRAP_TRACE)) {
 217                         psp->pr_why = PR_FAULTED;
 218                         psp->pr_what = FLTBPT;
 219                 } else {
 220                         psp->pr_why = PR_SIGNALLED;
 221                         psp->pr_what = siginfo->si_signo;
 222                 }
 223         } else if (lwpinfo.pl_flags & PL_FLAG_SCE) {
 224                 psp->pr_why = PR_SYSENTRY;
 225         } else if (lwpinfo.pl_flags & PL_FLAG_SCX) {
 226                 psp->pr_why = PR_SYSEXIT;
 227         }
 228
 229         return (psp);
 230 }