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