/* * Copyright (c) 2011 Petr Koupy * Copyright (c) 2011 Jiri Zarevucky * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /** @addtogroup libposix * @{ */ /** @file Time measurement support. */ #define LIBPOSIX_INTERNAL /* Must be first. */ #include "stdbool.h" #include "internal/common.h" #include "time.h" #include "ctype.h" #include "errno.h" #include "signal.h" #include "libc/malloc.h" #include "libc/task.h" #include "libc/stats.h" #include "libc/sys/time.h" // TODO: documentation // TODO: test everything in this file /* Helper functions ***********************************************************/ #define HOURS_PER_DAY (24) #define MINS_PER_HOUR (60) #define SECS_PER_MIN (60) #define MINS_PER_DAY (MINS_PER_HOUR * HOURS_PER_DAY) #define SECS_PER_HOUR (SECS_PER_MIN * MINS_PER_HOUR) #define SECS_PER_DAY (SECS_PER_HOUR * HOURS_PER_DAY) /** * * @param year * @return */ static bool _is_leap_year(time_t year) { year += 1900; if (year % 400 == 0) return true; if (year % 100 == 0) return false; if (year % 4 == 0) return true; return false; } /** * * @param year * @param mon * @return */ static int _days_in_month(time_t year, time_t mon) { assert(mon >= 0 && mon <= 11); year += 1900; static int month_days[] = { 31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; if (mon == 1) { /* february */ return _is_leap_year(year) ? 29 : 28; } else { return month_days[mon]; } } /** * * @param year * @param mon * @param mday * @return */ static int _day_of_year(time_t year, time_t mon, time_t mday) { static int mdays[] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 }; static int leap_mdays[] = { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }; return (_is_leap_year(year) ? leap_mdays[mon] : mdays[mon]) + mday - 1; } /** * Integer division that rounds to negative infinity. * * @param op1 * @param op2 * @return */ static time_t _floor_div(time_t op1, time_t op2) { if (op1 >= 0 || op1 % op2 == 0) { return op1 / op2; } else { return op1 / op2 - 1; } } /** * Modulo that rounds to negative infinity. * * @param op1 * @param op2 * @return */ static time_t _floor_mod(time_t op1, time_t op2) { int div = _floor_div(op1, op2); /* (a / b) * b + a % b == a */ /* thus, a % b == a - (a / b) * b */ int result = op1 - div * op2; /* Some paranoid checking to ensure I didn't make a mistake here. */ assert(result >= 0); assert(result < op2); assert(div * op2 + result == op1); return result; } /** * * @param year * @param mon * @param mday * @return */ static time_t _days_since_epoch(time_t year, time_t mon, time_t mday) { return (year - 70) * 365 + _floor_div(year - 69, 4) - _floor_div(year - 1, 100) + _floor_div(year + 299, 400) + _day_of_year(year, mon, mday); } /** * Assumes normalized broken-down time. * * @param tm * @return */ static time_t _secs_since_epoch(const struct posix_tm *tm) { return _days_since_epoch(tm->tm_year, tm->tm_mon, tm->tm_mday) * SECS_PER_DAY + tm->tm_hour * SECS_PER_HOUR + tm->tm_min * SECS_PER_MIN + tm->tm_sec; } /** * * @param year * @param mon * @param mday * @return */ static int _day_of_week(time_t year, time_t mon, time_t mday) { /* 1970-01-01 is Thursday */ return (_days_since_epoch(year, mon, mday) + 4) % 7; } struct _long_tm { time_t tm_sec; time_t tm_min; time_t tm_hour; time_t tm_mday; time_t tm_mon; time_t tm_year; int tm_wday; int tm_yday; int tm_isdst; }; /** * * @param ltm * @param ptm */ static void _posix_to_long_tm(struct _long_tm *ltm, struct posix_tm *ptm) { assert(ltm != NULL && ptm != NULL); ltm->tm_sec = ptm->tm_sec; ltm->tm_min = ptm->tm_min; ltm->tm_hour = ptm->tm_hour; ltm->tm_mday = ptm->tm_mday; ltm->tm_mon = ptm->tm_mon; ltm->tm_year = ptm->tm_year; ltm->tm_wday = ptm->tm_wday; ltm->tm_yday = ptm->tm_yday; ltm->tm_isdst = ptm->tm_isdst; } /** * * @param ptm * @param ltm */ static void _long_to_posix_tm(struct posix_tm *ptm, struct _long_tm *ltm) { assert(ltm != NULL && ptm != NULL); // FIXME: the cast should be unnecessary, libarch/common.h brain-damage assert((ltm->tm_year >= (int) INT_MIN) && (ltm->tm_year <= (int) INT_MAX)); ptm->tm_sec = ltm->tm_sec; ptm->tm_min = ltm->tm_min; ptm->tm_hour = ltm->tm_hour; ptm->tm_mday = ltm->tm_mday; ptm->tm_mon = ltm->tm_mon; ptm->tm_year = ltm->tm_year; ptm->tm_wday = ltm->tm_wday; ptm->tm_yday = ltm->tm_yday; ptm->tm_isdst = ltm->tm_isdst; } /** * * @param tm */ static void _normalize_time(struct _long_tm *tm) { // TODO: DST correction /* Adjust time. */ tm->tm_min += _floor_div(tm->tm_sec, SECS_PER_MIN); tm->tm_sec = _floor_mod(tm->tm_sec, SECS_PER_MIN); tm->tm_hour += _floor_div(tm->tm_min, MINS_PER_HOUR); tm->tm_min = _floor_mod(tm->tm_min, MINS_PER_HOUR); tm->tm_mday += _floor_div(tm->tm_hour, HOURS_PER_DAY); tm->tm_hour = _floor_mod(tm->tm_hour, HOURS_PER_DAY); /* Adjust month. */ tm->tm_year += _floor_div(tm->tm_mon, 12); tm->tm_mon = _floor_mod(tm->tm_mon, 12); /* Now the difficult part - days of month. */ /* Slow, but simple. */ // FIXME: do this faster while (tm->tm_mday < 1) { tm->tm_mon--; if (tm->tm_mon == -1) { tm->tm_mon = 11; tm->tm_year--; } tm->tm_mday += _days_in_month(tm->tm_year, tm->tm_mon); } while (tm->tm_mday > _days_in_month(tm->tm_year, tm->tm_mon)) { tm->tm_mday -= _days_in_month(tm->tm_year, tm->tm_mon); tm->tm_mon++; if (tm->tm_mon == 12) { tm->tm_mon = 0; tm->tm_year++; } } /* Calculate the remaining two fields. */ tm->tm_yday = _day_of_year(tm->tm_year, tm->tm_mon, tm->tm_mday); tm->tm_wday = _day_of_week(tm->tm_year, tm->tm_mon, tm->tm_mday); } /** * Which day the week-based year starts on relative to the first calendar day. * E.g. if the year starts on December 31st, the return value is -1. * * @param year * @return */ static int _wbyear_offset(int year) { int start_wday = _day_of_week(year, 0, 1); return _floor_mod(4 - start_wday, 7) - 3; } /** * Returns week-based year of the specified time. * Assumes normalized broken-down time. * * @param tm * @return */ static int _wbyear(const struct posix_tm *tm) { int day = tm->tm_yday - _wbyear_offset(tm->tm_year); if (day < 0) { /* Last week of previous year. */ return tm->tm_year - 1; } if (day > 364 + _is_leap_year(tm->tm_year)){ /* First week of next year. */ return tm->tm_year + 1; } /* All the other days are in the calendar year. */ return tm->tm_year; } /** * Week number of the year, assuming weeks start on sunday. * The first Sunday of January is the first day of week 1; * days in the new year before this are in week 0. * * @param tm Normalized broken-down time. * @return The week number (0 - 53). */ static int _sun_week_number(const struct posix_tm *tm) { int first_day = (7 - _day_of_week(tm->tm_year, 0, 1)) % 7; return (tm->tm_yday - first_day + 7) / 7; } /** * Week number of the year, assuming weeks start on monday. * If the week containing January 1st has four or more days in the new year, * then it is considered week 1. Otherwise, it is the last week of the previous * year, and the next week is week 1. Both January 4th and the first Thursday * of January are always in week 1. * * @param tm Normalized broken-down time. * @return The week number (1 - 53). */ static int _iso_week_number(const struct posix_tm *tm) { int day = tm->tm_yday - _wbyear_offset(tm->tm_year); if (day < 0) { /* Last week of previous year. */ return 53; } if (day > 364 + _is_leap_year(tm->tm_year)){ /* First week of next year. */ return 1; } /* All the other days give correct answer. */ return (day / 7 + 1); } /** * Week number of the year, assuming weeks start on monday. * The first Monday of January is the first day of week 1; * days in the new year before this are in week 0. * * @param tm Normalized broken-down time. * @return The week number (0 - 53). */ static int _mon_week_number(const struct posix_tm *tm) { int first_day = (1 - _day_of_week(tm->tm_year, 0, 1)) % 7; return (tm->tm_yday - first_day + 7) / 7; } /******************************************************************************/ int posix_daylight; long posix_timezone; char *posix_tzname[2]; /** * */ void posix_tzset(void) { // TODO: read environment posix_tzname[0] = (char *) "GMT"; posix_tzname[1] = (char *) "GMT"; posix_daylight = 0; posix_timezone = 0; } /** * * @param time1 * @param time0 * @return */ double posix_difftime(time_t time1, time_t time0) { return (double) (time1 - time0); } /** * This function first normalizes the provided broken-down time * (moves all values to their proper bounds) and then tries to * calculate the appropriate time_t representation. * * @param tm Broken-down time. * @return time_t representation of the time, undefined value on overflow */ time_t posix_mktime(struct posix_tm *tm) { // TODO: take DST flag into account // TODO: detect overflow struct _long_tm ltm; _posix_to_long_tm(<m, tm); _normalize_time(<m); _long_to_posix_tm(tm, <m); return _secs_since_epoch(tm); } /** * * @param timer * @return */ struct posix_tm *posix_gmtime(const time_t *timer) { static struct posix_tm result; return posix_gmtime_r(timer, &result); } /** * * @param timer * @param result * @return */ struct posix_tm *posix_gmtime_r(const time_t *restrict timer, struct posix_tm *restrict result) { assert(timer != NULL); assert(result != NULL); /* Set epoch and seconds to _long_tm struct and normalize to get * correct values. */ struct _long_tm ltm = { .tm_sec = *timer, .tm_min = 0, .tm_hour = 0, /* 00:00:xx */ .tm_mday = 1, .tm_mon = 0, /* January 1st */ .tm_year = 70, /* 1970 */ }; _normalize_time(<m); if (ltm.tm_year < (int) INT_MIN || ltm.tm_year > (int) INT_MAX) { errno = EOVERFLOW; return NULL; } _long_to_posix_tm(result, <m); return result; } /** * * @param timer * @return */ struct posix_tm *posix_localtime(const time_t *timer) { static struct posix_tm result; return posix_localtime_r(timer, &result); } /** * * @param timer * @param result * @return */ struct posix_tm *posix_localtime_r(const time_t *restrict timer, struct posix_tm *restrict result) { // TODO: deal with timezone // currently assumes system and all times are in GMT return posix_gmtime_r(timer, result); } /** * * @param timeptr * @return */ char *posix_asctime(const struct posix_tm *timeptr) { static char buf[ASCTIME_BUF_LEN]; return posix_asctime_r(timeptr, buf); } /** * * @param timeptr * @param buf * @return */ char *posix_asctime_r(const struct posix_tm *restrict timeptr, char *restrict buf) { assert(timeptr != NULL); assert(buf != NULL); static const char *wday[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" }; static const char *mon[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }; snprintf(buf, ASCTIME_BUF_LEN, "%s %s %2d %02d:%02d:%02d %d\n", wday[timeptr->tm_wday], mon[timeptr->tm_mon], timeptr->tm_mday, timeptr->tm_hour, timeptr->tm_min, timeptr->tm_sec, 1900 + timeptr->tm_year); return buf; } /** * * @param timer * @return */ char *posix_ctime(const time_t *timer) { struct posix_tm *loctime = posix_localtime(timer); if (loctime == NULL) { return NULL; } return posix_asctime(loctime); } /** * * @param timer * @param buf * @return */ char *posix_ctime_r(const time_t *timer, char *buf) { struct posix_tm loctime; if (posix_localtime_r(timer, &loctime) == NULL) { return NULL; } return posix_asctime_r(&loctime, buf); } /** * * @param s * @param maxsize * @param format * @param tm * @return */ size_t posix_strftime(char *restrict s, size_t maxsize, const char *restrict format, const struct posix_tm *restrict tm) { // TODO: use locale static const char *wday_abbr[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" }; static const char *wday[] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" }; static const char *mon_abbr[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }; static const char *mon[] = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" }; if (maxsize < 1) { return 0; } char *ptr = s; size_t consumed; size_t remaining = maxsize; #define append(...) { \ /* FIXME: this requires POSIX-correct snprintf */ \ /* otherwise it won't work with non-ascii chars */ \ consumed = snprintf(ptr, remaining, __VA_ARGS__); \ if (consumed >= remaining) { \ return 0; \ } \ ptr += consumed; \ remaining -= consumed; \ } #define recurse(fmt) { \ consumed = posix_strftime(ptr, remaining, fmt, tm); \ if (consumed == 0) { \ return 0; \ } \ ptr += consumed; \ remaining -= consumed; \ } #define TO_12H(hour) (((hour) > 12) ? ((hour) - 12) : \ (((hour) == 0) ? 12 : (hour))) while (*format != '\0') { if (*format != '%') { append("%c", *format); format++; continue; } format++; if (*format == '0' || *format == '+') { // TODO: padding format++; } while (isdigit(*format)) { // TODO: padding format++; } if (*format == 'O' || *format == 'E') { // TODO: locale's alternative format format++; } switch (*format) { case 'a': append("%s", wday_abbr[tm->tm_wday]); break; case 'A': append("%s", wday[tm->tm_wday]); break; case 'b': append("%s", mon_abbr[tm->tm_mon]); break; case 'B': append("%s", mon[tm->tm_mon]); break; case 'c': // TODO: locale-specific datetime format recurse("%Y-%m-%d %H:%M:%S"); break; case 'C': append("%02d", (1900 + tm->tm_year) / 100); break; case 'd': append("%02d", tm->tm_mday); break; case 'D': recurse("%m/%d/%y"); break; case 'e': append("%2d", tm->tm_mday); break; case 'F': recurse("%+4Y-%m-%d"); break; case 'g': append("%02d", _wbyear(tm) % 100); break; case 'G': append("%d", _wbyear(tm)); break; case 'h': recurse("%b"); break; case 'H': append("%02d", tm->tm_hour); break; case 'I': append("%02d", TO_12H(tm->tm_hour)); break; case 'j': append("%03d", tm->tm_yday); break; case 'k': append("%2d", tm->tm_hour); break; case 'l': append("%2d", TO_12H(tm->tm_hour)); break; case 'm': append("%02d", tm->tm_mon); break; case 'M': append("%02d", tm->tm_min); break; case 'n': append("\n"); break; case 'p': append("%s", tm->tm_hour < 12 ? "AM" : "PM"); break; case 'P': append("%s", tm->tm_hour < 12 ? "am" : "PM"); break; case 'r': recurse("%I:%M:%S %p"); break; case 'R': recurse("%H:%M"); break; case 's': append("%ld", _secs_since_epoch(tm)); break; case 'S': append("%02d", tm->tm_sec); break; case 't': append("\t"); break; case 'T': recurse("%H:%M:%S"); break; case 'u': append("%d", (tm->tm_wday == 0) ? 7 : tm->tm_wday); break; case 'U': append("%02d", _sun_week_number(tm)); break; case 'V': append("%02d", _iso_week_number(tm)); break; case 'w': append("%d", tm->tm_wday); break; case 'W': append("%02d", _mon_week_number(tm)); break; case 'x': // TODO: locale-specific date format recurse("%Y-%m-%d"); break; case 'X': // TODO: locale-specific time format recurse("%H:%M:%S"); break; case 'y': append("%02d", tm->tm_year % 100); break; case 'Y': append("%d", 1900 + tm->tm_year); break; case 'z': // TODO: timezone break; case 'Z': // TODO: timezone break; case '%': append("%%"); break; default: /* Invalid specifier, print verbatim. */ while (*format != '%') { format--; } append("%%"); break; } format++; } #undef append #undef recurse return maxsize - remaining; } /** * * @param s * @param maxsize * @param format * @param tm * @param loc * @return */ extern size_t posix_strftime_l(char *restrict s, size_t maxsize, const char *restrict format, const struct posix_tm *restrict tm, posix_locale_t loc) { // TODO not_implemented(); } /** * * @param clock_id * @param res * @return */ int posix_clock_getres(posix_clockid_t clock_id, struct posix_timespec *res) { assert(res != NULL); switch (clock_id) { case CLOCK_REALTIME: res->tv_sec = 0; res->tv_nsec = 1000; /* Microsecond resolution. */ return 0; default: errno = EINVAL; return -1; } } /** * * @param clock_id * @param tp * @return */ int posix_clock_gettime(posix_clockid_t clock_id, struct posix_timespec *tp) { assert(tp != NULL); switch (clock_id) { case CLOCK_REALTIME: ; struct timeval tv; gettimeofday(&tv, NULL); tp->tv_sec = tv.tv_sec; tp->tv_nsec = tv.tv_usec * 1000; return 0; default: errno = EINVAL; return -1; } } /** * * @param clock_id * @param tp * @return */ int posix_clock_settime(posix_clockid_t clock_id, const struct posix_timespec *tp) { assert(tp != NULL); switch (clock_id) { case CLOCK_REALTIME: // TODO: setting clock // FIXME: HelenOS doesn't actually support hardware // clock yet errno = EPERM; return -1; default: errno = EINVAL; return -1; } } /** * * @param clock_id * @param flags * @param rqtp * @param rmtp * @return */ int posix_clock_nanosleep(posix_clockid_t clock_id, int flags, const struct posix_timespec *rqtp, struct posix_timespec *rmtp) { assert(rqtp != NULL); assert(rmtp != NULL); switch (clock_id) { case CLOCK_REALTIME: // TODO: interruptible sleep if (rqtp->tv_sec != 0) { sleep(rqtp->tv_sec); } if (rqtp->tv_nsec != 0) { usleep(rqtp->tv_nsec / 1000); } return 0; default: errno = EINVAL; return -1; } } #if 0 struct __posix_timer { posix_clockid_t clockid; struct posix_sigevent evp; }; /** * * @param clockid * @param evp * @param timerid * @return */ int posix_timer_create(posix_clockid_t clockid, struct posix_sigevent *restrict evp, posix_timer_t *restrict timerid) { // TODO not_implemented(); } /** * * @param timerid * @return */ int posix_timer_delete(posix_timer_t timerid) { // TODO not_implemented(); } /** * * @param timerid * @return */ int posix_timer_getoverrun(posix_timer_t timerid) { // TODO not_implemented(); } /** * * @param timerid * @param value * @return */ int posix_timer_gettime(posix_timer_t timerid, struct posix_itimerspec *value) { // TODO not_implemented(); } /** * * @param timerid * @param flags * @param value * @param ovalue * @return */ int posix_timer_settime(posix_timer_t timerid, int flags, const struct posix_itimerspec *restrict value, struct posix_itimerspec *restrict ovalue) { // TODO not_implemented(); } #endif /** * Get CPU time used since the process invocation. * * @return Consumed CPU cycles by this process or -1 if not available. */ posix_clock_t posix_clock(void) { posix_clock_t total_cycles = -1; stats_task_t *task_stats = stats_get_task(task_get_id()); if (task_stats) { total_cycles = (posix_clock_t) (task_stats->kcycles + task_stats->ucycles); free(task_stats); task_stats = 0; } return total_cycles; } /** @} */