ktime.c

Go to the documentation of this file.

/*
 * Copyright (c) 2006-2022 Ali Mashtizadeh
 * All rights reserved.
 */
 
#include <stdbool.h>
#include <stdint.h>
 
#include <sys/kassert.h>
#include <sys/kdebug.h>
#include <sys/ktime.h>
#include <sys/spinlock.h>
 
static Spinlock ktimeLock;
static uint64_t ktimeLastEpoch;
static uint64_t ktimeLastTSC;
uint64_t ticksPerSecond;
 
static const char *dayOfWeek[7] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
static const char *months[12] = {
    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};
 
void
KTime_Init()
{
    Spinlock_Init(&ktimeLock, "KTime Lock", SPINLOCK_TYPE_NORMAL);
    ktimeLastEpoch = 0;
    ktimeLastTSC = 0;
    ticksPerSecond = 0;
}
 
static bool
KTimeIsLeapYear(uint64_t year)
{
    if ((year % 4) != 0)
        return false;
    if ((year % 100) != 0)
        return true;
    if ((year % 400) != 0)
        return false;
    return true;
}
 
static int
KTimeDaysInMonth(uint64_t year, uint64_t month)
{
    static const uint64_t days[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
 
    if ((month == 2) && KTimeIsLeapYear(year))
        return 29;
    else
        return days[month];
}
 
/*
 * This function recomputes yday, mday or wday given other fields
 */
void
KTime_Fixup(KTime *tm)
{
    uint64_t m;
 
    if (tm->yday == -1) {
        uint64_t yday = 0;
        for (m = 0; m < tm->month; m++) {
            yday += KTimeDaysInMonth(tm->year, m);
        }
        yday += tm->mday;
        tm->yday = yday;
    }
}
 
UnixEpoch
KTime_ToEpoch(const KTime *tm)
{
    uint64_t days = 0;
    uint64_t secs = 0;
    uint64_t y, m;
 
    // Convert to UNIX epoch
    for (y = 1970; y < tm->year; y++) {
        if (KTimeIsLeapYear(y))
            days += 366;
        else
            days += 365;
    }
 
    if (tm->yday == -1) {
        uint64_t yday = 0;
        for (m = 0; m < tm->month; m++) {
            yday += KTimeDaysInMonth(tm->year, m);
        }
        yday += tm->mday;
        days += yday;
    } else {
        days += tm->yday;
    }
 
    secs = 24 * days + tm->hour;
    secs = secs * 60 + tm->min;
    secs = secs * 60 + tm->sec;
 
    return secs;
}
 
void
KTime_FromEpoch(UnixEpoch epoch, KTime *tm)
{
    uint64_t secs, mins, hours;
    uint64_t days;
    uint64_t y, m;
 
    // Compute seconds
    secs = epoch % (60 * 60 * 24);
    days = epoch / (60 * 60 * 24);
    mins = secs / 60;
    secs = secs % 60;
 
    // Compute minutes
    hours = mins / 60;
    mins = mins % 60;
 
    // Compute hours
    hours = hours % 24;
 
    tm->sec = secs;
    tm->min = mins;
    tm->hour = hours;
 
    tm->wday = (days + 3) % 7;
 
    for (y = 1970; ; y++) {
        uint64_t daysOfYear;
        if (KTimeIsLeapYear(y)) {
            daysOfYear = 366;
        } else {
            daysOfYear = 365;
        }
 
        if (days < daysOfYear) {
            tm->yday = days;
            tm->year = y;
            break;
        }
        days -= daysOfYear;
    }
 
    for (m = 0; ; m++) {
        uint64_t daysOfMonth = KTimeDaysInMonth(tm->year, m);
 
        if (days < daysOfMonth) {
            tm->mday = days;
            tm->month = m;
            break;
        }
        days -= daysOfMonth;
    }
}
 
void
KTime_SetTime(UnixEpoch epoch, uint64_t tsc, uint64_t tps)
{
    Spinlock_Lock(&ktimeLock);
    ktimeLastEpoch = epoch;
    ktimeLastTSC = tsc;
    ticksPerSecond = tps;
    Spinlock_Unlock(&ktimeLock);
 
}
 
void
KTime_GetTime(KTime *tm)
{
    KTime_FromEpoch(KTime_GetEpoch(), tm);
}
 
UnixEpoch
KTime_GetEpoch()
{
    uint64_t tscDiff;
    uint64_t epoch;
 
    Spinlock_Lock(&ktimeLock);
    tscDiff = Time_GetTSC() - ktimeLastTSC;
    epoch = ktimeLastEpoch + tscDiff / ticksPerSecond;
    Spinlock_Unlock(&ktimeLock);
 
    return epoch;
}
 
UnixEpochNS
KTime_GetEpochNS()
{
    uint64_t tscDiff;
    uint64_t epoch;
 
    Spinlock_Lock(&ktimeLock);
    tscDiff = Time_GetTSC() - ktimeLastTSC;
    /*
     * This is ugly but it avoids overflowing tscDiff to time computation.  
     * Note that the bottom bits of ticksPerSecond are not significant so it is 
     * okay to discard them.
     */
    epoch = (ktimeLastEpoch * 1000000000ULL) + (tscDiff * 1000000ULL / ticksPerSecond * 1000ULL);
    Spinlock_Unlock(&ktimeLock);
 
    return epoch;
}
 
static void
Debug_Date()
{
    UnixEpoch epoch = KTime_GetEpoch();
    KTime tm;
 
    KTime_FromEpoch(epoch, &tm);
 
    kprintf("%s %s %d %02d:%02d:%02d %04d\n",
            dayOfWeek[tm.wday], months[tm.month],
            tm.mday, tm.hour, tm.min, tm.sec, tm.year);
 
    kprintf("Epoch: %lu\n", epoch);
}
 
REGISTER_DBGCMD(date, "Print date", Debug_Date);
 
static void
Debug_Ticks()
{
    kprintf("Ticks Per Second: %lu\n", ticksPerSecond);
}
 
REGISTER_DBGCMD(ticks, "Print ticks per second", Debug_Ticks);