mozglue/misc/TimeStamp.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 /*
   8  * Implementation of the OS-independent methods of the TimeStamp class
   9  */
  10
  11 #include "mozilla/Atomics.h"
  12 #include "mozilla/TimeStamp.h"
  13 #include <stdio.h>
  14 #include <string.h>
  15 #include <stdlib.h>
  16
  17 namespace mozilla {
  18
  19 /**
  20  * Wrapper class used to initialize static data used by the TimeStamp class
  21  */
  22 struct TimeStampInitialization
  23 {
  24   /**
  25    * First timestamp taken when the class static initializers are run. This
  26    * timestamp is used to sanitize timestamps coming from different sources.
  27    */
  28   TimeStamp mFirstTimeStamp;
  29
  30   /**
  31    * Timestamp representing the time when the process was created. This field
  32    * is populated lazily the first time this information is required and is
  33    * replaced every time the process is restarted.
  34    */
  35   TimeStamp mProcessCreation;
  36
  37   TimeStampInitialization()
  38   {
  39     TimeStamp::Startup();
  40     mFirstTimeStamp = TimeStamp::Now();
  41   };
  42
  43   ~TimeStampInitialization()
  44   {
  45     TimeStamp::Shutdown();
  46   };
  47 };
  48
  49 static bool sFuzzyfoxEnabled;
  50
  51 /* static */ bool
  52 TimeStamp::GetFuzzyfoxEnabled()
  53 {
  54   return sFuzzyfoxEnabled;
  55 }
  56
  57 /* static */ void
  58 TimeStamp::SetFuzzyfoxEnabled(bool aValue)
  59 {
  60   sFuzzyfoxEnabled = aValue;
  61 }
  62
  63 // These variables store the frozen time (as a TimeStamp) for FuzzyFox that
  64 // will be reported if FuzzyFox is enabled.
  65 // We overload the top bit of sCanonicalNow and sCanonicalGTC to
  66 // indicate if a Timestamp is a fuzzed timestamp (bit set) or not
  67 // (bit unset).
  68 #ifdef XP_WIN
  69 static Atomic<uint64_t> sCanonicalGTC;
  70 static Atomic<uint64_t> sCanonicalQPC;
  71 static Atomic<bool> sCanonicalHasQPC;
  72 #else
  73 static Atomic<uint64_t> sCanonicalNowTimeStamp;
  74 #endif
  75 static Atomic<int64_t> sCanonicalNowTime;
  76 // This variable stores the frozen time (as ms since the epoch) for FuzzyFox
  77 // to report if FuzzyFox is enabled.
  78 static TimeStampInitialization sInitOnce;
  79
  80 MFBT_API TimeStamp
  81 TimeStamp::ProcessCreation(bool* aIsInconsistent)
  82 {
  83   if (aIsInconsistent) {
  84     *aIsInconsistent = false;
  85   }
  86
  87   if (sInitOnce.mProcessCreation.IsNull()) {
  88     char* mozAppRestart = getenv("MOZ_APP_RESTART");
  89     TimeStamp ts;
  90
  91     /* When calling PR_SetEnv() with an empty value the existing variable may
  92      * be unset or set to the empty string depending on the underlying platform
  93      * thus we have to check if the variable is present and not empty. */
  94     if (mozAppRestart && (strcmp(mozAppRestart, "") != 0)) {
  95       /* Firefox was restarted, use the first time-stamp we've taken as the new
  96        * process startup time. */
  97       ts = sInitOnce.mFirstTimeStamp;
  98     } else {
  99       TimeStamp now = Now();
 100       uint64_t uptime = ComputeProcessUptime();
 101
 102       ts = now - TimeDuration::FromMicroseconds(uptime);
 103
 104       if ((ts > sInitOnce.mFirstTimeStamp) || (uptime == 0)) {
 105         /* If the process creation timestamp was inconsistent replace it with
 106          * the first one instead and notify that a telemetry error was
 107          * detected. */
 108         if (aIsInconsistent) {
 109           *aIsInconsistent = true;
 110         }
 111         ts = sInitOnce.mFirstTimeStamp;
 112       }
 113     }
 114
 115     sInitOnce.mProcessCreation = ts;
 116   }
 117
 118   return sInitOnce.mProcessCreation;
 119 }
 120
 121 void
 122 TimeStamp::RecordProcessRestart()
 123 {
 124   sInitOnce.mProcessCreation = TimeStamp();
 125 }
 126
 127 MFBT_API TimeStamp
 128 TimeStamp::NowFuzzy(TimeStampValue aValue)
 129 {
 130 #ifdef XP_WIN
 131   TimeStampValue canonicalNow = TimeStampValue(sCanonicalGTC, sCanonicalQPC, sCanonicalHasQPC, true);
 132 #else
 133   TimeStampValue canonicalNow = TimeStampValue(sCanonicalNowTimeStamp);
 134 #endif
 135
 136   if (TimeStamp::GetFuzzyfoxEnabled()) {
 137     if(MOZ_LIKELY(!canonicalNow.IsNull())) {
 138       return TimeStamp(canonicalNow);
 139     }
 140   }
 141   // When we disable Fuzzyfox, time may goes backwards, so we need to make sure
 142   // we don't do that.
 143   else if (MOZ_UNLIKELY(canonicalNow > aValue)) {
 144     return TimeStamp(canonicalNow);
 145   }
 146
 147   return TimeStamp(aValue);
 148 }
 149
 150 MFBT_API void
 151 TimeStamp::UpdateFuzzyTimeStamp(TimeStamp aValue)
 152 {
 153 #ifdef XP_WIN
 154   sCanonicalGTC = aValue.mValue.mGTC;
 155   sCanonicalQPC = aValue.mValue.mQPC;
 156   sCanonicalHasQPC = aValue.mValue.mHasQPC;
 157 #else
 158   sCanonicalNowTimeStamp = aValue.mValue.mTimeStamp;
 159 #endif
 160 }
 161
 162 MFBT_API int64_t
 163 TimeStamp::NowFuzzyTime()
 164 {
 165   return sCanonicalNowTime;
 166 }
 167
 168 MFBT_API void
 169 TimeStamp::UpdateFuzzyTime(int64_t aValue)
 170 {
 171   sCanonicalNowTime = aValue;
 172 }
 173
 174 } // namespace mozilla