1// Copyright (c) 2005, Google Inc. 2// All rights reserved. 3// 4// Redistribution and use in source and binary forms, with or without 5// modification, are permitted provided that the following conditions are 6// met: 7// 8// * Redistributions of source code must retain the above copyright 9// notice, this list of conditions and the following disclaimer. 10// * Redistributions in binary form must reproduce the above 11// copyright notice, this list of conditions and the following disclaimer 12// in the documentation and/or other materials provided with the 13// distribution. 14// * Neither the name of Google Inc. nor the names of its 15// contributors may be used to endorse or promote products derived from 16// this software without specific prior written permission. 17// 18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 30// --- 31// Author: Sanjay Ghemawat <opensource@google.com> 32// 33// Internal logging and related utility routines. 34 35#ifndef TCMALLOC_INTERNAL_LOGGING_H_ 36#define TCMALLOC_INTERNAL_LOGGING_H_ 37 38#include <config.h> 39#include <stddef.h> // for size_t 40#if defined HAVE_STDINT_H 41#include <stdint.h> 42#elif defined HAVE_INTTYPES_H 43#include <inttypes.h> 44#else 45#include <sys/types.h> 46#endif 47 48//------------------------------------------------------------------- 49// Utility routines 50//------------------------------------------------------------------- 51 52// Safe logging helper: we write directly to the stderr file 53// descriptor and avoid FILE buffering because that may invoke 54// malloc(). 55// 56// Example: 57// Log(kLog, __FILE__, __LINE__, "error", bytes); 58 59namespace tcmalloc { 60enum LogMode { 61 kLog, // Just print the message 62 kCrash, // Print the message and crash 63 kCrashWithStats // Print the message, some stats, and crash 64}; 65 66class Logger; 67 68// A LogItem holds any of the argument types that can be passed to Log() 69class LogItem { 70 public: 71 LogItem() : tag_(kEnd) { } 72 LogItem(const char* v) : tag_(kStr) { u_.str = v; } 73 LogItem(int v) : tag_(kSigned) { u_.snum = v; } 74 LogItem(long v) : tag_(kSigned) { u_.snum = v; } 75 LogItem(long long v) : tag_(kSigned) { u_.snum = v; } 76 LogItem(unsigned int v) : tag_(kUnsigned) { u_.unum = v; } 77 LogItem(unsigned long v) : tag_(kUnsigned) { u_.unum = v; } 78 LogItem(unsigned long long v) : tag_(kUnsigned) { u_.unum = v; } 79 LogItem(const void* v) : tag_(kPtr) { u_.ptr = v; } 80 private: 81 friend class Logger; 82 enum Tag { 83 kStr, 84 kSigned, 85 kUnsigned, 86 kPtr, 87 kEnd 88 }; 89 Tag tag_; 90 union { 91 const char* str; 92 const void* ptr; 93 int64_t snum; 94 uint64_t unum; 95 } u_; 96}; 97 98extern PERFTOOLS_DLL_DECL void Log(LogMode mode, const char* filename, int line, 99 LogItem a, LogItem b = LogItem(), 100 LogItem c = LogItem(), LogItem d = LogItem()); 101 102// Tests can override this function to collect logging messages. 103extern PERFTOOLS_DLL_DECL void (*log_message_writer)(const char* msg, int length); 104 105} // end tcmalloc namespace 106 107// Like assert(), but executed even in NDEBUG mode 108#undef CHECK_CONDITION 109#define CHECK_CONDITION(cond) \ 110do { \ 111 if (!(cond)) { \ 112 ::tcmalloc::Log(::tcmalloc::kCrash, __FILE__, __LINE__, #cond); \ 113 } \ 114} while (0) 115 116#define CHECK_CONDITION_PRINT(cond, str) \ 117do { \ 118 if (!(cond)) { \ 119 ::tcmalloc::Log(::tcmalloc::kCrash, __FILE__, __LINE__, str); \ 120 } \ 121} while (0) 122 123// Our own version of assert() so we can avoid hanging by trying to do 124// all kinds of goofy printing while holding the malloc lock. 125#ifndef NDEBUG 126#define ASSERT(cond) CHECK_CONDITION(cond) 127#define ASSERT_PRINT(cond, str) CHECK_CONDITION_PRINT(cond, str) 128#else 129#define ASSERT(cond) ((void) 0) 130#define ASSERT_PRINT(cond, str) ((void) 0) 131#endif 132 133// Print into buffer 134class TCMalloc_Printer { 135 private: 136 char* buf_; // Where should we write next 137 int left_; // Space left in buffer (including space for \0) 138 139 public: 140 // REQUIRES: "length > 0" 141 TCMalloc_Printer(char* buf, int length) : buf_(buf), left_(length) { 142 buf[0] = '\0'; 143 } 144 145 void printf(const char* format, ...) 146#ifdef HAVE___ATTRIBUTE__ 147 __attribute__ ((__format__ (__printf__, 2, 3))) 148#endif 149; 150}; 151 152#endif // TCMALLOC_INTERNAL_LOGGING_H_ 153