/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright (c) 1992, 2010, Oracle and/or its affiliates. All rights reserved. */ /* * Routines to provide profiling of shared libraries required by the called * executable. */ #include <stdio.h> #include <fcntl.h> #include <sys/mman.h> #include <unistd.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <sys/stat.h> #include <synch.h> #include <signal.h> #include <synch.h> #include <link.h> #include <libintl.h> #include <sys/param.h> #include <procfs.h> #include "msg.h" #include "sgs.h" #include "profile.h" #include "_rtld.h" static char Profile[MAXPATHLEN]; /* Profile buffer pathname */ static char *pname = 0; /* name of object to profile */ static L_hdr *Hptr; /* profile buffer header pointer */ static L_cgarc *Cptr; /* profile buffer call graph pointer */ static caddr_t Hpc, Lpc; /* Range of addresses being monitored */ static size_t Fsize; /* Size of mapped in profile buffer */ uintptr_t profcookie = 0; /* * When handling mutex's locally we need to mask signals. The signal * mask is for everything except SIGWAITING. */ static const sigset_t iset = { ~0U, ~0U, ~0U, ~0U }; static lwp_mutex_t sharedmutex = SHAREDMUTEX; static int prof_mutex_init(lwp_mutex_t *mp) { (void) memcpy(mp, &sharedmutex, sizeof (lwp_mutex_t)); return (0); } static int prof_mutex_lock(lwp_mutex_t *mp, sigset_t *oset) { if (oset) (void) sigprocmask(SIG_BLOCK, &iset, oset); (void) _lwp_mutex_lock(mp); return (0); } static int prof_mutex_unlock(mutex_t *mp, sigset_t *oset) { (void) _lwp_mutex_unlock(mp); if (oset) (void) sigprocmask(SIG_SETMASK, oset, NULL); return (0); } const char * _ldprof_msg(Msg mid) { return (dgettext(MSG_ORIG(MSG_SUNW_OST_SGS), MSG_ORIG(mid))); } /* * Determine whether a set (of arbitrary size) is in use - used to analyze proc * status information. */ static int setisinuse(uint32_t *sp, uint_t n) { while (n--) if (*sp++) return (1); return (0); } #define prisinuse(sp) \ setisinuse((uint32_t *)(sp), \ (uint_t)(sizeof (*(sp)) / sizeof (uint32_t))) uint_t la_version(uint_t version) { int fd; ssize_t num; pstatus_t status; if (version < LAV_CURRENT) { (void) fprintf(stderr, MSG_INTL(MSG_GEN_AUDITVERSION), LAV_CURRENT, version); return (LAV_CURRENT); } /* * To reduce the potential for deadlock conditions that can arise from * being monitored (say by truss(1)) while setting a lock in the profile * buffer, determine if someone is monitoring us. If so silently * disable profiling. */ if ((fd = open(MSG_ORIG(MSG_FMT_PROCSELF), O_RDONLY)) < 0) return (LAV_CURRENT); num = read(fd, &status, sizeof (status)); (void) close(fd); if ((num != sizeof (status)) || prisinuse(&status.pr_sigtrace) || prisinuse(&status.pr_flttrace) || prisinuse(&status.pr_sysentry) || prisinuse(&status.pr_sysexit)) { return (LAV_CURRENT); } /* * We're presently not being monitored (although there's no control of * someone attaching to us later), so retrieve the profile target name. */ if (dlinfo((void *)NULL, RTLD_DI_PROFILENAME, &pname) == -1) (void) fprintf(stderr, MSG_INTL(MSG_GEN_PROFNOTSET)); return (LAV_CURRENT); } int profile_open(const char *fname, Link_map *lmp) { size_t hsize; /* struct hdr size */ size_t psize; /* profile histogram size */ size_t csize; /* call graph array size */ size_t msize; /* size of memory being profiled */ int i, fd, fixed = 0; caddr_t lpc; caddr_t hpc; caddr_t addr; struct stat status; int new_buffer = 0; sigset_t mask; int err; Ehdr * ehdr; /* ELF header for file */ Phdr * phdr; /* program headers for file */ Dyn * dynp = 0; /* Dynamic section */ Word nsym = 0; /* no. of symtab ntries */ if (*Profile == '\0') { const char *dir, *suf; char *tmp; /* * From the basename of the specified filename generate the * appropriate profile buffer name. The profile file is created * if it does not already exist. */ if (((tmp = strrchr(fname, '/')) != 0) && (*(++tmp))) fname = tmp; #if defined(_ELF64) suf = MSG_ORIG(MSG_SUF_PROFILE_64); #else suf = MSG_ORIG(MSG_SUF_PROFILE); #endif if (dlinfo((void *)NULL, RTLD_DI_PROFILEOUT, &dir) == -1) dir = MSG_ORIG(MSG_PTH_VARTMP); (void) snprintf(Profile, MAXPATHLEN, MSG_ORIG(MSG_FMT_PROFILE), dir, fname, suf); } if ((fd = open(Profile, (O_RDWR | O_CREAT), 0666)) == -1) { err = errno; (void) fprintf(stderr, MSG_INTL(MSG_SYS_OPEN), Profile, strerror(err)); return (0); } /* * Now we determine the valid pc range for this object. The lpc is easy * (lmp->l_addr), to determine the hpc we must examine the Phdrs. */ lpc = hpc = (caddr_t)lmp->l_addr; /* LINTED */ ehdr = (Ehdr *)lpc; if (ehdr->e_phnum == 0) { (void) close(fd); return (0); } if (ehdr->e_type == ET_EXEC) fixed = 1; /* LINTED */ phdr = (Phdr *)(ehdr->e_phoff + lpc); for (i = 0; i < ehdr->e_phnum; i++, phdr++) { caddr_t _hpc; if (phdr->p_type == PT_DYNAMIC) { dynp = (Dyn *)phdr->p_vaddr; if (fixed == 0) { dynp = (Dyn *)((unsigned long)dynp + (unsigned long)lpc); } continue; } if (phdr->p_type != PT_LOAD) continue; _hpc = (caddr_t)(phdr->p_vaddr + phdr->p_memsz); if (fixed == 0) { _hpc = (caddr_t)((unsigned long)_hpc + (unsigned long)lpc); } if (_hpc > hpc) hpc = _hpc; } if (lpc == hpc) { (void) close(fd); return (0); } /* * In order to determine the number of symbols in the object scan the * dynamic section until we find the DT_HASH entry (hash[1] == symcnt). */ if (dynp) { for (; dynp->d_tag != DT_NULL; dynp++) { unsigned int *hashp; if (dynp->d_tag != DT_HASH) continue; hashp = (unsigned int *)dynp->d_un.d_ptr; if (fixed == 0) { hashp = (unsigned int *)((unsigned long)hashp + (unsigned long)lpc); } nsym = hashp[1]; break; } } /* * Determine the (minimum) size of the buffer to allocate */ Lpc = lpc = (caddr_t)PRF_ROUNDWN((long)lpc, sizeof (long)); Hpc = hpc = (caddr_t)PRF_ROUNDUP((long)hpc, sizeof (long)); hsize = sizeof (L_hdr); msize = (size_t)(hpc - lpc); psize = (size_t)PRF_ROUNDUP((msize / PRF_BARSIZE), sizeof (long)); csize = (nsym + 1) * PRF_CGINIT * sizeof (L_cgarc); Fsize = (hsize + psize + csize); /* * If the file size is zero (ie. we just created it), truncate it * to the minimum size. */ (void) fstat(fd, &status); if (status.st_size == 0) { if (ftruncate(fd, Fsize) == -1) { err = errno; (void) fprintf(stderr, MSG_INTL(MSG_SYS_FTRUNC), Profile, strerror(err)); (void) close(fd); return (0); } new_buffer++; } else Fsize = status.st_size; /* * Map the file in. */ if ((addr = (caddr_t)mmap(0, Fsize, (PROT_READ | PROT_WRITE), MAP_SHARED, fd, 0)) == (char *)-1) { err = errno; (void) fprintf(stderr, MSG_INTL(MSG_SYS_MMAP), Profile, strerror(err)); (void) close(fd); return (0); } (void) close(fd); /* * Initialize the remaining elements of the header. All pc addresses * that are recorded are relative to zero thus allowing the recorded * entries to be correlated with the symbols in the original file, * and to compensate for any differences in where the file is mapped. * If the high pc address has been initialized from a previous run, * and the new entry is different from the original then a new library * must have been installed. In this case bale out. */ /* LINTED */ Hptr = (L_hdr *)addr; if (new_buffer) (void) prof_mutex_init((lwp_mutex_t *)&Hptr->hd_mutex); (void) prof_mutex_lock((mutex_t *)&Hptr->hd_mutex, &mask); if (Hptr->hd_hpc) { if (Hptr->hd_hpc != (caddr_t)(hpc - lpc)) { (void) fprintf(stderr, MSG_INTL(MSG_GEN_PROFSZCHG), Profile); (void) prof_mutex_unlock((mutex_t *)&Hptr-> hd_mutex, &mask); (void) munmap((caddr_t)Hptr, Fsize); return (0); } } else { /* * Initialize the header information as we must have just * created the output file. */ Hptr->hd_magic = (unsigned int)PRF_MAGIC; #if defined(_ELF64) Hptr->hd_version = (unsigned int)PRF_VERSION_64; #else Hptr->hd_version = (unsigned int)PRF_VERSION; #endif Hptr->hd_hpc = (caddr_t)(hpc - lpc); /* LINTED */ Hptr->hd_psize = (unsigned int)psize; /* LINTED */ Hptr->hd_fsize = (unsigned int)Fsize; Hptr->hd_ncndx = nsym; Hptr->hd_lcndx = (nsym + 1) * PRF_CGINIT; } (void) prof_mutex_unlock((mutex_t *)&Hptr->hd_mutex, &mask); /* LINTED */ Cptr = (L_cgarc *)(addr + hsize + psize); /* * Turn on profiling */ /* LINTED */ profil((unsigned short *)(addr + hsize), psize, (unsigned long)lpc, (unsigned int) PRF_SCALE); return (1); } uint_t /* ARGSUSED1 */ la_objopen(Link_map *lmp, Lmid_t lmid, uintptr_t *cookie) { char *objname; /* * This would only occur if the getenv() in la_version() failed. * at this point there is nothing for us to do. */ if (pname == 0) return (0); /* * Just grab the 'basename' of the object current object for * comparing against the 'profiled object name' */ if (((objname = strrchr(lmp->l_name, '/')) == 0) || (*(++objname) == 0)) objname = lmp->l_name; /* * Is this the object we are going to profile. If not * just set the 'BINDFROM' flag for this object. */ if ((strcmp(pname, objname) != 0) && (strcmp(pname, lmp->l_name) != 0)) return (LA_FLG_BINDFROM); /* * Don't even try to profile an object that does not have * auditing enabled on it's link-map. This catches 'ld.so.1'. */ if (LIST(LINKMAP_TO_RTMAP(lmp))->lm_tflags & LML_TFLG_NOAUDIT) return (LA_FLG_BINDFROM); if (profile_open(pname, lmp) == 0) return (0); profcookie = *cookie; return (LA_FLG_BINDFROM | LA_FLG_BINDTO); } uint_t la_objclose(uintptr_t *cookie) { if (*cookie != profcookie) return (0); profcookie = 0; /* * Turn profil() off. */ profil(0, 0, 0, 0); (void) munmap((caddr_t)Hptr, Fsize); return (0); } static int remap_profile(int fd) { caddr_t addr; size_t l_fsize; l_fsize = Hptr->hd_fsize; if ((addr = (caddr_t)mmap(0, l_fsize, (PROT_READ | PROT_WRITE), MAP_SHARED, fd, 0)) == (char *)-1) { int err = errno; (void) fprintf(stderr, MSG_INTL(MSG_SYS_MMAP), Profile, strerror(err)); return (0); } (void) munmap((caddr_t)Hptr, Fsize); Fsize = l_fsize; /* LINTED */ Hptr = (L_hdr*) addr; /* LINTED */ Cptr = (L_cgarc *)(addr + sizeof (L_hdr) + Hptr->hd_psize); return (1); } /* * Update a call graph arc entry. This routine can be called three ways; * o On initialization from one of the bndr() functions. * In this case the `to' address is known, and may be used to * initialize the call graph entry if this function has not * been entered before. * o On initial relocation (ie. LD_BIND_NOW). In this case the `to' * address is known but the `from' isn't. The call graph entry * is initialized to hold this dummy `to' address, but will be * re-initialized later when a function is first called. * o From an initialized plt entry. When profiling, the plt entries * are filled in with the calling functions symbol index and * the plt_cg_elf interface function. This interface function * calls here to determine the `to' functions address, and in so * doing increments the call count. */ uintptr_t plt_cg_interp(uint_t ndx, caddr_t from, caddr_t to) { L_cgarc * cptr, cbucket; sigset_t mask; /* * If the from address is outside of the address range being profiled, * simply assign it to the `outside' address. */ if (from != PRF_UNKNOWN) { if ((from > Hpc) || (from < Lpc)) from = PRF_OUTADDR; else from = (caddr_t)(from - Lpc); } (void) prof_mutex_lock((mutex_t *)&Hptr->hd_mutex, &mask); /* * Has the buffer grown since last we looked at it (another processes * could have grown it...). */ /* LINTED */ if (Hptr->hd_fsize != (unsigned int)Fsize) { int fd; fd = open(Profile, O_RDWR, 0); if (remap_profile(fd) == 0) { (void) prof_mutex_unlock((mutex_t *)&Hptr->hd_mutex, &mask); exit(1); } (void) close(fd); } cptr = &Cptr[ndx]; if (cptr->cg_to == 0) { /* * If this is the first time this function has been called we * got here from one of the binders or an initial relocation * (ie. LD_BIND_NOW). In this case the `to' address is * provided. Initialize this functions call graph entry with * the functions address (retained as a relative offset). * If we know where the function call originated from * initialize the count field. */ cptr->cg_to = (caddr_t)(to - Lpc); cptr->cg_from = from; if (from != PRF_UNKNOWN) cptr->cg_count = 1; } else { /* * If a function has been called from a previous run, but we * don't know where we came from (ie. LD_BIND_NOW), then later * calls through the plt will be able to obtain the required * functions address, thus there is no need to proceed further. */ if (from != PRF_UNKNOWN) { /* * If the from addresses match simply bump the count. * If not scan the link list to find a match for this * `from' address. If one doesn't exit create a new * entry and link it in. */ while ((cptr->cg_from != from) && (cptr->cg_from != PRF_UNKNOWN)) { if (cptr->cg_next != 0) cptr = &Cptr[cptr->cg_next]; else { to = cptr->cg_to; cptr->cg_next = Hptr->hd_ncndx++; cptr = &Cptr[cptr->cg_next]; /* * If we've run out of file, extend it. */ if (Hptr->hd_ncndx == Hptr->hd_lcndx) { caddr_t addr; int fd; /* LINTED */ Hptr->hd_fsize += (unsigned int) PRF_CGNUMB * sizeof (L_cgarc); fd = open(Profile, O_RDWR, 0); if (ftruncate(fd, Hptr->hd_fsize) == -1) { int err = errno; (void) fprintf(stderr, MSG_INTL( MSG_SYS_FTRUNC), Profile, strerror(err)); (void) close(fd); cptr = &cbucket; } /* * Since the buffer will be * remapped, we need to be * prepared to adjust cptr. */ addr = (caddr_t)((Addr)cptr - (Addr)Cptr); if (remap_profile(fd) == 0) { /* CSTYLED */ (void) prof_mutex_unlock( (mutex_t *)&Hptr-> hd_mutex, &mask); exit(1); } cptr = (L_cgarc *)((Addr)addr + (Addr)Cptr); (void) close(fd); Hptr->hd_lcndx += PRF_CGNUMB; } cptr->cg_from = from; cptr->cg_to = to; } } /* * If we're updating an entry from an unknown call * address initialize this element, otherwise * increment the call count. */ if (cptr->cg_from == PRF_UNKNOWN) { cptr->cg_from = from; cptr->cg_count = 1; } else cptr->cg_count++; } } /* * Return the real address of the function. */ (void) prof_mutex_unlock((mutex_t *)&Hptr->hd_mutex, &mask); return ((uintptr_t)((Addr)cptr->cg_to + (Addr)Lpc)); } /* ARGSUSED2 */ #if defined(__sparcv9) uintptr_t la_sparcv9_pltenter(Elf64_Sym *symp, uint_t symndx, uintptr_t *refcookie, uintptr_t *defcookie, La_sparcv9_regs *regset, uint_t *sbflags, const char *sym_name) #elif defined(__sparc) uintptr_t la_sparcv8_pltenter(Elf32_Sym *symp, uint_t symndx, uintptr_t *refcookie, uintptr_t *defcookie, La_sparcv8_regs *regset, uint_t *sbflags) #elif defined(__amd64) uintptr_t la_amd64_pltenter(Elf64_Sym *symp, uint_t symndx, uintptr_t *refcookie, uintptr_t *defcookie, La_amd64_regs *regset, uint_t *sbflags, const char *sym_name) #elif defined(__i386) uintptr_t la_i86_pltenter(Elf32_Sym *symp, uint_t symndx, uintptr_t *refcookie, uintptr_t *defcookie, La_i86_regs *regset, uint_t *sbflags) #else #error unexpected architecture! #endif { caddr_t from; /* * profiling has been disabled. */ if (profcookie == 0) return (symp->st_value); #if defined(__sparc) /* * The callers return address is currently stored in O7 (which * will become I7 when the window shift occurs). */ from = (caddr_t)regset->lr_rego7; #elif defined(__amd64) /* * The callers return address is on the top of the stack for amd64 */ from = *(caddr_t *)(regset->lr_rsp); #elif defined(__i386) /* * The callers return address is on the top of the stack for i386 */ from = *(caddr_t *)(regset->lr_esp); #else #error unexpected architecture! #endif return (plt_cg_interp(symndx, (caddr_t)from, (caddr_t)symp->st_value)); }