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 <unistd.h>
  39 #include <stdio.h>
  40 #include <signal.h>
  41 #include <string.h>
  42 #include "_libproc.h"
  43
  44 int
  45 proc_clearflags(struct proc_handle *phdl, int mask)
  46 {
  47
  48         if (phdl == NULL)
  49                 return (EINVAL);
  50
  51         phdl->flags &= ~mask;
  52
  53         return (0);
  54 }
  55
  56 /*
  57  * NB: we return -1 as the Solaris libproc Psetrun() function.
  58  */
  59 int
  60 proc_continue(struct proc_handle *phdl)
  61 {
  62
  63         if (phdl == NULL)
  64                 return (-1);
  65
  66         if (ptrace(PT_CONTINUE, phdl->pid, (caddr_t)(uintptr_t) 1, 0) != 0)
  67                 return (-1);
  68
  69         phdl->status = PS_RUN;
  70
  71         return (0);
  72 }
  73
  74 int
  75 proc_detach(struct proc_handle *phdl, int reason)
  76 {
  77         int status;
  78
  79         if (phdl == NULL)
  80                 return (EINVAL);
  81         if (reason == PRELEASE_KILL) {
  82                 kill(phdl->pid, SIGKILL);
  83                 return (0);
  84         }
  85         if (ptrace(PT_DETACH, phdl->pid, 0, 0) != 0 && errno == ESRCH)
  86                 return (0);
  87         if (errno == EBUSY) {
  88                 kill(phdl->pid, SIGSTOP);
  89                 waitpid(phdl->pid, &status, WUNTRACED);
  90                 ptrace(PT_DETACH, phdl->pid, 0, 0);
  91                 kill(phdl->pid, SIGCONT);
  92                 return (0);
  93         }
  94
  95         return (0);
  96 }
  97
  98 int
  99 proc_getflags(struct proc_handle *phdl)
 100 {
 101
 102         if (phdl == NULL)
 103                 return (-1);
 104
 105         return(phdl->flags);
 106 }
 107
 108 int
 109 proc_setflags(struct proc_handle *phdl, int mask)
 110 {
 111
 112         if (phdl == NULL)
 113                 return (EINVAL);
 114
 115         phdl->flags |= mask;
 116
 117         return (0);
 118 }
 119
 120 int
 121 proc_state(struct proc_handle *phdl)
 122 {
 123
 124         if (phdl == NULL)
 125                 return (-1);
 126
 127         return (phdl->status);
 128 }
 129
 130 pid_t
 131 proc_getpid(struct proc_handle *phdl)
 132 {
 133
 134         if (phdl == NULL)
 135                 return (-1);
 136
 137         return (phdl->pid);
 138 }
 139
 140 int
 141 proc_wstatus(struct proc_handle *phdl)
 142 {
 143         int status;
 144
 145         if (phdl == NULL)
 146                 return (-1);
 147         if (waitpid(phdl->pid, &status, WUNTRACED) < 0) {
 148                 if (errno != EINTR)
 149                         warn("waitpid");
 150                 return (-1);
 151         }
 152         if (WIFSTOPPED(status))
 153                 phdl->status = PS_STOP;
 154         if (WIFEXITED(status) || WIFSIGNALED(status))
 155                 phdl->status = PS_UNDEAD;
 156         phdl->wstat = status;
 157
 158         return (phdl->status);
 159 }
 160
 161 int
 162 proc_getwstat(struct proc_handle *phdl)
 163 {
 164
 165         if (phdl == NULL)
 166                 return (-1);
 167
 168         return (phdl->wstat);
 169 }
 170
 171 char *
 172 proc_signame(int sig, char *name, size_t namesz)
 173 {
 174
 175         strlcpy(name, strsignal(sig), namesz);
 176
 177         return (name);
 178 }
 179
 180 int
 181 proc_read(struct proc_handle *phdl, void *buf, size_t size, size_t addr)
 182 {
 183         struct ptrace_io_desc piod;
 184
 185         if (phdl == NULL)
 186                 return (-1);
 187         piod.piod_op = PIOD_READ_D;
 188         piod.piod_len = size;
 189         piod.piod_addr = (void *)buf;
 190         piod.piod_offs = (void *)addr;
 191
 192         if (ptrace(PT_IO, phdl->pid, (caddr_t)&piod, 0) < 0)
 193                 return (-1);
 194         return (piod.piod_len);
 195 }
 196
 197 const lwpstatus_t *
 198 proc_getlwpstatus(struct proc_handle *phdl)
 199 {
 200         struct ptrace_lwpinfo lwpinfo;
 201         lwpstatus_t *psp = &phdl->lwps;
 202         siginfo_t *siginfo;
 203
 204         if (phdl == NULL)
 205                 return (NULL);
 206         if (ptrace(PT_LWPINFO, phdl->pid, (caddr_t)&lwpinfo,
 207             sizeof(lwpinfo)) < 0)
 208                 return (NULL);
 209         siginfo = &lwpinfo.pl_siginfo;
 210         if (lwpinfo.pl_event == PL_EVENT_SIGNAL &&
 211             (lwpinfo.pl_flags & PL_FLAG_SI) &&
 212             siginfo->si_signo == SIGTRAP &&
 213             (siginfo->si_code == TRAP_BRKPT ||
 214             siginfo->si_code == TRAP_TRACE)) {
 215                 psp->pr_why = PR_FAULTED;
 216                 psp->pr_what = FLTBPT;
 217         } else if (lwpinfo.pl_flags & PL_FLAG_SCE) {
 218                 psp->pr_why = PR_SYSENTRY;
 219         } else if (lwpinfo.pl_flags & PL_FLAG_SCX) {
 220                 psp->pr_why = PR_SYSEXIT;
 221         }
 222
 223         return (psp);
 224 }