git.cworth.org Git - apitrace/blob - common/trace_writer_local.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 "os.hpp"
  34 #include "trace_file.hpp"
  35 #include "trace_writer.hpp"
  36 #include "trace_format.hpp"
  37
  38
  39 namespace trace {
  40
  41
  42 static const char *memcpy_args[3] = {"dest", "src", "n"};
  43 const FunctionSig memcpy_sig = {0, "memcpy", 3, memcpy_args};
  44
  45 static const char *malloc_args[1] = {"size"};
  46 const FunctionSig malloc_sig = {1, "malloc", 1, malloc_args};
  47
  48 static const char *free_args[1] = {"ptr"};
  49 const FunctionSig free_sig = {2, "free", 1, free_args};
  50
  51 static const char *realloc_args[2] = {"ptr", "size"};
  52 const FunctionSig realloc_sig = {3, "realloc", 2, realloc_args};
  53
  54
  55 static void exceptionCallback(void)
  56 {
  57     localWriter.flush();
  58 }
  59
  60
  61 LocalWriter::LocalWriter() :
  62     acquired(0)
  63 {
  64     // Install the signal handlers as early as possible, to prevent
  65     // interfering with the application's signal handling.
  66     os::setExceptionCallback(exceptionCallback);
  67 }
  68
  69 LocalWriter::~LocalWriter()
  70 {
  71     os::resetExceptionCallback();
  72 }
  73
  74 void
  75 LocalWriter::open(void) {
  76
  77     static unsigned dwCounter = 0;
  78
  79     const char *szExtension = "trace";
  80     char szFileName[PATH_MAX];
  81     const char *lpFileName;
  82
  83     lpFileName = getenv("TRACE_FILE");
  84     if (lpFileName) {
  85         strncpy(szFileName, lpFileName, PATH_MAX);
  86     }
  87     else {
  88         os::Path szProcessName = os::getProcessName();
  89         os::Path szCurrentDir = os::getCurrentDir();
  90
  91         for (;;) {
  92             FILE *file;
  93
  94             if (dwCounter)
  95                 snprintf(szFileName, PATH_MAX, "%s%c%s.%u.%s", szCurrentDir.str(), PATH_SEP, szProcessName.str(), dwCounter, szExtension);
  96             else
  97                 snprintf(szFileName, PATH_MAX, "%s%c%s.%s", szCurrentDir.str(), PATH_SEP, szProcessName.str(), szExtension);
  98
  99             file = fopen(szFileName, "rb");
 100             if (file == NULL)
 101                 break;
 102
 103             fclose(file);
 104
 105             ++dwCounter;
 106         }
 107     }
 108
 109     os::log("apitrace: tracing to %s\n", szFileName);
 110
 111     Writer::open(szFileName);
 112
 113 #if 0
 114     // For debugging the exception handler
 115     *((int *)0) = 0;
 116 #endif
 117 }
 118
 119 unsigned LocalWriter::beginEnter(const FunctionSig *sig) {
 120     os::acquireMutex();
 121     ++acquired;
 122
 123     if (!m_file->isOpened()) {
 124         open();
 125     }
 126
 127     return Writer::beginEnter(sig);
 128 }
 129
 130 void LocalWriter::endEnter(void) {
 131     Writer::endEnter();
 132     --acquired;
 133     os::releaseMutex();
 134 }
 135
 136 void LocalWriter::beginLeave(unsigned call) {
 137     os::acquireMutex();
 138     ++acquired;
 139     Writer::beginLeave(call);
 140 }
 141
 142 void LocalWriter::endLeave(void) {
 143     Writer::endLeave();
 144     --acquired;
 145     os::releaseMutex();
 146 }
 147
 148 void LocalWriter::flush(void) {
 149     /*
 150      * Do nothing if the mutex is already acquired (e.g., if a segfault happen
 151      * while writing the file) to prevent dead-lock.
 152      */
 153
 154     if (!acquired) {
 155         os::acquireMutex();
 156         if (m_file->isOpened()) {
 157             os::log("apitrace: flushing trace due to an exception\n");
 158             m_file->flush();
 159         }
 160         os::releaseMutex();
 161     }
 162 }
 163
 164
 165 LocalWriter localWriter;
 166
 167
 168 } /* namespace trace */
 169