Clock.c

// This file was extracted from the TCG Published
// Trusted Platform Module Library
// Part 4: Supporting Routines
// Family "2.0"
// Level 00 Revision 01.16
// October 30, 2014

#include "PlatformData.h"
#include "Platform.h"

#ifdef __linux__

#include <sys/time.h>
// Function clock() does not provide accurate wall clock time on linux, let's
// substitite it with our own caclulations.
//
// Return current wall clock modulo milliseconds.
static UINT64 clock(void)
{
  struct timeval tv;
  gettimeofday(&tv, NULL);
  return (UINT64)tv.tv_sec * 1000 + tv.tv_usec / 1000;
}
#else
#include <time.h>
#endif
//
//
//          Functions
//
//          _plat__ClockReset()
//
//     Set the current clock time as initial time. This function is called at a power on event to reset the clock
//
LIB_EXPORT void
_plat__ClockReset(
     void
     )
{
     // Implementation specific: Microsoft C set CLOCKS_PER_SEC to be 1/1000,
     // so here the measurement of clock() is in millisecond.
     s_initClock = clock();
     s_adjustRate = CLOCK_NOMINAL;
     return;
}
//
//
//          _plat__ClockTimeFromStart()
//
//     Function returns the compensated                time    from    the    start    of   the    command      when
//     _plat__ClockTimeFromStart() was called.
//
unsigned long long
_plat__ClockTimeFromStart(
     void
     )
{
     unsigned long long currentClock = clock();
     return ((currentClock - s_initClock) * CLOCK_NOMINAL) / s_adjustRate;
}
//
//
//          _plat__ClockTimeElapsed()
//
//     Get the time elapsed from current to the last time the _plat__ClockTimeElapsed() is called. For the first
//     _plat__ClockTimeElapsed() call after a power on event, this call report the elapsed time from power on to
//     the current call
//
LIB_EXPORT unsigned long long
_plat__ClockTimeElapsed(
     void
//
    )
{
    unsigned long long elapsed;
    unsigned long long currentClock = clock();
    elapsed = ((currentClock - s_initClock) * CLOCK_NOMINAL) / s_adjustRate;
    s_initClock += (elapsed * s_adjustRate) / CLOCK_NOMINAL;
#ifdef DEBUGGING_TIME
   // Put this in so that TPM time will pass much faster than real time when
   // doing debug.
   // A value of 1000 for DEBUG_TIME_MULTIPLER will make each ms into a second
   // A good value might be 100
   elapsed *= DEBUG_TIME_MULTIPLIER
#endif
              return elapsed;
}
//
//
//        _plat__ClockAdjustRate()
//
//     Adjust the clock rate
//
LIB_EXPORT void
_plat__ClockAdjustRate(
    int                adjust         // IN: the adjust number.   It could be positive
                                      //     or negative
    )
{
    // We expect the caller should only use a fixed set of constant values to
    // adjust the rate
    switch(adjust)
    {
        case CLOCK_ADJUST_COARSE:
            s_adjustRate += CLOCK_ADJUST_COARSE;
            break;
        case -CLOCK_ADJUST_COARSE:
            s_adjustRate -= CLOCK_ADJUST_COARSE;
            break;
        case CLOCK_ADJUST_MEDIUM:
            s_adjustRate += CLOCK_ADJUST_MEDIUM;
            break;
        case -CLOCK_ADJUST_MEDIUM:
            s_adjustRate -= CLOCK_ADJUST_MEDIUM;
            break;
        case CLOCK_ADJUST_FINE:
            s_adjustRate += CLOCK_ADJUST_FINE;
            break;
        case -CLOCK_ADJUST_FINE:
            s_adjustRate -= CLOCK_ADJUST_FINE;
            break;
        default:
            // ignore any other values;
            break;
    }
    if(s_adjustRate > (CLOCK_NOMINAL + CLOCK_ADJUST_LIMIT))
        s_adjustRate = CLOCK_NOMINAL + CLOCK_ADJUST_LIMIT;
    if(s_adjustRate < (CLOCK_NOMINAL - CLOCK_ADJUST_LIMIT))
        s_adjustRate = CLOCK_NOMINAL-CLOCK_ADJUST_LIMIT;
    return;
}