LCOV - code coverage report
Current view: top level - src - log-utils.h (source / functions) Hit Total Coverage
Test: app.info Lines: 9 10 90.0 %
Date: 2017-04-26 Functions: 1 1 100.0 %

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

Generated by: LCOV version 1.10