src/v8/src/log-utils.h

   1 // Copyright 2006-2009 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef V8_LOG_UTILS_H_
   6 #define V8_LOG_UTILS_H_
   7
   8 #include "src/allocation.h"
   9
  10 namespace v8 {
  11 namespace internal {
  12
  13 class Logger;
  14
  15 // Functions and data for performing output of log messages.
  16 class Log {
  17  public:
  18   // Performs process-wide initialization.
  19   void Initialize(const char* log_file_name);
  20
  21   // Disables logging, but preserves acquired resources.
  22   void stop() { is_stopped_ = true; }
  23
  24   static bool InitLogAtStart() {
  25     return FLAG_log || FLAG_log_api || FLAG_log_code || FLAG_log_gc
  26         || FLAG_log_handles || FLAG_log_suspect || FLAG_log_regexp
  27         || FLAG_ll_prof || FLAG_perf_basic_prof || FLAG_perf_jit_prof
  28         || FLAG_log_internal_timer_events;
  29   }
  30
  31   // Frees all resources acquired in Initialize and Open... functions.
  32   // When a temporary file is used for the log, returns its stream descriptor,
  33   // leaving the file open.
  34   FILE* Close();
  35
  36   // Returns whether logging is enabled.
  37   bool IsEnabled() {
  38     return !is_stopped_ && output_handle_ != NULL;
  39   }
  40
  41   // Size of buffer used for formatting log messages.
  42   static const int kMessageBufferSize = 2048;
  43
  44   // This mode is only used in tests, as temporary files are automatically
  45   // deleted on close and thus can't be accessed afterwards.
  46   static const char* const kLogToTemporaryFile;
  47   static const char* const kLogToConsole;
  48
  49   // Utility class for formatting log messages. It fills the message into the
  50   // static buffer in Log.
  51   class MessageBuilder BASE_EMBEDDED {
  52    public:
  53     // Create a message builder starting from position 0.
  54     // This acquires the mutex in the log as well.
  55     explicit MessageBuilder(Log* log);
  56     ~MessageBuilder() { }
  57
  58     // Append string data to the log message.
  59     void Append(const char* format, ...);
  60
  61     // Append string data to the log message.
  62     void AppendVA(const char* format, va_list args);
  63
  64     // Append a character to the log message.
  65     void Append(const char c);
  66
  67     // Append double quoted string to the log message.
  68     void AppendDoubleQuotedString(const char* string);
  69
  70     // Append a heap string.
  71     void Append(String* str);
  72
  73     // Appends an address.
  74     void AppendAddress(Address addr);
  75
  76     void AppendSymbolName(Symbol* symbol);
  77
  78     void AppendDetailed(String* str, bool show_impl_info);
  79
  80     // Append a portion of a string.
  81     void AppendStringPart(const char* str, int len);
  82
  83     // Write the log message to the log file currently opened.
  84     void WriteToLogFile();
  85
  86    private:
  87     Log* log_;
  88     LockGuard<Mutex> lock_guard_;
  89     int pos_;
  90   };
  91
  92  private:
  93   explicit Log(Logger* logger);
  94
  95   // Opens stdout for logging.
  96   void OpenStdout();
  97
  98   // Opens file for logging.
  99   void OpenFile(const char* name);
 100
 101   // Opens a temporary file for logging.
 102   void OpenTemporaryFile();
 103
 104   // Implementation of writing to a log file.
 105   int WriteToFile(const char* msg, int length) {
 106     ASSERT(output_handle_ != NULL);
 107     size_t rv = fwrite(msg, 1, length, output_handle_);
 108     ASSERT(static_cast<size_t>(length) == rv);
 109     USE(rv);
 110     fflush(output_handle_);
 111     return length;
 112   }
 113
 114   // Whether logging is stopped (e.g. due to insufficient resources).
 115   bool is_stopped_;
 116
 117   // When logging is active output_handle_ is used to store a pointer to log
 118   // destination.  mutex_ should be acquired before using output_handle_.
 119   FILE* output_handle_;
 120
 121   // mutex_ is a Mutex used for enforcing exclusive
 122   // access to the formatting buffer and the log file or log memory buffer.
 123   Mutex mutex_;
 124
 125   // Buffer used for formatting log messages. This is a singleton buffer and
 126   // mutex_ should be acquired before using it.
 127   char* message_buffer_;
 128
 129   Logger* logger_;
 130
 131   friend class Logger;
 132 };
 133
 134
 135 } }  // namespace v8::internal
 136
 137 #endif  // V8_LOG_UTILS_H_