/*
 * Returns 1 if success, 0 in case of QueryPerformanceCounter is not supported.
 *
 * Calibration is done as described above.
 *
 * To ensure that the calibration is accurate, we interleave sampling
 * the microsecond resolution counter via QueryPerformanceCounter with the 1
 * millisecond resolution system clock via GetSystemTimeAsFileTime.
 * When we see the edge transition where the system clock ticks, we
 * compare the before and after microsecond counter values.  If it is
 * within a calibration threshold (kMaxCalibrationDiff), then we
 * record the instantaneous system time (1 msresolution) and the
 * 64-bit counter value (~0.5 mks reslution).  Since we have a before and
 * after counter value, we interpolate it to get the "average" counter
 * value to associate with the system time.
 */
static int NaClCalibrateWindowsClockQpc(struct NaClTimeState *ntsp) {
  FILETIME  ft_start;
  FILETIME  ft_prev;
  FILETIME  ft_now;
  LARGE_INTEGER  counter_before;
  LARGE_INTEGER  counter_after;
  int64_t  counter_diff;
  int64_t  counter_diff_ms;
  uint64_t end_of_calibrate;
  int sys_time_changed;
  int calibration_success = 0;

  NaClLog(5, "Entered NaClCalibrateWindowsClockQpc\n");

  GetSystemTimeAsFileTime(&ft_start);
  ft_prev = ft_start;
  end_of_calibrate = NaClFileTimeToMs(&ft_start) + kCalibrateTimeoutMs;

  do {
    if (!QueryPerformanceCounter(&counter_before))
      return 0;
    GetSystemTimeAsFileTime(&ft_now);
    if (!QueryPerformanceCounter(&counter_after))
      return 0;

    counter_diff = counter_after.QuadPart - counter_before.QuadPart;
    counter_diff_ms =
        (counter_diff * kMillisecondsPerSecond) / ntsp->qpc_frequency;
    sys_time_changed = (ft_now.dwHighDateTime != ft_prev.dwHighDateTime) ||
        (ft_now.dwLowDateTime != ft_prev.dwLowDateTime);

    if ((counter_diff >= 0) &&
        (counter_diff_ms <= kMaxCalibrationDiff) &&
        sys_time_changed) {
      calibration_success = 1;
      break;
    }
    if (sys_time_changed)
      ft_prev = ft_now;
  } while (NaClFileTimeToMs(&ft_now) < end_of_calibrate);

  ntsp->system_time_start_ms = NaClFileTimeToMs(&ft_now);
  ntsp->qpc_start = counter_before.QuadPart + (counter_diff / 2);
  ntsp->last_qpc = counter_after.QuadPart;

  NaClLog(5,
          "Leaving NaClCalibrateWindowsClockQpc : %d\n",
          calibration_success);
  return calibration_success;
}
示例#2
0
/*
 * Calibration is done as described above.
 *
 * To ensure that the calibration is accurate, we interleave sampling
 * the millisecond resolution counter via timeGetTime with the 10-55
 * millisecond resolution system clock via GetSystemTimeAsFileTime.
 * When we see the edge transition where the system clock ticks, we
 * compare the before and after millisecond counter values.  If it is
 * within a calibration threshold (kMaxCalibrationDiff), then we
 * record the instantaneous system time (10-55 msresolution) and the
 * 32-bit counter value (1ms reslution).  Since we have a before and
 * after counter value, we interpolate it to get the "average" counter
 * value to associate with the system time.
 */
static void NaClCalibrateWindowsClockMu(struct NaClTimeState *ntsp) {
  FILETIME  ft_start;
  FILETIME  ft_now;
  DWORD     ms_counter_before;
  DWORD     ms_counter_after;
  uint32_t  ms_counter_diff;

  NaClLog(4, "Entered NaClCalibrateWindowsClockMu\n");
  GetSystemTimeAsFileTime(&ft_start);
  ms_counter_before = timeGetTime();
  for (;;) {
    GetSystemTimeAsFileTime(&ft_now);
    ms_counter_after = timeGetTime();
    ms_counter_diff = ms_counter_after - (uint32_t) ms_counter_before;
    NaClLog(4, "ms_counter_diff %u\n", ms_counter_diff);
    if (ms_counter_diff <= kMaxCalibrationDiff &&
        (ft_now.dwHighDateTime != ft_start.dwHighDateTime ||
         ft_now.dwLowDateTime != ft_start.dwLowDateTime)) {
      break;
    }
    ms_counter_before = ms_counter_after;
  }
  ntsp->system_time_start_ms = NaClFileTimeToMs(&ft_now);
  /*
   * Average the counter values.  Note unsigned computation of
   * ms_counter_diff, so that was mod 2**32 arithmetic, and the
   * addition of half the difference is numerically correct, whereas
   * (ms_counter_before + ms_counter_after)/2 is wrong due to
   * overflow.
   */
  ntsp->ms_counter_start = (DWORD) (ms_counter_before + (ms_counter_diff / 2));

  NaClLog(4, "Leaving NaClCalibrateWindowsClockMu\n");
}
int NaClGetTimeOfDayIntern(struct nacl_abi_timeval *tv,
                           struct NaClTimeState    *ntsp) {
  FILETIME  ft_now;
  DWORD     ms_counter_now;
  uint64_t  t_ms;
  DWORD     ms_counter_at_ft_now;
  uint32_t  ms_counter_diff;
  uint64_t  unix_time_ms;

  if (ntsp->can_use_qpc)
    return NaClGetTimeOfDayInternQpc(tv, ntsp, 1);

  GetSystemTimeAsFileTime(&ft_now);
  ms_counter_now = timeGetTime();
  t_ms = NaClFileTimeToMs(&ft_now);

  NaClXMutexLock(&ntsp->mu);

  if (!ntsp->allow_low_resolution) {
    NaClLog(5, "ms_counter_now       %"NACL_PRIu32"\n",
            (uint32_t) ms_counter_now);
    NaClLog(5, "t_ms                 %"NACL_PRId64"\n", t_ms);
    NaClLog(5, "system_time_start_ms %"NACL_PRIu64"\n",
            ntsp->system_time_start_ms);

    ms_counter_at_ft_now = (DWORD)
        (ntsp->ms_counter_start +
         (uint32_t) (t_ms - ntsp->system_time_start_ms));

    NaClLog(5, "ms_counter_at_ft_now %"NACL_PRIu32"\n",
            (uint32_t) ms_counter_at_ft_now);

    ms_counter_diff = ms_counter_now - (uint32_t) ms_counter_at_ft_now;

    NaClLog(5, "ms_counter_diff      %"NACL_PRIu32"\n", ms_counter_diff);

    if (ms_counter_diff <= kMaxMillsecondDriftBeforeRecalibration) {
      t_ms = t_ms + ms_counter_diff;
    } else {
      NaClCalibrateWindowsClockMu(ntsp);
      t_ms = ntsp->system_time_start_ms;
    }

    NaClLog(5, "adjusted t_ms =      %"NACL_PRIu64"\n", t_ms);
  }

  unix_time_ms = t_ms - ntsp->epoch_start_ms;

  NaClXMutexUnlock(&ntsp->mu);

  NaClLog(5, "unix_time_ms  =      %"NACL_PRId64"\n", unix_time_ms);
  /*
   * Unix time is measured relative to a different epoch, Jan 1, 1970.
   * See the module initialization for epoch_start_ms.
   */

  tv->nacl_abi_tv_sec = (nacl_abi_time_t) (unix_time_ms / 1000);
  tv->nacl_abi_tv_usec = (nacl_abi_suseconds_t) ((unix_time_ms % 1000) * 1000);
  return 0;
}
示例#4
0
void NaClTimeInternalInit(struct NaClTimeState *ntsp) {
  TIMECAPS    tc;
  SYSTEMTIME  st;
  FILETIME    ft;

  /*
   * Maximize timer/Sleep resolution.
   */
  timeGetDevCaps(&tc, sizeof tc);
  ntsp->wPeriodMin = tc.wPeriodMin;
  ntsp->time_resolution_ns = tc.wPeriodMin * NACL_NANOS_PER_MILLI;
  NaClLog(0, "NaClTimeInternalInit: timeBeginPeriod(%u)\n", tc.wPeriodMin);
  timeBeginPeriod(ntsp->wPeriodMin);

  /*
   * Compute Unix epoch start; calibrate high resolution clock.
   */
  st.wYear = 1970;
  st.wMonth = 1;
  st.wDay = 1;
  st.wHour = 0;
  st.wMinute = 0;
  st.wSecond = 0;
  st.wMilliseconds = 0;
  SystemTimeToFileTime(&st, &ft);
  ntsp->epoch_start_ms = NaClFileTimeToMs(&ft);
  ntsp->last_reported_time_ms = 0;
  NaClLog(0, "Unix epoch start is  %"NACL_PRIu64"ms in Windows epoch time\n",
          ntsp->epoch_start_ms);
  NaClMutexCtor(&ntsp->mu);
  /*
   * We don't actually grab the lock, since the module initializer
   * should be called before going threaded.
   */
  NaClCalibrateWindowsClockMu(ntsp);
}
int NaClGetTimeOfDayInternQpc(struct nacl_abi_timeval *tv,
                              struct NaClTimeState    *ntsp,
                              int allow_calibration) {
  FILETIME  ft_now;
  int64_t sys_now_mks;
  LARGE_INTEGER qpc;
  int64_t qpc_diff;
  int64_t qpc_diff_mks;
  int64_t qpc_now_mks;
  int64_t drift_mks;
  int64_t drift_ms;

  NaClLog(5, "Entered NaClGetTimeOfDayInternQpc\n");

  NaClXMutexLock(&ntsp->mu);

  GetSystemTimeAsFileTime(&ft_now);
  QueryPerformanceCounter(&qpc);
  sys_now_mks = NaClFileTimeToMs(&ft_now) * kMicrosecondsPerMillisecond;
  NaClLog(5, " sys_now_mks = %"NACL_PRId64" (us)\n", sys_now_mks);
  qpc_diff = qpc.QuadPart - ntsp->qpc_start;
  NaClLog(5, " qpc_diff = %"NACL_PRId64" (counts)\n", qpc_diff);
  /*
   * Coarse qpc_now_mks to 10 microseconds resolution,
   * to match the other platforms and not make a side-channel
   * attack any easier than it needs to be.
   */
  qpc_diff_mks = ((qpc_diff * (kMicrosecondsPerSecond / kCoarseMks)) /
      ntsp->qpc_frequency) * kCoarseMks;
  NaClLog(5, " qpc_diff_mks = %"NACL_PRId64" (us)\n", qpc_diff_mks);

  qpc_now_mks = (ntsp->system_time_start_ms * kMicrosecondsPerMillisecond) +
      qpc_diff_mks;
  NaClLog(5, " system_time_start_ms %"NACL_PRIu64"\n",
          ntsp->system_time_start_ms);
  NaClLog(5, " qpc_now_mks = %"NACL_PRId64" (us)\n", qpc_now_mks);

  if ((qpc_diff < 0) || (qpc.QuadPart < ntsp->last_qpc)) {
    NaClLog(5, " need recalibration\n");
    if (allow_calibration) {
      NaClCalibrateWindowsClockQpc(ntsp);
      NaClXMutexUnlock(&ntsp->mu);
      return NaClGetTimeOfDayInternQpc(tv, ntsp, 0);
    } else {
      NaClLog(5, " ... but using coarse, system time instead.\n");
      /* use GetSystemTimeAsFileTime(), not QPC */
      qpc_now_mks = sys_now_mks;
    }
  }
  ntsp->last_qpc = qpc.QuadPart;
  drift_mks = sys_now_mks - qpc_now_mks;
  if (qpc_now_mks > sys_now_mks)
    drift_mks = qpc_now_mks - sys_now_mks;

  drift_ms = drift_mks / kMicrosecondsPerMillisecond;
  NaClLog(5, " drift_ms = %"NACL_PRId64"\n", drift_ms);

  if (allow_calibration &&
      (drift_ms > kMaxMillsecondDriftBeforeRecalibration)) {
    NaClLog(5, "drift_ms recalibration\n");
    NaClCalibrateWindowsClockQpc(ntsp);
    NaClXMutexUnlock(&ntsp->mu);
    return NaClGetTimeOfDayInternQpc(tv, ntsp, 0);
  }

  NaClXMutexUnlock(&ntsp->mu);

  /* translate to unix time base */
  qpc_now_mks = qpc_now_mks
      - ntsp->epoch_start_ms * kMicrosecondsPerMillisecond;

  tv->nacl_abi_tv_sec =
      (nacl_abi_time_t)(qpc_now_mks / kMicrosecondsPerSecond);
  tv->nacl_abi_tv_usec =
      (nacl_abi_suseconds_t)(qpc_now_mks % kMicrosecondsPerSecond);
  return 0;
}
void NaClTimeInternalInit(struct NaClTimeState *ntsp) {
  TIMECAPS    tc;
  SYSTEMTIME  st;
  FILETIME    ft;
  LARGE_INTEGER qpc_freq;

  /*
   * Maximize timer/Sleep resolution.
   */
  timeGetDevCaps(&tc, sizeof tc);

  if (ntsp->allow_low_resolution) {
    /* Set resolution to max so we don't over-promise. */
    ntsp->wPeriodMin = tc.wPeriodMax;
  } else {
    ntsp->wPeriodMin = tc.wPeriodMin;
    timeBeginPeriod(ntsp->wPeriodMin);
    NaClLog(4, "NaClTimeInternalInit: timeBeginPeriod(%u)\n", ntsp->wPeriodMin);
  }
  ntsp->time_resolution_ns = ntsp->wPeriodMin * NACL_NANOS_PER_MILLI;

  /*
   * Compute Unix epoch start; calibrate high resolution clock.
   */
  st.wYear = 1970;
  st.wMonth = 1;
  st.wDay = 1;
  st.wHour = 0;
  st.wMinute = 0;
  st.wSecond = 0;
  st.wMilliseconds = 0;
  SystemTimeToFileTime(&st, &ft);
  ntsp->epoch_start_ms = NaClFileTimeToMs(&ft);
  NaClLog(4, "Unix epoch start is  %"NACL_PRIu64"ms in Windows epoch time\n",
          ntsp->epoch_start_ms);

  NaClMutexCtor(&ntsp->mu);

  /*
   * We don't actually grab the lock, since the module initializer
   * should be called before going threaded.
   */
  ntsp->can_use_qpc = 0;
  if (!ntsp->allow_low_resolution) {
    ntsp->can_use_qpc = QueryPerformanceFrequency(&qpc_freq);
    /*
     * On Athlon X2 CPUs (e.g. model 15) QueryPerformanceCounter is
     * unreliable.  Fallback to low-res clock.
     */
    if (strstr(CPU_GetBrandString(), "AuthenticAMD") && (CPU_GetFamily() == 15))
        ntsp->can_use_qpc = 0;

    NaClLog(4,
            "CPU_GetBrandString->[%s] ntsp->can_use_qpc=%d\n",
            CPU_GetBrandString(),
            ntsp->can_use_qpc);

    if (ntsp->can_use_qpc) {
      ntsp->qpc_frequency = qpc_freq.QuadPart;
      NaClLog(4, "qpc_frequency = %"NACL_PRId64" (counts/s)\n",
              ntsp->qpc_frequency);
      if (!NaClCalibrateWindowsClockQpc(ntsp))
        ntsp->can_use_qpc = 0;
    }
    if (!ntsp->can_use_qpc)
      NaClCalibrateWindowsClockMu(ntsp);
  }
}