base/win/event_trace_controller.cc

   1 // Copyright (c) 2009 The Chromium 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 // Implementation of a Windows event trace controller class.
   6 #include "base/win/event_trace_controller.h"
   7 #include "base/logging.h"
   8
   9 namespace base {
  10 namespace win {
  11
  12 EtwTraceProperties::EtwTraceProperties() {
  13   memset(buffer_, 0, sizeof(buffer_));
  14   EVENT_TRACE_PROPERTIES* prop = get();
  15
  16   prop->Wnode.BufferSize = sizeof(buffer_);
  17   prop->Wnode.Flags = WNODE_FLAG_TRACED_GUID;
  18   prop->LoggerNameOffset = sizeof(EVENT_TRACE_PROPERTIES);
  19   prop->LogFileNameOffset = sizeof(EVENT_TRACE_PROPERTIES) +
  20                             sizeof(wchar_t) * kMaxStringLen;
  21 }
  22
  23 HRESULT EtwTraceProperties::SetLoggerName(const wchar_t* logger_name) {
  24   size_t len = wcslen(logger_name) + 1;
  25   if (kMaxStringLen < len)
  26     return E_INVALIDARG;
  27
  28   memcpy(buffer_ + get()->LoggerNameOffset,
  29          logger_name,
  30          sizeof(wchar_t) * len);
  31   return S_OK;
  32 }
  33
  34 HRESULT EtwTraceProperties::SetLoggerFileName(const wchar_t* logger_file_name) {
  35   size_t len = wcslen(logger_file_name) + 1;
  36   if (kMaxStringLen < len)
  37     return E_INVALIDARG;
  38
  39   memcpy(buffer_ + get()->LogFileNameOffset,
  40          logger_file_name,
  41          sizeof(wchar_t) * len);
  42   return S_OK;
  43 }
  44
  45 EtwTraceController::EtwTraceController() : session_(NULL) {
  46 }
  47
  48 EtwTraceController::~EtwTraceController() {
  49   Stop(NULL);
  50 }
  51
  52 HRESULT EtwTraceController::Start(const wchar_t* session_name,
  53     EtwTraceProperties* prop) {
  54   DCHECK(NULL == session_ && session_name_.empty());
  55   EtwTraceProperties ignore;
  56   if (prop == NULL)
  57     prop = &ignore;
  58
  59   HRESULT hr = Start(session_name, prop, &session_);
  60   if (SUCCEEDED(hr))
  61     session_name_ = session_name;
  62
  63   return hr;
  64 }
  65
  66 HRESULT EtwTraceController::StartFileSession(const wchar_t* session_name,
  67     const wchar_t* logfile_path, bool realtime) {
  68   DCHECK(NULL == session_ && session_name_.empty());
  69
  70   EtwTraceProperties prop;
  71   prop.SetLoggerFileName(logfile_path);
  72   EVENT_TRACE_PROPERTIES& p = *prop.get();
  73   p.Wnode.ClientContext = 1;  // QPC timer accuracy.
  74   p.LogFileMode = EVENT_TRACE_FILE_MODE_SEQUENTIAL;  // Sequential log.
  75   if (realtime)
  76     p.LogFileMode |= EVENT_TRACE_REAL_TIME_MODE;
  77
  78   p.MaximumFileSize = 100;  // 100M file size.
  79   p.FlushTimer = 30;  // 30 seconds flush lag.
  80   return Start(session_name, &prop);
  81 }
  82
  83 HRESULT EtwTraceController::StartRealtimeSession(const wchar_t* session_name,
  84     size_t buffer_size) {
  85   DCHECK(NULL == session_ && session_name_.empty());
  86   EtwTraceProperties prop;
  87   EVENT_TRACE_PROPERTIES& p = *prop.get();
  88   p.LogFileMode = EVENT_TRACE_REAL_TIME_MODE | EVENT_TRACE_USE_PAGED_MEMORY;
  89   p.FlushTimer = 1;  // flush every second.
  90   p.BufferSize = 16;  // 16 K buffers.
  91   p.LogFileNameOffset = 0;
  92   return Start(session_name, &prop);
  93 }
  94
  95 HRESULT EtwTraceController::EnableProvider(REFGUID provider, UCHAR level,
  96     ULONG flags) {
  97   ULONG error = ::EnableTrace(TRUE, flags, level, &provider, session_);
  98   return HRESULT_FROM_WIN32(error);
  99 }
 100
 101 HRESULT EtwTraceController::DisableProvider(REFGUID provider) {
 102   ULONG error = ::EnableTrace(FALSE, 0, 0, &provider, session_);
 103   return HRESULT_FROM_WIN32(error);
 104 }
 105
 106 HRESULT EtwTraceController::Stop(EtwTraceProperties* properties) {
 107   EtwTraceProperties ignore;
 108   if (properties == NULL)
 109     properties = &ignore;
 110
 111   ULONG error = ::ControlTrace(session_, NULL, properties->get(),
 112     EVENT_TRACE_CONTROL_STOP);
 113   if (ERROR_SUCCESS != error)
 114     return HRESULT_FROM_WIN32(error);
 115
 116   session_ = NULL;
 117   session_name_.clear();
 118   return S_OK;
 119 }
 120
 121 HRESULT EtwTraceController::Flush(EtwTraceProperties* properties) {
 122   EtwTraceProperties ignore;
 123   if (properties == NULL)
 124     properties = &ignore;
 125
 126   ULONG error = ::ControlTrace(session_, NULL, properties->get(),
 127                                EVENT_TRACE_CONTROL_FLUSH);
 128   if (ERROR_SUCCESS != error)
 129     return HRESULT_FROM_WIN32(error);
 130
 131   return S_OK;
 132 }
 133
 134 HRESULT EtwTraceController::Start(const wchar_t* session_name,
 135     EtwTraceProperties* properties, TRACEHANDLE* session_handle) {
 136   DCHECK(properties != NULL);
 137   ULONG err = ::StartTrace(session_handle, session_name, properties->get());
 138   return HRESULT_FROM_WIN32(err);
 139 }
 140
 141 HRESULT EtwTraceController::Query(const wchar_t* session_name,
 142     EtwTraceProperties* properties) {
 143   ULONG err = ::ControlTrace(NULL, session_name, properties->get(),
 144                              EVENT_TRACE_CONTROL_QUERY);
 145   return HRESULT_FROM_WIN32(err);
 146 };
 147
 148 HRESULT EtwTraceController::Update(const wchar_t* session_name,
 149     EtwTraceProperties* properties) {
 150   DCHECK(properties != NULL);
 151   ULONG err = ::ControlTrace(NULL, session_name, properties->get(),
 152                              EVENT_TRACE_CONTROL_UPDATE);
 153   return HRESULT_FROM_WIN32(err);
 154 }
 155
 156 HRESULT EtwTraceController::Stop(const wchar_t* session_name,
 157     EtwTraceProperties* properties) {
 158   DCHECK(properties != NULL);
 159   ULONG err = ::ControlTrace(NULL, session_name, properties->get(),
 160                              EVENT_TRACE_CONTROL_STOP);
 161   return HRESULT_FROM_WIN32(err);
 162 }
 163
 164 HRESULT EtwTraceController::Flush(const wchar_t* session_name,
 165     EtwTraceProperties* properties) {
 166   DCHECK(properties != NULL);
 167   ULONG err = ::ControlTrace(NULL, session_name, properties->get(),
 168                              EVENT_TRACE_CONTROL_FLUSH);
 169   return HRESULT_FROM_WIN32(err);
 170 }
 171
 172 }  // namespace win
 173 }  // namespace base