diff options
Diffstat (limited to 'gprofng/libcollector/mmaptrace.c')
| -rw-r--r-- | gprofng/libcollector/mmaptrace.c | 1691 |
1 files changed, 1691 insertions, 0 deletions
diff --git a/gprofng/libcollector/mmaptrace.c b/gprofng/libcollector/mmaptrace.c new file mode 100644 index 0000000..ac5c997 --- /dev/null +++ b/gprofng/libcollector/mmaptrace.c @@ -0,0 +1,1691 @@ +/* Copyright (C) 2021 Free Software Foundation, Inc. + Contributed by Oracle. + + This file is part of GNU Binutils. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, 51 Franklin Street - Fifth Floor, Boston, + MA 02110-1301, USA. */ + +/* + * memory map tracking + * incorporating former "loadobjects" into more general "map" + * (including code and data segments and dynamic functions) + */ + +#include "config.h" +#include <alloca.h> +#include <dlfcn.h> +#include <errno.h> +#include <fcntl.h> +#include <elf.h> +#include <sys/mman.h> +#include <sys/param.h> +#include <stdint.h> + +#include "gp-defs.h" +#include "collector.h" +#include "gp-experiment.h" +#include "memmgr.h" + +/* + * These are obsolete and unreliable. + * They are included here only for historical compatibility. + */ +#define MA_SHARED 0x08 /* changes are shared by mapped object */ +#define MA_ANON 0x40 /* anonymous memory (e.g. /dev/zero) */ +#define MA_ISM 0x80 /* intimate shared mem (shared MMU resources) */ +#define MA_BREAK 0x10 /* grown by brk(2) */ +#define MA_STACK 0x20 /* grown automatically on stack faults */ + +typedef struct prmap_t +{ + unsigned long pr_vaddr; /* virtual address of mapping */ + unsigned long pr_size; /* size of mapping in bytes */ + char *pr_mapname; /* name in /proc/<pid>/object */ + int pr_mflags; /* protection and attribute flags (see below) */ + unsigned long pr_offset; /* offset into mapped object, if any */ + unsigned long pr_dev; + unsigned long pr_ino; + int pr_pagesize; /* pagesize (bytes) for this mapping */ +} prmap_t; + +/* TprintfT(<level>,...) definitions. Adjust per module as needed */ +#define DBG_LT0 0 // for high-level configuration, unexpected errors/warnings +#define DBG_LT1 1 // for configuration details, warnings +#define DBG_LT2 2 +#define DBG_LT3 3 +#define DBG_LT4 4 + +#define SYS_MMAP_NAME "mmap" +#define SYS_MMAP64_NAME "mmap64" +#define SYS_MUNMAP_NAME "munmap" +#define SYS_DLOPEN_NAME "dlopen" +#define SYS_DLCLOSE_NAME "dlclose" + +typedef struct MapInfo +{ + struct MapInfo *next; + unsigned long vaddr; + unsigned long size; + char *mapname; /* name in /proc/<pid>/object */ + char *filename; + unsigned long offset; + int mflags; + int pagesize; +} MapInfo; + +typedef struct NameInfo +{ + struct NameInfo *next; + char *mapname; + char filename[1]; /* dynamic length file name */ +} NameInfo; + +static NameInfo *namemaps = NULL; +static MapInfo mmaps; /* current memory maps */ +static struct DataHandle *map_hndl = NULL; +static char dyntext_fname[MAXPATHLEN]; +static void *mapcache = NULL; +static char *maptext = NULL; +static size_t maptext_sz = 4096; /* initial buffer size */ +static int mmap_mode = 0; +static int mmap_initted = 0; +static collector_mutex_t map_lock = COLLECTOR_MUTEX_INITIALIZER; +static collector_mutex_t dyntext_lock = COLLECTOR_MUTEX_INITIALIZER; + +/* a reentrance guard for the interposition functions ensures that updates to + the map cache/file are sequential, with the first doing the final update */ +static int reentrance = 0; +#define CHCK_REENTRANCE (reentrance || mmap_mode <= 0) +#define CURR_REENTRANCE reentrance +#define PUSH_REENTRANCE reentrance++ +#define POP_REENTRANCE reentrance-- + +#define CALL_REAL(x) (__real_##x) +#define NULL_PTR(x) (__real_##x == NULL) + +/* interposition function handles */ +static void *(*__real_mmap)(void* start, size_t length, int prot, int flags, + int fd, off_t offset) = NULL; +static void *(*__real_mmap64)(void* start, size_t length, int prot, int flags, + int fd, off64_t offset) = NULL; +static int (*__real_munmap)(void* start, size_t length) = NULL; +static void *(*__real_dlopen)(const char* pathname, int mode) = NULL; +#if (ARCH(Intel) && WSIZE(32)) || ARCH(SPARC) +static void *(*__real_dlopen_2_1)(const char* pathname, int mode) = NULL; +static void *(*__real_dlopen_2_0)(const char* pathname, int mode) = NULL; +#endif +static int (*__real_dlclose)(void* handle) = NULL; +static void (*collector_heap_record)(int, size_t, void*) = NULL; + +/* internal function prototypes */ +static int init_mmap_intf (); +static int init_mmap_files (); +static void append_segment_record (char *format, ...); +static void update_map_segments (hrtime_t hrt, int resolve); +static void resolve_mapname (MapInfo *map, char *name); +static void record_segment_map (hrtime_t timestamp, uint64_t loadaddr, + unsigned long msize, int pagesize, int modeflags, + long long offset, unsigned check, char *name); +static void record_segment_unmap (hrtime_t timestamp, uint64_t loadaddr); + +/* Linux needs handling of the vsyscall page to get its data into the map.xml file */ +static void process_vsyscall_page (); + +#define MAXVSYSFUNCS 10 +static int nvsysfuncs = 0; +static char *sysfuncname[MAXVSYSFUNCS]; +static uint64_t sysfuncvaddr[MAXVSYSFUNCS]; +static unsigned long sysfuncsize[MAXVSYSFUNCS]; + +#define MAXDYN 20 +static int ndyn = 0; +static char *dynname [MAXDYN]; +static void *dynvaddr [MAXDYN]; +static unsigned dynsize [MAXDYN]; +static char *dynfuncname[MAXDYN]; + +/*===================================================================*/ + +/* + * void __collector_mmap_init_mutex_locks() + * Iinitialize mmap mutex locks. + */ +void +__collector_mmap_init_mutex_locks () +{ + __collector_mutex_init (&map_lock); + __collector_mutex_init (&dyntext_lock); +} + +/* __collector_ext_update_map_segments called by the audit agent + * Is is also called by dbx/collector when a (possible) map update + * is intimated, such as after dlopen/dlclose. + * Required when libcollector.so is not preloaded and interpositions inactive. + */ +int +__collector_ext_update_map_segments (void) +{ + if (!mmap_initted) + return 0; + TprintfT (0, "__collector_ext_update_map_segments(%d)\n", CURR_REENTRANCE); + if (CHCK_REENTRANCE) + return 0; + PUSH_REENTRANCE; + update_map_segments (GETRELTIME (), 1); + POP_REENTRANCE; + return 0; +} +/* + * int __collector_ext_mmap_install() + * Install and initialise mmap tracing. + */ +int +__collector_ext_mmap_install (int record) +{ + TprintfT (0, "__collector_ext_mmap_install(mmap_mode=%d)\n", mmap_mode); + if (NULL_PTR (mmap)) + { + if (init_mmap_intf ()) + { + TprintfT (0, "ERROR: collector mmap tracing initialization failed.\n"); + return COL_ERROR_EXPOPEN; + } + } + else + TprintfT (DBG_LT2, "collector mmap tracing: mmap pointer not null\n"); + + /* Initialize side door interface with the heap tracing module */ + collector_heap_record = (void(*)(int, size_t, void*))dlsym (RTLD_DEFAULT, "__collector_heap_record"); + if (record) + { + map_hndl = __collector_create_handle (SP_MAP_FILE); + if (map_hndl == NULL) + return COL_ERROR_MAPOPEN; + if (init_mmap_files ()) + { + TprintfT (0, "ERROR: collector init_mmap_files() failed.\n"); + return COL_ERROR_EXPOPEN; + } + } + mmaps.next = NULL; + mapcache = NULL; + PUSH_REENTRANCE; + update_map_segments (GETRELTIME (), 1); // initial map + POP_REENTRANCE; + mmap_mode = 1; + mmap_initted = 1; + process_vsyscall_page (); + return COL_ERROR_NONE; +} + +/* + * int __collector_ext_mmap_deinstall() + * Optionally update final map and stop tracing mmap events. + */ +int +__collector_ext_mmap_deinstall (int update) +{ + if (!mmap_initted) + return COL_ERROR_NONE; + mmap_mode = 0; + if (update) + { + /* Final map */ + PUSH_REENTRANCE; + update_map_segments (GETRELTIME (), 1); + POP_REENTRANCE; + } + TprintfT (0, "__collector_ext_mmap_deinstall(%d)\n", update); + if (map_hndl != NULL) + { + __collector_delete_handle (map_hndl); + map_hndl = NULL; + } + __collector_mutex_lock (&map_lock); // get lock before resetting + + /* Free all memory maps */ + MapInfo *mp; + for (mp = mmaps.next; mp;) + { + MapInfo *next = mp->next; + __collector_freeCSize (__collector_heap, mp, sizeof (*mp)); + mp = next; + } + mmaps.next = NULL; + + /* Free all name maps */ + NameInfo *np; + for (np = namemaps; np;) + { + NameInfo *next = np->next; + __collector_freeCSize (__collector_heap, np, sizeof (*np) + __collector_strlen (np->filename)); + np = next; + } + namemaps = NULL; + mapcache = __collector_reallocVSize (__collector_heap, mapcache, 0); + mmaps.next = NULL; + mapcache = NULL; + __collector_mutex_unlock (&map_lock); + TprintfT (0, "__collector_ext_mmap_deinstall done\n"); + return 0; +} + +/* + * void __collector_mmap_fork_child_cleanup() + * Perform all necessary cleanup steps in child process after fork(). + */ +void +__collector_mmap_fork_child_cleanup () +{ + /* Initialize all mmap "mutex" locks */ + __collector_mmap_init_mutex_locks (); + if (!mmap_initted) + return; + mmap_mode = 0; + __collector_delete_handle (map_hndl); + __collector_mutex_lock (&map_lock); // get lock before resetting + + /* Free all memory maps */ + MapInfo *mp; + for (mp = mmaps.next; mp;) + { + MapInfo *next = mp->next; + __collector_freeCSize (__collector_heap, mp, sizeof (*mp)); + mp = next; + } + mmaps.next = NULL; + + /* Free all name maps */ + NameInfo *np; + for (np = namemaps; np;) + { + NameInfo *next = np->next; + __collector_freeCSize (__collector_heap, np, sizeof (*np) + __collector_strlen (np->filename)); + np = next; + } + namemaps = NULL; + mapcache = __collector_reallocVSize (__collector_heap, mapcache, 0); + mmap_initted = 0; + reentrance = 0; + __collector_mutex_unlock (&map_lock); +} + +static int +init_mmap_files () +{ + TprintfT (DBG_LT2, "init_mmap_files\n"); + /* also create the headerless dyntext file (if required) */ + CALL_UTIL (snprintf)(dyntext_fname, sizeof (dyntext_fname), "%s/%s", + __collector_exp_dir_name, SP_DYNTEXT_FILE); + if (CALL_UTIL (access)(dyntext_fname, F_OK) != 0) + { + int fd = CALL_UTIL (open)(dyntext_fname, O_RDWR | O_CREAT | O_TRUNC, + S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); + if (fd == -1) + { + char errmsg[256]; + TprintfT (0, "ERROR: init_mmap_files: open(%s) failed\n", + dyntext_fname); + __collector_log_write ("<event kind=\"%s\" id=\"%d\" ec=\"%d\">%s: %s</event>\n", + SP_JCMD_CERROR, COL_ERROR_DYNOPEN, errno, + dyntext_fname, errmsg); + return COL_ERROR_DYNOPEN; + } + else + CALL_UTIL (close)(fd); + } + return COL_ERROR_NONE; +} + +static void +append_segment_record (char *format, ...) +{ + char buf[1024]; + char *bufptr = buf; + va_list va; + va_start (va, format); + int sz = __collector_xml_vsnprintf (bufptr, sizeof (buf), format, va); + va_end (va); + + if (__collector_expstate != EXP_OPEN && __collector_expstate != EXP_PAUSED) + { + TprintfT (0, "append_segment_record: expt neither open nor paused (%d); " + "not writing to map.xml\n\t%s", __collector_expstate, buf); + return; + } + if (sz >= sizeof (buf)) + { + /* Allocate a new buffer */ + sz += 1; /* add the terminating null byte */ + bufptr = (char*) alloca (sz); + va_start (va, format); + sz = __collector_xml_vsnprintf (bufptr, sz, format, va); + va_end (va); + } + int rc = __collector_write_string (map_hndl, bufptr, sz); + if (rc != 0) + (void) __collector_log_write ("<event kind=\"%s\" id=\"%d\"></event>\n", + SP_JCMD_CERROR, COL_ERROR_MAPWRITE); +} + +static void +record_segment_map (hrtime_t timestamp, uint64_t loadaddr, unsigned long msize, + int pagesize, int modeflags, long long offset, + unsigned check, char *name) +{ + + TprintfT (DBG_LT2, "record_segment_map(%s @ 0x%llx)\n", name, (long long) loadaddr); + append_segment_record ("<event kind=\"map\" object=\"segment\" tstamp=\"%u.%09u\" " + "vaddr=\"0x%016llX\" size=\"%lu\" pagesz=\"%d\" foffset=\"%c0x%08llX\" " + "modes=\"0x%03X\" chksum=\"0x%0X\" name=\"%s\"/>\n", + (unsigned) (timestamp / NANOSEC), + (unsigned) (timestamp % NANOSEC), + loadaddr, msize, pagesize, + offset < 0 ? '-' : '+', offset < 0 ? -offset : offset, + modeflags, check, name); +} + +static void +record_segment_unmap (hrtime_t timestamp, uint64_t loadaddr) +{ + TprintfT (DBG_LT2, "record_segment_unmap(@ 0x%llx)\n", (long long) loadaddr); + append_segment_record ("<event kind=\"unmap\" tstamp=\"%u.%09u\" vaddr=\"0x%016llX\"/>\n", + (unsigned) (timestamp / NANOSEC), + (unsigned) (timestamp % NANOSEC), loadaddr); +} + +#if WSIZE(64) +#define ELF_EHDR Elf64_Ehdr +#define ELF_PHDR Elf64_Phdr +#define ELF_SHDR Elf64_Shdr +#define ELF_DYN Elf64_Dyn +#define ELF_AUX Elf64_auxv_t +#define ELF_SYM Elf64_Sym +#define ELF_ST_BIND ELF64_ST_BIND +#define ELF_ST_TYPE ELF64_ST_TYPE +#elif WSIZE(32) +#define ELF_EHDR Elf32_Ehdr +#define ELF_PHDR Elf32_Phdr +#define ELF_SHDR Elf32_Shdr +#define ELF_DYN Elf32_Dyn +#define ELF_AUX Elf32_auxv_t +#define ELF_SYM Elf32_Sym +#define ELF_ST_BIND ELF32_ST_BIND +#define ELF_ST_TYPE ELF32_ST_TYPE +#endif + +static unsigned +checksum_mapname (MapInfo* map) +{ + unsigned checksum = 0; + /* only checksum code segments */ + if ((map->mflags & (PROT_EXEC | PROT_READ)) == 0 || + (map->mflags & PROT_WRITE) != 0) + return 0; + checksum = (unsigned) - 1; + TprintfT (DBG_LT2, "checksum_mapname checksum = 0x%0X\n", checksum); + return checksum; +} + + +#if (ARCH(Intel) && WSIZE(32)) || ARCH(SPARC) +static void* +dlopen_searchpath_symver (void*(real_dlopen) (), void* caller_addr, const char* basename, int mode) +#else +static void* +dlopen_searchpath (void* caller_addr, const char* basename, int mode) +#endif +{ + TprintfT (DBG_LT2, "dlopen_searchpath(%p, %s, %d)\n", caller_addr, basename, mode); + Dl_info dl_info; + if (dladdr (caller_addr, &dl_info) == 0) + { + TprintfT (0, "ERROR: dladdr(%p): %s\n", caller_addr, dlerror ()); + return 0; + } + TprintfT (DBG_LT2, "dladdr(%p): %p fname=%s\n", + caller_addr, dl_info.dli_fbase, dl_info.dli_fname); + int noload = RTLD_BINDING_MASK | RTLD_NOLOAD; //XXXX why RTLD_BINDING_MASK? +#define WORKAROUND_RTLD_BUG 1 +#ifdef WORKAROUND_RTLD_BUG + // A dynamic linker dlopen bug can result in corruption/closure of open streams + // XXXX workaround should be removed once linker patches are all available +#if WSIZE(64) +#define MAINBASE 0x400000 +#elif WSIZE(32) +#define MAINBASE 0x08048000 +#endif + const char* tmp_path = + (dl_info.dli_fbase == (void*) MAINBASE) ? NULL : dl_info.dli_fname; + void* caller_hndl = NULL; +#if ((ARCH(Intel) && WSIZE(32)) || ARCH(SPARC)) + caller_hndl = (real_dlopen) (tmp_path, noload); +#else + caller_hndl = CALL_REAL (dlopen)(tmp_path, noload); +#endif + +#else //XXXX workaround should be removed once linker patches are all available + + void* caller_hndl = NULL; +#if (ARCH(Intel) && WSIZE(32) || ARCH(SPARC) + caller_hndl = (real_dlopen) (dl_info.dli_fname, noload); +#else + caller_hndl = CALL_REAL (dlopen)(dl_info.dli_fname, noload); +#endif + +#endif //XXXX workaround should be removed once linker patches are all available + + if (!caller_hndl) + { + TprintfT (0, "ERROR: dlopen(%s,NOLOAD): %s\n", dl_info.dli_fname, dlerror ()); + return 0; + } + Dl_serinfo _info, *info = &_info; + Dl_serpath *path; + + /* determine search path count and required buffer size */ + dlinfo (caller_hndl, RTLD_DI_SERINFOSIZE, (void *) info); + + /* allocate new buffer and initialize */ + /* + CR# 7191331 + There is a bug in Linux that causes the first call + to dlinfo() to return a small value for the dls_size. + + The first call to dlinfo() determines the search path + count and the required buffer size. The second call to + dlinfo() tries to obtain the search path information. + + However, the size of the buffer that is returned by + the first call to the dlinfo() is incorrect (too small). + The second call to dlinfo() uses the incorrect size to + allocate memory on the stack and internally uses the memcpy() + function to copy the search paths to the allocated memory space. + The length of the search path is much larger than the buffer + that is allocated on the stack. The memcpy() overwrites some + of the information that are saved on the stack, specifically, + it overwrites the "basename" parameter. + + collect crashes right after the second call to dlinfo(). + + The search paths are used to locate the shared libraries. + dlinfo() creates the search paths based on the paths + that are assigned to LD_LIBRARY_PATH environment variable + and the standard library paths. The standard library paths + consists of the /lib and the /usr/lib paths. The + standard library paths are always included to the search + paths by dlinfo() even if the LD_LIBRARY_PATH environment + variable is not defined. Therefore, at the very least the + dls_cnt is assigned to 2 (/lib and /usr/lib) and dlinfo() + will never assign dls_cnt to zero. The dls_cnt is the count + of the potential paths for searching the shared libraries. + + So we need to increase the buffer size before the second + call to dlinfo(). There are number of ways to increase + the buffer size. However, none of them can calculate the + buffer size precisely. Some users on the web have suggested + to multiply the MAXPATHLEN by dls_cnt for the buffer size. + The MAXPATHLEN is assigned to 1024 bytes. In my opinion + this is too much. So I have decided to multiply dls_size + by dls_cnt for the buffer size since the dls_size is much + smaller than 1024 bytes. + + I have already confirmed with our user that the workaround + is working with his real application. Additionally, + the dlopen_searchpath() function is called only by the + libcorrector init() function when the experiment is started. + Therefore, allocating some extra bytes on the stack which + is local to this routine is harmless. + */ + + info = alloca (_info.dls_size * _info.dls_cnt); + info->dls_size = _info.dls_size; + info->dls_cnt = _info.dls_cnt; + + /* obtain search path information */ + dlinfo (caller_hndl, RTLD_DI_SERINFO, (void *) info); + path = &info->dls_serpath[0]; + + char pathname[MAXPATHLEN]; + for (unsigned int cnt = 1; cnt <= info->dls_cnt; cnt++, path++) + { + __collector_strlcpy (pathname, path->dls_name, sizeof (pathname)); + __collector_strlcat (pathname, "/", sizeof (pathname)); + __collector_strlcat (pathname, basename, sizeof (pathname)); + void* ret = NULL; +#if (ARCH(Intel) && WSIZE(32)) || ARCH(SPARC) + ret = (real_dlopen) (pathname, mode); +#else + ret = CALL_REAL (dlopen)(pathname, mode); +#endif + TprintfT (DBG_LT2, "try %d/%d: %s = %p\n", cnt, info->dls_cnt, pathname, ret); + if (ret) + return ret; // success! + } + return 0; +} + +static void +resolve_mapname (MapInfo *map, char *name) +{ + map->filename = ""; + map->mapname = ""; + if (name == NULL || *name == '\0') + { + if (map->mflags & MA_STACK) + map->filename = "<" SP_MAP_STACK ">"; + else if (map->mflags & MA_BREAK) + map->filename = "<" SP_MAP_HEAP ">"; + else if (map->mflags & MA_ISM) + map->filename = "<" SP_MAP_SHMEM ">"; + return; + } + NameInfo *np; + for (np = namemaps; np; np = np->next) + if (__collector_strcmp (np->mapname, name) == 0) + break; + + if (np == NULL) + { + const char *fname; + fname = name; + /* Create and link a new name map */ + size_t fnamelen = __collector_strlen (fname) + 1; + np = (NameInfo*) __collector_allocCSize (__collector_heap, sizeof (NameInfo) + fnamelen, 1); + if (np == NULL) // We could not get memory + return; + np->mapname = np->filename; + __collector_strlcpy (np->filename, fname, fnamelen); + np->next = namemaps; + namemaps = np; + } + map->mapname = np->mapname; + map->filename = np->filename; + if (map->filename[0] == (char) 0) + map->filename = map->mapname; + TprintfT (DBG_LT2, "resolve_mapname: %s resolved to %s\n", map->mapname, map->filename); +} + +static unsigned long +str2ulong (char **ss) +{ + char *s = *ss; + unsigned long val = 0UL; + const int base = 16; + for (;;) + { + char c = *s++; + if (c >= '0' && c <= '9') + val = val * base + (c - '0'); + else if (c >= 'a' && c <= 'f') + val = val * base + (c - 'a') + 10; + else if (c >= 'A' && c <= 'F') + val = val * base + (c - 'A') + 10; + else + break; + } + *ss = s - 1; + return val; +} + +static void +update_map_segments (hrtime_t hrt, int resolve) +{ + size_t filesz; + if (__collector_mutex_trylock (&map_lock)) + { + TprintfT (0, "WARNING: update_map_segments(resolve=%d) BUSY\n", resolve); + return; + } + TprintfT (DBG_LT2, "\n"); + TprintfT (DBG_LT2, "begin update_map_segments(hrt, %d)\n", resolve); + + // Note: there is similar code to read /proc/$PID/map[s] in + // perfan/er_kernel/src/KSubExp.cc KSubExp::write_subexpt_map() + const char* proc_map = "/proc/self/maps"; + size_t bufsz = maptext_sz; + int done = 0; + filesz = 0; + int map_fd = CALL_UTIL (open)(proc_map, O_RDONLY); + while (!done) + { + bufsz *= 2; + maptext = __collector_reallocVSize (__collector_heap, maptext, bufsz); + TprintfT (DBG_LT2, " update_map_segments: Loop for bufsize=%ld\n", + (long) bufsz); + for (;;) + { + int n = CALL_UTIL (read)(map_fd, maptext + filesz, bufsz - filesz); + TprintfT (DBG_LT2, " update_map_segments: __collector_read(bufp=%p nbyte=%ld)=%d\n", + maptext + filesz, (long) ( bufsz - filesz), n); + if (n < 0) + { + TprintfT (0, "ERROR: update_map_segments: read(maps): errno=%d\n", errno); + (void) __collector_log_write ("<event kind=\"%s\" id=\"%d\" ec=\"%d\">%s</event>\n", + SP_JCMD_CERROR, COL_ERROR_MAPREAD, errno, proc_map); + CALL_UTIL (close)(map_fd); + __collector_mutex_unlock (&map_lock); + return; + } + else if (n == 0) + { + done = 1; + break; + } + filesz += n; + if (filesz >= bufsz) /* Buffer too small */ + break; + } + } + CALL_UTIL (close)(map_fd); + maptext_sz = filesz; + + int mapcache_entries = 0; + char *str, *str1; + for (str = maptext;; str = str1) + { + for (str1 = str; str1 - maptext < filesz; str1++) + { + if (*str1 == '\n') + { + *str1 = (char) 0; + break; + } + } + if (str1 - maptext >= filesz) + break; + str1++; + mapcache_entries++; + mapcache = __collector_reallocVSize (__collector_heap, mapcache, + sizeof (prmap_t) * mapcache_entries); + prmap_t *map = ((prmap_t *) mapcache) + (mapcache_entries - 1); + map->pr_vaddr = str2ulong (&str); + str++; + unsigned long eaddr = str2ulong (&str); + str++; + map->pr_size = eaddr - map->pr_vaddr; + map->pr_mflags = 0; + map->pr_mflags += (*str++ == 'r' ? PROT_READ : 0); + map->pr_mflags += (*str++ == 'w' ? PROT_WRITE : 0); + map->pr_mflags += (*str++ == 'x' ? PROT_EXEC : 0); + map->pr_mflags += (*str++ == 's' ? MA_SHARED : 0); + str++; + map->pr_offset = str2ulong (&str); + str++; + map->pr_dev = str2ulong (&str) * 0x100; + str++; + map->pr_dev += str2ulong (&str); + str++; + map->pr_ino = str2ulong (&str); + if (map->pr_dev == 0) + map->pr_mflags |= MA_ANON; + while (*str == ' ') + str++; + map->pr_mapname = str; + map->pr_pagesize = 4096; + } + + /* Compare two maps and record all differences */ + unsigned nidx = 0; + MapInfo *prev = &mmaps; + MapInfo *oldp = mmaps.next; + for (;;) + { + prmap_t *newp = nidx < mapcache_entries ? + (prmap_t*) mapcache + nidx : NULL; + if (oldp == NULL && newp == NULL) + break; + + /* If two maps are equal proceed to the next pair */ + if (oldp && newp && + oldp->vaddr == newp->pr_vaddr && + oldp->size == newp->pr_size && + __collector_strcmp (oldp->mapname, newp->pr_mapname) == 0) + { + prev = oldp; + oldp = oldp->next; + nidx++; + continue; + } + /* Check if we need to unload the old map first */ + if (newp == NULL || (oldp && oldp->vaddr <= newp->pr_vaddr)) + { + if (oldp != NULL) + { + /* Don't record MA_ANON maps except MA_STACK and MA_BREAK */ + if ((!(oldp->mflags & MA_ANON) || (oldp->mflags & (MA_STACK | MA_BREAK)))) + record_segment_unmap (hrt, oldp->vaddr); + /* Remove and free map */ + prev->next = oldp->next; + MapInfo *tmp = oldp; + oldp = oldp->next; + __collector_freeCSize (__collector_heap, tmp, sizeof (*tmp)); + } + } + else + { + MapInfo *map = (MapInfo*) __collector_allocCSize (__collector_heap, sizeof (MapInfo), 1); + if (map == NULL) + { + __collector_mutex_unlock (&map_lock); + return; + } + map->vaddr = newp->pr_vaddr; + map->size = newp->pr_size; + map->offset = newp->pr_offset; + map->mflags = newp->pr_mflags; + map->pagesize = newp->pr_pagesize; + resolve_mapname (map, newp->pr_mapname); + + /* Insert new map */ + map->next = prev->next; + prev->next = map; + prev = map; + + /* Don't record MA_ANON maps except MA_STACK and MA_BREAK */ + if (!(newp->pr_mflags & MA_ANON) || (newp->pr_mflags & (MA_STACK | MA_BREAK))) + { + unsigned checksum = checksum_mapname (map); + record_segment_map (hrt, map->vaddr, map->size, + map->pagesize, map->mflags, + map->offset, checksum, map->filename); + } + nidx++; + } + } + TprintfT (DBG_LT2, "update_map_segments: done\n\n"); + __collector_mutex_unlock (&map_lock); +} /* update_map_segments */ + +/* + * Map addr to a segment. Cope with split segments. + */ +int +__collector_check_segment_internal (unsigned long addr, unsigned long *base, + unsigned long *end, int maxnretries, int MA_FLAGS) +{ + int number_of_tries = 0; +retry: + ; + + unsigned long curbase = 0; + unsigned long curfoff = 0; + unsigned long cursize = 0; + + MapInfo *mp; + for (mp = mmaps.next; mp; mp = mp->next) + { + + if (curbase + cursize == mp->vaddr && + curfoff + cursize == mp->offset && + ((mp->mflags & MA_FLAGS) == MA_FLAGS + || __collector_strncmp (mp->mapname, "[vdso]", 6) == 0 + || __collector_strncmp (mp->mapname, "[vsyscall]", 10) == 0 + )) + cursize = mp->vaddr + mp->size - curbase; + else if (addr < mp->vaddr) + break; + else if ((mp->mflags & MA_FLAGS) != MA_FLAGS + && __collector_strncmp (mp->mapname, "[vdso]", 6) + && __collector_strncmp (mp->mapname, "[vsyscall]", 10)) + { + curbase = 0; + curfoff = 0; + cursize = 0; + } + else + { + curbase = mp->vaddr; + curfoff = mp->offset; + cursize = mp->size; + } + } + + if (addr >= curbase && addr < curbase + cursize) + { + *base = curbase; + *end = curbase + cursize; + return 1; + } + + /* + * 21275311 Unwind failure in native stack for java application running on jdk8 on x86 + * + * On JDK8, we've observed cases where Java-compiled methods end up + * in virtual address segments that were "dead zones" (mflags&PROT_READ==0) at + * the time of the last update_map_segments() but are now "live". So if we + * fail to find a segment, let's call update_map_segments and then retry + * before giving up. + */ + if (number_of_tries < maxnretries) + { + number_of_tries++; + __collector_ext_update_map_segments (); + goto retry; + } + *base = 0; + *end = 0; + return 0; +} + +/** + * Check if address belongs to a readable and executable segment + * @param addr + * @param base + * @param end + * @param maxnretries + * @return 1 - yes, 0 - no + */ +int +__collector_check_segment (unsigned long addr, unsigned long *base, + unsigned long *end, int maxnretries) +{ + int MA_FLAGS = PROT_READ | PROT_EXEC; + int res = __collector_check_segment_internal (addr, base, end, maxnretries, MA_FLAGS); + return res; +} + +/** + * Check if address belongs to a readable segment + * @param addr + * @param base + * @param end + * @param maxnretries + * @return 1 - yes, 0 - no + */ +int +__collector_check_readable_segment( unsigned long addr, unsigned long *base, unsigned long *end, int maxnretries ) +{ + int MA_FLAGS = PROT_READ; + int res = __collector_check_segment_internal(addr, base, end, maxnretries, MA_FLAGS); + return res; +} + +static ELF_AUX *auxv = NULL; + +static void +process_vsyscall_page () +{ + TprintfT (DBG_LT2, "process_vsyscall_page()\n"); + if (ndyn != 0) + { + /* We've done this one in this process, and cached the results */ + /* use the cached results */ + for (int i = 0; i < ndyn; i++) + { + append_segment_record ("<event kind=\"map\" object=\"dynfunc\" name=\"%s\" " + "vaddr=\"0x%016lX\" size=\"%u\" funcname=\"%s\" />\n", + dynname[i], dynvaddr[i], dynsize[i], dynfuncname[i]); + TprintfT (DBG_LT2, "process_vsyscall_page: append_segment_record map dynfunc='%s' vaddr=0x%016lX size=%ld funcname='%s' -- from cache\n", + dynname[i], (unsigned long) dynvaddr[i], + (long) dynsize[i], dynfuncname[i]); + } + } + if (nvsysfuncs != 0) + { + /* We've done this one in this process, and cached the results */ + /* use the cached results */ + hrtime_t hrt = GETRELTIME (); + for (int i = 0; i < nvsysfuncs; i++) + { + append_segment_record ("<event kind=\"map\" object=\"function\" tstamp=\"%u.%09u\" " + "vaddr=\"0x%016lX\" size=\"%u\" name=\"%s\" />\n", + (unsigned) (hrt / NANOSEC), (unsigned) (hrt % NANOSEC), + (unsigned long) sysfuncvaddr[i], (unsigned) sysfuncsize[i], sysfuncname[i]); + TprintfT (DBG_LT2, "process_vsyscall_page: append_segment_record map function='%s' vaddr=0x%016lX size=%ld -- from cache\n", + sysfuncname[i], (unsigned long) sysfuncvaddr[i], (long) sysfuncsize[i]); + } + } + if (ndyn + nvsysfuncs != 0) + return; + + /* After fork we can't rely on environ as it might have + * been moved by putenv(). Use the pointer saved by the parent. + */ + if (auxv == NULL) + { + char **envp = (char**) environ; + if (envp == NULL) + return; + while (*envp++ != NULL); + auxv = (ELF_AUX*) envp; + } + TprintfT (DBG_LT2, "process_vsyscall_page, auxv = ox%p\n", auxv); + + ELF_AUX *ap; +#ifdef DEBUG + for (ap = auxv; ap->a_type != AT_NULL; ap++) + TprintfT (DBG_LT2, "process_vsyscall_page: ELF_AUX: " + " a_type = 0x%016llx %10lld " + " a_un.a_val = 0x%016llx %10lld\n", + (long long) ap->a_type, (long long) ap->a_type, + (long long) ap->a_un.a_val, (long long) ap->a_un.a_val); +#endif + + // find the first ELF_AUX of type AT_SYSINFO_EHDR + ELF_EHDR *ehdr = NULL; + for (ap = auxv; ap->a_type != AT_NULL; ap++) + { + if (ap->a_type == AT_SYSINFO_EHDR) + { + // newer Linuxes do not have a_ptr field, they just have a_val + ehdr = (ELF_EHDR*) ap->a_un.a_val; + if (ehdr != NULL) + break; + } + } + + // If one is found + if (ehdr != NULL) + { + char *mapName = "SYSINFO_EHDR"; + MapInfo *mp; + for (mp = mmaps.next; mp; mp = mp->next) + { + if ((unsigned long) ehdr == mp->vaddr) + { + mp->mflags |= PROT_EXEC; + if (mp->mapname && mp->mapname[0]) + mapName = mp->mapname; + break; + } + } + + // Find the dynsym section and record all symbols + char *base = (char*) ehdr; + ELF_SHDR *shdr = (ELF_SHDR*) (base + ehdr->e_shoff); + int i; + +#if 0 + TprintfT (DBG_LT2, "process_vsyscall_page: ehdr: EI_CLASS=%lld EI_DATA=%lld EI_OSABI=%lld e_type=%lld e_machine=%lld e_version=%lld\n" + " e_entry =0x%016llx %10lld e_phoff =0x%016llx %10lld\n" + " e_shoff =0x%016llx %10lld e_flags =0x%016llx %10lld\n" + " e_ehsize =0x%016llx %10lld e_phentsize =0x%016llx %10lld\n" + " e_phnum =0x%016llx %10lld e_shentsize =0x%016llx %10lld\n" + " e_shnum =0x%016llx %10lld e_shstrndx =0x%016llx %10lld\n", + (long long) ehdr->e_ident[EI_CLASS], (long long) ehdr->e_ident[EI_DATA], (long long) ehdr->e_ident[EI_OSABI], + (long long) ehdr->e_type, (long long) ehdr->e_machine, (long long) ehdr->e_version, + (long long) ehdr->e_entry, (long long) ehdr->e_entry, + (long long) ehdr->e_phoff, (long long) ehdr->e_phoff, + (long long) ehdr->e_shoff, (long long) ehdr->e_shoff, + (long long) ehdr->e_flags, (long long) ehdr->e_flags, + (long long) ehdr->e_ehsize, (long long) ehdr->e_ehsize, + (long long) ehdr->e_phentsize, (long long) ehdr->e_phentsize, + (long long) ehdr->e_phnum, (long long) ehdr->e_phnum, + (long long) ehdr->e_shentsize, (long long) ehdr->e_shentsize, + (long long) ehdr->e_shnum, (long long) ehdr->e_shnum, + (long long) ehdr->e_shstrndx, (long long) ehdr->e_shstrndx); + for (i = 1; i < ehdr->e_shnum; i++) + { + TprintfT (DBG_LT2, "process_vsyscall_page: SECTION=%d sh_name=%lld '%s'\n" + " sh_type =0x%016llx %10lld\n" + " sh_flags =0x%016llx %10lld\n" + " sh_addr =0x%016llx %10lld\n" + " sh_offset =0x%016llx %10lld\n" + " sh_size =0x%016llx %10lld\n" + " sh_link =0x%016llx %10lld\n" + " sh_info =0x%016llx %10lld\n" + " sh_addralign =0x%016llx %10lld\n" + " sh_entsize =0x%016llx %10lld\n", + i, (long long) shdr[i].sh_name, base + shdr[ehdr->e_shstrndx].sh_offset + shdr[i].sh_name, + (long long) shdr[i].sh_type, (long long) shdr[i].sh_type, + (long long) shdr[i].sh_flags, (long long) shdr[i].sh_flags, + (long long) shdr[i].sh_addr, (long long) shdr[i].sh_addr, + (long long) shdr[i].sh_offset, (long long) shdr[i].sh_offset, + (long long) shdr[i].sh_size, (long long) shdr[i].sh_size, + (long long) shdr[i].sh_link, (long long) shdr[i].sh_link, + (long long) shdr[i].sh_info, (long long) shdr[i].sh_info, + (long long) shdr[i].sh_addralign, (long long) shdr[i].sh_addralign, + (long long) shdr[i].sh_entsize, (long long) shdr[i].sh_entsize); + } +#endif + + int dynSec = -1; + for (i = 1; i < ehdr->e_shnum; i++) + if (shdr[i].sh_type == SHT_DYNSYM) + { + dynSec = i; + break; + } + if (dynSec != -1) + { + char *symbase = base + shdr[shdr[dynSec].sh_link].sh_offset; + ELF_SYM *symbols = (ELF_SYM*) (base + shdr[dynSec].sh_offset); + int nextSec = 0; + int n = shdr[dynSec].sh_size / shdr[dynSec].sh_entsize; + for (i = 0; i < n; i++) + { + ELF_SYM *sym = symbols + i; + TprintfT (DBG_LT2, "process_vsyscall_page: symbol=%d st_name=%lld '%s'\n" + " st_size = 0x%016llx %10lld\n" + " st_value = 0x%016llx %10lld\n" + " st_shndx = 0x%016llx %10lld\n" + " st_info = 0x%016llx %10lld\n", + i, (long long) sym->st_name, symbase + sym->st_name, + (long long) sym->st_size, (long long) sym->st_size, + (long long) sym->st_value, (long long) sym->st_value, + (long long) sym->st_shndx, (long long) sym->st_shndx, + (long long) sym->st_info, (long long) sym->st_info); + if (sym->st_shndx <= 0 || sym->st_size <= 0 || + ELF_ST_BIND (sym->st_info) != STB_GLOBAL || ELF_ST_TYPE (sym->st_info) != STT_FUNC) + continue; + if (nextSec == 0) + nextSec = sym->st_shndx; + else if (nextSec > sym->st_shndx) + nextSec = sym->st_shndx; + } + if (nextSec == 0) + ehdr = NULL; + + while (nextSec != 0) + { + int curSec = nextSec; + char *bgn = base + shdr[curSec].sh_offset; + char *end = bgn + shdr[curSec].sh_size; + for (i = 0; i < n; i++) + { + ELF_SYM *sym = symbols + i; + if (sym->st_shndx <= 0 || sym->st_size <= 0 || + ELF_ST_BIND (sym->st_info) != STB_GLOBAL || ELF_ST_TYPE (sym->st_info) != STT_FUNC) + continue; + if (sym->st_shndx > curSec) + { + if (nextSec == curSec) + nextSec = sym->st_shndx; + else if (nextSec > sym->st_shndx) + nextSec = sym->st_shndx; + nextSec = sym->st_shndx; + continue; + } + if (sym->st_shndx != curSec) + continue; + long long st_delta = (sym->st_value >= shdr[sym->st_shndx].sh_addr) ? + (sym->st_value - shdr[sym->st_shndx].sh_addr) : -1; + char *st_value = bgn + st_delta; + if (st_delta >= 0 && st_value + sym->st_size <= end) + { + append_segment_record ("<event kind=\"map\" object=\"dynfunc\" name=\"%s\" " + "vaddr=\"0x%016lX\" size=\"%u\" funcname=\"%s\" />\n", + mapName, (void*) st_value, sym->st_size, symbase + sym->st_name); + + TprintfT (DBG_LT2, "process_vsyscall_page: append_segment_record map dynfunc='%s' vaddr=%016lX size=%ld funcname='%s'\n", + mapName, (unsigned long) st_value, + (long) sym->st_size, symbase + sym->st_name); + + /* now cache this for a subsequent experiment */ + if (ndyn >= MAXDYN) + __collector_log_write ("<event kind=\"%s\" id=\"%d\">MAXDYN=%d</event>\n", + SP_JCMD_CERROR, COL_ERROR_MAPCACHE, MAXDYN); + else + { + dynname [ndyn] = CALL_UTIL (libc_strdup)(mapName); + dynvaddr [ndyn] = (void *) st_value; + dynsize [ndyn] = (unsigned) sym->st_size; + dynfuncname[ndyn] = CALL_UTIL (libc_strdup)(symbase + sym->st_name); + TprintfT (DBG_LT2, "process_vsyscall_page: cached entry %d map function='%s' vaddr=0x%016lX size=%ld '%s'\n", + ndyn, dynname[ndyn], (unsigned long) dynvaddr[ndyn], + (long) dynsize[ndyn], dynfuncname[ndyn]); + ndyn++; + } + } + } + __collector_int_func_load (DFUNC_KERNEL, mapName, NULL, + (void*) (base + shdr[curSec].sh_offset), shdr[curSec].sh_size, 0, NULL); + + /* now cache this function for a subsequent experiment */ + if (nvsysfuncs >= MAXVSYSFUNCS) + __collector_log_write ("<event kind=\"%s\" id=\"%d\">MAXVSYSFUNCS=%d</event>\n", + SP_JCMD_CERROR, COL_ERROR_MAPCACHE, MAXVSYSFUNCS); + else + { + sysfuncname[nvsysfuncs] = CALL_UTIL (libc_strdup)(mapName); + sysfuncvaddr[nvsysfuncs] = (unsigned long) (base + shdr[curSec].sh_offset); + sysfuncsize[nvsysfuncs] = (unsigned long) (shdr[curSec].sh_size); + TprintfT (DBG_LT2, "process_vsyscall_page: cached entry %d map function='%s' vaddr=0x%016lX size=%ld\n", + nvsysfuncs, sysfuncname[nvsysfuncs], + (unsigned long) sysfuncvaddr[nvsysfuncs], + (long) sysfuncsize[nvsysfuncs]); + nvsysfuncs++; + } + TprintfT (DBG_LT2, "process_vsyscall_page: collector_int_func_load='%s' vaddr=0x%016lX size=%ld\n", + mapName, (unsigned long) (base + shdr[curSec].sh_offset), + (long) shdr[curSec].sh_size); + if (curSec == nextSec) + break; + } + } + } + +#if WSIZE(32) + unsigned long vsysaddr = (unsigned long) 0xffffe000; +#elif WSIZE(64) + unsigned long vsysaddr = (unsigned long) 0xffffffffff600000; +#endif + // Make sure the vsyscall map has PROT_EXEC + MapInfo *mp; + for (mp = mmaps.next; mp; mp = mp->next) + { + TprintfT (DBG_LT2, "MapInfo: vaddr=0x%016llx [size=%lld] mflags=0x%llx offset=%lld pagesize=%lld\n" + " mapname='%s' filename='%s'\n", + (unsigned long long) mp->vaddr, (long long) mp->size, + (long long) mp->mflags, (long long) mp->offset, (long long) mp->pagesize, + mp->mapname ? mp->mapname : "NULL", + mp->filename ? mp->filename : "NULL"); + if (vsysaddr == mp->vaddr) + mp->mflags |= PROT_EXEC; + if ((unsigned long) ehdr == (unsigned long) mp->vaddr) + continue; + if (__collector_strncmp (mp->mapname, "[vdso]", 6) == 0 + || __collector_strncmp (mp->mapname, "[vsyscall]", 10) == 0) + { + /* + * On rubbia ( 2.6.9-5.ELsmp #1 SMP 32-bit ) access to ehdr causes SEGV. + * There doesn't seem to be a way to reliably determine the actual presence + * of the page: even when /proc reports it's there it can't be accessed. + * We will have to put up with <Unknown> on some Linuxes until this is resolved. + __collector_int_func_load(DFUNC_KERNEL, mp->mapname, NULL, (void*) mp->vaddr, mp->size, 0, NULL); + */ + hrtime_t hrt = GETRELTIME (); + append_segment_record ( + "<event kind=\"map\" object=\"function\" tstamp=\"%u.%09u\" " + "vaddr=\"0x%016lX\" size=\"%u\" name=\"%s\" />\n", + (unsigned) (hrt / NANOSEC), (unsigned) (hrt % NANOSEC), + (unsigned long) mp->vaddr, (unsigned) mp->size, mp->mapname); + TprintfT (DBG_LT2, "process_vsyscall_page: append_segment_record map function = %s, vaddr = 0x%016lX, size = %u\n", + mp->mapname, (unsigned long) mp->vaddr, (unsigned) mp->size); + + /* now cache this function for a subsequent experiment */ + if (nvsysfuncs >= MAXVSYSFUNCS) + __collector_log_write ("<event kind=\"%s\" id=\"%d\">MAXVSYSFUNCS=%d</event>\n", + SP_JCMD_CERROR, COL_ERROR_MAPCACHE, MAXVSYSFUNCS); + else + { + sysfuncname[nvsysfuncs] = CALL_UTIL (libc_strdup)(mp->mapname); + sysfuncvaddr[nvsysfuncs] = mp->vaddr; + sysfuncsize[nvsysfuncs] = (unsigned long) mp->size; + TprintfT (DBG_LT2, "process_vsyscall_page: cached entry %d map function='%s' vaddr=0x%016lX size=%ld\n", + nvsysfuncs, sysfuncname[nvsysfuncs], + (unsigned long) sysfuncvaddr[nvsysfuncs], + (long) sysfuncsize[nvsysfuncs]); + nvsysfuncs++; + + } + } + } +} + +/* + * collector API for dynamic functions + */ +void collector_func_load () __attribute__ ((weak, alias ("__collector_func_load"))); +void +__collector_func_load (char *name, char *alias, char *sourcename, + void *vaddr, int size, int lntsize, DT_lineno *lntable) +{ + __collector_int_func_load (DFUNC_API, name, sourcename, + vaddr, size, lntsize, lntable); +} + +void collector_func_unload () __attribute__ ((weak, alias ("__collector_func_unload"))); +void +__collector_func_unload (void *vaddr) +{ + __collector_int_func_unload (DFUNC_API, vaddr); +} + +/* routines for handling dynamic functions */ +static void +rwrite (int fd, void *buf, size_t nbyte) +{ + size_t left = nbyte; + size_t res; + char *ptr = (char*) buf; + while (left > 0) + { + res = CALL_UTIL (write)(fd, ptr, left); + if (res == -1) + { + TprintfT (0, "ERROR: rwrite(%s) failed: errno=%d\n", dyntext_fname, errno); + (void) __collector_log_write ("<event kind=\"%s\" id=\"%d\" ec=\"%d\">%s</event>\n", + SP_JCMD_CERROR, COL_ERROR_DYNWRITE, errno, dyntext_fname); + return; + } + left -= res; + ptr += res; + } +} + +void +__collector_int_func_load (dfunc_mode_t mode, char *name, char *sourcename, + void *vaddr, int size, int lntsize, DT_lineno *lntable) +{ + char name_buf[32]; + int slen; + static char pad[16]; + int padn; + if (!mmap_initted) + return; + hrtime_t hrt = GETRELTIME (); + + if (name == NULL) + { + /* generate a name based on vaddr */ + CALL_UTIL (snprintf)(name_buf, sizeof (name_buf), "0x%lx", (unsigned long) vaddr); + name = name_buf; + } + + switch (mode) + { + case DFUNC_API: + case DFUNC_KERNEL: + append_segment_record ("<event kind=\"map\" object=\"function\" tstamp=\"%u.%09u\" " + "vaddr=\"0x%016lX\" size=\"%u\" name=\"%s\" />\n", + (unsigned) (hrt / NANOSEC), (unsigned) (hrt % NANOSEC), + (unsigned long) vaddr, (unsigned) size, name); + break; + case DFUNC_JAVA: + append_segment_record ("<event kind=\"map\" object=\"jcm\" tstamp=\"%u.%09u\" " + "vaddr=\"0x%016lX\" size=\"%u\" methodId=\"%s\" />\n", + (unsigned) (hrt / NANOSEC), (unsigned) (hrt % NANOSEC), + (unsigned long) vaddr, (unsigned) size, name); + break; + default: + return; + } + + /* 21275311 Unwind failure in native stack for java application running on jdk8 on x86 + * Check: + * - function starts in a known segment (base1 != 0) + * - function ends in the same segment (base1==base2 && end1==end2) + * If not, then call update_map_segments(). + */ + unsigned long base1, end1, base2, end2; + __collector_check_segment ((unsigned long) vaddr, &base1, &end1, 0); + if (base1) + __collector_check_segment (((unsigned long) vaddr)+((unsigned long) size), &base2, &end2, 0); + if (base1 == 0 || base1 != base2 || end1 != end2) + __collector_ext_update_map_segments (); + + /* Write a copy of actual code to the "dyntext" file */ + DT_header dt_hdr; + dt_hdr.type = DT_HEADER; + dt_hdr.size = sizeof (dt_hdr); + dt_hdr.time = hrt; + unsigned long t = (unsigned long) vaddr; /* to suppress a warning from gcc */ + dt_hdr.vaddr = (uint64_t) t; + + DT_code dt_code; + dt_code.type = DT_CODE; + void *code = vaddr; + if (vaddr != NULL && size > 0) + { + dt_code.size = sizeof (dt_code) + ((size + 0xf) & ~0xf); + if (mode == DFUNC_KERNEL) + { + /* Some Linuxes don't accept vaddrs from the vsyscall + * page in write(). Make a copy. + */ + code = alloca (size); + __collector_memcpy (code, vaddr, size); + } + } + else + dt_code.size = 0; + + DT_srcfile dt_src; + dt_src.type = DT_SRCFILE; + if (sourcename) + { + slen = CALL_UTIL (strlen)(sourcename) + 1; + dt_src.size = slen ? sizeof (dt_src) + ((slen + 0xf) & ~0xf) : 0; + } + else + { + slen = 0; + dt_src.size = 0; + } + + DT_ltable dt_ltbl; + dt_ltbl.type = DT_LTABLE; + if (lntable != NULL && lntsize > 0) + dt_ltbl.size = sizeof (dt_ltbl) + lntsize * sizeof (DT_lineno); + else + dt_ltbl.size = 0; + + int fd = CALL_UTIL (open)(dyntext_fname, O_RDWR | O_APPEND); + if (fd == -1) + { + TprintfT (0, "ERROR: __collector_int_func_load: open(%s) failed: errno=%d\n", + dyntext_fname, errno); + (void) __collector_log_write ("<event kind=\"%s\" id=\"%d\" ec=\"%d\">%s</event>\n", + SP_JCMD_CERROR, COL_ERROR_DYNOPEN, errno, dyntext_fname); + return; + } + + /* Lock the whole file */ + __collector_mutex_lock (&dyntext_lock); + rwrite (fd, &dt_hdr, sizeof (dt_hdr)); + if (dt_code.size) + { + padn = dt_code.size - sizeof (dt_code) - size; + rwrite (fd, &dt_code, sizeof (dt_code)); + rwrite (fd, code, size); + rwrite (fd, &pad, padn); + } + if (dt_src.size) + { + padn = dt_src.size - sizeof (dt_src) - slen; + rwrite (fd, &dt_src, sizeof (dt_src)); + rwrite (fd, sourcename, slen); + rwrite (fd, &pad, padn); + } + if (dt_ltbl.size) + { + rwrite (fd, &dt_ltbl, sizeof (dt_ltbl)); + rwrite (fd, lntable, dt_ltbl.size - sizeof (dt_ltbl)); + } + + /* Unlock the file */ + __collector_mutex_unlock( &dyntext_lock ); + CALL_UTIL(close( fd ) ); +} + +void +__collector_int_func_unload (dfunc_mode_t mode, void *vaddr) +{ + if (!mmap_initted) + return; + hrtime_t hrt = GETRELTIME (); + if (mode == DFUNC_API) + append_segment_record ("<event kind=\"unmap\" tstamp=\"%u.%09u\" vaddr=\"0x%016lX\"/>\n", + (unsigned) (hrt / NANOSEC), (unsigned) (hrt % NANOSEC), (unsigned long) vaddr); + else if (mode == DFUNC_JAVA) + /* note that the "vaddr" is really a method id, not an address */ + append_segment_record ("<event kind=\"unmap\" tstamp=\"%u.%09u\" methodId=\"0x%016lX\"/>\n", + (unsigned) (hrt / NANOSEC), (unsigned) (hrt % NANOSEC), (unsigned long) vaddr); + else + return; +} + +/* + * int init_mmap_intf() + * Set up interposition (if not already done). + */ +static int +init_mmap_intf () +{ + if (__collector_dlsym_guard) + return 1; + void *dlflag; + __real_mmap = (void*(*)(void* addr, size_t len, int prot, int flags, + int fildes, off_t off))dlsym (RTLD_NEXT, SYS_MMAP_NAME); + if (__real_mmap == NULL) + { + + /* We are probably dlopened after libthread/libc, + * try to search in the previously loaded objects + */ + __real_mmap = (void*(*)(void* addr, size_t len, int prot, int flags, + int fildes, off_t off))dlsym (RTLD_DEFAULT, SYS_MMAP_NAME); + if (__real_mmap == NULL) + { + TprintfT (0, "ERROR: collector real mmap not found\n"); + return 1; + } + TprintfT (DBG_LT2, "collector real mmap found with RTLD_DEFAULT\n"); + dlflag = RTLD_DEFAULT; + } + else + { + TprintfT (DBG_LT2, "collector real mmap found with RTLD_NEXT\n"); + dlflag = RTLD_NEXT; + } + + TprintfT (DBG_LT2, "init_mmap_intf() @%p __real_mmap\n", __real_mmap); + __real_mmap64 = (void*(*)(void *, size_t, int, int, int, off64_t)) + dlsym (dlflag, SYS_MMAP64_NAME); + TprintfT (DBG_LT2, "init_mmap_intf() @%p __real_mmap64\n", __real_mmap64); + __real_munmap = (int(*)(void *, size_t)) dlsym (dlflag, SYS_MUNMAP_NAME); + TprintfT (DBG_LT2, "init_mmap_intf() @%p __real_munmap\n", __real_munmap); + + // dlopen/dlmopen/dlclose are in libdl.so + __real_dlopen = (void*(*)(const char *, int)) + dlvsym (dlflag, SYS_DLOPEN_NAME, SYS_DLOPEN_VERSION); + TprintfT (DBG_LT2, "init_mmap_intf() [%s] @%p __real_dlopen\n", + SYS_DLOPEN_VERSION, __real_dlopen); +#if (ARCH(Intel) && WSIZE(32)) || ARCH(SPARC) + __real_dlopen_2_1 = __real_dlopen; + __real_dlopen_2_0 = (void*(*)(const char *, int)) + dlvsym (dlflag, SYS_DLOPEN_NAME, "GLIBC_2.0"); +#endif + + __real_dlclose = (int(*)(void* handle))dlsym (dlflag, SYS_DLCLOSE_NAME); + TprintfT (DBG_LT2, "init_mmap_intf() @%p __real_dlclose\n", __real_dlclose); + TprintfT (DBG_LT2, "init_mmap_intf() done\n"); + + return 0; +} + +/*------------------------------------------------------------- mmap */ +void * +mmap (void *start, size_t length, int prot, int flags, int fd, off_t offset) +{ + int err = 0; + if (NULL_PTR (mmap)) + err = init_mmap_intf (); + if (err) + return MAP_FAILED; + + /* hrtime_t hrt = GETRELTIME(); */ + void *ret = CALL_REAL (mmap)(start, length, prot, flags, fd, offset); + + if (!CHCK_REENTRANCE && (ret != MAP_FAILED) && collector_heap_record != NULL) + { + PUSH_REENTRANCE; + /* write a separate record for mmap tracing */ + collector_heap_record (MMAP_TRACE, length, ret); + POP_REENTRANCE; + } + TprintfT (DBG_LT2, "libcollector.mmap(%p, %ld, %d, %d, %d, 0x%lld) = %p\n", + start, (long) length, prot, flags, fd, (long long) offset, ret); + return ret; +} + +/*------------------------------------------------------------- mmap64 */ +#if WSIZE(32) /* mmap64 only defined for non-64-bit */ + +void * +mmap64 (void *start, size_t length, int prot, int flags, int fd, off64_t offset) +{ + if (NULL_PTR (mmap64)) + init_mmap_intf (); + + /* hrtime_t hrt = GETRELTIME(); */ + void *ret = CALL_REAL (mmap64)(start, length, prot, flags, fd, offset); + if (!CHCK_REENTRANCE && (ret != MAP_FAILED) && collector_heap_record != NULL) + { + PUSH_REENTRANCE; + /* write a separate record for mmap tracing */ + collector_heap_record (MMAP_TRACE, length, ret); + POP_REENTRANCE; + } + TprintfT (DBG_LT2, "libcollector.mmap64(%p, %ld, %d, %d, %d, 0x%lld) = %p\n", + start, (long) length, prot, flags, fd, (long long) offset, ret); + return ret; +} +#endif /* WSIZE(32) */ + +/*------------------------------------------------------------- munmap */ +int +munmap (void *start, size_t length) +{ + if (NULL_PTR (munmap)) + init_mmap_intf (); + + /* hrtime_t hrt = GETRELTIME(); */ + int rc = CALL_REAL (munmap)(start, length); + if (!CHCK_REENTRANCE && (rc == 0) && collector_heap_record != NULL) + { + PUSH_REENTRANCE; + /* write a separate record for mmap tracing */ + collector_heap_record (MUNMAP_TRACE, length, start); + POP_REENTRANCE; + } + TprintfT (DBG_LT2, "libcollector.munmap(%p, %ld) = %d\n", start, (long) length, rc); + return rc; +} + + +/*------------------------------------------------------------- dlopen */ +// map interposed symbol versions +#if (ARCH(Intel) && WSIZE(32)) || ARCH(SPARC) + +static void * +__collector_dlopen_symver (void*(real_dlopen) (), void *caller, const char *pathname, int mode); + +void * +__collector_dlopen_2_1 (const char *pathname, int mode) +{ + if (NULL_PTR (dlopen)) + init_mmap_intf (); + void *caller = __builtin_return_address (0); // must be called inside dlopen first layer interpostion + return __collector_dlopen_symver (CALL_REAL (dlopen_2_1), caller, pathname, mode); +} + +void * +__collector_dlopen_2_0 (const char *pathname, int mode) +{ + if (NULL_PTR (dlopen)) + init_mmap_intf (); + void* caller = __builtin_return_address (0); // must be called inside dlopen first layer interpostion + return __collector_dlopen_symver (CALL_REAL (dlopen_2_0), caller, pathname, mode); +} + +__asm__(".symver __collector_dlopen_2_1,dlopen@@GLIBC_2.1"); +__asm__(".symver __collector_dlopen_2_0,dlopen@GLIBC_2.0"); + +#endif + +#if (ARCH(Intel) && WSIZE(32)) || ARCH(SPARC) +static void * +__collector_dlopen_symver (void*(real_dlopen) (), void *caller, const char *pathname, int mode) +#else +void * +dlopen (const char *pathname, int mode) +#endif +{ + const char * real_pathname = pathname; + char new_pathname[MAXPATHLEN]; + int origin_offset = 0; + TprintfT (DBG_LT2, "dlopen: pathname=%s, mode=%d\n", pathname ? pathname : "NULL", mode); + if (pathname && __collector_strStartWith (pathname, "$ORIGIN/") == 0) + origin_offset = 8; + else if (pathname && __collector_strStartWith (pathname, "${ORIGIN}/") == 0) + origin_offset = 10; + if (origin_offset) + { +#if ! ((ARCH(Intel) && WSIZE(32)) || ARCH(SPARC)) + // 'caller' is not passed as an argument + void * caller = __builtin_return_address (0); // must be called inside dlopen first layer interpostion +#endif + Dl_info dl_info; + if (caller && dladdr (caller, &dl_info) != 0) + { + TprintfT (DBG_LT2, "dladdr(%p): %p fname=%s\n", + caller, dl_info.dli_fbase, dl_info.dli_fname); + new_pathname[0] = '\0'; + const char *p = __collector_strrchr (dl_info.dli_fname, '/'); + if (p) + __collector_strlcpy (new_pathname, dl_info.dli_fname, + (p - dl_info.dli_fname + 2) < MAXPATHLEN ? (p - dl_info.dli_fname + 2) : MAXPATHLEN); + __collector_strlcat (new_pathname, pathname + origin_offset, MAXPATHLEN - CALL_UTIL (strlen)(new_pathname)); + real_pathname = new_pathname; + } + else + TprintfT (0, "ERROR: dladdr(%p): %s\n", caller, dlerror ()); + } + if (NULL_PTR (dlopen)) + init_mmap_intf (); + TprintfT (DBG_LT2, "libcollector.dlopen(%s,%d) interposing\n", + pathname ? pathname : "", mode); + void* ret = NULL; + + // set guard for duration of handling dlopen, since want to ensure + // new mappings are resolved after the actual dlopen has occurred + PUSH_REENTRANCE; + hrtime_t hrt = GETRELTIME (); + + if (real_pathname && !__collector_strchr (real_pathname, '/')) + { // got an unqualified name + // get caller and use its searchpath +#if ! ((ARCH(Intel) && WSIZE(32)) || ARCH(SPARC)) + void* caller = __builtin_return_address (0); // must be called inside dlopen +#endif + if (caller) + { +#if (ARCH(Intel) && WSIZE(32)) || ARCH(SPARC) + ret = dlopen_searchpath_symver (real_dlopen, caller, real_pathname, mode); +#else + ret = dlopen_searchpath (caller, real_pathname, mode); +#endif + } + } + + if (!ret) + { +#if (ARCH(Intel) && WSIZE(32)) || ARCH(SPARC) + ret = (real_dlopen) (real_pathname, mode); +#else + ret = CALL_REAL (dlopen)(real_pathname, mode); +#endif + } + TprintfT (DBG_LT2, "libcollector -- dlopen(%s) returning %p\n", pathname, ret); + + /* Don't call update if dlopen failed: preserve dlerror() */ + if (ret && (mmap_mode > 0) && !(mode & RTLD_NOLOAD)) + update_map_segments (hrt, 1); + TprintfT (DBG_LT2, "libcollector -- dlopen(%s) returning %p\n", pathname, ret); + POP_REENTRANCE; + return ret; +} + +/*------------------------------------------------------------- dlclose */ +int +dlclose (void *handle) +{ + if (NULL_PTR (dlclose)) + init_mmap_intf (); + TprintfT (DBG_LT2, "__collector_dlclose(%p) entered\n", handle); + hrtime_t hrt = GETRELTIME (); + if (!CHCK_REENTRANCE) + { + PUSH_REENTRANCE; + update_map_segments (hrt, 1); + POP_REENTRANCE; + hrt = GETRELTIME (); + } + int ret = CALL_REAL (dlclose)(handle); + + /* Don't call update if dlclose failed: preserve dlerror() */ + if (!ret && !CHCK_REENTRANCE) + { + PUSH_REENTRANCE; + update_map_segments (hrt, 1); + POP_REENTRANCE; + } + TprintfT (DBG_LT2, "__collector_dlclose(%p) returning %d\n", handle, ret); + return ret; +} |