git.cworth.org Git - apitrace/blob - trace_local_writer.cpp

   1 /**************************************************************************
   2  *
   3  * Copyright 2007-2011 VMware, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  *
  24  **************************************************************************/
  25
  26
  27 #include <assert.h>
  28 #include <stdarg.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32
  33 #include <zlib.h>
  34
  35 #include "os.hpp"
  36 #include "trace_writer.hpp"
  37 #include "trace_format.hpp"
  38
  39
  40 namespace Trace {
  41
  42
  43 static void exceptionCallback(void)
  44 {
  45     OS::DebugMessage("apitrace: flushing trace due to an exception\n");
  46     localWriter.flush();
  47 }
  48
  49
  50 LocalWriter::LocalWriter() :
  51     acquired(0)
  52 {}
  53
  54 LocalWriter::~LocalWriter()
  55 {
  56     OS::ResetExceptionCallback();
  57 }
  58
  59 void
  60 LocalWriter::open(void) {
  61
  62     static unsigned dwCounter = 0;
  63
  64     const char *szExtension = "trace";
  65     char szFileName[PATH_MAX];
  66     const char *lpFileName;
  67
  68     lpFileName = getenv("TRACE_FILE");
  69     if (lpFileName) {
  70         strncpy(szFileName, lpFileName, PATH_MAX);
  71     }
  72     else {
  73         char szProcessName[PATH_MAX];
  74         char szCurrentDir[PATH_MAX];
  75         OS::GetProcessName(szProcessName, PATH_MAX);
  76         OS::GetCurrentDir(szCurrentDir, PATH_MAX);
  77
  78         for (;;) {
  79             FILE *file;
  80
  81             if (dwCounter)
  82                 snprintf(szFileName, PATH_MAX, "%s%c%s.%u.%s", szCurrentDir, PATH_SEP, szProcessName, dwCounter, szExtension);
  83             else
  84                 snprintf(szFileName, PATH_MAX, "%s%c%s.%s", szCurrentDir, PATH_SEP, szProcessName, szExtension);
  85
  86             file = fopen(szFileName, "rb");
  87             if (file == NULL)
  88                 break;
  89
  90             fclose(file);
  91
  92             ++dwCounter;
  93         }
  94     }
  95
  96     OS::DebugMessage("apitrace: tracing to %s\n", szFileName);
  97
  98     Writer::open(szFileName);
  99
 100     OS::SetExceptionCallback(exceptionCallback);
 101
 102 #if 0
 103     // For debugging the exception handler
 104     *((int *)0) = 0;
 105 #endif
 106 }
 107
 108 unsigned LocalWriter::beginEnter(const FunctionSig *sig) {
 109     OS::AcquireMutex();
 110     ++acquired;
 111
 112     if (!g_gzFile) {
 113         open();
 114     }
 115
 116     return Writer::beginEnter(sig);
 117 }
 118
 119 void LocalWriter::endEnter(void) {
 120     Writer::endEnter();
 121     --acquired;
 122     OS::ReleaseMutex();
 123 }
 124
 125 void LocalWriter::beginLeave(unsigned call) {
 126     OS::AcquireMutex();
 127     ++acquired;
 128     Writer::beginLeave(call);
 129 }
 130
 131 void LocalWriter::endLeave(void) {
 132     Writer::endLeave();
 133     --acquired;
 134     OS::ReleaseMutex();
 135 }
 136
 137 void LocalWriter::flush(void) {
 138     /*
 139      * Do nothing if the mutex is already acquired (e.g., if a segfault happen
 140      * while writing the file) to prevent dead-lock.
 141      */
 142
 143     if (!acquired) {
 144         OS::AcquireMutex();
 145             if (g_gzFile) {
 146                 gzflush(g_gzFile, Z_SYNC_FLUSH);
 147             }
 148         OS::ReleaseMutex();
 149     }
 150 }
 151
 152
 153 LocalWriter localWriter;
 154
 155
 156 } /* namespace Trace */
 157