Index: head/cddl/compat/opensolaris/include/libproc.h =================================================================== --- head/cddl/compat/opensolaris/include/libproc.h (revision 309596) +++ head/cddl/compat/opensolaris/include/libproc.h (revision 309597) @@ -1,46 +1,43 @@ /* * Copyright (C) 2008 John Birrell * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ * */ #ifndef _COMPAT_OPENSOLARIS_LIBPROC_H_ #define _COMPAT_OPENSOLARIS_LIBPROC_H_ #include #define ps_prochandle proc_handle #define Lmid_t int #define PR_RLC 0x0001 #define PR_KLC 0x0002 -#define PGRAB_RDONLY O_RDONLY -#define PGRAB_FORCE 0 - #include_next #endif Index: head/cddl/lib/libdtrace/libproc_compat.h =================================================================== --- head/cddl/lib/libdtrace/libproc_compat.h (revision 309596) +++ head/cddl/lib/libdtrace/libproc_compat.h (revision 309597) @@ -1,64 +1,67 @@ /* * Copyright (c) 2010 The FreeBSD Foundation * All rights reserved. * * This software was developed by Rui Paulo under sponsorship from the * FreeBSD Foundation. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ /* * Compatibility functions between Solaris libproc and FreeBSD libproc. * Functions sorted alphabetically. */ #define PR_LMID_EVERY 0 +#define PGRAB_RDONLY PATTACH_RDONLY +#define PGRAB_FORCE PATTACH_FORCE + #define Psetrun(p, a1, a2) proc_continue((p)) #define Pxlookup_by_addr(p, a, n, s, sym, i) \ proc_addr2sym(p, a, n, s, sym) #define Pxlookup_by_name(p, l, s1, s2, sym, a) \ proc_name2sym(p, s1, s2, sym, a) #define Paddr_to_map proc_addr2map #define Pcreate_error strerror #define Pdelbkpt proc_bkptdel #define Pgrab_error strerror #define Plmid(p, a, l) (-1) #define Plmid_to_map(p, l, o) proc_name2map(p, o) #define Plookup_by_addr proc_addr2sym #define Pname_to_ctf(p, obj) (ctf_file_t *)proc_name2ctf(p, obj) #define Pname_to_map proc_name2map #define Pobject_iter proc_iter_objs #define Pobject_iter_resolved(p, f, arg) proc_iter_objs(p, f, arg) #define Pobjname proc_objname #define Pread proc_read #define Prd_agent proc_rdagent #define Prelease proc_detach #define Psetbkpt proc_bkptset #define Psetflags proc_setflags #define Pstate proc_state #define Psymbol_iter_by_addr proc_iter_symbyaddr #define Punsetflags proc_clearflags #define Pupdate_maps proc_rdagent #define Pupdate_syms proc_updatesyms #define Pxecbkpt proc_bkptexec Index: head/lib/libproc/libproc.h =================================================================== --- head/lib/libproc/libproc.h (revision 309596) +++ head/lib/libproc/libproc.h (revision 309597) @@ -1,165 +1,170 @@ /*- * Copyright (c) 2010 The FreeBSD Foundation * Copyright (c) 2008 John Birrell (jb@freebsd.org) * All rights reserved. * * Portions of this software were developed by Rui Paulo under sponsorship * from the FreeBSD Foundation. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #ifndef _LIBPROC_H_ #define _LIBPROC_H_ #include #include #include struct ctf_file; struct proc_handle; typedef void (*proc_child_func)(void *); /* Values returned by proc_state(). */ #define PS_IDLE 1 #define PS_STOP 2 #define PS_RUN 3 #define PS_UNDEAD 4 #define PS_DEAD 5 #define PS_LOST 6 +/* Flags for proc_attach(). */ +#define PATTACH_FORCE 0x01 +#define PATTACH_RDONLY 0x02 +#define PATTACH_NOSTOP 0x04 + /* Reason values for proc_detach(). */ #define PRELEASE_HANG 1 #define PRELEASE_KILL 2 typedef struct prmap { uintptr_t pr_vaddr; /* Virtual address. */ size_t pr_size; /* Mapping size in bytes */ size_t pr_offset; /* Mapping offset in object */ char pr_mapname[PATH_MAX]; /* Mapping filename */ uint8_t pr_mflags; /* Protection flags */ #define MA_READ 0x01 #define MA_WRITE 0x02 #define MA_EXEC 0x04 #define MA_COW 0x08 #define MA_NEEDS_COPY 0x10 #define MA_NOCOREDUMP 0x20 } prmap_t; typedef struct prsyminfo { u_int prs_lmid; /* Map id. */ u_int prs_id; /* Symbol id. */ } prsyminfo_t; typedef int proc_map_f(void *, const prmap_t *, const char *); typedef int proc_sym_f(void *, const GElf_Sym *, const char *); /* Values for ELF sections */ #define PR_SYMTAB 1 #define PR_DYNSYM 2 /* Values for the 'mask' parameter in the iteration functions */ #define BIND_LOCAL 0x0001 #define BIND_GLOBAL 0x0002 #define BIND_WEAK 0x0004 #define BIND_ANY (BIND_LOCAL|BIND_GLOBAL|BIND_WEAK) #define TYPE_NOTYPE 0x0100 #define TYPE_OBJECT 0x0200 #define TYPE_FUNC 0x0400 #define TYPE_SECTION 0x0800 #define TYPE_FILE 0x1000 #define TYPE_ANY (TYPE_NOTYPE|TYPE_OBJECT|TYPE_FUNC|TYPE_SECTION|\ TYPE_FILE) typedef enum { REG_PC, REG_SP, REG_RVAL1, REG_RVAL2 } proc_reg_t; #define SIG2STR_MAX 8 typedef struct lwpstatus { int pr_why; #define PR_REQUESTED 1 #define PR_FAULTED 2 #define PR_SYSENTRY 3 #define PR_SYSEXIT 4 #define PR_SIGNALLED 5 int pr_what; #define FLTBPT -1 } lwpstatus_t; #define PR_MODEL_ILP32 1 #define PR_MODEL_LP64 2 struct proc_handle_public { pid_t pid; }; #define proc_getpid(phdl) (((struct proc_handle_public *)(phdl))->pid) /* Function prototype definitions. */ __BEGIN_DECLS prmap_t *proc_addr2map(struct proc_handle *, uintptr_t); prmap_t *proc_name2map(struct proc_handle *, const char *); char *proc_objname(struct proc_handle *, uintptr_t, char *, size_t); int proc_iter_objs(struct proc_handle *, proc_map_f *, void *); int proc_iter_symbyaddr(struct proc_handle *, const char *, int, int, proc_sym_f *, void *); int proc_addr2sym(struct proc_handle *, uintptr_t, char *, size_t, GElf_Sym *); int proc_attach(pid_t pid, int flags, struct proc_handle **pphdl); int proc_continue(struct proc_handle *); int proc_clearflags(struct proc_handle *, int); int proc_create(const char *, char * const *, proc_child_func *, void *, struct proc_handle **); int proc_detach(struct proc_handle *, int); int proc_getflags(struct proc_handle *); int proc_name2sym(struct proc_handle *, const char *, const char *, GElf_Sym *, prsyminfo_t *); struct ctf_file *proc_name2ctf(struct proc_handle *, const char *); int proc_setflags(struct proc_handle *, int); int proc_state(struct proc_handle *); int proc_getmodel(struct proc_handle *); int proc_wstatus(struct proc_handle *); int proc_getwstat(struct proc_handle *); char * proc_signame(int, char *, size_t); int proc_read(struct proc_handle *, void *, size_t, size_t); const lwpstatus_t *proc_getlwpstatus(struct proc_handle *); void proc_free(struct proc_handle *); rd_agent_t *proc_rdagent(struct proc_handle *); void proc_updatesyms(struct proc_handle *); int proc_bkptset(struct proc_handle *, uintptr_t, unsigned long *); int proc_bkptdel(struct proc_handle *, uintptr_t, unsigned long); void proc_bkptregadj(unsigned long *); int proc_bkptexec(struct proc_handle *, unsigned long); int proc_regget(struct proc_handle *, proc_reg_t, unsigned long *); int proc_regset(struct proc_handle *, proc_reg_t, unsigned long); __END_DECLS #endif /* _LIBPROC_H_ */ Index: head/lib/libproc/proc_create.c =================================================================== --- head/lib/libproc/proc_create.c (revision 309596) +++ head/lib/libproc/proc_create.c (revision 309597) @@ -1,257 +1,262 @@ /*- * Copyright (c) 2008 John Birrell (jb@freebsd.org) * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include "_libproc.h" static int getelfclass(int); static int proc_init(pid_t, int, int, struct proc_handle **); static int getelfclass(int fd) { GElf_Ehdr ehdr; Elf *e; int class; class = ELFCLASSNONE; if ((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL) goto out; if (gelf_getehdr(e, &ehdr) == NULL) goto out; class = ehdr.e_ident[EI_CLASS]; out: (void)elf_end(e); return (class); } static int proc_init(pid_t pid, int flags, int status, struct proc_handle **pphdl) { struct kinfo_proc *kp; struct proc_handle *phdl; int error, class, count, fd; error = ENOMEM; if ((phdl = malloc(sizeof(*phdl))) == NULL) goto out; memset(phdl, 0, sizeof(*phdl)); phdl->public.pid = pid; phdl->flags = flags; phdl->status = status; phdl->procstat = procstat_open_sysctl(); if (phdl->procstat == NULL) goto out; /* Obtain a path to the executable. */ if ((kp = procstat_getprocs(phdl->procstat, KERN_PROC_PID, pid, &count)) == NULL) goto out; error = procstat_getpathname(phdl->procstat, kp, phdl->execpath, sizeof(phdl->execpath)); procstat_freeprocs(phdl->procstat, kp); if (error != 0) goto out; /* Use it to determine the data model for the process. */ if ((fd = open(phdl->execpath, O_RDONLY)) < 0) { error = errno; goto out; } class = getelfclass(fd); switch (class) { case ELFCLASS64: phdl->model = PR_MODEL_LP64; break; case ELFCLASS32: phdl->model = PR_MODEL_ILP32; break; case ELFCLASSNONE: default: error = EINVAL; break; } (void)close(fd); out: *pphdl = phdl; return (error); } int proc_attach(pid_t pid, int flags, struct proc_handle **pphdl) { struct proc_handle *phdl; int error, status; - if (pid == 0 || pid == getpid()) + if (pid == 0 || (pid == getpid() && (flags & PATTACH_RDONLY) == 0)) return (EINVAL); if (elf_version(EV_CURRENT) == EV_NONE) return (ENOENT); /* * Allocate memory for the process handle, a structure containing * all things related to the process. */ error = proc_init(pid, flags, PS_RUN, &phdl); if (error != 0) goto out; - if (ptrace(PT_ATTACH, proc_getpid(phdl), 0, 0) != 0) { - error = errno; - DPRINTF("ERROR: cannot ptrace child process %d", pid); - goto out; - } + if ((flags & PATTACH_RDONLY) == 0) { + if (ptrace(PT_ATTACH, proc_getpid(phdl), 0, 0) != 0) { + error = errno; + DPRINTF("ERROR: cannot ptrace child process %d", pid); + goto out; + } - /* Wait for the child process to stop. */ - if (waitpid(pid, &status, WUNTRACED) == -1) { - error = errno; - DPRINTF("ERROR: child process %d didn't stop as expected", pid); - goto out; - } + /* Wait for the child process to stop. */ + if (waitpid(pid, &status, WUNTRACED) == -1) { + error = errno; + DPRINTF("ERROR: child process %d didn't stop as expected", pid); + goto out; + } - /* Check for an unexpected status. */ - if (!WIFSTOPPED(status)) - DPRINTFX("ERROR: child process %d status 0x%x", pid, status); - else - phdl->status = PS_STOP; + /* Check for an unexpected status. */ + if (!WIFSTOPPED(status)) + DPRINTFX("ERROR: child process %d status 0x%x", pid, status); + else + phdl->status = PS_STOP; + if ((flags & PATTACH_NOSTOP) != 0) + proc_continue(phdl); + } + out: - if (error && phdl != NULL) { + if (error != 0 && phdl != NULL) { proc_free(phdl); phdl = NULL; } *pphdl = phdl; return (error); } int proc_create(const char *file, char * const *argv, proc_child_func *pcf, void *child_arg, struct proc_handle **pphdl) { struct proc_handle *phdl; int error = 0; int status; pid_t pid; if (elf_version(EV_CURRENT) == EV_NONE) return (ENOENT); /* Fork a new process. */ if ((pid = vfork()) == -1) error = errno; else if (pid == 0) { /* The child expects to be traced. */ if (ptrace(PT_TRACE_ME, 0, 0, 0) != 0) _exit(1); if (pcf != NULL) (*pcf)(child_arg); /* Execute the specified file: */ execvp(file, argv); /* Couldn't execute the file. */ _exit(2); /* NOTREACHED */ } else { /* The parent owns the process handle. */ error = proc_init(pid, 0, PS_IDLE, &phdl); if (error != 0) goto bad; /* Wait for the child process to stop. */ if (waitpid(pid, &status, WUNTRACED) == -1) { error = errno; DPRINTF("ERROR: child process %d didn't stop as expected", pid); goto bad; } /* Check for an unexpected status. */ if (!WIFSTOPPED(status)) { error = errno; DPRINTFX("ERROR: child process %d status 0x%x", pid, status); goto bad; } else phdl->status = PS_STOP; } bad: if (error && phdl != NULL) { proc_free(phdl); phdl = NULL; } *pphdl = phdl; return (error); } void proc_free(struct proc_handle *phdl) { struct file_info *file; size_t i; for (i = 0; i < phdl->nmappings; i++) { file = phdl->mappings[i].file; if (file != NULL && --file->refs == 0) { if (file->elf != NULL) { (void)elf_end(file->elf); (void)close(file->fd); if (file->symtab.nsyms > 0) free(file->symtab.index); if (file->dynsymtab.nsyms > 0) free(file->dynsymtab.index); } free(file); } } if (phdl->maparrsz > 0) free(phdl->mappings); if (phdl->procstat != NULL) procstat_close(phdl->procstat); if (phdl->rdap != NULL) rd_delete(phdl->rdap); free(phdl); } Index: head/lib/libproc/proc_util.c =================================================================== --- head/lib/libproc/proc_util.c (revision 309596) +++ head/lib/libproc/proc_util.c (revision 309597) @@ -1,238 +1,242 @@ /*- * Copyright (c) 2010 The FreeBSD Foundation * Copyright (c) 2008 John Birrell (jb@freebsd.org) * All rights reserved. * * Portions of this software were developed by Rui Paulo under sponsorship * from the FreeBSD Foundation. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include "_libproc.h" int proc_clearflags(struct proc_handle *phdl, int mask) { if (phdl == NULL) return (EINVAL); phdl->flags &= ~mask; return (0); } /* * NB: we return -1 as the Solaris libproc Psetrun() function. */ int proc_continue(struct proc_handle *phdl) { int pending; if (phdl == NULL) return (-1); if (phdl->status == PS_STOP && WSTOPSIG(phdl->wstat) != SIGTRAP) pending = WSTOPSIG(phdl->wstat); else pending = 0; if (ptrace(PT_CONTINUE, proc_getpid(phdl), (caddr_t)(uintptr_t)1, pending) != 0) return (-1); phdl->status = PS_RUN; return (0); } int proc_detach(struct proc_handle *phdl, int reason) { int status; pid_t pid; if (phdl == NULL) return (EINVAL); + if (reason == PRELEASE_HANG) + return (EINVAL); if (reason == PRELEASE_KILL) { kill(proc_getpid(phdl), SIGKILL); - return (0); + goto free; } + if ((phdl->flags & PATTACH_RDONLY) != 0) + goto free; pid = proc_getpid(phdl); if (ptrace(PT_DETACH, pid, 0, 0) != 0 && errno == ESRCH) - return (0); + goto free; if (errno == EBUSY) { kill(pid, SIGSTOP); waitpid(pid, &status, WUNTRACED); ptrace(PT_DETACH, pid, 0, 0); kill(pid, SIGCONT); - return (0); } - +free: + proc_free(phdl); return (0); } int proc_getflags(struct proc_handle *phdl) { if (phdl == NULL) return (-1); return (phdl->flags); } int proc_setflags(struct proc_handle *phdl, int mask) { if (phdl == NULL) return (EINVAL); phdl->flags |= mask; return (0); } int proc_state(struct proc_handle *phdl) { if (phdl == NULL) return (-1); return (phdl->status); } int proc_getmodel(struct proc_handle *phdl) { if (phdl == NULL) return (-1); return (phdl->model); } int proc_wstatus(struct proc_handle *phdl) { int status; if (phdl == NULL) return (-1); if (waitpid(proc_getpid(phdl), &status, WUNTRACED) < 0) { if (errno != EINTR) DPRINTF("waitpid"); return (-1); } if (WIFSTOPPED(status)) phdl->status = PS_STOP; if (WIFEXITED(status) || WIFSIGNALED(status)) phdl->status = PS_UNDEAD; phdl->wstat = status; return (phdl->status); } int proc_getwstat(struct proc_handle *phdl) { if (phdl == NULL) return (-1); return (phdl->wstat); } char * proc_signame(int sig, char *name, size_t namesz) { strlcpy(name, strsignal(sig), namesz); return (name); } int proc_read(struct proc_handle *phdl, void *buf, size_t size, size_t addr) { struct ptrace_io_desc piod; if (phdl == NULL) return (-1); piod.piod_op = PIOD_READ_D; piod.piod_len = size; piod.piod_addr = (void *)buf; piod.piod_offs = (void *)addr; if (ptrace(PT_IO, proc_getpid(phdl), (caddr_t)&piod, 0) < 0) return (-1); return (piod.piod_len); } const lwpstatus_t * proc_getlwpstatus(struct proc_handle *phdl) { struct ptrace_lwpinfo lwpinfo; lwpstatus_t *psp = &phdl->lwps; siginfo_t *siginfo; if (phdl == NULL) return (NULL); if (ptrace(PT_LWPINFO, proc_getpid(phdl), (caddr_t)&lwpinfo, sizeof(lwpinfo)) < 0) return (NULL); siginfo = &lwpinfo.pl_siginfo; if (lwpinfo.pl_event == PL_EVENT_SIGNAL && (lwpinfo.pl_flags & PL_FLAG_SI) != 0) { if (siginfo->si_signo == SIGTRAP && (siginfo->si_code == TRAP_BRKPT || siginfo->si_code == TRAP_TRACE)) { psp->pr_why = PR_FAULTED; psp->pr_what = FLTBPT; } else { psp->pr_why = PR_SIGNALLED; psp->pr_what = siginfo->si_signo; } } else if (lwpinfo.pl_flags & PL_FLAG_SCE) { psp->pr_why = PR_SYSENTRY; } else if (lwpinfo.pl_flags & PL_FLAG_SCX) { psp->pr_why = PR_SYSEXIT; } return (psp); }