1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 
  26 #pragma ident   "%Z%%M% %I%     %E% SMI"
  27 
  28 #include <stdarg.h>
  29 #include <string.h>
  30 #include "Pcontrol.h"
  31 
  32 /*
  33  * This file implements the process services declared in <proc_service.h>.
  34  * This enables libproc to be used in conjunction with libc_db and
  35  * librtld_db.  As most of these facilities are already provided by
  36  * (more elegant) interfaces in <libproc.h>, we can just call those.
  37  *
  38  * NOTE: We explicitly do *not* implement the functions ps_kill() and
  39  * ps_lrolltoaddr() in this library.  The very existence of these functions
  40  * causes libc_db to create an "agent thread" in the target process.
  41  * The only way to turn off this behavior is to omit these functions.
  42  */
  43 
  44 #pragma weak ps_pdread = ps_pread
  45 #pragma weak ps_ptread = ps_pread
  46 #pragma weak ps_pdwrite = ps_pwrite
  47 #pragma weak ps_ptwrite = ps_pwrite
  48 
  49 ps_err_e
  50 ps_pdmodel(struct ps_prochandle *P, int *modelp)
  51 {
  52         *modelp = P->status.pr_dmodel;
  53         return (PS_OK);
  54 }
  55 
  56 ps_err_e
  57 ps_pread(struct ps_prochandle *P, psaddr_t addr, void *buf, size_t size)
  58 {
  59         if (P->ops->p_pread(P, buf, size, addr) != size)
  60                 return (PS_BADADDR);
  61         return (PS_OK);
  62 }
  63 
  64 ps_err_e
  65 ps_pwrite(struct ps_prochandle *P, psaddr_t addr, const void *buf, size_t size)
  66 {
  67         if (P->ops->p_pwrite(P, buf, size, addr) != size)
  68                 return (PS_BADADDR);
  69         return (PS_OK);
  70 }
  71 
  72 /*
  73  * libc_db calls matched pairs of ps_pstop()/ps_pcontinue()
  74  * in the belief that the client may have left the process
  75  * running while calling in to the libc_db interfaces.
  76  *
  77  * We interpret the meaning of these functions to be an inquiry
  78  * as to whether the process is stopped, not an action to be
  79  * performed to make it stopped.  For similar reasons, we also
  80  * return PS_OK for core files in order to allow libc_db to
  81  * operate on these as well.
  82  */
  83 ps_err_e
  84 ps_pstop(struct ps_prochandle *P)
  85 {
  86         if (P->state != PS_STOP && P->state != PS_DEAD)
  87                 return (PS_ERR);
  88         return (PS_OK);
  89 }
  90 
  91 ps_err_e
  92 ps_pcontinue(struct ps_prochandle *P)
  93 {
  94         if (P->state != PS_STOP && P->state != PS_DEAD)
  95                 return (PS_ERR);
  96         return (PS_OK);
  97 }
  98 
  99 /*
 100  * ps_lstop() and ps_lcontinue() are not called by any code in libc_db
 101  * or librtld_db.  We make them behave like ps_pstop() and ps_pcontinue().
 102  */
 103 /* ARGSUSED1 */
 104 ps_err_e
 105 ps_lstop(struct ps_prochandle *P, lwpid_t lwpid)
 106 {
 107         if (P->state != PS_STOP && P->state != PS_DEAD)
 108                 return (PS_ERR);
 109         return (PS_OK);
 110 }
 111 
 112 /* ARGSUSED1 */
 113 ps_err_e
 114 ps_lcontinue(struct ps_prochandle *P, lwpid_t lwpid)
 115 {
 116         if (P->state != PS_STOP && P->state != PS_DEAD)
 117                 return (PS_ERR);
 118         return (PS_OK);
 119 }
 120 
 121 ps_err_e
 122 ps_lgetregs(struct ps_prochandle *P, lwpid_t lwpid, prgregset_t regs)
 123 {
 124         if (P->state != PS_STOP && P->state != PS_DEAD)
 125                 return (PS_ERR);
 126 
 127         if (Plwp_getregs(P, lwpid, regs) == 0)
 128                 return (PS_OK);
 129 
 130         return (PS_BADLID);
 131 }
 132 
 133 ps_err_e
 134 ps_lsetregs(struct ps_prochandle *P, lwpid_t lwpid, const prgregset_t regs)
 135 {
 136         if (P->state != PS_STOP)
 137                 return (PS_ERR);
 138 
 139         if (Plwp_setregs(P, lwpid, regs) == 0)
 140                 return (PS_OK);
 141 
 142         return (PS_BADLID);
 143 }
 144 
 145 ps_err_e
 146 ps_lgetfpregs(struct ps_prochandle *P, lwpid_t lwpid, prfpregset_t *regs)
 147 {
 148         if (P->state != PS_STOP && P->state != PS_DEAD)
 149                 return (PS_ERR);
 150 
 151         if (Plwp_getfpregs(P, lwpid, regs) == 0)
 152                 return (PS_OK);
 153 
 154         return (PS_BADLID);
 155 }
 156 
 157 ps_err_e
 158 ps_lsetfpregs(struct ps_prochandle *P, lwpid_t lwpid, const prfpregset_t *regs)
 159 {
 160         if (P->state != PS_STOP)
 161                 return (PS_ERR);
 162 
 163         if (Plwp_setfpregs(P, lwpid, regs) == 0)
 164                 return (PS_OK);
 165 
 166         return (PS_BADLID);
 167 }
 168 
 169 #if defined(sparc) || defined(__sparc)
 170 
 171 ps_err_e
 172 ps_lgetxregsize(struct ps_prochandle *P, lwpid_t lwpid, int *xrsize)
 173 {
 174         char fname[PATH_MAX];
 175         struct stat statb;
 176 
 177         if (P->state == PS_DEAD) {
 178                 lwp_info_t *lwp = list_next(&P->core->core_lwp_head);
 179                 uint_t i;
 180 
 181                 for (i = 0; i < P->core->core_nlwp; i++, lwp = list_next(lwp)) {
 182                         if (lwp->lwp_id == lwpid) {
 183                                 if (lwp->lwp_xregs != NULL)
 184                                         *xrsize = sizeof (prxregset_t);
 185                                 else
 186                                         *xrsize = 0;
 187                                 return (PS_OK);
 188                         }
 189                 }
 190 
 191                 return (PS_BADLID);
 192         }
 193 
 194         (void) snprintf(fname, sizeof (fname), "%s/%d/lwp/%d/xregs",
 195             procfs_path, (int)P->status.pr_pid, (int)lwpid);
 196 
 197         if (stat(fname, &statb) != 0)
 198                 return (PS_BADLID);
 199 
 200         *xrsize = (int)statb.st_size;
 201         return (PS_OK);
 202 }
 203 
 204 ps_err_e
 205 ps_lgetxregs(struct ps_prochandle *P, lwpid_t lwpid, caddr_t xregs)
 206 {
 207         if (P->state != PS_STOP && P->state != PS_DEAD)
 208                 return (PS_ERR);
 209 
 210         /* LINTED - alignment */
 211         if (Plwp_getxregs(P, lwpid, (prxregset_t *)xregs) == 0)
 212                 return (PS_OK);
 213 
 214         return (PS_BADLID);
 215 }
 216 
 217 ps_err_e
 218 ps_lsetxregs(struct ps_prochandle *P, lwpid_t lwpid, caddr_t xregs)
 219 {
 220         if (P->state != PS_STOP)
 221                 return (PS_ERR);
 222 
 223         /* LINTED - alignment */
 224         if (Plwp_setxregs(P, lwpid, (prxregset_t *)xregs) == 0)
 225                 return (PS_OK);
 226 
 227         return (PS_BADLID);
 228 }
 229 
 230 #endif  /* sparc */
 231 
 232 #if defined(__i386) || defined(__amd64)
 233 
 234 ps_err_e
 235 ps_lgetLDT(struct ps_prochandle *P, lwpid_t lwpid, struct ssd *ldt)
 236 {
 237 #if defined(__amd64) && defined(_LP64)
 238         if (P->status.pr_dmodel != PR_MODEL_NATIVE) {
 239 #endif
 240         prgregset_t regs;
 241         struct ssd *ldtarray;
 242         ps_err_e error;
 243         uint_t gs;
 244         int nldt;
 245         int i;
 246 
 247         if (P->state != PS_STOP && P->state != PS_DEAD)
 248                 return (PS_ERR);
 249 
 250         /*
 251          * We need to get the ldt entry that matches the
 252          * value in the lwp's GS register.
 253          */
 254         if ((error = ps_lgetregs(P, lwpid, regs)) != PS_OK)
 255                 return (error);
 256 
 257         gs = regs[GS];
 258 
 259         if ((nldt = Pldt(P, NULL, 0)) <= 0 ||
 260             (ldtarray = malloc(nldt * sizeof (struct ssd))) == NULL)
 261                 return (PS_ERR);
 262         if ((nldt = Pldt(P, ldtarray, nldt)) <= 0) {
 263                 free(ldtarray);
 264                 return (PS_ERR);
 265         }
 266 
 267         for (i = 0; i < nldt; i++) {
 268                 if (gs == ldtarray[i].sel) {
 269                         *ldt = ldtarray[i];
 270                         break;
 271                 }
 272         }
 273         free(ldtarray);
 274 
 275         if (i < nldt)
 276                 return (PS_OK);
 277 #if defined(__amd64) && defined(_LP64)
 278         }
 279 #endif
 280 
 281         return (PS_ERR);
 282 }
 283 
 284 #endif  /* __i386 || __amd64 */
 285 
 286 /*
 287  * Libthread_db doesn't use this function currently, but librtld_db uses
 288  * it for its debugging output.  We turn this on via rd_log if our debugging
 289  * switch is on, and then echo the messages sent to ps_plog to stderr.
 290  */
 291 void
 292 ps_plog(const char *fmt, ...)
 293 {
 294         va_list ap;
 295 
 296         if (_libproc_debug && fmt != NULL && *fmt != '\0') {
 297                 va_start(ap, fmt);
 298                 (void) vfprintf(stderr, fmt, ap);
 299                 va_end(ap);
 300                 if (fmt[strlen(fmt) - 1] != '\n')
 301                         (void) fputc('\n', stderr);
 302         }
 303 }
 304 
 305 /*
 306  * Store a pointer to our internal copy of the aux vector at the address
 307  * specified by the caller.  It should not hold on to this data for too long.
 308  */
 309 ps_err_e
 310 ps_pauxv(struct ps_prochandle *P, const auxv_t **aux)
 311 {
 312         if (P->auxv == NULL)
 313                 Preadauxvec(P);
 314 
 315         if (P->auxv == NULL)
 316                 return (PS_ERR);
 317 
 318         *aux = (const auxv_t *)P->auxv;
 319         return (PS_OK);
 320 }
 321 
 322 ps_err_e
 323 ps_pbrandname(struct ps_prochandle *P, char *buf, size_t len)
 324 {
 325         return (Pbrandname(P, buf, len) ? PS_OK : PS_ERR);
 326 }
 327 
 328 /*
 329  * Search for a symbol by name and return the corresponding address.
 330  */
 331 ps_err_e
 332 ps_pglobal_lookup(struct ps_prochandle *P, const char *object_name,
 333         const char *sym_name, psaddr_t *sym_addr)
 334 {
 335         GElf_Sym sym;
 336 
 337         if (Plookup_by_name(P, object_name, sym_name, &sym) == 0) {
 338                 dprintf("pglobal_lookup <%s> -> %p\n",
 339                     sym_name, (void *)(uintptr_t)sym.st_value);
 340                 *sym_addr = (psaddr_t)sym.st_value;
 341                 return (PS_OK);
 342         }
 343 
 344         return (PS_NOSYM);
 345 }
 346 
 347 /*
 348  * Search for a symbol by name and return the corresponding symbol
 349  * information.  If we're compiled _LP64, we just call Plookup_by_name
 350  * and return because ps_sym_t is defined to be an Elf64_Sym, which
 351  * is the same as a GElf_Sym.  In the _ILP32 case, we have to convert
 352  * Plookup_by_name's result back to a ps_sym_t (which is an Elf32_Sym).
 353  */
 354 ps_err_e
 355 ps_pglobal_sym(struct ps_prochandle *P, const char *object_name,
 356         const char *sym_name, ps_sym_t *symp)
 357 {
 358 #if defined(_ILP32)
 359         GElf_Sym sym;
 360 
 361         if (Plookup_by_name(P, object_name, sym_name, &sym) == 0) {
 362                 symp->st_name = (Elf32_Word)sym.st_name;
 363                 symp->st_value = (Elf32_Addr)sym.st_value;
 364                 symp->st_size = (Elf32_Word)sym.st_size;
 365                 symp->st_info = ELF32_ST_INFO(
 366                     GELF_ST_BIND(sym.st_info), GELF_ST_TYPE(sym.st_info));
 367                 symp->st_other = sym.st_other;
 368                 symp->st_shndx = sym.st_shndx;
 369                 return (PS_OK);
 370         }
 371 
 372 #elif defined(_LP64)
 373         if (Plookup_by_name(P, object_name, sym_name, symp) == 0)
 374                 return (PS_OK);
 375 #endif
 376         return (PS_NOSYM);
 377 }