| // -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- |
| // Copyright (c) 2006, Google Inc. |
| // All rights reserved. |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * 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. |
| // * Neither the name of Google Inc. nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT |
| // OWNER 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 <config.h> |
| #if (defined(_WIN32) || defined(__MINGW32__)) && !defined(__CYGWIN__) && !defined(__CYGWIN32) |
| # define PLATFORM_WINDOWS 1 |
| #endif |
| |
| #include <ctype.h> // for isspace() |
| #include <stdlib.h> // for getenv() |
| #include <stdio.h> // for snprintf(), sscanf() |
| #include <string.h> // for memmove(), memchr(), etc. |
| #include <fcntl.h> // for open() |
| #include <errno.h> // for errno |
| #ifdef HAVE_UNISTD_H |
| #include <unistd.h> // for read() |
| #endif |
| #if defined __MACH__ // Mac OS X, almost certainly |
| #include <mach-o/dyld.h> // for iterating over dll's in ProcMapsIter |
| #include <mach-o/loader.h> // for iterating over dll's in ProcMapsIter |
| #include <sys/types.h> |
| #include <sys/sysctl.h> // how we figure out numcpu's on OS X |
| #elif defined __FreeBSD__ |
| #include <sys/sysctl.h> |
| #elif defined __sun__ // Solaris |
| #include <procfs.h> // for, e.g., prmap_t |
| #elif defined(PLATFORM_WINDOWS) |
| #include <process.h> // for getpid() (actually, _getpid()) |
| #include <shlwapi.h> // for SHGetValueA() |
| #include <tlhelp32.h> // for Module32First() |
| #endif |
| #include "base/sysinfo.h" |
| #include "base/commandlineflags.h" |
| #include "base/dynamic_annotations.h" // for RunningOnValgrind |
| #include "base/logging.h" |
| #include "base/cycleclock.h" |
| |
| #ifdef PLATFORM_WINDOWS |
| #ifdef MODULEENTRY32 |
| // In a change from the usual W-A pattern, there is no A variant of |
| // MODULEENTRY32. Tlhelp32.h #defines the W variant, but not the A. |
| // In unicode mode, tlhelp32.h #defines MODULEENTRY32 to be |
| // MODULEENTRY32W. These #undefs are the only way I see to get back |
| // access to the original, ascii struct (and related functions). |
| #undef MODULEENTRY32 |
| #undef Module32First |
| #undef Module32Next |
| #undef PMODULEENTRY32 |
| #undef LPMODULEENTRY32 |
| #endif /* MODULEENTRY32 */ |
| // MinGW doesn't seem to define this, perhaps some windowsen don't either. |
| #ifndef TH32CS_SNAPMODULE32 |
| #define TH32CS_SNAPMODULE32 0 |
| #endif /* TH32CS_SNAPMODULE32 */ |
| #endif /* PLATFORM_WINDOWS */ |
| |
| // Re-run fn until it doesn't cause EINTR. |
| #define NO_INTR(fn) do {} while ((fn) < 0 && errno == EINTR) |
| |
| // open/read/close can set errno, which may be illegal at this |
| // time, so prefer making the syscalls directly if we can. |
| #ifdef HAVE_SYS_SYSCALL_H |
| # include <sys/syscall.h> |
| #endif |
| #ifdef SYS_open // solaris 11, at least sometimes, only defines SYS_openat |
| # define safeopen(filename, mode) syscall(SYS_open, filename, mode) |
| #else |
| # define safeopen(filename, mode) open(filename, mode) |
| #endif |
| #ifdef SYS_read |
| # define saferead(fd, buffer, size) syscall(SYS_read, fd, buffer, size) |
| #else |
| # define saferead(fd, buffer, size) read(fd, buffer, size) |
| #endif |
| #ifdef SYS_close |
| # define safeclose(fd) syscall(SYS_close, fd) |
| #else |
| # define safeclose(fd) close(fd) |
| #endif |
| |
| // ---------------------------------------------------------------------- |
| // GetenvBeforeMain() |
| // GetUniquePathFromEnv() |
| // Some non-trivial getenv-related functions. |
| // ---------------------------------------------------------------------- |
| |
| // It's not safe to call getenv() in the malloc hooks, because they |
| // might be called extremely early, before libc is done setting up |
| // correctly. In particular, the thread library may not be done |
| // setting up errno. So instead, we use the built-in __environ array |
| // if it exists, and otherwise read /proc/self/environ directly, using |
| // system calls to read the file, and thus avoid setting errno. |
| // /proc/self/environ has a limit of how much data it exports (around |
| // 8K), so it's not an ideal solution. |
| const char* GetenvBeforeMain(const char* name) { |
| #if defined(HAVE___ENVIRON) // if we have it, it's declared in unistd.h |
| if (__environ) { // can exist but be NULL, if statically linked |
| const int namelen = strlen(name); |
| for (char** p = __environ; *p; p++) { |
| if (!memcmp(*p, name, namelen) && (*p)[namelen] == '=') // it's a match |
| return *p + namelen+1; // point after = |
| } |
| return NULL; |
| } |
| #endif |
| #if defined(PLATFORM_WINDOWS) |
| // TODO(mbelshe) - repeated calls to this function will overwrite the |
| // contents of the static buffer. |
| static char envvar_buf[1024]; // enough to hold any envvar we care about |
| if (!GetEnvironmentVariableA(name, envvar_buf, sizeof(envvar_buf)-1)) |
| return NULL; |
| return envvar_buf; |
| #endif |
| // static is ok because this function should only be called before |
| // main(), when we're single-threaded. |
| static char envbuf[16<<10]; |
| if (*envbuf == '\0') { // haven't read the environ yet |
| int fd = safeopen("/proc/self/environ", O_RDONLY); |
| // The -2 below guarantees the last two bytes of the buffer will be \0\0 |
| if (fd == -1 || // unable to open the file, fall back onto libc |
| saferead(fd, envbuf, sizeof(envbuf) - 2) < 0) { // error reading file |
| RAW_VLOG(1, "Unable to open /proc/self/environ, falling back " |
| "on getenv(\"%s\"), which may not work", name); |
| if (fd != -1) safeclose(fd); |
| return getenv(name); |
| } |
| safeclose(fd); |
| } |
| const int namelen = strlen(name); |
| const char* p = envbuf; |
| while (*p != '\0') { // will happen at the \0\0 that terminates the buffer |
| // proc file has the format NAME=value\0NAME=value\0NAME=value\0... |
| const char* endp = (char*)memchr(p, '\0', sizeof(envbuf) - (p - envbuf)); |
| if (endp == NULL) // this entry isn't NUL terminated |
| return NULL; |
| else if (!memcmp(p, name, namelen) && p[namelen] == '=') // it's a match |
| return p + namelen+1; // point after = |
| p = endp + 1; |
| } |
| return NULL; // env var never found |
| } |
| |
| extern "C" { |
| const char* TCMallocGetenvSafe(const char* name) { |
| return GetenvBeforeMain(name); |
| } |
| } |
| |
| // This takes as an argument an environment-variable name (like |
| // CPUPROFILE) whose value is supposed to be a file-path, and sets |
| // path to that path, and returns true. If the env var doesn't exist, |
| // or is the empty string, leave path unchanged and returns false. |
| // The reason this is non-trivial is that this function handles munged |
| // pathnames. Here's why: |
| // |
| // If we're a child process of the 'main' process, we can't just use |
| // getenv("CPUPROFILE") -- the parent process will be using that path. |
| // Instead we append our pid to the pathname. How do we tell if we're a |
| // child process? Ideally we'd set an environment variable that all |
| // our children would inherit. But -- and this is seemingly a bug in |
| // gcc -- if you do a setenv() in a shared libarary in a global |
| // constructor, the environment setting is lost by the time main() is |
| // called. The only safe thing we can do in such a situation is to |
| // modify the existing envvar. So we do a hack: in the parent, we set |
| // the high bit of the 1st char of CPUPROFILE. In the child, we |
| // notice the high bit is set and append the pid(). This works |
| // assuming cpuprofile filenames don't normally have the high bit set |
| // in their first character! If that assumption is violated, we'll |
| // still get a profile, but one with an unexpected name. |
| // TODO(csilvers): set an envvar instead when we can do it reliably. |
| bool GetUniquePathFromEnv(const char* env_name, char* path) { |
| char* envval = getenv(env_name); |
| if (envval == NULL || *envval == '\0') |
| return false; |
| if (envval[0] & 128) { // high bit is set |
| snprintf(path, PATH_MAX, "%c%s_%u", // add pid and clear high bit |
| envval[0] & 127, envval+1, (unsigned int)(getpid())); |
| } else { |
| snprintf(path, PATH_MAX, "%s", envval); |
| envval[0] |= 128; // set high bit for kids to see |
| } |
| return true; |
| } |
| |
| // ---------------------------------------------------------------------- |
| // CyclesPerSecond() |
| // NumCPUs() |
| // It's important this not call malloc! -- they may be called at |
| // global-construct time, before we've set up all our proper malloc |
| // hooks and such. |
| // ---------------------------------------------------------------------- |
| |
| static double cpuinfo_cycles_per_second = 1.0; // 0.0 might be dangerous |
| static int cpuinfo_num_cpus = 1; // Conservative guess |
| |
| void SleepForMilliseconds(int milliseconds) { |
| #ifdef PLATFORM_WINDOWS |
| _sleep(milliseconds); // Windows's _sleep takes milliseconds argument |
| #else |
| // Sleep for a few milliseconds |
| struct timespec sleep_time; |
| sleep_time.tv_sec = milliseconds / 1000; |
| sleep_time.tv_nsec = (milliseconds % 1000) * 1000000; |
| while (nanosleep(&sleep_time, &sleep_time) != 0 && errno == EINTR) |
| ; // Ignore signals and wait for the full interval to elapse. |
| #endif |
| } |
| |
| // Helper function estimates cycles/sec by observing cycles elapsed during |
| // sleep(). Using small sleep time decreases accuracy significantly. |
| static int64 EstimateCyclesPerSecond(const int estimate_time_ms) { |
| assert(estimate_time_ms > 0); |
| if (estimate_time_ms <= 0) |
| return 1; |
| double multiplier = 1000.0 / (double)estimate_time_ms; // scale by this much |
| |
| const int64 start_ticks = CycleClock::Now(); |
| SleepForMilliseconds(estimate_time_ms); |
| const int64 guess = int64(multiplier * (CycleClock::Now() - start_ticks)); |
| return guess; |
| } |
| |
| // ReadIntFromFile is only called on linux and cygwin platforms. |
| #if defined(__linux__) || defined(__CYGWIN__) || defined(__CYGWIN32__) |
| // Helper function for reading an int from a file. Returns true if successful |
| // and the memory location pointed to by value is set to the value read. |
| static bool ReadIntFromFile(const char *file, int *value) { |
| bool ret = false; |
| int fd = open(file, O_RDONLY); |
| if (fd != -1) { |
| char line[1024]; |
| char* err; |
| memset(line, '\0', sizeof(line)); |
| read(fd, line, sizeof(line) - 1); |
| const int temp_value = strtol(line, &err, 10); |
| if (line[0] != '\0' && (*err == '\n' || *err == '\0')) { |
| *value = temp_value; |
| ret = true; |
| } |
| close(fd); |
| } |
| return ret; |
| } |
| #endif |
| |
| // WARNING: logging calls back to InitializeSystemInfo() so it must |
| // not invoke any logging code. Also, InitializeSystemInfo() can be |
| // called before main() -- in fact it *must* be since already_called |
| // isn't protected -- before malloc hooks are properly set up, so |
| // we make an effort not to call any routines which might allocate |
| // memory. |
| |
| static void InitializeSystemInfo() { |
| static bool already_called = false; // safe if we run before threads |
| if (already_called) return; |
| already_called = true; |
| |
| bool saw_mhz = false; |
| |
| if (RunningOnValgrind()) { |
| // Valgrind may slow the progress of time artificially (--scale-time=N |
| // option). We thus can't rely on CPU Mhz info stored in /sys or /proc |
| // files. Thus, actually measure the cps. |
| cpuinfo_cycles_per_second = EstimateCyclesPerSecond(100); |
| saw_mhz = true; |
| } |
| |
| #if defined(__linux__) || defined(__CYGWIN__) || defined(__CYGWIN32__) |
| char line[1024]; |
| char* err; |
| int freq; |
| |
| // If the kernel is exporting the tsc frequency use that. There are issues |
| // where cpuinfo_max_freq cannot be relied on because the BIOS may be |
| // exporintg an invalid p-state (on x86) or p-states may be used to put the |
| // processor in a new mode (turbo mode). Essentially, those frequencies |
| // cannot always be relied upon. The same reasons apply to /proc/cpuinfo as |
| // well. |
| if (!saw_mhz && |
| ReadIntFromFile("/sys/devices/system/cpu/cpu0/tsc_freq_khz", &freq)) { |
| // The value is in kHz (as the file name suggests). For example, on a |
| // 2GHz warpstation, the file contains the value "2000000". |
| cpuinfo_cycles_per_second = freq * 1000.0; |
| saw_mhz = true; |
| } |
| |
| // If CPU scaling is in effect, we want to use the *maximum* frequency, |
| // not whatever CPU speed some random processor happens to be using now. |
| if (!saw_mhz && |
| ReadIntFromFile("/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq", |
| &freq)) { |
| // The value is in kHz. For example, on a 2GHz machine, the file |
| // contains the value "2000000". |
| cpuinfo_cycles_per_second = freq * 1000.0; |
| saw_mhz = true; |
| } |
| |
| // Read /proc/cpuinfo for other values, and if there is no cpuinfo_max_freq. |
| const char* pname = "/proc/cpuinfo"; |
| int fd = open(pname, O_RDONLY); |
| if (fd == -1) { |
| perror(pname); |
| if (!saw_mhz) { |
| cpuinfo_cycles_per_second = EstimateCyclesPerSecond(1000); |
| } |
| return; // TODO: use generic tester instead? |
| } |
| |
| double bogo_clock = 1.0; |
| bool saw_bogo = false; |
| int num_cpus = 0; |
| line[0] = line[1] = '\0'; |
| int chars_read = 0; |
| do { // we'll exit when the last read didn't read anything |
| // Move the next line to the beginning of the buffer |
| const int oldlinelen = strlen(line); |
| if (sizeof(line) == oldlinelen + 1) // oldlinelen took up entire line |
| line[0] = '\0'; |
| else // still other lines left to save |
| memmove(line, line + oldlinelen+1, sizeof(line) - (oldlinelen+1)); |
| // Terminate the new line, reading more if we can't find the newline |
| char* newline = strchr(line, '\n'); |
| if (newline == NULL) { |
| const int linelen = strlen(line); |
| const int bytes_to_read = sizeof(line)-1 - linelen; |
| assert(bytes_to_read > 0); // because the memmove recovered >=1 bytes |
| chars_read = read(fd, line + linelen, bytes_to_read); |
| line[linelen + chars_read] = '\0'; |
| newline = strchr(line, '\n'); |
| } |
| if (newline != NULL) |
| *newline = '\0'; |
| |
| #if defined(__powerpc__) || defined(__ppc__) |
| // PowerPC cpus report the frequency in "clock" line |
| if (strncasecmp(line, "clock", sizeof("clock")-1) == 0) { |
| const char* freqstr = strchr(line, ':'); |
| if (freqstr) { |
| // PowerPC frequencies are only reported as MHz (check 'show_cpuinfo' |
| // function at arch/powerpc/kernel/setup-common.c) |
| char *endp = strstr(line, "MHz"); |
| if (endp) { |
| *endp = 0; |
| cpuinfo_cycles_per_second = strtod(freqstr+1, &err) * 1000000.0; |
| if (freqstr[1] != '\0' && *err == '\0' && cpuinfo_cycles_per_second > 0) |
| saw_mhz = true; |
| } |
| } |
| #else |
| // When parsing the "cpu MHz" and "bogomips" (fallback) entries, we only |
| // accept postive values. Some environments (virtual machines) report zero, |
| // which would cause infinite looping in WallTime_Init. |
| if (!saw_mhz && strncasecmp(line, "cpu MHz", sizeof("cpu MHz")-1) == 0) { |
| const char* freqstr = strchr(line, ':'); |
| if (freqstr) { |
| cpuinfo_cycles_per_second = strtod(freqstr+1, &err) * 1000000.0; |
| if (freqstr[1] != '\0' && *err == '\0' && cpuinfo_cycles_per_second > 0) |
| saw_mhz = true; |
| } |
| } else if (strncasecmp(line, "bogomips", sizeof("bogomips")-1) == 0) { |
| const char* freqstr = strchr(line, ':'); |
| if (freqstr) { |
| bogo_clock = strtod(freqstr+1, &err) * 1000000.0; |
| if (freqstr[1] != '\0' && *err == '\0' && bogo_clock > 0) |
| saw_bogo = true; |
| } |
| #endif |
| } else if (strncasecmp(line, "processor", sizeof("processor")-1) == 0) { |
| num_cpus++; // count up every time we see an "processor :" entry |
| } |
| } while (chars_read > 0); |
| close(fd); |
| |
| if (!saw_mhz) { |
| if (saw_bogo) { |
| // If we didn't find anything better, we'll use bogomips, but |
| // we're not happy about it. |
| cpuinfo_cycles_per_second = bogo_clock; |
| } else { |
| // If we don't even have bogomips, we'll use the slow estimation. |
| cpuinfo_cycles_per_second = EstimateCyclesPerSecond(1000); |
| } |
| } |
| if (cpuinfo_cycles_per_second == 0.0) { |
| cpuinfo_cycles_per_second = 1.0; // maybe unnecessary, but safe |
| } |
| if (num_cpus > 0) { |
| cpuinfo_num_cpus = num_cpus; |
| } |
| |
| #elif defined __FreeBSD__ |
| // For this sysctl to work, the machine must be configured without |
| // SMP, APIC, or APM support. hz should be 64-bit in freebsd 7.0 |
| // and later. Before that, it's a 32-bit quantity (and gives the |
| // wrong answer on machines faster than 2^32 Hz). See |
| // http://lists.freebsd.org/pipermail/freebsd-i386/2004-November/001846.html |
| // But also compare FreeBSD 7.0: |
| // http://fxr.watson.org/fxr/source/i386/i386/tsc.c?v=RELENG70#L223 |
| // 231 error = sysctl_handle_quad(oidp, &freq, 0, req); |
| // To FreeBSD 6.3 (it's the same in 6-STABLE): |
| // http://fxr.watson.org/fxr/source/i386/i386/tsc.c?v=RELENG6#L131 |
| // 139 error = sysctl_handle_int(oidp, &freq, sizeof(freq), req); |
| #if __FreeBSD__ >= 7 |
| uint64_t hz = 0; |
| #else |
| unsigned int hz = 0; |
| #endif |
| size_t sz = sizeof(hz); |
| const char *sysctl_path = "machdep.tsc_freq"; |
| if ( sysctlbyname(sysctl_path, &hz, &sz, NULL, 0) != 0 ) { |
| fprintf(stderr, "Unable to determine clock rate from sysctl: %s: %s\n", |
| sysctl_path, strerror(errno)); |
| cpuinfo_cycles_per_second = EstimateCyclesPerSecond(1000); |
| } else { |
| cpuinfo_cycles_per_second = hz; |
| } |
| // TODO(csilvers): also figure out cpuinfo_num_cpus |
| |
| #elif defined(PLATFORM_WINDOWS) |
| # pragma comment(lib, "shlwapi.lib") // for SHGetValue() |
| // In NT, read MHz from the registry. If we fail to do so or we're in win9x |
| // then make a crude estimate. |
| OSVERSIONINFO os; |
| os.dwOSVersionInfoSize = sizeof(os); |
| DWORD data, data_size = sizeof(data); |
| if (GetVersionEx(&os) && |
| os.dwPlatformId == VER_PLATFORM_WIN32_NT && |
| SUCCEEDED(SHGetValueA(HKEY_LOCAL_MACHINE, |
| "HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0", |
| "~MHz", NULL, &data, &data_size))) |
| cpuinfo_cycles_per_second = (int64)data * (int64)(1000 * 1000); // was mhz |
| else |
| cpuinfo_cycles_per_second = EstimateCyclesPerSecond(500); // TODO <500? |
| |
| // Get the number of processors. |
| SYSTEM_INFO info; |
| GetSystemInfo(&info); |
| cpuinfo_num_cpus = info.dwNumberOfProcessors; |
| |
| #elif defined(__MACH__) && defined(__APPLE__) |
| // returning "mach time units" per second. the current number of elapsed |
| // mach time units can be found by calling uint64 mach_absolute_time(); |
| // while not as precise as actual CPU cycles, it is accurate in the face |
| // of CPU frequency scaling and multi-cpu/core machines. |
| // Our mac users have these types of machines, and accuracy |
| // (i.e. correctness) trumps precision. |
| // See cycleclock.h: CycleClock::Now(), which returns number of mach time |
| // units on Mac OS X. |
| mach_timebase_info_data_t timebase_info; |
| mach_timebase_info(&timebase_info); |
| double mach_time_units_per_nanosecond = |
| static_cast<double>(timebase_info.denom) / |
| static_cast<double>(timebase_info.numer); |
| cpuinfo_cycles_per_second = mach_time_units_per_nanosecond * 1e9; |
| |
| int num_cpus = 0; |
| size_t size = sizeof(num_cpus); |
| int numcpus_name[] = { CTL_HW, HW_NCPU }; |
| if (::sysctl(numcpus_name, arraysize(numcpus_name), &num_cpus, &size, 0, 0) |
| == 0 |
| && (size == sizeof(num_cpus))) |
| cpuinfo_num_cpus = num_cpus; |
| |
| #else |
| // Generic cycles per second counter |
| cpuinfo_cycles_per_second = EstimateCyclesPerSecond(1000); |
| #endif |
| } |
| |
| double CyclesPerSecond(void) { |
| InitializeSystemInfo(); |
| return cpuinfo_cycles_per_second; |
| } |
| |
| int NumCPUs(void) { |
| InitializeSystemInfo(); |
| return cpuinfo_num_cpus; |
| } |
| |
| // ---------------------------------------------------------------------- |
| // HasPosixThreads() |
| // Return true if we're running POSIX (e.g., NPTL on Linux) |
| // threads, as opposed to a non-POSIX thread library. The thing |
| // that we care about is whether a thread's pid is the same as |
| // the thread that spawned it. If so, this function returns |
| // true. |
| // ---------------------------------------------------------------------- |
| bool HasPosixThreads() { |
| #if defined(__linux__) |
| #ifndef _CS_GNU_LIBPTHREAD_VERSION |
| #define _CS_GNU_LIBPTHREAD_VERSION 3 |
| #endif |
| char buf[32]; |
| // We assume that, if confstr() doesn't know about this name, then |
| // the same glibc is providing LinuxThreads. |
| if (confstr(_CS_GNU_LIBPTHREAD_VERSION, buf, sizeof(buf)) == 0) |
| return false; |
| return strncmp(buf, "NPTL", 4) == 0; |
| #elif defined(PLATFORM_WINDOWS) || defined(__CYGWIN__) || defined(__CYGWIN32__) |
| return false; |
| #else // other OS |
| return true; // Assume that everything else has Posix |
| #endif // else OS_LINUX |
| } |
| |
| // ---------------------------------------------------------------------- |
| |
| #if defined __linux__ || defined __FreeBSD__ || defined __sun__ || defined __CYGWIN__ || defined __CYGWIN32__ |
| static void ConstructFilename(const char* spec, pid_t pid, |
| char* buf, int buf_size) { |
| CHECK_LT(snprintf(buf, buf_size, |
| spec, |
| static_cast<int>(pid ? pid : getpid())), buf_size); |
| } |
| #endif |
| |
| // A templatized helper function instantiated for Mach (OS X) only. |
| // It can handle finding info for both 32 bits and 64 bits. |
| // Returns true if it successfully handled the hdr, false else. |
| #ifdef __MACH__ // Mac OS X, almost certainly |
| template<uint32_t kMagic, uint32_t kLCSegment, |
| typename MachHeader, typename SegmentCommand> |
| static bool NextExtMachHelper(const mach_header* hdr, |
| int current_image, int current_load_cmd, |
| uint64 *start, uint64 *end, char **flags, |
| uint64 *offset, int64 *inode, char **filename, |
| uint64 *file_mapping, uint64 *file_pages, |
| uint64 *anon_mapping, uint64 *anon_pages, |
| dev_t *dev) { |
| static char kDefaultPerms[5] = "r-xp"; |
| if (hdr->magic != kMagic) |
| return false; |
| const char* lc = (const char *)hdr + sizeof(MachHeader); |
| // TODO(csilvers): make this not-quadradic (increment and hold state) |
| for (int j = 0; j < current_load_cmd; j++) // advance to *our* load_cmd |
| lc += ((const load_command *)lc)->cmdsize; |
| if (((const load_command *)lc)->cmd == kLCSegment) { |
| const intptr_t dlloff = _dyld_get_image_vmaddr_slide(current_image); |
| const SegmentCommand* sc = (const SegmentCommand *)lc; |
| if (start) *start = sc->vmaddr + dlloff; |
| if (end) *end = sc->vmaddr + sc->vmsize + dlloff; |
| if (flags) *flags = kDefaultPerms; // can we do better? |
| if (offset) *offset = sc->fileoff; |
| if (inode) *inode = 0; |
| if (filename) |
| *filename = const_cast<char*>(_dyld_get_image_name(current_image)); |
| if (file_mapping) *file_mapping = 0; |
| if (file_pages) *file_pages = 0; // could we use sc->filesize? |
| if (anon_mapping) *anon_mapping = 0; |
| if (anon_pages) *anon_pages = 0; |
| if (dev) *dev = 0; |
| return true; |
| } |
| |
| return false; |
| } |
| #endif |
| |
| // Finds |c| in |text|, and assign '\0' at the found position. |
| // The original character at the modified position should be |c|. |
| // A pointer to the modified position is stored in |endptr|. |
| // |endptr| should not be NULL. |
| static bool ExtractUntilChar(char *text, int c, char **endptr) { |
| CHECK_NE(text, NULL); |
| CHECK_NE(endptr, NULL); |
| char *found; |
| found = strchr(text, c); |
| if (found == NULL) { |
| *endptr = NULL; |
| return false; |
| } |
| |
| *endptr = found; |
| *found = '\0'; |
| return true; |
| } |
| |
| // Increments |*text_pointer| while it points a whitespace character. |
| // It is to follow sscanf's whilespace handling. |
| static void SkipWhileWhitespace(char **text_pointer, int c) { |
| if (isspace(c)) { |
| while (isspace(**text_pointer) && isspace(*((*text_pointer) + 1))) { |
| ++(*text_pointer); |
| } |
| } |
| } |
| |
| template<class T> |
| static T StringToInteger(char *text, char **endptr, int base) { |
| assert(false); |
| return T(); |
| } |
| |
| template<> |
| int StringToInteger<int>(char *text, char **endptr, int base) { |
| return strtol(text, endptr, base); |
| } |
| |
| template<> |
| int64 StringToInteger<int64>(char *text, char **endptr, int base) { |
| return strtoll(text, endptr, base); |
| } |
| |
| template<> |
| uint64 StringToInteger<uint64>(char *text, char **endptr, int base) { |
| return strtoull(text, endptr, base); |
| } |
| |
| template<typename T> |
| static T StringToIntegerUntilChar( |
| char *text, int base, int c, char **endptr_result) { |
| CHECK_NE(endptr_result, NULL); |
| *endptr_result = NULL; |
| |
| char *endptr_extract; |
| if (!ExtractUntilChar(text, c, &endptr_extract)) |
| return 0; |
| |
| T result; |
| char *endptr_strto; |
| result = StringToInteger<T>(text, &endptr_strto, base); |
| *endptr_extract = c; |
| |
| if (endptr_extract != endptr_strto) |
| return 0; |
| |
| *endptr_result = endptr_extract; |
| SkipWhileWhitespace(endptr_result, c); |
| |
| return result; |
| } |
| |
| static char *CopyStringUntilChar( |
| char *text, unsigned out_len, int c, char *out) { |
| char *endptr; |
| if (!ExtractUntilChar(text, c, &endptr)) |
| return NULL; |
| |
| strncpy(out, text, out_len); |
| out[out_len-1] = '\0'; |
| *endptr = c; |
| |
| SkipWhileWhitespace(&endptr, c); |
| return endptr; |
| } |
| |
| template<typename T> |
| static bool StringToIntegerUntilCharWithCheck( |
| T *outptr, char *text, int base, int c, char **endptr) { |
| *outptr = StringToIntegerUntilChar<T>(*endptr, base, c, endptr); |
| if (*endptr == NULL || **endptr == '\0') return false; |
| ++(*endptr); |
| return true; |
| } |
| |
| static bool ParseProcMapsLine(char *text, uint64 *start, uint64 *end, |
| char *flags, uint64 *offset, |
| int *major, int *minor, int64 *inode, |
| unsigned *filename_offset) { |
| #if defined(__linux__) |
| /* |
| * It's similar to: |
| * sscanf(text, "%"SCNx64"-%"SCNx64" %4s %"SCNx64" %x:%x %"SCNd64" %n", |
| * start, end, flags, offset, major, minor, inode, filename_offset) |
| */ |
| char *endptr = text; |
| if (endptr == NULL || *endptr == '\0') return false; |
| |
| if (!StringToIntegerUntilCharWithCheck(start, endptr, 16, '-', &endptr)) |
| return false; |
| |
| if (!StringToIntegerUntilCharWithCheck(end, endptr, 16, ' ', &endptr)) |
| return false; |
| |
| endptr = CopyStringUntilChar(endptr, 5, ' ', flags); |
| if (endptr == NULL || *endptr == '\0') return false; |
| ++endptr; |
| |
| if (!StringToIntegerUntilCharWithCheck(offset, endptr, 16, ' ', &endptr)) |
| return false; |
| |
| if (!StringToIntegerUntilCharWithCheck(major, endptr, 16, ':', &endptr)) |
| return false; |
| |
| if (!StringToIntegerUntilCharWithCheck(minor, endptr, 16, ' ', &endptr)) |
| return false; |
| |
| if (!StringToIntegerUntilCharWithCheck(inode, endptr, 10, ' ', &endptr)) |
| return false; |
| |
| *filename_offset = (endptr - text); |
| return true; |
| #else |
| return false; |
| #endif |
| } |
| |
| ProcMapsIterator::ProcMapsIterator(pid_t pid) { |
| Init(pid, NULL, false); |
| } |
| |
| ProcMapsIterator::ProcMapsIterator(pid_t pid, Buffer *buffer) { |
| Init(pid, buffer, false); |
| } |
| |
| ProcMapsIterator::ProcMapsIterator(pid_t pid, Buffer *buffer, |
| bool use_maps_backing) { |
| Init(pid, buffer, use_maps_backing); |
| } |
| |
| void ProcMapsIterator::Init(pid_t pid, Buffer *buffer, |
| bool use_maps_backing) { |
| pid_ = pid; |
| using_maps_backing_ = use_maps_backing; |
| dynamic_buffer_ = NULL; |
| if (!buffer) { |
| // If the user didn't pass in any buffer storage, allocate it |
| // now. This is the normal case; the signal handler passes in a |
| // static buffer. |
| buffer = dynamic_buffer_ = new Buffer; |
| } else { |
| dynamic_buffer_ = NULL; |
| } |
| |
| ibuf_ = buffer->buf_; |
| |
| stext_ = etext_ = nextline_ = ibuf_; |
| ebuf_ = ibuf_ + Buffer::kBufSize - 1; |
| nextline_ = ibuf_; |
| |
| #if defined(__linux__) || defined(__CYGWIN__) || defined(__CYGWIN32__) |
| if (use_maps_backing) { // don't bother with clever "self" stuff in this case |
| ConstructFilename("/proc/%d/maps_backing", pid, ibuf_, Buffer::kBufSize); |
| } else if (pid == 0) { |
| // We have to kludge a bit to deal with the args ConstructFilename |
| // expects. The 1 is never used -- it's only impt. that it's not 0. |
| ConstructFilename("/proc/self/maps", 1, ibuf_, Buffer::kBufSize); |
| } else { |
| ConstructFilename("/proc/%d/maps", pid, ibuf_, Buffer::kBufSize); |
| } |
| // No error logging since this can be called from the crash dump |
| // handler at awkward moments. Users should call Valid() before |
| // using. |
| NO_INTR(fd_ = open(ibuf_, O_RDONLY)); |
| #elif defined(__FreeBSD__) |
| // We don't support maps_backing on freebsd |
| if (pid == 0) { |
| ConstructFilename("/proc/curproc/map", 1, ibuf_, Buffer::kBufSize); |
| } else { |
| ConstructFilename("/proc/%d/map", pid, ibuf_, Buffer::kBufSize); |
| } |
| NO_INTR(fd_ = open(ibuf_, O_RDONLY)); |
| #elif defined(__sun__) |
| if (pid == 0) { |
| ConstructFilename("/proc/self/map", 1, ibuf_, Buffer::kBufSize); |
| } else { |
| ConstructFilename("/proc/%d/map", pid, ibuf_, Buffer::kBufSize); |
| } |
| NO_INTR(fd_ = open(ibuf_, O_RDONLY)); |
| #elif defined(__MACH__) |
| current_image_ = _dyld_image_count(); // count down from the top |
| current_load_cmd_ = -1; |
| #elif defined(PLATFORM_WINDOWS) |
| snapshot_ = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | |
| TH32CS_SNAPMODULE32, |
| GetCurrentProcessId()); |
| memset(&module_, 0, sizeof(module_)); |
| #else |
| fd_ = -1; // so Valid() is always false |
| #endif |
| |
| } |
| |
| ProcMapsIterator::~ProcMapsIterator() { |
| #if defined(PLATFORM_WINDOWS) |
| if (snapshot_ != INVALID_HANDLE_VALUE) CloseHandle(snapshot_); |
| #elif defined(__MACH__) |
| // no cleanup necessary! |
| #else |
| if (fd_ >= 0) NO_INTR(close(fd_)); |
| #endif |
| delete dynamic_buffer_; |
| } |
| |
| bool ProcMapsIterator::Valid() const { |
| #if defined(PLATFORM_WINDOWS) |
| return snapshot_ != INVALID_HANDLE_VALUE; |
| #elif defined(__MACH__) |
| return 1; |
| #else |
| return fd_ != -1; |
| #endif |
| } |
| |
| bool ProcMapsIterator::Next(uint64 *start, uint64 *end, char **flags, |
| uint64 *offset, int64 *inode, char **filename) { |
| return NextExt(start, end, flags, offset, inode, filename, NULL, NULL, |
| NULL, NULL, NULL); |
| } |
| |
| // This has too many arguments. It should really be building |
| // a map object and returning it. The problem is that this is called |
| // when the memory allocator state is undefined, hence the arguments. |
| bool ProcMapsIterator::NextExt(uint64 *start, uint64 *end, char **flags, |
| uint64 *offset, int64 *inode, char **filename, |
| uint64 *file_mapping, uint64 *file_pages, |
| uint64 *anon_mapping, uint64 *anon_pages, |
| dev_t *dev) { |
| |
| #if defined(__linux__) || defined(__FreeBSD__) || defined(__CYGWIN__) || defined(__CYGWIN32__) |
| do { |
| // Advance to the start of the next line |
| stext_ = nextline_; |
| |
| // See if we have a complete line in the buffer already |
| nextline_ = static_cast<char *>(memchr (stext_, '\n', etext_ - stext_)); |
| if (!nextline_) { |
| // Shift/fill the buffer so we do have a line |
| int count = etext_ - stext_; |
| |
| // Move the current text to the start of the buffer |
| memmove(ibuf_, stext_, count); |
| stext_ = ibuf_; |
| etext_ = ibuf_ + count; |
| |
| int nread = 0; // fill up buffer with text |
| while (etext_ < ebuf_) { |
| NO_INTR(nread = read(fd_, etext_, ebuf_ - etext_)); |
| if (nread > 0) |
| etext_ += nread; |
| else |
| break; |
| } |
| |
| // Zero out remaining characters in buffer at EOF to avoid returning |
| // garbage from subsequent calls. |
| if (etext_ != ebuf_ && nread == 0) { |
| memset(etext_, 0, ebuf_ - etext_); |
| } |
| *etext_ = '\n'; // sentinel; safe because ibuf extends 1 char beyond ebuf |
| nextline_ = static_cast<char *>(memchr (stext_, '\n', etext_ + 1 - stext_)); |
| } |
| *nextline_ = 0; // turn newline into nul |
| nextline_ += ((nextline_ < etext_)? 1 : 0); // skip nul if not end of text |
| // stext_ now points at a nul-terminated line |
| uint64 tmpstart, tmpend, tmpoffset; |
| int64 tmpinode; |
| int major, minor; |
| unsigned filename_offset = 0; |
| #if defined(__linux__) |
| // for now, assume all linuxes have the same format |
| if (!ParseProcMapsLine( |
| stext_, |
| start ? start : &tmpstart, |
| end ? end : &tmpend, |
| flags_, |
| offset ? offset : &tmpoffset, |
| &major, &minor, |
| inode ? inode : &tmpinode, &filename_offset)) continue; |
| #elif defined(__CYGWIN__) || defined(__CYGWIN32__) |
| // cygwin is like linux, except the third field is the "entry point" |
| // rather than the offset (see format_process_maps at |
| // http://cygwin.com/cgi-bin/cvsweb.cgi/src/winsup/cygwin/fhandler_process.cc?rev=1.89&content-type=text/x-cvsweb-markup&cvsroot=src |
| // Offset is always be 0 on cygwin: cygwin implements an mmap |
| // by loading the whole file and then calling NtMapViewOfSection. |
| // Cygwin also seems to set its flags kinda randomly; use windows default. |
| char tmpflags[5]; |
| if (offset) |
| *offset = 0; |
| strcpy(flags_, "r-xp"); |
| if (sscanf(stext_, "%llx-%llx %4s %llx %x:%x %lld %n", |
| start ? start : &tmpstart, |
| end ? end : &tmpend, |
| tmpflags, |
| &tmpoffset, |
| &major, &minor, |
| inode ? inode : &tmpinode, &filename_offset) != 7) continue; |
| #elif defined(__FreeBSD__) |
| // For the format, see http://www.freebsd.org/cgi/cvsweb.cgi/src/sys/fs/procfs/procfs_map.c?rev=1.31&content-type=text/x-cvsweb-markup |
| tmpstart = tmpend = tmpoffset = 0; |
| tmpinode = 0; |
| major = minor = 0; // can't get this info in freebsd |
| if (inode) |
| *inode = 0; // nor this |
| if (offset) |
| *offset = 0; // seems like this should be in there, but maybe not |
| // start end resident privateresident obj(?) prot refcnt shadowcnt |
| // flags copy_on_write needs_copy type filename: |
| // 0x8048000 0x804a000 2 0 0xc104ce70 r-x 1 0 0x0 COW NC vnode /bin/cat |
| if (sscanf(stext_, "0x%" SCNx64 " 0x%" SCNx64 " %*d %*d %*p %3s %*d %*d 0x%*x %*s %*s %*s %n", |
| start ? start : &tmpstart, |
| end ? end : &tmpend, |
| flags_, |
| &filename_offset) != 3) continue; |
| #endif |
| |
| // Depending on the Linux kernel being used, there may or may not be a space |
| // after the inode if there is no filename. sscanf will in such situations |
| // nondeterministically either fill in filename_offset or not (the results |
| // differ on multiple calls in the same run even with identical arguments). |
| // We don't want to wander off somewhere beyond the end of the string. |
| size_t stext_length = strlen(stext_); |
| if (filename_offset == 0 || filename_offset > stext_length) |
| filename_offset = stext_length; |
| |
| // We found an entry |
| if (flags) *flags = flags_; |
| if (filename) *filename = stext_ + filename_offset; |
| if (dev) *dev = minor | (major << 8); |
| |
| if (using_maps_backing_) { |
| // Extract and parse physical page backing info. |
| char *backing_ptr = stext_ + filename_offset + |
| strlen(stext_+filename_offset); |
| |
| // find the second '(' |
| int paren_count = 0; |
| while (--backing_ptr > stext_) { |
| if (*backing_ptr == '(') { |
| ++paren_count; |
| if (paren_count >= 2) { |
| uint64 tmp_file_mapping; |
| uint64 tmp_file_pages; |
| uint64 tmp_anon_mapping; |
| uint64 tmp_anon_pages; |
| |
| sscanf(backing_ptr+1, "F %" SCNx64 " %" SCNd64 ") (A %" SCNx64 " %" SCNd64 ")", |
| file_mapping ? file_mapping : &tmp_file_mapping, |
| file_pages ? file_pages : &tmp_file_pages, |
| anon_mapping ? anon_mapping : &tmp_anon_mapping, |
| anon_pages ? anon_pages : &tmp_anon_pages); |
| // null terminate the file name (there is a space |
| // before the first (. |
| backing_ptr[-1] = 0; |
| break; |
| } |
| } |
| } |
| } |
| |
| return true; |
| } while (etext_ > ibuf_); |
| #elif defined(__sun__) |
| // This is based on MA_READ == 4, MA_WRITE == 2, MA_EXEC == 1 |
| static char kPerms[8][4] = { "---", "--x", "-w-", "-wx", |
| "r--", "r-x", "rw-", "rwx" }; |
| COMPILE_ASSERT(MA_READ == 4, solaris_ma_read_must_equal_4); |
| COMPILE_ASSERT(MA_WRITE == 2, solaris_ma_write_must_equal_2); |
| COMPILE_ASSERT(MA_EXEC == 1, solaris_ma_exec_must_equal_1); |
| Buffer object_path; |
| int nread = 0; // fill up buffer with text |
| NO_INTR(nread = read(fd_, ibuf_, sizeof(prmap_t))); |
| if (nread == sizeof(prmap_t)) { |
| long inode_from_mapname = 0; |
| prmap_t* mapinfo = reinterpret_cast<prmap_t*>(ibuf_); |
| // Best-effort attempt to get the inode from the filename. I think the |
| // two middle ints are major and minor device numbers, but I'm not sure. |
| sscanf(mapinfo->pr_mapname, "ufs.%*d.%*d.%ld", &inode_from_mapname); |
| |
| if (pid_ == 0) { |
| CHECK_LT(snprintf(object_path.buf_, Buffer::kBufSize, |
| "/proc/self/path/%s", mapinfo->pr_mapname), |
| Buffer::kBufSize); |
| } else { |
| CHECK_LT(snprintf(object_path.buf_, Buffer::kBufSize, |
| "/proc/%d/path/%s", |
| static_cast<int>(pid_), mapinfo->pr_mapname), |
| Buffer::kBufSize); |
| } |
| ssize_t len = readlink(object_path.buf_, current_filename_, PATH_MAX); |
| CHECK_LT(len, PATH_MAX); |
| if (len < 0) |
| len = 0; |
| current_filename_[len] = '\0'; |
| |
| if (start) *start = mapinfo->pr_vaddr; |
| if (end) *end = mapinfo->pr_vaddr + mapinfo->pr_size; |
| if (flags) *flags = kPerms[mapinfo->pr_mflags & 7]; |
| if (offset) *offset = mapinfo->pr_offset; |
| if (inode) *inode = inode_from_mapname; |
| if (filename) *filename = current_filename_; |
| if (file_mapping) *file_mapping = 0; |
| if (file_pages) *file_pages = 0; |
| if (anon_mapping) *anon_mapping = 0; |
| if (anon_pages) *anon_pages = 0; |
| if (dev) *dev = 0; |
| return true; |
| } |
| #elif defined(__MACH__) |
| // We return a separate entry for each segment in the DLL. (TODO(csilvers): |
| // can we do better?) A DLL ("image") has load-commands, some of which |
| // talk about segment boundaries. |
| // cf image_for_address from http://svn.digium.com/view/asterisk/team/oej/minivoicemail/dlfcn.c?revision=53912 |
| for (; current_image_ >= 0; current_image_--) { |
| const mach_header* hdr = _dyld_get_image_header(current_image_); |
| if (!hdr) continue; |
| if (current_load_cmd_ < 0) // set up for this image |
| current_load_cmd_ = hdr->ncmds; // again, go from the top down |
| |
| // We start with the next load command (we've already looked at this one). |
| for (current_load_cmd_--; current_load_cmd_ >= 0; current_load_cmd_--) { |
| #ifdef MH_MAGIC_64 |
| if (NextExtMachHelper<MH_MAGIC_64, LC_SEGMENT_64, |
| struct mach_header_64, struct segment_command_64>( |
| hdr, current_image_, current_load_cmd_, |
| start, end, flags, offset, inode, filename, |
| file_mapping, file_pages, anon_mapping, |
| anon_pages, dev)) { |
| return true; |
| } |
| #endif |
| if (NextExtMachHelper<MH_MAGIC, LC_SEGMENT, |
| struct mach_header, struct segment_command>( |
| hdr, current_image_, current_load_cmd_, |
| start, end, flags, offset, inode, filename, |
| file_mapping, file_pages, anon_mapping, |
| anon_pages, dev)) { |
| return true; |
| } |
| } |
| // If we get here, no more load_cmd's in this image talk about |
| // segments. Go on to the next image. |
| } |
| #elif defined(PLATFORM_WINDOWS) |
| static char kDefaultPerms[5] = "r-xp"; |
| BOOL ok; |
| if (module_.dwSize == 0) { // only possible before first call |
| module_.dwSize = sizeof(module_); |
| ok = Module32First(snapshot_, &module_); |
| } else { |
| ok = Module32Next(snapshot_, &module_); |
| } |
| if (ok) { |
| uint64 base_addr = reinterpret_cast<DWORD_PTR>(module_.modBaseAddr); |
| if (start) *start = base_addr; |
| if (end) *end = base_addr + module_.modBaseSize; |
| if (flags) *flags = kDefaultPerms; |
| if (offset) *offset = 0; |
| if (inode) *inode = 0; |
| if (filename) *filename = module_.szExePath; |
| if (file_mapping) *file_mapping = 0; |
| if (file_pages) *file_pages = 0; |
| if (anon_mapping) *anon_mapping = 0; |
| if (anon_pages) *anon_pages = 0; |
| if (dev) *dev = 0; |
| return true; |
| } |
| #endif |
| |
| // We didn't find anything |
| return false; |
| } |
| |
| int ProcMapsIterator::FormatLine(char* buffer, int bufsize, |
| uint64 start, uint64 end, const char *flags, |
| uint64 offset, int64 inode, |
| const char *filename, dev_t dev) { |
| // We assume 'flags' looks like 'rwxp' or 'rwx'. |
| char r = (flags && flags[0] == 'r') ? 'r' : '-'; |
| char w = (flags && flags[0] && flags[1] == 'w') ? 'w' : '-'; |
| char x = (flags && flags[0] && flags[1] && flags[2] == 'x') ? 'x' : '-'; |
| // p always seems set on linux, so we set the default to 'p', not '-' |
| char p = (flags && flags[0] && flags[1] && flags[2] && flags[3] != 'p') |
| ? '-' : 'p'; |
| |
| const int rc = snprintf(buffer, bufsize, |
| "%08" PRIx64 "-%08" PRIx64 " %c%c%c%c %08" PRIx64 " %02x:%02x %-11" PRId64 " %s\n", |
| start, end, r,w,x,p, offset, |
| static_cast<int>(dev/256), static_cast<int>(dev%256), |
| inode, filename); |
| return (rc < 0 || rc >= bufsize) ? 0 : rc; |
| } |
| |
| namespace tcmalloc { |
| |
| // Helper to add the list of mapped shared libraries to a profile. |
| // Fill formatted "/proc/self/maps" contents into buffer 'buf' of size 'size' |
| // and return the actual size occupied in 'buf'. We fill wrote_all to true |
| // if we successfully wrote all proc lines to buf, false else. |
| // We do not provision for 0-terminating 'buf'. |
| int FillProcSelfMaps(char buf[], int size, bool* wrote_all) { |
| ProcMapsIterator::Buffer iterbuf; |
| ProcMapsIterator it(0, &iterbuf); // 0 means "current pid" |
| |
| uint64 start, end, offset; |
| int64 inode; |
| char *flags, *filename; |
| int bytes_written = 0; |
| *wrote_all = true; |
| while (it.Next(&start, &end, &flags, &offset, &inode, &filename)) { |
| const int line_length = it.FormatLine(buf + bytes_written, |
| size - bytes_written, |
| start, end, flags, offset, |
| inode, filename, 0); |
| if (line_length == 0) |
| *wrote_all = false; // failed to write this line out |
| else |
| bytes_written += line_length; |
| |
| } |
| return bytes_written; |
| } |
| |
| // Dump the same data as FillProcSelfMaps reads to fd. |
| // It seems easier to repeat parts of FillProcSelfMaps here than to |
| // reuse it via a call. |
| void DumpProcSelfMaps(RawFD fd) { |
| ProcMapsIterator::Buffer iterbuf; |
| ProcMapsIterator it(0, &iterbuf); // 0 means "current pid" |
| |
| uint64 start, end, offset; |
| int64 inode; |
| char *flags, *filename; |
| ProcMapsIterator::Buffer linebuf; |
| while (it.Next(&start, &end, &flags, &offset, &inode, &filename)) { |
| int written = it.FormatLine(linebuf.buf_, sizeof(linebuf.buf_), |
| start, end, flags, offset, inode, filename, |
| 0); |
| RawWrite(fd, linebuf.buf_, written); |
| } |
| } |
| |
| } // namespace tcmalloc |