xpcom/build/LateWriteChecks.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include <algorithm>
   8
   9 #include "mozilla/IOInterposer.h"
  10 #include "mozilla/PoisonIOInterposer.h"
  11 #include "mozilla/ProcessedStack.h"
  12 #include "mozilla/SHA1.h"
  13 #include "mozilla/Scoped.h"
  14 #include "mozilla/StaticPtr.h"
  15 #include "mozilla/Telemetry.h"
  16 #include "mozilla/Unused.h"
  17 #include "nsAppDirectoryServiceDefs.h"
  18 #include "nsDirectoryServiceUtils.h"
  19 #include "nsLocalFile.h"
  20 #include "nsPrintfCString.h"
  21 #include "mozilla/StackWalk.h"
  22 #include "plstr.h"
  23 #include "prio.h"
  24
  25 #ifdef XP_WIN
  26 #define NS_SLASH "\\"
  27 #include <fcntl.h>
  28 #include <io.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <sys/stat.h>
  32 #include <windows.h>
  33 #else
  34 #define NS_SLASH "/"
  35 #endif
  36
  37 #include "LateWriteChecks.h"
  38
  39 using namespace mozilla;
  40
  41 /*************************** Auxiliary Declarations ***************************/
  42
  43 // This a wrapper over a file descriptor that provides a Printf method and
  44 // computes the sha1 of the data that passes through it.
  45 class SHA1Stream {
  46  public:
  47   explicit SHA1Stream(FILE* aStream) : mFile(aStream) {
  48     MozillaRegisterDebugFILE(mFile);
  49   }
  50
  51   void Printf(const char* aFormat, ...) MOZ_FORMAT_PRINTF(2, 3) {
  52     MOZ_ASSERT(mFile);
  53     va_list list;
  54     va_start(list, aFormat);
  55     nsAutoCString str;
  56     str.AppendPrintf(aFormat, list);
  57     va_end(list);
  58     mSHA1.update(str.get(), str.Length());
  59     Unused << fwrite(str.get(), 1, str.Length(), mFile);
  60   }
  61   void Finish(SHA1Sum::Hash& aHash) {
  62     int fd = fileno(mFile);
  63     fflush(mFile);
  64     MozillaUnRegisterDebugFD(fd);
  65     fclose(mFile);
  66     mSHA1.finish(aHash);
  67     mFile = nullptr;
  68   }
  69
  70  private:
  71   FILE* mFile;
  72   SHA1Sum mSHA1;
  73 };
  74
  75 static void RecordStackWalker(uint32_t aFrameNumber, void* aPC, void* aSP,
  76                               void* aClosure) {
  77   std::vector<uintptr_t>* stack =
  78       static_cast<std::vector<uintptr_t>*>(aClosure);
  79   stack->push_back(reinterpret_cast<uintptr_t>(aPC));
  80 }
  81
  82 /**************************** Late-Write Observer  ****************************/
  83
  84 /**
  85  * An implementation of IOInterposeObserver to be registered with IOInterposer.
  86  * This observer logs all writes as late writes.
  87  */
  88 class LateWriteObserver final : public IOInterposeObserver {
  89   using char_type = filesystem::Path::value_type;
  90
  91  public:
  92   explicit LateWriteObserver(const char_type* aProfileDirectory)
  93       : mProfileDirectory(NS_xstrdup(aProfileDirectory)) {}
  94   ~LateWriteObserver() {
  95     free(mProfileDirectory);
  96     mProfileDirectory = nullptr;
  97   }
  98
  99   void Observe(IOInterposeObserver::Observation& aObservation) override;
 100
 101  private:
 102   char_type* mProfileDirectory;
 103 };
 104
 105 void LateWriteObserver::Observe(IOInterposeObserver::Observation& aOb) {
 106   // Crash if that is the shutdown check mode
 107   if (gShutdownChecks == SCM_CRASH) {
 108     MOZ_CRASH();
 109   }
 110
 111   // If we have shutdown mode SCM_NOTHING or we can't record then abort
 112   if (gShutdownChecks == SCM_NOTHING || !Telemetry::CanRecordExtended()) {
 113     return;
 114   }
 115
 116   // Write the stack and loaded libraries to a file. We can get here
 117   // concurrently from many writes, so we use multiple temporary files.
 118   std::vector<uintptr_t> rawStack;
 119
 120   MozStackWalk(RecordStackWalker, /* skipFrames */ 0, /* maxFrames */ 0,
 121                &rawStack);
 122   Telemetry::ProcessedStack stack = Telemetry::GetStackAndModules(rawStack);
 123
 124   nsTAutoString<char_type> nameAux(mProfileDirectory);
 125   nameAux.AppendLiteral(NS_SLASH "Telemetry.LateWriteTmpXXXXXX");
 126   char_type* name = nameAux.BeginWriting();
 127
 128   // We want the sha1 of the entire file, so please don't write to fd
 129   // directly; use sha1Stream.
 130   FILE* stream;
 131 #ifdef XP_WIN
 132   HANDLE hFile;
 133   do {
 134     // mkstemp isn't supported so keep trying until we get a file
 135     _wmktemp_s(char16ptr_t(name), NS_strlen(name) + 1);
 136     hFile = CreateFileW(char16ptr_t(name), GENERIC_WRITE, 0, nullptr,
 137                         CREATE_NEW, FILE_ATTRIBUTE_NORMAL, nullptr);
 138   } while (GetLastError() == ERROR_FILE_EXISTS);
 139
 140   if (hFile == INVALID_HANDLE_VALUE) {
 141     MOZ_CRASH("Um, how did we get here?");
 142   }
 143
 144   // http://support.microsoft.com/kb/139640
 145   int fd = _open_osfhandle((intptr_t)hFile, _O_APPEND);
 146   if (fd == -1) {
 147     MOZ_CRASH("Um, how did we get here?");
 148   }
 149
 150   stream = _fdopen(fd, "w");
 151 #else
 152   int fd = mkstemp(name);
 153   if (fd == -1) {
 154     MOZ_CRASH("mkstemp failed");
 155   }
 156   stream = fdopen(fd, "w");
 157 #endif
 158
 159   SHA1Stream sha1Stream(stream);
 160
 161   size_t numModules = stack.GetNumModules();
 162   sha1Stream.Printf("%u\n", (unsigned)numModules);
 163   for (size_t i = 0; i < numModules; ++i) {
 164     Telemetry::ProcessedStack::Module module = stack.GetModule(i);
 165     sha1Stream.Printf("%s %s\n", module.mBreakpadId.get(),
 166                       NS_ConvertUTF16toUTF8(module.mName).get());
 167   }
 168
 169   size_t numFrames = stack.GetStackSize();
 170   sha1Stream.Printf("%u\n", (unsigned)numFrames);
 171   for (size_t i = 0; i < numFrames; ++i) {
 172     const Telemetry::ProcessedStack::Frame& frame = stack.GetFrame(i);
 173     // NOTE: We write the offsets, while the atos tool expects a value with
 174     // the virtual address added. For example, running otool -l on the the
 175     // firefox binary shows
 176     //      cmd LC_SEGMENT_64
 177     //      cmdsize 632
 178     //      segname __TEXT
 179     //      vmaddr 0x0000000100000000
 180     // so to print the line matching the offset 123 one has to run
 181     // atos -o firefox 0x100000123.
 182     sha1Stream.Printf("%d %x\n", frame.mModIndex, (unsigned)frame.mOffset);
 183   }
 184
 185   SHA1Sum::Hash sha1;
 186   sha1Stream.Finish(sha1);
 187
 188   // Note: These files should be deleted by telemetry once it reads them. If
 189   // there were no telemetry runs by the time we shut down, we just add files
 190   // to the existing ones instead of replacing them. Given that each of these
 191   // files is a bug to be fixed, that is probably the right thing to do.
 192
 193   // We append the sha1 of the contents to the file name. This provides a simple
 194   // client side deduplication.
 195   nsAutoString finalName(NS_LITERAL_STRING("Telemetry.LateWriteFinal-"));
 196   for (int i = 0; i < 20; ++i) {
 197     finalName.AppendPrintf("%02x", sha1[i]);
 198   }
 199   RefPtr<nsLocalFile> file = new nsLocalFile(nameAux);
 200   file->RenameTo(nullptr, finalName);
 201 }
 202
 203 /******************************* Setup/Teardown *******************************/
 204
 205 static StaticAutoPtr<LateWriteObserver> sLateWriteObserver;
 206
 207 namespace mozilla {
 208
 209 void InitLateWriteChecks() {
 210   nsCOMPtr<nsIFile> mozFile;
 211   NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, getter_AddRefs(mozFile));
 212   if (mozFile) {
 213     PathString nativePath = mozFile->NativePath();
 214     if (nativePath.get()) {
 215       sLateWriteObserver = new LateWriteObserver(nativePath.get());
 216     }
 217   }
 218 }
 219
 220 void BeginLateWriteChecks() {
 221   if (sLateWriteObserver) {
 222     IOInterposer::Register(IOInterposeObserver::OpWriteFSync,
 223                            sLateWriteObserver);
 224   }
 225 }
 226
 227 void StopLateWriteChecks() {
 228   if (sLateWriteObserver) {
 229     IOInterposer::Unregister(IOInterposeObserver::OpAll, sLateWriteObserver);
 230     // Deallocation would not be thread-safe, and StopLateWriteChecks() is
 231     // called at shutdown and only in special cases.
 232     // sLateWriteObserver = nullptr;
 233   }
 234 }
 235
 236 }  // namespace mozilla